Bir listenin ortalamasını alma (ör. [2,6,7])

• Listenin uzunluğunu öğrenin: [2,6,7] -> 3
• Listedeki sayılarını toplamak: 2 + 6 + 7 = 15.
• Onların sayısı ile toplamı bölün: 15 / 3 = 5.

N daha yüksek bir ortalamaya sahipse bir değer, M daha yüksek bir ortama sahipse başka bir değer ve bir kravat olması durumunda başka bir değer döndürerek, N ve M pozitif tamsayıların iki listesinin ortalamalarını karşılaştırmalısınız .

G / Ç kuralları

Tüm standart Giriş ve Çıkış yöntemlerine izin verilir.

Giriş

Girdiyi iki ayrı liste, iç içe liste veya görev için uygun olduğunu düşündüğünüz herhangi bir şey olarak alabilirsiniz. Lütfen biçimi belirtin.

Çıktı

Sağlanan değerler farklı olmalı ve en az bir boşluk olmayan karakterden oluşmalıdır. Ayrıca, çalışmalar arasında tutarlı olmalıdırlar ( N için tek bir değer, M için tek bir değer, Tie için tek bir değer ). Lütfen cevabınızdakileri belirtin. Değerler boş olmayan Dizeler, Bool değerleri, Tamsayılar veya uygun olduğunu düşündüğünüz herhangi bir şey olabilir.

gözlük

• Listelerin uzunluğu eşit olmayabilir.

• Listelerin boş olmadığı garanti edilir.

Test Durumları

Ben değerleri seçti N wins, M winsve Tiehemen hemen aşikar olan,.

N, M -> Çıktı (Ortalamalar)

[7], [6] -> N kazanır (N'nin 7'si, M'nin 6'sı vardır)
[4,5], [4,4] -> N kazanır (N 4.5, M 4 var)
[2,3,4], [4,5,6] -> M kazanır (N 3, M 5)
[4,1,3], [7,3,2,1,1,2] -> Kravat (her ikisinde de 2.666 var ...)
[100,390,1], [89,82,89] -> N kazanır (N'nin 163.666 ..., M'nin 86.666 ...)
[92,892], [892,92] -> Kravat (listeler temelde aynıdır) 
[10,182], [12,78,203,91] -> Kravat (her ikisinde de 96 var)

Varsayılan Loopholes uygulanır. Açıklamalar teşvik edilir! Bu kod golf , bu yüzden bayt içindeki en kısa kod kazanır!

Aslında 5 bayt

♂æi-s

Çevrimiçi deneyin!

1için N > M, 0için N = M, -1için N < M.

Açıklama:

♂æi-s Takes input in format [N, M]
♂æ    Map average
  i   Dump to stack in reverse
   -  Subtract
    s Get sign

Mathematica, 15 bayt

Order@@Mean/@#&

Çevrimiçi deneyin!

Functionki bu iki listenin bir listesini bekliyor. Mean/@#girişteki her listenin aritmetik ortalamasını alır, sonra bu araçlar geçirilir Order, bu -1da ilk liste kazanırsa, 0bir kravat 1varsa ve ikinci liste kazanırsa geri döner .

JavaScript (ES6), 52 50 bayt

(@Shaggy sayesinde 2 bayt kaydedildi.)

İşte iki adet 50 baytlık çözüm:

f=(N,M,a=eval(N.join`+`)/N.length)=>M?(a-f(M))/0:a

(N,M,A=a=>eval(a.join`+`)/a.length)=>(A(N)-A(M))/0

İade Sonsuz N, için -Infinity M ve NaN bir bağ için.

İlk çözüm, özyineleme nedeniyle biraz açıklama gerektirebilir:

İşleve yapılan ilk çağrıda a, Ndizinin ortalaması olarak başlatılır :

a=eval(N.join`+`)/N.length

M bu noktada bir değere sahiptir, bu nedenle koşullu ifadenin ilk bölümüne şu ad verilir:

M ? (a-f(M))/0 : a  ----------    

İşlev, bu kez ikame bu ifade içinde adlandırılır Miçin N.

Bu ikinci işlev çağrısında, bir önceki açağrıdaki ortalama N–– olarak başlatılır M.

İşleve yapılan bu çağrı sırasında ikinci bir parametre olmadığından, koşullu ifadenin ikinci kısmı tetiklenir, bu da ortalamayı döndürür:

M ? (a-f(M))/0 : a  --

Şimdi ifadeyi daha iyi anlayabiliriz:

(a - f(M)) / 0

Onun:

(the average of N  minus  the average of M) divided by 0

Ortalamalar arasındaki fark pozitif bir sayı, negatif bir sayı veya 0 olacaktır.

Farkın 0'a bölünmesi, gerektiğinde üç farklı değer sağlayan Infinity , -Infinity veya NaN ile sonuçlanır .

