L'idea è principalmente di BIO 2017 q1 . Ho avuto l'idea di pubblicare questa sfida dalla mia sfida Sequenze binarie , dal momento che a molte persone sembrava piacere.

Inoltre, questa è la prima sfida che ho pubblicato senza pubblicare sulla sandbox. Lo cancellerò se non piace a nessuno.

Regole

Prendi una sequenza di cifre in ternario (base 3); questo potrebbe essere una stringa, una matrice o il valore numerico insieme al numero di zeri precedenti.

Per ogni riga nel triangolo, viene generata una riga in basso fino a quando non vi è una sola cifra nell'ultima riga. Per trovare una cifra sotto altre due cifre, la cifra sarà la stessa di due sopra di essa se queste altre due cifre sopra sono uguali. Altrimenti, sarà la cifra che non è uguale a nessuno dei due. Ecco un esempio:

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

Si prevede di restituire solo l'ultima riga.

Rendi il tuo codice breve.

Casi test

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

Buccia , 9 byte

%3←ΩεẊo_+

Provalo online!

Spiegazione

L'idea principale è calcolare la mappatura di due cifre su una come f (a, b) = (-ab)% 3 . Ai fini del golf possiamo ritardare il modulo fino alla fine.

   Ωε       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.

In linea di principio, è anche possibile calcolare il risultato direttamente moltiplicando ciascun elemento per il coefficiente binomiale corrispondente e moltiplicando la somma per -1 per gli elenchi di lunghezza pari, ma non conosco un modo per farlo in meno byte.

MATL , 10 byte

td"HYCEsI\

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Per ogni coppia di cifre, il codice calcola il doppio della somma modulo 3. Il processo viene ripetuto tante volte quanto la lunghezza dell'input meno 1.

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 byte

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

Provalo online!

Recluta nelle liste secondarie eliminando rispettivamente il primo e l'ultimo elemento.

Questo sarebbe più pulito in Python 3 se potesse effettivamente decomprimere f=lambda a,*b,c:....

Emojicode , 242 byte

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

Utilizza lo stesso algoritmo della mia risposta C. Provalo online!

Gelatina , 9 byte

+2\N$Ḋ¿%3

Provalo online!

Utilizzando l'algoritmo Husk di Martin Ender.

Haskell , 36 byte

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

Provalo online!

Salva 1 byte sul più simmetrico:

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

Provalo online!

L'idea è semplice: calcolare ricorsivamente la funzione sulle liste secondarie eliminando rispettivamente il primo e l'ultimo elemento e combinarli con \a b -> mod(-a-b)3. Questo sembra più breve di zipWithquesto ing.

Haskell , 44 byte

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

Provalo online!

C (gcc) , 91 88 84 byte

-1 byte grazie a @ 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;}

Ottiene l'array e la lunghezza. Provalo online!

J, 23 15 byte

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

Grazie a @miles

Vecchia soluzione:

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

Ispirato alla soluzione di Martin Ender:

Spiegazione

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

Lotto, 122 byte

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

Utilizza l'espansione binomiale. Come sottolinea @MartinEnder, la somma deve essere negata (modulo 3) se il numero di valori (che vengono conteggiati nel primo ciclo) è pari, quindi nè impostato su uno 1o di 2conseguenza. Il secondo ciclo calcola quindi la somma tramite i coefficienti binomiali.

APL (Dyalog) , 17 byte

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

Provalo online!

Come?

2+/⍵ - somma ogni due elementi adiacenti

3- - sottrazione vettoriale da tre

3| - modulo vettoriale per tre

⍣ - ripetere fino a ...

1=≢⍺ - è rimasto solo un oggetto

APL + WIN, 30 28 byte

2 byte salvati per gentile concessione di Uriel.

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

Spiegazione:

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.

Questo è un modo per scrivere codice in loop in APL su una sola riga.

Javascript (ES6), 58 byte

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