Die Idee dazu stammt hauptsächlich aus dem ersten Quartal 2017 der BIO . Die Idee, diese Herausforderung zu posten, kam mir durch meine Herausforderung mit binären Sequenzen , da es vielen Leuten zu gefallen schien.

Dies ist auch die erste Herausforderung, die ich veröffentlicht habe, ohne sie in der Sandbox zu veröffentlichen. Ich werde es löschen, wenn es niemand mag.

Regeln

Geben Sie eine Folge von ternären Ziffern ein (Basis 3). Dies kann eine Zeichenfolge, ein Array oder der numerische Wert zusammen mit der Anzahl der vorangestellten Nullen sein.

Für jede Zeile im Dreieck wird eine Zeile darunter generiert, bis die letzte Zeile nur noch eine Ziffer enthält. Um eine Ziffer unter zwei anderen Ziffern zu finden, ist die Ziffer dieselbe wie zwei darüber, wenn diese beiden anderen Ziffern gleich sind. Andernfalls ist es die Ziffer, die keiner von beiden entspricht. Hier ist ein Beispiel:

0 0 1 2 0 1 2 2
 0 2 0 1 2 0 2
  1 1 2 0 1 1
   1 0 1 2 1
    2 2 0 0
     2 1 0
      0 2
       1

Es wird nur erwartet, dass Sie die letzte Zeile zurückgeben.

Machen Sie Ihren Code kurz.

Testfälle

0 -> 0
11 -> 1
10 -> 2
000 -> 0
012 -> 1
21102 -> 2
201021 -> 1
111111 -> 1
1020202020 -> 2
0212121210 -> 0

Schale , 9 Bytes

%3←ΩεẊo_+

Probieren Sie es online!

Erläuterung

Die Hauptidee besteht darin, die Zuordnung von zwei Ziffern zu einer als f (a, b) = (-ab)% 3 zu berechnen . Für Golfzwecke können wir das Modulo bis zum Ende aufschieben.

   Ωε       Apply the following function until the list is only one
            element in length.
     Ẋo       Apply the following function to pairs of adjacent values.
       _+       Add the two values and negate the result.
  ←         Take the first (and only) element of this list.
%3          Take it modulo 3.

Im Prinzip ist es auch möglich, das Ergebnis direkt zu berechnen, indem jedes Element mit dem entsprechenden Binomialkoeffizienten multipliziert wird und die Summe für Listen mit gerader Länge mit -1 multipliziert wird , aber ich kenne keine Möglichkeit, dies in weniger Bytes zu tun.

MATL , 10 Bytes

td"HYCEsI\

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Für jedes Ziffernpaar berechnet der Code das Doppelte der Summe Modulo 3. Der Vorgang wird so oft wie die Länge der Eingabe minus 1 wiederholt.

t        % Implicit input: array of length n. Duplicate
d        % Consecutive differences. Gives an array of length n-1
"        % For each (that is, do n-1 times)
  HYC    %   2-column matrix where each column is a sliding block of length 2
  E      %   Times 2, element-wise
  s      %   Sum of each column
  I\     %   Modulo 3
         % Implicit end. Implicit display

Python 2 , 48 Bytes

f=lambda a,*l:-(f(*l)+f(a,*l[:-1]))%3if l else a

Probieren Sie es online!

Rekursiert in den Unterlisten und löscht jeweils das erste und das letzte Element.

Dies wäre in Python 3 sauberer, wenn es tatsächlich entpackt werden könnte f=lambda a,*b,c:....

Emojicode , 242 Bytes

🐋🍨🍇🐖🔢➡️🚂🍇🔂i⏩➖🐔🐕1 0🍇🔂j⏩0i🍇🍊❎😛🍺🔲🐽🐕j🚂🍺🔲🐽🐕➕1j🚂🍇🐷🐕j➖➖3🍺🔲🐽🐕j🚂🍺🔲🐽🐕➕1j🚂🍉🍉🍉🍎🍺🔲🐽🐕0🚂🍉🍉

