Golf dizisi miyim?


18

Tanım ve Kurallar

Bir Golfy dizi her bir eleman olan tamsayılar bir dizi olduğu için eşit ya da daha yüksek, daha önceki elemanlarının her aritmetik ortalaması. Göreviniz girdi olarak verilen bir dizi pozitif tam sayının golf olup olmadığını belirlemektir.

Test Kutuları ve Örnek

Örneğin, aşağıdaki dizi:

[1, 4, 3, 8, 6]

Golfçü bir dizidir, çünkü her terim kendisinden önce gelenlerin aritmetik ortalamasından yüksektir. Adım adım çalışalım:

Sayı -> Önceki öğeler -> Ortalama -> Kuralı izliyor mu?

1 -> [] -> 0,0 -> 1 ≥ 0,0 (Doğru)
4 -> [1] -> 1,0 -> 4 ≥ 1,0 (Doğru)
3 -> [1, 4] -> 2,5 -> 3 ≥ 2,5 (Doğru)
8 -> [1, 4, 3] -> 2. (6) -> 8 ≥ 2. (6) (Doğru)
6 -> [1, 4, 3, 8] -> 4.0 -> 6 ≥ 4.0 (Doğru)

Tüm unsurlar koşula saygı gösterir, bu nedenle bu bir golf dizisidir. Bu zorluğun amacı için, boş bir listenin ( []) ortalamasının olduğunu varsayacağız 0.

Daha fazla test örneği:

Giriş -> Çıkış

[3] -> Doğru
[2, 12] -> Doğru
[1, 4, 3, 8, 6] -> Doğru
[1, 2, 3, 4, 5] -> Doğru
[6, 6, 6, 6, 6] -> Doğru
[3, 2] -> Yanlış
[4, 5, 6, 4] -> Yanlış
[4, 2, 1, 5, 7] -> Yanlış
[45, 45, 46, 43] -> Yanlış
[32, 9, 15, 19, 10] -> Yanlış

Bu CodeGolf-Hackathon gelen Puzzle 1 olduğunu ve aynı zamanda Anarchy Golf (ki kırık) yayınlanmıştır unutmayın - Histokrat tarafından yeniden , ama ben her iki sitede orijinal yazar ve böylece onları burada yeniden göndermenize izin.


Girdi her zaman pozitif tamsayıların bir listesi midir?
Kelly Lowder

@KellyLowder Evet.
Bay Xcoder

Bu eğlenceli bir problem, Anarchy Golf'te daha fazla test senaryosuyla yeniden yayınlamayı düşünüyordum ama bunun üzerinde çalışabileceğini düşündüm.
histokrat

@histocrat Devam et ve Anarchy Golf'e geri gönder, önce sömürülebilecek şeyleri düşünmeliydim. İlginç bulduğunuz için oldukça memnunum (Btw lütfen bana burada ping atın ve tekrar gönderirseniz bir bağlantı verin).
Bay Xcoder

3
@streetster Bunlar denk. Sum / i> x Sum ile aynıdır> xi Sum + x ile aynıdır x (i + 1) (Sum + x) / (i + 1)> x ile aynıdır.
histokrat

Yanıtlar:


13

Python 2 , 37 bayt

def g(a):sum(a)>len(a)*a.pop()or g(a)

Çevrimiçi deneyin!

Çıkış kodu ile çıkışlar: Golf dizileri için çökmeler (çıkış kodu 1), sadece golf olmayan diziler için çıkış kodu 0 ile çıkar. ovs ve Jonathan Frech 3 bayt kurtardı.

Python 2 , 44 bayt

f=lambda a:a and sum(a)<=len(a)*a.pop()*f(a)

Çevrimiçi deneyin!

TrueGolf dizileri için geri dönen daha geleneksel bir varyant False. Jonathan Frech 2 bayt kurtardı.


1
Bence a==[]orolabilir a and.
Jonathan Frech

2
Bu aslında zekidir - sum(a)<=len(a)*a.pop()*[]temel durum için ortaya çıkar , ki bu her zaman doğrudur int < list!
Lynn

3
39 bayt , doğru girdiler için çöküyor.
ovs

1
@ovial işlevi kullanarak 37 bayt .
Jonathan Frech

11

Jöle , 6 5 bayt

<ÆmƤE

Çevrimiçi deneyin!

Nasıl çalışır

