विल रोजर्स फेनोमेनन

Question

तथाकथित विल रोजर्स घटना में दो तत्वों (दो) के बीच औसत को बढ़ाकर आँकड़ों को मोड़ने का एक तरीका बताया गया है जब एक तत्व को दो सेटों के बीच ले जाया जाता है। एक सरल उदाहरण के रूप में, दो सेटों पर विचार करें

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

उनके अंकगणित साधन क्रमशः हैं 2और 5। हम ले जाते हैं 4करने के लिए A:

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

अब औसत 2.5और 5.5क्रमशः हैं, इसलिए दोनों औसत एक साधारण रीग्रुपिंग के माध्यम से उठाए गए हैं।

एक अन्य उदाहरण के रूप में, विचार करें

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

दूसरी ओर, सेटों के लिए दोनों औसत बढ़ाना संभव नहीं है

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

चुनौती

गैर-नकारात्मक पूर्णांक की दो सूचियों को देखते हुए, यह निर्धारित करें कि क्या एक सूची से दूसरी सूची में एक पूर्णांक को स्थानांतरित करके दोनों औसत बढ़ाना संभव है।

एक खाली सूची के औसत को परिभाषित नहीं किया गया है, इसलिए यदि किसी सूची में केवल एक तत्व है, तो इस तत्व को स्थानांतरित नहीं किया जा सकता है।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

इनपुट किसी भी सुविधाजनक स्ट्रिंग या सूची प्रारूप में लिया जा सकता है।

आपको यह नहीं मानना ​​चाहिए कि प्रत्येक सूची में तत्व अद्वितीय हैं, न ही वे क्रमबद्ध हैं। आप मान सकते हैं कि दोनों सूचियों में कम से कम एक तत्व है।

आउटपुट सत्य होना चाहिए अगर दोनों औसत एक एकल पूर्णांक और फ़ॉसी को स्थानांतरित करके उठाए जा सकते हैं ।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

परीक्षण के मामलों

Truthy:

[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]

Falsy:

[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]

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं, उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# 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>

Comments

एक गणितज्ञ और एक कोडर के रूप में, मैं वास्तव में चुनौती को संबोधित नहीं कर सकता, लेकिन मुझे निम्नलिखित प्रश्न में दिलचस्पी है: यदि दोनों औसत पूर्णांक के कुछ परिमित संग्रह (जैसे पांच) को एक सेट से दूसरे में स्थानांतरित करके उठाया जा सकता है , क्या यह हमेशा अनुसरण करता है कि दोनों औसत केवल एक पूर्णांक को स्थानांतरित करके उठाया जा सकता है ? इस प्रकार यह दिखाना कि चुनौती वास्तव में सभी मामलों को कवर करती है।

— ट्रेवर जे रिचर्ड्स

@TrevorRichards मुझे लगता है कि आखिरी झूठा परीक्षण मामला इसमें शामिल है। आप एक 1और 9अधिक ले जा सकते हैं , जो औसत दोनों को बढ़ाएगा, लेकिन आप एक एकल को स्थानांतरित करके ऐसा नहीं कर सकते।

— मार्टिन एंडर

@TrevorRichards सामान्य तौर पर, अगर A और B के सेट का औसत a & b के साथ <b है तो दोनों औसत को उठाया जा सकता है यदि B का सबसेट C है जिसमें औसत c ऐसा है कि <c <b। दूसरी ओर, यदि आपको B से A तक जाने वाले सभी तत्वों को मानों की आवश्यकता है <b तो आपकी परिकल्पना सच होगी।

— अल्‍चीमिस्ट

Answer 1

पायथ, 29 28 26 24 बाइट्स

मेरे साथ 3 बाइट्स को बचाने के लिए @Jakube के लिए धन्यवाद .pऔर L।

बहुत ही सरल, जाँचता है कि सूची 2 में कोई भी तत्व सूची 1 के माध्य से अधिक है और सूची 2 के माध्य से कम है, तो सूची 1 और सूची 2 के साथ दोहराता है।

