Hiện tượng được gọi là Will Rogers mô tả một cách để điều chỉnh số liệu thống kê bằng cách tăng trung bình trong hai (đa) bộ khi một phần tử được di chuyển giữa hai bộ. Một ví dụ đơn giản, hãy xem xét hai bộ

A = {1, 2, 3}
B = {4, 5, 6}

Phương tiện số học của họ là 2và 5, tương ứng. Nếu chúng ta di chuyển 4đến A:

A = {1, 2, 3, 4}
B = {5, 6}

Bây giờ trung bình là 2.5và 5.5, tương ứng, vì vậy cả hai trung bình đã được nâng lên thông qua một nhóm đơn giản.

Một ví dụ khác, hãy xem xét

A = {3, 4, 5, 6} --> A = {3, 5, 6}
B = {2, 3, 4, 5} --> B = {2, 3, 4, 4, 5}

Mặt khác, không thể tăng cả hai mức trung bình cho các bộ

A = {1, 5, 9}
B = {4, 5, 7, 8}

Các thách thức

Đưa ra hai danh sách các số nguyên không âm, xác định xem có thể tăng cả hai trung bình hay không bằng cách di chuyển một số nguyên từ danh sách này sang danh sách khác.

Trung bình của một danh sách trống không được xác định, vì vậy nếu một trong các danh sách chỉ chứa một phần tử, phần tử này không thể được di chuyển.

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Đầu vào có thể được thực hiện trong bất kỳ định dạng chuỗi hoặc danh sách thuận tiện.

Bạn không được cho rằng các thành phần trong mỗi danh sách là duy nhất và chúng cũng không được sắp xếp. Bạn có thể cho rằng cả hai danh sách đều chứa ít nhất một yếu tố.

Output nên truthy nếu cả hai trung bình có thể được nâng lên bằng cách di chuyển một số nguyên đơn và falsy khác.

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Các trường hợp thử nghiệm

Sự thật:

[1], [2, 3]
[1, 2, 3], [4, 5, 6]
[3, 4, 5, 6], [2, 3, 4, 5]
[6, 5, 9, 5, 6, 0], [6, 2, 0, 9, 5, 2]
[0, 4], [9, 1, 0, 2, 8, 0, 5, 5, 4, 9]

Giả mạo:

[1], [2]
[2, 4], [5]
[1, 5], [2, 3, 4, 5]
[2, 1, 2, 3, 1, 3], [5, 1, 6]
[4, 4, 5, 2, 4, 0], [9, 2, 10, 1, 9, 0]

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

# Ruby, <s>104</s> <s>101</s> 96 bytes

<script>site = 'meta.codegolf'; postID = 5314; isAnswer = true; QUESTION_ID = 53913</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Pyth, 29 28 26 24 byte

Cảm ơn @Jakube đã tiết kiệm cho tôi 3 byte với .pvà L.

Rất đơn giản, kiểm tra xem có bất kỳ phần tử nào trong danh sách 2 lớn hơn giá trị trung bình của danh sách 1 và nhỏ hơn giá trị trung bình của danh sách 2 không, sau đó lặp lại với danh sách 1 và danh sách 2 được chuyển đổi.

Lcsblbff&>YyhT<YyeTeT.pQ

In một danh sách không trống cho sự thật và []cho falsey.

L                    Define y(b). Pyth has no builtin for mean
 c                   Float div
  sb                 Sum of b
  lb                 Length of b
f        .pQ         Filter all permutations of input
 f     eT            Filter the last element of the filter var
  &                  Logical and
   >Y                Inner filter var greater than
    y                Call the mean function we defined earlier
     hT              First element of outer filter var
   <Y                Inner filter var less than
    y                Mean of
     eT              Last element of outer filternvar

Hãy thử trực tuyến tại đây .

Phòng thử nghiệm.

Trăn 3, 74

lambda*L:any(sum(C)/len(C)>x>sum(D)/len(D)for(C,D)in[L,L[::-1]]for x in C)