<ÆmƤE  Main link. Argument: A (integer array)

 ÆmƤ   Compute the arithmetic means (Æm) of all prefixes (Ƥ) of A.
<      Perform element-wise comparison. Note that the leftmost comparison always
       yields 0, as n is equal to the arithmetic mean of [n].
    E  Test if all elements of the resulting array are equal, which is true if and
       only if all comparisons yielded 0.

cairdcoinheringaahing's 6-byter (alternatif):ÆmƤµ⁼Ṣ
Bay

@ Mr.Xcoder Golf Yaptı!
Dennis

Vay be bu parlak :-)
Bay Xcoder

5

JavaScript (ES6), 33 32 bayt

a=>a.some(e=>e*++i<(s+=e),s=i=0)

Kod, gibi negatif değerler üzerinde de çalışır [-3, -2]. Diğer diziler için falsegolfy dizisi döndürür true. Düzenleme: @JustinMariner sayesinde 1 bayt kaydedildi.


1
!Spesifikasyon sadece iki farklı değer istediğinden , bırakabilirsiniz, bu yüzden falsegolfy dizisi olduğunda geri dönmek iyidir.
Justin Mariner


4

MATL , 9 8 bayt

tYstf/<a

Aksi halde 0, golf dizileri için çıkışlar 1.

Çevrimiçi deneyin!

açıklama

Girişi düşünün [1, 4, 3, 8, 6].

t    % Implicit input. Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 4, 3, 8, 6]
Ys   % Cumulative sum
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22]
t    % Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 5, 8, 16, 22]
f    % Find: indices of nonzeros. Gives [1, 2, ..., n], where n is input size
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 2, 3, 4, 5]
/    % Divide, element-wise
     % STACK: [1, 4, 3, 8, 6], [1, 2.5, 2.6667, 4, 4.4]
<    % Less than?, element-wise
     % STACK: [0, 0, 0, 0, 0]
a    % Any: true if and only there is some nonzero. Implicit display
     % STACK: 0

4

Haskell , 53 50 48 bayt

and.(z(<=).scanl1(+)<*>z(*)[1..].tail)
z=zipWith

Çevrimiçi deneyin!

Düzenleme: Zgarb sayesinde -3 bayt!

açıklama

Yukarıdaki noktadan bağımsız sürüm aşağıdaki programa eşdeğerdir:

f s = and $ zipWith(<=) (scanl1(+)s) (zipWith(*)[1..](tail s))

Bir giriş Verilen s=[1,4,3,8,6], scanl1(+)sönek toplamlarını hesaplar [1,5,8,16,22]ve zipWith(*)[1..](tail s)ilk elemanı ve çoğalır onların indeksi diğer tüm unsurlar düşer: [4,6,24,24]. Listede olan golfy İkili önek toplamları küçüktür veya iki listeyi sıkıştırma kontrol edilebilir elemanlar kez endeksine eşit olursa (<=)ve tüm sonuçlar olduğunu kontrol Trueile and.


1
Sen tip hatayı önlemek böyle .
Zgarb

@Zgarb Gez, bu bariz çözüm. İşaret ettiğiniz için teşekkürler!
Laikoni

3

C # (Görsel C # Derleyici) , 71 + 18 = 89 bayt

x=>x.Select((n,i)=>new{n,i}).Skip(1).All(y=>x.Take(y.i).Average()<=y.n)

için ek 18 bayt using System.Linq;

Çevrimiçi deneyin!


2
Siteye Hoşgeldiniz! :)
DJMcMayhem

Genel olarak, ithalat beyannameleri kod golfü içerisinde ücretsiz kabul edilmez. Bu, ifadeyi gerektirdiğinden, using System.Linq;gerçekte 89 bayt olur, bazen "71 + 18 = 89" olarak ifade edilir, ancak 18 baytın gerekli olduğunu ancak çözümün bir parçası olmadığını gösterirken, son sayının başlık satırındaki son sayı olduğunu gösterir ( bazı otomatik ayrıştırıcılar için yararlıdır).
Kamil Drakari

3

APL (Dyalog) , 10 bayt

Bu anonim bir zımni önek fonksiyonudur (APL açısından monadik tren olarak adlandırılır).

∧/⊢≥+⍳∘≢

TIO'daki tüm test senaryolarını deneyin!

bu mu

∧/ tamamen doğru

 elementler

 büyük veya eşit

+\ kümülatif toplamlar

÷ bölü

   1 ile 1 arasındaki tamsayılar

   the

   eleman sayısı

