La idea de esto es principalmente de BIO 2017 q1 . Se me ocurrió la idea de publicar este desafío desde mi desafío de Secuencias binarias , ya que a mucha gente parecía gustarle.

Además, este es el primer desafío que publico sin publicar en el sandbox. Lo eliminaré si a nadie le gusta.

Reglas

Tomar en una secuencia de dígitos en ternario (base 3); Esto podría ser como una cadena, una matriz o el valor numérico junto con el número de ceros anteriores.

Para cada fila del triángulo, se genera una fila debajo hasta que solo haya un dígito en la última fila. Para encontrar un dígito debajo de otros dos dígitos, el dígito será el mismo que dos arriba si estos otros dos dígitos arriba son iguales. De lo contrario, será el dígito que no sea igual a ninguno de ellos. Aquí hay un ejemplo:

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

Solo se espera que devuelva la última fila.

Haz tu código corto.

Casos de prueba

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

Casco , 9 bytes

%3←ΩεẊo_+

Pruébalo en línea!

Explicación

La idea principal es calcular la asignación de dos dígitos a uno como f (a, b) = (-ab)% 3 . Para fines de golf, podemos retrasar el módulo hasta el final.

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

En principio, también es posible calcular el resultado directamente multiplicando cada elemento por el coeficiente binomial correspondiente y multiplicando la suma por -1 para listas de longitud par, pero no conozco una forma de hacerlo en menos bytes.

MATL , 10 bytes

td"HYCEsI\

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Para cada par de dígitos, el código calcula dos veces la suma del módulo 3. El proceso se repite tantas veces como la longitud de la entrada menos 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 bytes

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

Pruébalo en línea!

Se repite en las sublistas eliminando el primer y el último elemento respectivamente.

Esto sería más limpio en Python 3 si realmente pudiera desempaquetar f=lambda a,*b,c:....

Emojicode , 242 bytes

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

Utiliza el mismo algoritmo que mi respuesta C. Pruébalo en línea!

Jalea , 9 bytes

+2\N$Ḋ¿%3

Pruébalo en línea!

Usando el algoritmo Husk de Martin Ender.

Haskell , 36 bytes

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

Pruébalo en línea!

Ahorra 1 byte sobre el más simétrico:

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

Pruébalo en línea!

La idea es simple: calcula recursivamente la función en las sublistas eliminando el primer y el último elemento respectivamente, y combínalos con \a b -> mod(-a-b)3. Esto parece más corto que zipWithesta función.

Haskell , 44 bytes

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

Pruébalo en línea!

C (gcc) , 91 88 84 bytes

-1 byte gracias 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;}

Obtiene la matriz y la longitud. Pruébalo en línea!

J, 23 15 bytes

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

Gracias a @miles

Antigua solución:

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

Inspirado por la solución de Martin Ender:

Explicación

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

Lote, 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%

Utiliza expansión binomial. Como señala @MartinEnder, la suma tiene que ser negada (módulo 3) si el número de valores (que se cuentan en el primer bucle) es par, por lo que nse establece en uno 1o en 2consecuencia. El segundo ciclo luego calcula la suma a través de los coeficientes binomiales.

APL (Dyalog) , 17 bytes

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

Pruébalo en línea!

¿Cómo?

2+/⍵ - suma cada dos elementos adyacentes

3- - restar vectorizado de tres

3| - módulo vectorizado por tres

⍣ - repetir hasta...

1=≢⍺ - solo queda un artículo

APL + WIN, 30 28 bytes

2 bytes guardados por cortesía de Uriel.

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

Explicación:

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.

Esta es una forma de escribir código de bucle en APL en una sola línea.

Javascript (ES6), 58 bytes

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