Lấy hai danh sách làm đầu vào. Kiểm tra xem danh sách đầu tiên có thành phần lớn hơn mức trung bình nhưng nhỏ hơn danh sách khác không. Sau đó, làm tương tự cho hai đầu vào hoán đổi. Có một sự hiểu biết danh sách hai lớp ngắn hơn so với việc xác định một chức năng riêng biệt để thử hai thứ tự (82):

f=lambda A,B:any(sum(A)/len(A)>x>sum(B)/len(B)for x in A)
lambda A,B:f(A,B)|f(B,A)

Haskell, 58 57

x%y=any(\n->(\g->g x<0&&g y>0)$sum.map(n-))x
x?y=x%y||y%x

chúng ta có thể kiểm tra xem chúng ta phóng to hay hạ mức trung bình bằng cách kiểm tra xem phần tử cần loại bỏ hoặc bao gồm lớn hơn hay nhỏ hơn mức trung bình.

chúng ta có thể kiểm tra xem bằng cách kiểm tra xem trung bình nhỏ hơn hay lớn hơn một phần tử bằng cách loại bỏ phần tử đó khỏi mảng và kiểm tra xem trung bình của mảng mới là âm hay dương, điều này cũng giống như kiểm tra xem tổng đó là dương hay âm .

kiểm tra đó được đặt rất đơn giản như sum.map(-n+).

Toán học, 49 47 byte