?


APL'nin "the" sembolü var ??
user2390246

1
@ user2390246 şeyleri "kedileri say" da "bağlanır" gibi birbirine bağlanır. Buna gerçekten Compose denir .
Adám

3

C (gcc) , 62 60 62 bayt

  • İki gereksiz parantez kaldırıldı.
  • İşlevin yeniden kullanılabilirliğini ( b=) düzeltmek için iki bayt eklendi .
f(A,S,k,b)int*A;{for(S=k=b=0;*A;S+=*A++)b+=!(S<=*A*k++);b=!b;}

Çevrimiçi deneyin!


3

05AB1E , 5 bayt

ηÅA÷W

Çevrimiçi deneyin!

Dennis ve Adnan'ın kapsamlı yardımı bu indirgenmiş versiyona ulaştı. Ayrıca bunu mümkün kılmak için bir hata düzeltildi, tekrar teşekkürler çocuklar. Bu cevap için çok az kredi alıyorum.


05AB1E , 10 bayt

ηεÅA}ü.S_P

Çevrimiçi deneyin!


Uzun çünkü DgsO/05AB1E'de "ortalama" nın eşdeğeridir.

Görünüşe göre ÅAaritmetik ortalama.


Ortalamaları hesaplamak için Jelly'de +\÷J(birikimli toplamı indekslere bölerim) kullanırdım. 05AB1E'de o kadar kolay değil mi? Düzenleme: Nevermind.
Dennis

@Dennis ah, 05AB1E'deki kümülatif toplam, dizi uzunluğunu elde etmek, ortalamayı almak için itmek ve bölmek, diğer bir deyişle hala 5 bayt ü+olmaktan başka endekslerle hiçbir divi yoktur . gL1,2,...,n
Sihirli Ahtapot Urn

.S_<=herhangi bir fikir lmk varsa, gitmek için UZUN bir yoldur .
Sihirli Ahtapot Urn

÷WBunun yerine çalışır mıydı ü.S_P?
Dennis

1
Ah, @Adnan sadece bir vektörelleştirmeyi sabit ÅAyüzden, ηÅA÷Wşimdi çalışıyor.
Dennis


2

PowerShell , 60 bayt

param($a)$o=1;$a|%{$o*=$_-ge($a[0..$i++]-join'+'|iex)/$i};$o

Çevrimiçi deneyin!

Girdiyi değişmez dizi olarak alır (ör . @(1, 4, 3, 8, 6)) $a. $oUtput değişkenimizi olarak ayarlar 1. Sonra dönüyor $a. Her yinelemede, (ab) PowerShell'in *=, $oiştirakimizle bir Boole karşılaştırmasının sonucuna örtülü dökümünü kullanıyoruz. Boolean, mevcut değerin $_, önceden eklenen önceki terimlere ( ) -ggöre daha düşük veya normal olup olmadığı, daha önce gördüğümüz terimlere bölünüp bölünmediğidir . Yani, yol boyunca herhangi bir adım yanlışsa, o zamane$a[0..$i++]-join'+'|iex$i$o0 . Aksi takdirde, 1boyunca kalacaktır .

Daha sonra basitçe $oboru hattına yerleştiriyoruz ve çıktı örtük. 1doğruluk ve falsey 0için.




2

Cubix , 35 bayt

/I?/\+psu0^.\)*sqs;-\;;U;O1.....?@^

Çevrimiçi deneyin!

Alanın en verimli kullanımı değil (kodda 6 adet ops yok) Golf dizisi için, golf dizisi için çıkış 1üretmez.

Aşağıdaki kübü genişletir:

      / I ?
      / \ +
      p s u
0 ^ . \ ) * s q s ; - \
; ; U ; O 1 . . . . . ?
@ ^ . . . . . . . . . .
      . . .
      . . .
      . . .

Açıklama gelecek, ancak temelde Luis Mendo'nun MATL yanıtı veya Dennis ' Julia yanıtı gibi bir şey ifade ediyor .

Kaçışını izle!



2

SQL (MySQL), 68 bayt

select min(n>=(select ifnull(avg(n),1)from t s where s.i<t.i))from t

Çevrimiçi deneyin!

İade 1 Golfy diziler için ve 0 aksi. Adlandırılmış bir tablodan girdi alır , t. Oluşturmak için şunu tçalıştırın:

CREATE TABLE t(i SERIAL,n INT)