Test Durumları:

f=(N,M,a=eval(N.join`+`)/N.length)=>M?(a-f(M))/0:a

console.log(f([7], [6]                 )) // N wins  (N has 7, M has 6 )
console.log(f([4,5], [4,4]             )) // N wins  (N has 4.5, M has 4)
console.log(f([2,3,4], [4,5,6]         )) // M wins  (N has 3, M has 5)
console.log(f([4,1,3], [7,3,2,1,1,2]   )) // Tie     (both have 2.666...)
console.log(f([100,390,1], [89,82,89]  )) // N wins  (N has 163.666..., M has 86.666...)
console.log(f([92,892], [892,92]       )) // Tie     (lists are basically identical) 
console.log(f([10,182], [12,78,203,91] )) // Tie     (both have 96)

Mathematica, 21 bayt

Sign[Mean@#-Mean@#2]&

#Galibiyet için 1, galibiyet için -1 #2, kravat için 0.

MATL , 8 bayt

Soooo birçok değiştirici ( Yve Z). Kısaltmanın bir yolunu bulamıyorum. sum / number_of_elementsüç bayttır. Bunu yapmanın daha iyi bir yolu olabilir -ZSama bir tane bulamıyorum.

YmiYm-ZS

Çevrimiçi deneyin!

           % Take first input implicitly
Ym         % Mean of that input
  i        % Grab second input
   Ym      % Mean of that input
     -     % Subtract
      ZS   % Sign

1İlk girişin daha büyük 0olup olmadığını, bağlandıklarını ve -1ikinci girişin daha büyük olduğunu döndürür .

05AB1E , 9 bayt

1. Eğer Mkazanç, -1 halinde Nkazanç ve 0 , bir bağ için.

vyOyg/}.S

Çevrimiçi deneyin!

açıklama

v           # for each y in list of lists
 yO         # sum y
   yg       # get length of y
     /      # divide
      }     # end loop
       .S   # compare

Julia , 27 bayt

(x,y)->cmp(mean(x),mean(y))

Çevrimiçi deneyin!

1İlk ortalamanın daha büyük, -1ikincisinin ise ve eşitse döndürür 0.

Python 2 , 43 bayt

lambda p:cmp(*[sum(l)*1./len(l)for l in p])

Çevrimiçi deneyin!

Oktav , 27 bayt

@(x,y)sign(mean(x)-mean(y))

Çevrimiçi deneyin!

İki vektörü x.ygirdi olarak alır, meanher iki vektörü de alır ve birini diğerinden çıkartır. Almak için, bu işaretini alın 1, 0ve -1üç farklı alternatifler.

Python 2, 49 bayt

lambda N,M:cmp(1.*sum(N)/len(N),1.*sum(M)/len(M))

Çevrimiçi deneyin

APL (Dyalog) , 11 bayt

İki listenin bir listesini ister. 1Solda daha yüksek ortalama varsa, aynı ortalamaya sahipse 0 ve sağda daha yüksek ortalama varsa yazdırır ¯1.

×-/(+/÷≢)¨⎕

Çevrimiçi deneyin!

⎕ Komut istemi

(...)¨  Her birine aşağıdaki tacit işlevini uygulayın:

 +/ toplam

 ÷ bölü

 ≢ taksitli

-/ aralarına eksi ekleyin (ve değerlendirin)

× işaret

Javascript, 81 66 58 56 bayt

Luke sayesinde 15 bayt tasarruf etti

Justin Mariner sayesinde 2 bayt kurtardı

n=>m=>Math.sign((a=b=>eval(b.join`+`)/b.length)(m)-a(n))

Bağ 0, M 1 ve N -1'dir. Currying sözdizimi kullanılarak çağrılır, örn.f([7])([6])

PHP , 68 bayt

<?foreach($_GET as$v)$r[]=array_sum($v)/count($v);echo$r[0]<=>$r[1];

Çevrimiçi deneyin!

PHP , 69 bayt

<?=($s=array_sum)($a=$_GET[0])/count($a)<=>$s($b=$_GET[1])/count($b);

Çevrimiçi deneyin!

uzay gemisi operatörü -1 daha az, 0 kravat, 1 daha büyük

Haskell, 65 43 Bayt

Nimi sayesinde 22 bayt kaydedildi!

a x=sum x/sum[1|_<-x] 
x#y=compare(a x)$a y

Daha iyi bir yol olmalı ... Ama tip dönüşümleri beni mahvetti.

kullanım