m=Mean;MemberQ[#2,x_/;m@#<x<m@#2]&@@#~SortBy~m&

Đánh giá một hàm thuần túy dự kiến ​​đầu vào trong biểu mẫu {list1, list2}.

APL, 45 40 byte

Đã lưu 5 byte nhờ Moris Zucca!

{U←∊⍺⍵[⊃⍒M←(+/÷≢)¨⍺⍵]⋄1∊(U<⌈/M)∧(U>⌊/M)}

Điều này tạo ra một hàm dyadic không tên, chấp nhận các mảng ở bên trái và bên phải và trả về 1 hoặc 0.

{
  M←(+/÷≢)¨⍺⍵          ⍝ Compute the mean of each array
  U←∊⍺⍵[⊃⍒M]           ⍝ Get the array with the larger mean
  1∊(U<⌈/M)∧(U>⌊/M)    ⍝ Any smaller mean < U < larger mean
}

Bạn có thể thử nó trực tuyến .

R, 66 52 byte

Là một hàm không tên, chấp nhận 2 vectơ. Đã thoát khỏi một số mà giả.

function(a,b)any(a<(m=mean)(a)&a>m(b),b<m(b)&b>m(a))

Xét nghiệm

> f=
+ function(a,b)any(a<(m=mean)(a)&a>m(b),b<m(b)&b>m(a))
> f(c(1), c(2, 3))
[1] TRUE
> f(c(1, 2, 3), c(4, 5, 6))
[1] TRUE
> f(c(3, 4, 5, 6), c(2, 3, 4, 5))
[1] TRUE
> f(c(6, 5, 9, 5, 6, 0), c(6, 2, 0, 9, 5, 2))
[1] TRUE
> f(c(0, 4), c(9, 1, 0, 2, 8, 0, 5, 5, 4, 9))
[1] TRUE
> 
> f(c(1), c(2))
[1] FALSE
> f(c(2, 4), c(5))
[1] FALSE
> f(c(1, 5), c(2, 3, 4, 5))
[1] FALSE
> f(c(2, 1, 2, 3, 1, 3), c(5, 1, 6))
[1] FALSE
> f(c(4, 4, 5, 2, 4, 0), c(9, 2, 10, 1, 9, 0))
[1] FALSE
> 

SAS / IML, 67

start m(a,b);return((a>b[:]&&a<a[:])||(b>a[:]&&b<b[:]))[<>];finish;

Nó sử dụng các toán tử giảm chỉ số để có câu trả lời, trả về 0 nếu không tìm thấy phần tử nào phù hợp với yêu cầu hoặc 1 nếu tìm thấy.

Không chơi gôn, ở đây tôi trả về giá trị thực bằng cách sử dụng phép nhân ma trận:

proc iml;
  b={1 2 3 4 5 6 7 8 9 };
  a={2 3 4 5 6};
  start m(a,b);
  return (a#(a>b[:] && a < a[:]) || b#(b>a[:] && b < b[:]))[<>];
  finish;

  z= m(a,b);
  print z;
quit;

Các xét nghiệm:

%macro test(a,b,n);
  z&n=m({&a},{&b});
  print z&n;
%mend test;

proc iml;
  b={1 2 3 4 5 };
  a={2 3 4 5 6 7};
start m(a,b);return((a>b[:]&&a<a[:])||(b>a[:]&&b<b[:]))[<>];finish;

* True;
 %test(1,2 3,1);
 %test(1 2 3,4 5 6,2);
 %test(3 4 5 6, 2 3 4 5,3);
 %test(6 5 9 5 6 0,6 2 0 9 5 2,4);
 %test(0 4, 9 1 0 2 8 0 5 5 4 9,5);
* False;
 %test(1,2,6);
 %test(2 4, 5,7);
 %test(1 5, 2 3 4 5,8);
 %test(2 1 2 3 1 3, 5 1 6,9);
 %test(4 4 5 2 4 0, 9 2 10 1 9 0,10);

quit;

(Ngưng tụ cho dễ đọc)

z1 1

z2 1

z3 1

z4 1

z5 1

z6 0

z7 0

z8 0

z9 0

z10 0

Python 2.7, 102 98 96

lambda p:any([1for i in 0,1for e in p[i]if g[i^1]<e<g[i]]for g in[[sum(l)*1./len(l)for l in p]])

Lấy đầu vào là mảng của 2 đầu vào và trả về boolean.
Logic là - tìm avg của 2 danh sách, sau đó tìm một phần tử sao cho nó nhỏ hơn avg của danh sách của chính nó và lớn hơn mức trung bình của danh sách khác.

Kiểm tra nó cho các đầu vào đã cho là demo-ed ở đây

CJam, 28 byte

{{_:+1$,d/\+}%$~(m],@0=i)>&}

Đây là một hàm ẩn danh bật ra một mảng hai chiều từ ngăn xếp và trả lại một mảng các phần tử có thể di chuyển được.

Trong các trình duyệt được hỗ trợ, bạn có thể xác minh tất cả các trường hợp kiểm tra cùng một lúc trong trình thông dịch CJam .

Các trường hợp thử nghiệm

Mã

q~]{{_:+1$,d/\+}%$~(m],@0=i)>&}%:p

Đầu vào

[[1] [2 3]]
[[1 2 3] [4 5 6]]
[[3 4 5 6] [2 3 4 5]]
[[6 5 9 5 6 0] [6 2 0 9 5 2]]
[[0 4] [9 1 0 2 8 0 5 5 4 9]]
[[1] [2]]
[[2 4] [5]]
[[1 5] [2 3 4 5]]
[[2 1 2 3 1 3] [5 1 6]]
[[4 4 5 2 4 0] [9 2 10 1 9 0]]

Đầu ra

[2]
[4]
[4]
[5]
[4]
""
""
""
""
""

Làm thế nào nó hoạt động

Nếu A và B là mảng và avg (A) avg (B), chúng ta chỉ cần kiểm tra xem B ∩ {avg (A) + 1, Lỗi, ⌈avg (B) - 1} không trống. Bất kỳ yếu tố nào trong giao lộ này có thể được chuyển từ B sang A để tăng cả hai mức trung bình.