ve değerleri yüklemek için:

truncate table t;insert into t(n)values(3),(2);


1

Python 2 , 52 bayt

lambda A:all(k*j>=sum(A[:j])for j,k in enumerate(A))

Çevrimiçi deneyin!

Python 2 , 50 48 44 42 bayt

  • Satır içi ve kullanarak iki bayt kaydedildi and.
  • Zincirleme görevi ile Bay Xcoder sayesinde iki bayt kurtardıS=k=0 .
  • Kullanarak iki bayt orve karşılaştırmanın boolean değerini kartış değeri olarak kaydetti.
  • Ovs sayesinde iki bayt kurtardı ; a NameErroryerine tanımsız değişken kullanarak a yükseltmek ZeroDivisionError.
S=k=0
for j in input():k+=S<=j*k or J;S+=j

Çevrimiçi deneyin!


Alternatif sürümünüz için 46 bayt .
Bay Xcoder

@ Mr.Xcoder Teşekkürler.
Jonathan Frech


@ovs Teşekkürler; bir istisna oluşturmak için düzgün bir bayt yolu.
Jonathan Frech

1

q / kdb + , 14 bayt

Çözüm:

min x>=avgs x:

Örnekler:

q)min x>=avgs x:1 4 3 8 6
1b                           / truthy
q)min x>=avgs x:4 2 1 5 7
0b                           / falsey

Açıklama:

avgsDahili ile oldukça basit :

min x>=avgs x: / solution
            x: / store input in variable x
       avgs    / calculate running averages
    x>=        / array comparison, x greater than running average
min            / take minimum of list of booleans


1

R , 38 34 bayt

function(x)any(cumsum(x)/seq(x)>x)

Çevrimiçi deneyin!


çok hoş. Neden daha önce bir R cevabı yoktu ...
Giuseppe

Hepiniz benim için kolay olanı kurtarıyordunuz.
ngm

yişlev argümanlarında tanımlamak yerine, cumsum(x)doğrudan kullanmak 4 bayt daha kısadır. cummeanR üssünde mevcut olmayan bir utanç
Giuseppe

1

++ , 54 bayt ekle

D,g,@@#,BFB
D,k,@,¦+AbL/
D,f,@,dbLR$€g€k0b]$+ABcB]£>ª!

Çevrimiçi deneyin!

Orijinal olmayan sürüm, 30 bayt

D,f,@,¬+AbLRBcB/@0@B]ABcB]£>ª!

Çevrimiçi deneyin!

Her ikisi de golf dizileri için çıkış 1 , aksi takdirde 0

Onlar nasıl çalışır

İlk sürüm, başka çözümleri kontrol etmeden benim tarafımdan oluşturuldu. İkincisi Dennis'in yorumundan ilham aldı , bu yüzden bundan daha az memnunum.

İlk sürüm

Burada ana fonksiyonumuzu tanımlıyoruz fgirdi dizimizin golfitesini hesaplayan ,bir. İlk olarak, son eklerini vermemiz gerekir.bir, ilk önce aralık üretilerek yapılır B: =[1,...|bir|], nerede |bir| uzunluğunu gösterir bir. Bu kod ile yapılır dbLR$hangi yaprakları,[B,bir]yığını olarak. Daha sonra ikili fonksiyonu tekrarlıyoruzg over these two lists. Being dyadic, the function binds its left argument as A for each iterated element. It then iterates over the range B, which each element from B being the right argument provided to g. g is defined as

D,g,@@#,BFB

which is a dyadic function (i.e. takes 2 arguments), and pushes its arguments to the stack in reversed order (#) before execution. BF then flattens the two arguments. We'll assume that the arguments are A and ex. This leaves the stack as [...A,e], where ... represents an array splat. Finally, B takes the first e elements of A and returns a list containing those elements.

Note : The function names g and k aren't chosen randomly. If the commands given to an operator (such as ) doesn't currently have a function (which g and k don't), then the named functions are searched for a matching function. This saves 2 bytes, as normally the function would have to wrapped in {...} to be recognised as a user-defined function. At the time of writing, the currently unused single byte commands are I, K, U, Y, Z, g, k, l, u and w.

When g is applied over the elements of a range x, this returns a list of prefixes for A. We then map our second helper function k over each of these prefixes. k is defined as

D,k,@,¦+AbL/

which is the standard implementation of the arithmetic mean. ¦+ calculates the sum of the argument, AbL calculates its length, then / divides the sum by the length. This calculates the arithmetic mean of each prefix, yielding a new array, C.

Unfortunately, C contains the mean of A as its final element, and does not include the mean of the empty list, 0. Therefore, we would have to remove the final element, and prepend a 0, but popping can be skipped, saving two bytes, for reasons explained in a second. Instead, we push [0] underneath C with 0b]$, then concatenate the two arrays forming a new array, C+.

Now, we need to check each element as being less than its corresponding element in A. We push A once again and zip the two arrays together with ABcB]. This is the reason we don't need to pop the final element: Bc is implemented with Python's zip function, which truncates the longer arrays to fit the length of the shortest array. Here, this removes the final element of C+ when creating the pairs.