Lcsblbff&>YyhT<YyeTeT.pQ

[]सत्य के लिए एक गैर-रिक्त सूची प्रिंट करता है, और फ़ासी के लिए।

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

इसे यहाँ ऑनलाइन आज़माएँ ।

परीक्षण सूट।

Answer 2

पायथन 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)

इनपुट के रूप में दो सूचियाँ लेता है। जाँच करता है कि पहली सूची में एक तत्व है जो औसत से बड़ा है लेकिन दूसरे की तुलना में छोटा है। फिर, दो इनपुट अदला-बदली के लिए एक ही करता है। दो-आदेशों की कोशिश करने के लिए एक अलग-अलग कार्य को परिभाषित करने की तुलना में दो-परत सूची की समझ कम थी: (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)

Answer 3

हास्केल, 58 57

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

हम जाँच कर सकते हैं कि क्या हम जाँच करके या कम करके जाँचते हैं कि तत्व निकालने या शामिल करने का तत्व औसत से बड़ा या छोटा है या नहीं।

हम जाँच सकते हैं कि एरे से उस तत्व को हटाकर एवरेज किसी तत्व से छोटा या बड़ा है या नहीं, और यह चेक करके कि नए एरे का औसत निगेटिव है या पॉजिटिव है, जो बदले में यह जाँच रहा है कि योग पॉजिटिव है या निगेटिव। ।

जाँच है कि बहुत ही सरल रूप में रखा गया है sum.map(-n+)।

Answer 4

गणितज्ञ, ४ ९ ४ 49 बाइट्स

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

एक शुद्ध फ़ंक्शन का मूल्यांकन करता है जो प्रपत्र में इनपुट की अपेक्षा करता है {list1, list2}।

Answer 5

एपीएल, 45 40 बाइट्स

मोरिस ज़ुक्का के लिए धन्यवाद 5 बाइट्स बचाए!

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

यह एक अनाम डायैडिक फ़ंक्शन बनाता है जो बाईं और दाईं ओर सरणियों को स्वीकार करता है और 1 या 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
}

आप इसे ऑनलाइन आज़मा सकते हैं ।

Comments

आप इसका अर्थ इस प्रकार लिख सकते हैं: (+ / write

— मोरिस ज़ुका

@MorisZucca धन्यवाद! अपने सुझाव का उपयोग करने के लिए संपादित।

— एलेक्स ए।

Answer 6

आर, 66 52 बाइट्स

एक अनाम फ़ंक्शन के रूप में, जो 2 वैक्टर स्वीकार करता है। कुछ चंचल जो से छुटकारा मिल गया।

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

टेस्ट

> 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
> 

Answer 7

एसएएस / आईएमएल, 67

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

यह उत्तर पाने के लिए सबस्क्रिप्ट कमी परिचालकों का उपयोग करता है, 0 लौटाता है यदि कोई तत्व नहीं मिला है जो आवश्यकताओं से मेल खाता है या 1 पाया जाता है।

गैर-गोल्फ, यहां मैं मैट्रिक्स गुणन का उपयोग करके स्वयं वास्तविक मूल्य लौटाता हूं:

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;

टेस्ट:

%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;

(पठनीयता के लिए संघनित)

z1 1

z2 1

z3 1

z4 1

z5 1

z6 0

z7 0

z8 0

z9 0

z10 0

Answer 8

पायथन 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]])

इनपुट को 2 इनपुट की सरणी के रूप में लेता है और बूलियन देता है।
तर्क 2 सूचियों के avg को फिर से चालू करता है, फिर एक ऐसा तत्व खोजता है, जो अपनी सूची के औसत से कम और दूसरी सूची के औसत से अधिक हो।

दिए गए इनपुट के लिए इसका परीक्षण यहाँ डेमो-एड है

Comments

