Son zamanlarda cevapsız kalan Diffy oyunları hakkında bir soru yayınladım . Sorun değil, soru gerçekten zor, ama topun yuvarlanabilmesi için Diffy oyunları hakkında daha kolay bir soru yapmak istiyorum.

Diffy nasıl çalışır?

Diffy Oyunları Bul kopyalandı

Diffy oyunu aşağıdaki gibi çalışır: Negatif olmayan tam sayıların bir listesiyle başlarsınız, bu örnekte kullanacağız

3 4 5 8

Sonra bitişik sayılar arasındaki mutlak farkı alırsın

 (8)  3   4   5   8
    5   1   1   3

O zaman tekrar et. Bir döngü girdiğinizi fark edinceye kadar tekrar edersiniz. Ve sonra genel olarak oyun yeniden en baştan başlar.

3 4 5 8
5 1 1 3
2 4 0 2
0 2 4 2
2 2 2 2
0 0 0 0
0 0 0 0

Oyunların çoğu, kaybedilen bir durum olarak kabul edilen tüm sıfırlardan oluşan bir diziyle sona erer, ancak nadir birkaç oyun daha büyük döngülere takılır.

Görev

Bir Diffy oyununun başlangıç ​​durumu göz önüne alındığında, oyunun sonunda tüm sıfırların durumuna ulaşıp ulaşmadığını belirleyin. İki durumun her biri için bir Truthy veya Falsy değeri vermelisiniz. Hangisi önemli değil ki hangisidir?

Amaç, kaynağınızdaki bayt sayısını en aza indirmektir.

Pyth, 6 bayt

suaV+e

Test odası

Bu program çok uygundur. 0 (falsy) tüm sıfırları ifade eder, başka bir şey (gerçeği) tüm sıfırları ifade etmez.

Nasıl çalışır:

suaV+e
suaV+eGGGQ    Variable introduction.
 u       Q    Apply the following function repeatedly to its previous result,
              starting with the input. Stop when a value occurs which has
              occurred before.
  aV          Take the absolute differences between elements at the same indices of
        G     The previous list and
    +eGG      The previous list with its last element prepended.
s             The repeated value is returned. Sum its entries. This is zero (falsy)
              if and only if the entries are all zero.

Mathematica, 52 bayt