(#) [7] [6]

GTİlk argüman kazanırsa, LTikinci argüman kazanırsa ve bağlarsa döndürür EQ.

Çevrimiçi deneyin!

J, 10 bayt

*@-&(+/%#)

Bir liste solda, bir liste sağda verilmiştir. Sol ortalama daha küçükse _1, daha büyükse 1 ve eşitse 0 döndürür

• (+/%#) bir listenin ortalamasını hesaplamak için standart bir J çatalıdır
• &ikili çatal üzerinde bir varyasyon sağlar. her iki argümana da sağ tarafı (bu durumda ortalama fiil) uygular ve sonra bunları sol taraftaki fiile iletir, bu durumda ...
• *@- çıkartma ve ardından "işareti" ifadesi gelir: böylece sağ ortalama soldan çıkarılır ve sonucun işareti verilir - _1, 1 veya 0

Pyth, 10 8 7 6 bayt

Bir bayt kaydettiğiniz için @isaacg teşekkürler

._-F.O

Girdi iç içe bir liste olarak alınır [N, M],. Çıkışlar -1ise N < M, 1eğer N > Mve 0eşit iseler.

Çevrimiçi Deneyin

TI-Basic, 25 21 13 12 10 bayt

Lirtosiast sayesinde -2 bayt

:tanh(ᴇ9mean(L₁-mean(L₂

Jöle , 7 bayt

S÷Lµ€IṠ

İki listelerin bir listesini, kabul bir monadic bağlantı N,Mdöndürür:
[-1]için N;
[1]için M; ve
[0]bir kravat için.
O sonucu yazdırır tam bir program olarak (tek bir öğe listeleri yalnızca, bu nedenle içeriklerini yazdırmak -1, 1ya 0).

Çevrimiçi deneyin!

Nasıl?

S÷Lµ€IṠ - Link: list of lists, [N,M]
   µ€   - perform the chain to the left for €ach (of N, M)
S       -   sum
  L     -   length
 ÷      -   divide (yields the average)
     I  - incremental differences (yields [avg(M) - avg(N)])
      Ṡ - sign (yields: [1] if avg(M)>avg(N); [-1] if avg(N)>avg(M); or [0] if equal)

Perl 6 , 25 bayt

{sign [-] .map:{.sum/$_}}

Çevrimiçi deneyin!

Tek bir argüman alır, iki elemanlı sayı listelerini alır. 1İlk listenin ortalaması daha büyükse -1, ikinci liste 0varsa ve ortalamalar eşitse döndürür .

JavaScript (ES6), 60 bayt

a=>(b=(c=a.map(d=>eval(d.join`+`)/d.length))[0])-c[1])?b>0:0

0İçin Tie, trueiçin Nve falseiçin çıkışlar M.

JavaScript (ES6), 60 54 bayt

@Luke ve @Neil sayesinde -6 bayt

(i,[x,y]=i.map(v=>eval(v.join`+`)/v.length))=>y-x&&x>y

Girdiyi 2 elemanlı dizi olarak alır [N, M]. Çıkışlar true, 0ya falseiçin N, Tieya daM sırasıyla.

açıklama

(i,                 // input array: [N, M]
    [x,y] =         // destructure assignment: set x and y to...
    i.map(v=>       // the input values mapped as...
        eval(v.join`+`) // the sum, by joining the array with +
        / v.length      // divided by the length
    )
) => y-x && x>y     // return 0 for tie, or the result of avg(N) > avg(M)

Snippet'i Test Et

Boşluk / virgülle ayrılmış sayıları girin.

f=
(i,[x,y]=i.map(v=>eval(v.join`+`)/v.length))=>y-x&&x>y

<div oninput="O.value=f([N.value,M.value].map(x=>x.split(/[ ,]+/)))">N <input id=N> M <input id=M></div>
Out: <input id=O disabled>

Pip , 13 bayt

{$CM$+*a/#*a}

Bu, listelerin listesini alan bir işlevdir. İade 1ilk ortalaması, büyükse -1ikinci büyükse,0 . Tüm test senaryolarını burada çalıştırın.

Arka fon

Bu çözüm Pip'in iki metaoperatörünü yoğun olarak kullanıyor:

• $, katlayın. İkili bir işleç alıp listenin öğeleri arasına uygulayın. Örneğin +, ekleme, ancak $+bir liste toplar. Bunu not et$İkili bir işleci bir tekli işleci haline getiren bir .
• *, harita. Tekli bir operatör alın ve listenin her öğesine uygulayın. Örneğin #, bir listenin uzunluğunu verir, ancak#* listenin öğelerinin uzunluğunu (bir listesini) verir.
• Bu iki metaoperatör birleştirilebilir: $+*listenin her bir öğesinin toplandığı bir liste üzerinde katlanır / artı işaretler.

Pip hakkında bilinmesi gereken diğer bir şey, birçok operatörün listelerde varsayılan olarak çalıştığıdır. Örneğin, [1 2 3] * 5verir [5 10 15]; [1 2 3] * [2 3 4]verir [2 6 12]; ve [[1 2] [3 4]] * [5 6]verir[[5 10] [18 24]] .

açıklama

Örnek bir giriş kullanacağız [[2 3 4] [2 3 4 6]]:

• {...}
  Bir işlevi tanımlar. (İlk) argüman yerel değişkene bağlıdır a.
• #*a
  Harita #sublists uzunlukları alma, işlevin argümanı için. Sonuç:[3 4]
• a/#*a
  Alt listelerini ailgili uzunluklarına göre bölün (unsurlarını) . Sonuç:[[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  Harita $+sublists toplayarak, bu sonuca (ek üzerinde kat). Sonuç:[3 3.75]
• $CM$+*a/#*a
  Üzerinde katlayın CMveren -1, 0ya da 1(Python en gibi iki işlenen karşılaştırılmasına bağlı olarak cmp). Sonuç: -1(çünkü 3küçük3.75 ).

Pip'teki işlevleri, kimlik işlevini içeren ifadeler yazarak da tanımlayabilirsiniz _. Örneğin, _*_argümanını kareye alan bir işlevdir - sözdizimsel şeker {a*a}ve daha az bayt. Ancak, yorumlayıcının geçerli sürümünde metaoperator _ile çalışmasını engelleyen bir hata var *. Bu sabit tamamlandıktan sonra, bu çözüm olabilir 11 byte : $CM$+*_/#*_.

C (gcc), 91 98 bayt

u,v,j;f(x,y,a,b)int*a,*b;{for(u=v=0;x--;u+=a[x])for(j=0;j<y;)v+=b[j++];j=u*y-v;x=j>0?2:!j;}

C için yanlış bir yer ve muhtemelen bölünme gerektirmeyen tek cevap. En azından kod kaydırıcı olmadan görüntülenir.

İçin 0,1,2 Dönüş M>N, M=N, M<Nsırasıyla. Olarak girdi Alır length of M, length of N, M, N.

Brachylog , 8 bayt

⟨+/l⟩ᵐ-ṡ

Çevrimiçi deneyin!

Çıkışlar 1İlk liste daha büyük bir ortalama varsa, -1ikinci liste daha büyük bir ortalama vardır ve bir 0de bağlı olup olmadığını.

açıklama

     ᵐ        Map:
⟨   ⟩           Fork:
 +                Sum…
  /               …divided by…
   l              …length
       -      Subtract
        ṡ     Sign

Java, 105 bayt

s->s.stream().map(l->l.stream().reduce((i,j)->i+j).get()/l.size()).reduce((i,j)->Math.signum(i-j)).get();

İzin verilen girdilere göre iç içe bir liste alan Lambda.

Liste listesini akar, her ikisini de ortalamalarına dönüştürür, sonra farkın işaretini döndürür. 1ilk liste daha büyükse, -1ikinci liste daha büyükse, 0bir kravat için.

R 38 34 bayt

function(a,b)sign(mean(a)-mean(b))

Giriş olarak iki sayısal vektör alan fonksiyon. İlk liste ortalaması daha yüksekse 1, aynı ise 0, ikinci liste ortalaması daha yüksekse -1 değerini döndürür.

MATL , 6 bayt

Çok kaba olma! *

!-ssZS

Giriş yığını sırası:

M
N

Çıktı:

 1 = N wins  
-1 = M wins  
 0 = tie

Çevrimiçi deneyin!

!-ssZS
========
!           % transpose M
 -          % N - M^T using elementwise subtraction and implicit expansion
  s         % sum columns of the result
   s        % sum the resulting row vector
    ZS      % sign of the sum

_{* Bu cevap, herhangi bir fakir, savunmasız sayıya kaba davranılmaksızın golf edildi.}

Java (OpenJDK 8) , 76 62 bayt

a->b->Math.signum(a.average().orElse(0)-b.average().orElse(0))

Çevrimiçi deneyin!

Girdi herhangi bir şey olabileceğinden, girdi olarak almaya karar verdim IntStream. Bir standarda böyle bir giriş alabilirsiniz int[]ile Arrays.stream(array).

Çıktı 1"N kazancı", -1"M kazancı" ve 0kravat içindir.

kaydeder

• @Zircon ve @Xanderhall'ın içgörülerinden -14 bayt!

Dyalog APL, 14 bytes

×(-/(+/÷≢)¨∘⊢)

1 if the left is greater, ¯1 if the right is and 0 on tie.

How?

¨∘⊢ for each list

+/÷≢ calculate average (+/ sum ÷ divide by ≢ length)

-/ subtract the averages

× sign of the result

Common Lisp, 74 71 bytes

(defun g(x)(/(apply'+ x)(length x)))(defun f(x y)(signum(-(g x)(g y))))

Try it online!