Verwendet den gleichen Algorithmus wie meine C-Antwort. Probieren Sie es online!

Gelee , 9 Bytes

+2\N$Ḋ¿%3

Probieren Sie es online!

Verwendung des Martin Ender-Husk-Algorithmus.

Haskell , 36 Bytes

f[a]=a
f(h:t)=mod(-f t-f(h:init t))3

Probieren Sie es online!

Spart 1 Byte gegenüber den symmetrischeren:

f[a]=a
f l=mod(-f(tail l)-f(init l))3

Probieren Sie es online!

Die Idee ist einfach: Berechnen Sie rekursiv die Funktion in den Unterlisten, indem Sie das erste und das letzte Element löschen und mit diesen kombinieren \a b -> mod(-a-b)3. Dies scheint kürzer zu sein als zipWithdiese Funktion.

Haskell , 44 Bytes

f[a]=mod a 3
f l=f$zipWith((-).(0-))l$tail l

Probieren Sie es online!

C (GCC) , 91 88 84 Bytes

-1 Byte Danke an @ Mr.Xcoder!

j;f(a,l)int*a;{for(;l-->1;)for(j=0;j<l;)a[j++]=a[j]^a[j+1]?3-a[j]-a[j+1]:a[j];a=*a;}

Ruft das Array und die Länge ab. Probieren Sie es online!

J, 23 15 Bytes

3&(|2+/\-)~<:@#

Vielen Dank an @miles

Alte Lösung:

3|2&(-@+/\)^:(#>1:)^:_]

Inspiriert von Martin Enders Lösung:

Erläuterung

3|2&(-@+/\)^:(#>1:)^:_]    | Whole program
                      ]    | Seperates the argument from the _ (infinity)
           ^:(#>1:)^:_     | Do while the length is greater than one
  2&(-@+/\)                | Inverse of the sum of adjacent elements
3|                         | Modulo 3

Batch, 122 Bytes

@set/an=2,s=i=l=0
@for %%e in (%*)do @set/al+=1,n^^=3
@for %%e in (%*)do @set/as+=%%e*n,s%%=3,n*=l-=1,n/=i+=1
@echo %s%

Verwendet Binomialerweiterung. Wie @MartinEnder hervorhebt, muss die Summe negiert werden (Modulo 3), wenn die Anzahl der Werte (die in der ersten Schleife gezählt werden) gerade ist, und daher nentweder 1oder 2entsprechend festgelegt werden. Die zweite Schleife berechnet dann die Summe über die Binomialkoeffizienten.

APL (Dyalog) , 17 Bytes

{3|3-2+/⍵}⍣{1=≢⍺}

Probieren Sie es online!

Wie?

2+/⍵ - Summiere jeweils zwei benachbarte Gegenstände

3- - vektorisierte subtrahieren von drei

3| - vektorisiertes Modulo um drei

⍣ - wiederhole bis...

1=≢⍺ - Es ist nur noch ein Artikel übrig

APL + WIN, 30 28 Bytes

2 Bytes mit freundlicher Genehmigung von Uriel gespeichert.

n←⎕⋄¯1↑∊⍎¨(⍴n)⍴⊂'n←3|3-2+/n'

Erläuterung:

n←⎕ Prompt for screen input of the form: 0 0 1 2 0 1 2 2

'n←3|3-2+/n' Successive rows are 3 mod 3 minus successive digit pairs.

(⍴n)⍴⊂ Create a nested vector of the row code, one element per row. 

¯1↑∊⍎¨ Execute each element of row code, flatten result and take final value.

Dies ist eine Möglichkeit, Schleifencode in APL in eine einzelne Zeile zu schreiben.

Javascript (ES6), 58 Byte

f=s=>s[1]?f(s.replace(/.(?=(.?))/g,(a,b)=>b&&(6-a-b)%3)):s