{          }%              e# For each of the arrays:
 _:+                       e#   Compute the sum of its elements.
    1$,                    e#   Compute its length.
       d/                  e#   Cast to Double and perform division.
         \+                e#   Prepend the computed average to the array.
             $             e# Sort the arrays (by the averages).
              ~            e# Dump both arrays on the stack.
               (           e# Shift out the higher average.
                m]         e# Round up to the nearest integer b.
                  ,        e# Push [0 ... b-1].
                   @0=     e# Replace the array with lower average by its average.
                      i)   e# Round down to the nearest integer a and add 1.
                        >  e# Skip the first a integer of the range.
                           e# This pushes [a+1 ... b-1].
                         & e# Intersect the result with the remaining array.

Điều này đẩy mảng của tất cả các phần tử của mảng có mức trung bình cao hơn có thể được di chuyển để tăng cả mức trung bình. Mảng này trống / giả khi và chỉ khi không có phần tử nào có thể được di chuyển để đạt được kết quả này.

Ruby, 86

A=->x{x.reduce(0.0,:+)/x.size}
F=->q{b,a=q.sort_by{|x|A[x]};a.any?{|x|x<A[a]&&x>A[b]}}

Đưa vào như một mảng chứa hai mảng.

Cố gắng tìm một mục trung bình phụ từ nhóm có mức trung bình cao hơn lớn hơn mức trung bình của nhóm khác.

Kiểm tra: http://ideone.com/444W4U

Matlab, 54

Sử dụng chức năng ẩn danh:

f=@(A,B)any([B>mean(A)&B<mean(B) A>mean(B)&A<mean(A)])

Ví dụ:

>> f=@(A,B)any([B>mean(A)&B<mean(B) A>mean(B)&A<mean(A)])
f = 
    @(A,B)any([B>mean(A)&B<mean(B),A>mean(B)&A<mean(A)])

>> f([1 2 3],[4 5 6])
ans =
     1

>> f([3 4 5 6],[2 3 4 5])
ans =
     1

>> f([1 5 9],[4 5 7 8])
ans =
     0

C #, 104

bool f(int[]a,int[]b){double i=a.Average(),j=b.Average();return a.Any(x=>x<i&&x>j)||b.Any(x=>x<j&&x>i);}

Các cuộc gọi ví dụ:

f(new []{1,2,3}, new []{4,5,6})
f(new []{1}, new []{2, 3})
f(new []{1, 2, 3}, new []{4, 5, 6})
f(new []{3, 4, 5, 6}, new []{2, 3, 4, 5})
f(new []{6, 5, 9, 5, 6, 0}, new []{6, 2, 0, 9, 5, 2})
f(new []{0, 4}, new []{9, 1, 0, 2, 8, 0, 5, 5, 4, 9})

f(new []{1}, new []{2})
f(new []{2, 4}, new []{5})
f(new []{1, 5}, new []{2, 3, 4, 5})
f(new []{2, 1, 2, 3, 1, 3}, new []{5, 1, 6})
f(new []{4, 4, 5, 2, 4, 0}, new []{9, 2, 10, 1, 9, 0})

C ++ 14, 157 byte

Như lambda chưa được đặt tên, trả về bởi tham số cuối cùng r. Giả sử A, Blà container như vector<int>hoặc array<int,>.

[](auto A,auto B,int&r){auto m=[](auto C){auto s=0.;for(auto x:C)s+=x;return s/C.size();};r=0;for(auto x:A)r+=x<m(A)&&x>m(B);for(auto x:B)r+=x<m(B)&&x>m(A);}

Ung dung:

auto f=
[](auto A,auto B,int&r){
  auto m=[](auto C){
   auto s=0.;
   for(auto x:C) s+=x;
   return s/C.size();
  };
  r=0;
  for (auto x:A) r+=x<m(A)&&x>m(B);
  for (auto x:B) r+=x<m(B)&&x>m(A);
}
;

Sử dụng:

int main() {
  std::vector<int>
    a={1,2,3}, b={4,5,6};
  //  a={1,5,9}, b={4,5,7,8};
  int r;
  f(a,b,r);
  std::cout << r << std::endl;
}