1>Max@Nest[Abs[#-RotateLeft@#]&,#,Max[1+#]^Tr[1^#]]&

Giriş ve geri dönüş olarak negatif olmayan tam sayıların bir listesini alarak saf işlev Trueveya False.

Abs[#-RotateLeft@#]&farklı oyunun bir turunu yürüten bir fonksiyondur. (Teknik olarak bu olmalı RotateRight, ama nihai cevap etkilenmedi ve hey, serbest bayt.) Böylece farklı oyunun turlarını Nest[...,#,R]yürütür ve sonucun tamamen sıfır olup olmadığını tespit eder.R1>Max@

Kaç tane farklı oyun turu Ryapacağımızı nasıl bilebiliriz? Girdideki men büyük değer buysa , mkaç tur yaptığımızdan bağımsız olarak asla bir tam sayı üretmeyeceğimize dikkat edin . Uzunlukta listelerin toplam sayısı lnegatif olmayan tamsayılar tüm sınırlanmış mDİR (m+1)^l. Bu yüzden (m+1)^l, zorlu oyunun turlarını gerçekleştirirsek, o zamana kadar iki kez bir liste görmemiz garantilidir ve dolayısıyla oyunun periyodik bölümünde olacaktır. Özellikle, eğer oyunun sonuçlarının (m+1)^ltümü sıfır listesindeyse, oyun tüm sıfırlarda biter . Bu ifade Max[1+#]^Tr[1^#]hesaplar.

Jöle , 13 bayt

Ṁ‘*L
ṙ1ạ
ÇÑ¡Ṁ

Tüm sıfır durumuna ulaşılacaksa 0 (falsey) çıkışı verir, aksi takdirde bir gerçek değer (pozitif bir tamsayı) döndürülür.

Çevrimiçi deneyin!

Kullanım ilk gözlem , Greg Martin tarafından yapılan bir dizi içindeki sayılar alan bırakmak asla bu [0, m] m çok performans, giriş maksimal elemanıdır (m + 1) ^L mermi l girişin uzunluğu isteği yeterli durumdadır.

Nasıl?

Ṁ‘*L - Link 1, number of rounds to perform: list a
Ṁ    - maximum of a
 ‘   - incremented
   L - length of a
  *  - exponentiate

ṙ1ạ - Link 2, perform a round: list x
ṙ1  - rotate x left by 1
  ạ - absolute difference (vectorises) with x

ÇÑ¡Ṁ - Main link: list a
  ¡  - repeat:
Ç    -     the last link (2) as a monad
 Ñ   -     the next link (1) as a monad times
   Ṁ - return the maximum of the resulting list

PHP, 144 Bayt

sıfır için 0, true için herhangi bir pozitif tamsayı değeri için 0 yazdır

<?for($r[]=$_GET[0];!$t;){$e=end($r);$e[]=$e[$c=0];for($n=[];++$c<count($e);)$n[]=abs($e[$c-1]-$e[$c]);$t=in_array($n,$r);$r[]=$n;}echo max($n);

Çevrimiçi sürüm

Expanded

for($r[]=$_GET;!$t;){
    $e=end($r);  # copy last array
    $e[]=$e[$c=0]; # add the first item as last item
    for($n=[];++$c<count($e);)$n[]=abs($e[$c-1]-$e[$c]); # make new array
    $t=in_array($n,$r); # is new array in result array
    $r[]=$n; # add the new array
}
echo max($n); # Output max of last array

R (3.3.1), 87 bayt

Tüm sıfırlarda biten bir oyun için sıfırı, aksi takdirde pozitif bir sayı döndürür.

z=scan();sum(Reduce(function(x,y)abs(diff(c(x,x[1]))),rep(list(z),max(z+1)^length(z))))

Greg Martin tarafından aynı gerçeğe dayanır ve farkları çözmek için yerleşik farkları kullanır.

Röda , 80 bayt

f l...{x=[{peek a;[_];[a]}()|slide 2|abs _-_];[sum(x)=0]if[x in l]else{x|f*l+x}}

Çevrimiçi deneyin!

Ungolfed:

function f(l...) { /* function f, variadic arguments */
    x := [ /* x is a list of */
        { /* duplicate the first element of the stream to the last position */
            peek a /* read the first element of the stream */
            [_]    /* pull all values and push them */
            [a]    /* push a */
        }() |
        slide(2) | /* duplicate every element except first and last */
        abs(_-_)   /* calculate the difference of every pair */
    ]
    /* If we have already encountered x */
    if [ x in l ] do
        return sum(x) = 0 /* Check if x contains only zeroes */
    else
        x | f(*l+x) /* Call f again, with x appended to l */
    done
}

05AB1E , 13 bayt

İade 1 o sıfır biter ve eğer 0 aksi.

Z¹g*F¤¸ì¥Ä}_P

Çevrimiçi deneyin!

açıklama

Üst mermi sınırını kullanır: yorum bölümünde xnormax(input)*len(input) tarafından açıklanmıştır .

Z              # get max(input)
 ¹g            # get length of input
   *           # multiply
    F          # that many times do:
     ¤         # get the last value of the current list (originally input)
      ¸        # wrap it
       ì       # prepend to the list
        ¥      # calculate deltas
         Ä     # calculate absolute values
          }    # end loop
           _   # negate each (turns 0 into 1 and everything else to 0)
            P  # calculate product

J, 22 bayt

Tüm sıfırlarda biten bir yozlaşmış oyun için döndürür 0(ki falseJ'de etkilidir ). İade 1( true) inci yineleme sıfır olmayan bir sayı içerir, burada n listenin uzunluğu ile çarpımı orijinal dizi büyük tam sayıya eşit ise. Bunun neden doğru olduğunu açıklayan Greg Martin'in cevabına bakınız .

*>./|&(-1&|.)^:(#*>./)

Çeviri:

• İşaret nedir *
• en değerli >./
• Aşağıdakileri istediğiniz kadar yinelediğinizde ^:( )
• listenin uzunluğu listedeki en büyük değerle #çarpılır : *>./
  • mutlak değerini almak |&arasında
  • liste (- )ile arasındaki fark
  • liste bir döndürülmüş 1&|.

Örnekler:

   *>./|&(-1&|.)^:(#*>./) 1 1 0
1
   *>./|&(-1&|.)^:(#*>./) 42 42 41
1
   *>./|&(-1&|.)^:(#*>./) 3 4 5 8
0
   *>./|&(-1&|.)^:(#*>./) 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 1
0

JavaScript (ES6), 95 92 90 bayt

f=(a,b=(Math.max(...a)+1)**(c=a.length))=>b?f(a.map((v,i)=>v-a[++i%c]),b-1):a.every(v=>!v)

açıklama

Sayaç (listedeki maksimum değerden başlayarak artı bir listenin [ = (max + 1)**length] uzunluğunun gücünden biri) başlayan sürece kendini tekrarlayan işlev sıfır değildir. Her aramada, sayaç azalır ve sıfıra geldiğinde listedeki tüm öğeler sıfıra karşı kontrol edilir. Hepsi sıfıra eşitse, program geri döner trueve falseaksi halde.

PHP, 123 115

for($a=$_GET,$b=[];!in_array($a,$b);){$b[]=$c=$a;$c[]=$c[0];foreach($a as$d=>&$e)$e=abs($e-$c[$d+1]);}echo!max($a);

HTTP ile giriş almak örneğin ?3&4&5&8, birkaç bayttan tasarruf sağlar.

Tüm sıfırlara ulaşırsa veya başka bir şey yapmazsa 1 yazdırır.

for($e=$argv,$r=[];!in_array($e,$r);$q=$e[0]){$e[0]=end($e);$r[]=$e;foreach($e as$k=>&$q)$q=abs($q-$e[$k+1]);}echo!max($e);

Argümanlar listesini komut satırından alır. Bunun daha da golf oynayabileceği hissine kapıldım (@Titus'a bakarak).

Python 3.6, 101 bayt

def f(t):
 x={}
 while x.get(t,1):x[t]=0;t=(*(abs(a-b)for a,b in zip(t,t[1:]+t[:1])),)
 return any(t)

Sayıların bir demetini alır ve sıfırlarla bitiyorsa False, dönerse True ile döner.

JavaScript (ES6), 84 83 bayt

İade true, tümü sıfır ile biten bir oyun için falsebaşka türlü.

f=(a,k=a)=>k[b=a.map((n,i)=>Math.abs(n-a[(i||a.length)-1]))]?!+b.join``:f(k[b]=b,k)

Ölçek

f=(a,k=a)=>k[b=a.map((n,i)=>Math.abs(n-a[(i||a.length)-1]))]?!+b.join``:f(k[b]=b,k)

console.log(f([3,4,5,8])); // ends in zeros
console.log(f([1,0,1]));   // does not end in zeros
console.log(f([7]));       // ends in zeros