आप बाइट को बचाने के *1.बजाय कर सकते हैं *1.0। वैकल्पिक रूप से, यदि आप पायथन 3 में ऐसा करते हैं, तो विभाजन डिफ़ॉल्ट रूप से एक फ्लोट लौटाएगा, इसलिए आपको उस गुणन की बिल्कुल भी आवश्यकता नहीं होगी। (मुझे नहीं लगता कि आपको पायथन 3 का उपयोग करने के लिए अपने कोड को बदलना होगा।)

— मैथमैडन

@ मथमंदन ने मुझे एक बाइट से बचाया। धन्यवाद :)

— कमेहामे

आप को हटाने के द्वारा यह एक गुमनाम समारोह बना सकते हैं f=और परिवर्तन in[0,1]forकरने के लिए in 0,1for। चूँकि आप वास्तव में 101 बाइट्स पर हैं, यह आपको 98 तक ले आता है।

— Kade

@ Vioz- धन्यवाद, मुझे नहीं पता था कि मैं ऐसा कर सकता हूं :)

— कमेहामे

Answer 9

सीजेएम, 28 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो स्टैक से दो-आयामी सरणी पॉप करता है और बदले में चल तत्वों की एक सरणी छोड़ता है।

समर्थित ब्राउज़रों में, आप CJam दुभाषिया में एक बार में सभी परीक्षण मामलों को सत्यापित कर सकते हैं ।

परीक्षण के मामलों

कोड

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

इनपुट

[[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]]

उत्पादन

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

यह काम किस प्रकार करता है

यदि A और B सरणियाँ हैं और avg (A) g avg (B) हम केवल यह जाँचते हैं कि B g {theavg (A), + 1,…, (avg (B) ⌉-1} गैर-रिक्त है या नहीं। इस चौराहे के किसी भी तत्व को दोनों औसत बढ़ाने के लिए B से A तक ले जाया जा सकता है ।

{          }%              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.

यह सरणी के सभी तत्वों के उच्च औसत के साथ धक्का देता है जिसे दोनों औसत बढ़ाने के लिए ले जाया जा सकता है। यदि यह परिणाम प्राप्त करने के लिए किसी भी तत्व को स्थानांतरित नहीं किया जा सकता है तो ही यह सरणी खाली / गलत है।

Answer 10

रूबी, 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]}}

इनपुट के रूप में दो ऐरे युक्त एक सरणी लेता है।

समूह से एक उप औसत आइटम खोजने की कोशिश करता है जो दूसरे समूह के औसत से अधिक है।

टेस्ट: http://ideone.com/444W4U

Comments

बिना किसी सूचना के इस पर काम करना शुरू कर दिया, पहले से ही एक रूबी समाधान था, कुछ बहुत ही समान के साथ समाप्त हो गया, लेकिन यह दो कम वर्णों को नेट करता है मान लें कि फ़ंक्शन पहली सूची 'बेहतर' है, फिर स्वयं को दूसरे तरीके से कॉल करें। f=->a,s=1{i,j=a.map{|x|x.inject(0.0,:+)/x.size};a[0].any?{|y|i>y&&j<y}||s&&f[b,a,p]}

— २२:५२ पर histocrat

@ हिस्टोक्रेट अच्छा तरीका! मुझे bहालांकि वैरिएबल के बारे में NameError मिलता है । मुझे लगता है कि पुनरावर्ती कॉल कुछ ऐसा होना चाहिए f[a.rotate,p]।

— क्रिस्टियन लुपस्कू

उफ़, इसलिए मुझे धोखा देकर, एक बेहतर स्कोर मिला।

— हिस्टोक्रेट

Answer 11

मतलब, ५४

एक अनाम फ़ंक्शन का उपयोग करना:

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 = 
    @(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

Answer 12

सी #, 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);}

उदाहरण कॉल:

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})

Answer 13

सी ++ 14, 157 बाइट्स

अनाम लैम्ब्डा के रूप में, अंतिम पैरामीटर द्वारा लौटाया जाता है r। मान लिया गया है A, Bकी तरह कंटेनर होने के लिए vector<int>या 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);}

Ungolfed:

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);
}
;

उपयोग:

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;
}