Finally, we starmap pA,qC+;p<q¬(pq) over each pair p,q to obtain an array of all 0s if the array is golfy, and array containing at least a single 1 if otherwise. We then check that all elements are falsey i.e. are equal to 0 with ª! and return that value.

The second version

This takes advantage of Dennis' approach to remove 24 bytes, by eliminating the helper functions. Given our input array of A, we first compute the cumulative sums with ¬+, i.e the array created from [A0,A0+A1,A0+A1+A2,...,A0+...+Ai]. We then generate Jelly's equivalent of J (indicies), by calculating the range B:=[1...|A|] where |A| once again means the length of the array.

Next, we divide each element in A by the corresponding index in B with BcB/ and prepend 0 with @0@B]. This results in a new array, C+, defined as

C+:=[0,A0,A0+A12,A0+A1+A23,...,A0+...+Aii+1]

The final part is identical to the first version: we push and zip A with C+, then starmap inequality over each pair before asserting that all elements in the resulting array were falsy.


0

Pyth, 11 10 bytes

-1 byte thanks to Mr. Xcoder

.A.egb.O<Q

Try it online!


7 bytes: SI.OM._ (port of cairdcoinheringaahing's solution from Jelly, by Erik the Outgolfer), or 10 bytes using your approach: .A.egb.O<Q
Mr. Xcoder

Post the port as yourself, it's a totally different approach!
Dave

0

Java (OpenJDK 8), 96 bytes

I know it's not a good golfing language, but I still gave it a go!

Input array as first argument of comma separated ints to test.

Returns 1 for true, 0 for false.

a->{int i=1,j,r=1,s=0;for(;i<a.length;i++,s=0){for(j=0;j<i;s+=a[j++]);r=s/i>a[i]?0:r;}return r;}

Try it online!


0

Java 7, 100 bytes

Golfed:

int g(int[]a){int i=1,m=0,s=m,r=1;for(;i<a.length;){s+=a[i-1];m=s/i;r-=a[i++]<m&&r>0?1:0;}return r;}

Ungolfed:

int golfy(int[]a)
{
    int i = 1, m = 0, s = m, r = 1;
    for (; i < a.length;)
    {
        s += a[i-1];
        m = s / i;
        r -= a[i++] < m && r>0? 1 : 0;
    }
    return r;
}

Try it online

Returns 0 for ungolfy and 1 for golfy arrays. Slightly longer than java 8 answer.


0

PHP, 44 bytes

while($n=$argv[++$i])$n<($s+=$n)/$i&&die(1);

takes input from command line arguments, exits with 0 (ok) for a golfy array, with 1 else.

Run with -nr or try it online.


0

J, 19 bytes

[:*/[>:[:}:0,+/\%#\

+/\ % #\ averages of the prefixes: #\ produces 1..n

}:0, add 0 to the beginning and remove the last

[>: is the original list element by element >= to the shifted list of averages?

*/ are all the elements greater, ie, the previous list is all 1s?

Try it online!



0

Japt, 10 bytes

Came up with two 10 byte solutions, can't seem to improve on that.

eȨU¯Y x÷Y

Try it


Explanation

               :Implicit input of array U
eÈ             :Is every element, at 0-based index Y
  ¨            :Greater than or equal to
   U¯Y         :U sliced from index 0 to index Y
        ÷Y     :Divide each element by Y
       x       :Reduce by addition

Alternative

eÈ*°Y¨(T±X

Try it

               :Implicit input of array U
eÈ             :Is every element X (at 0-based index Y)
  *°Y          :Multiplied by Y incremented by 1
     ¨         :Greater than or equal to
      (T±X     :T (initially 0) incremented by X
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.