A ideia disso é principalmente da BIO 2017, primeiro trimestre . Tive a ideia de postar esse desafio no meu desafio de Seqüências binárias , pois muitas pessoas pareciam gostar.

Além disso, este é o primeiro desafio que publiquei sem postar na sandbox. Vou excluí-lo se ninguém gostar.

Regras

Pegue uma sequência de dígitos em ternário (base 3); pode ser uma string, uma matriz ou o valor numérico, juntamente com o número de zeros anteriores.

Para cada linha do triângulo, uma linha abaixo é gerada até que haja apenas um dígito na última linha. Para encontrar um dígito abaixo de dois outros dígitos, o dígito será igual a dois acima, se esses dois dígitos acima forem iguais. Caso contrário, será o dígito que não é igual a nenhum deles. Aqui está um exemplo:

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

Você só deve retornar a última linha.

Faça seu código curto.

Casos de teste

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

Casca , 9 bytes

%3←ΩεẊo_+

Experimente online!

Explicação

A idéia principal é calcular o mapeamento de dois dígitos para um como f (a, b) = (-ab)% 3 . Para fins de golfe, podemos atrasar o módulo até o 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.

Em princípio, também é possível calcular o resultado diretamente multiplicando cada elemento pelo coeficiente binomial correspondente e multiplicando a soma por -1 para listas de comprimento par, mas não sei como fazer isso em menos bytes.

MATL , 10 bytes

td"HYCEsI\

Experimente online!Ou verifique todos os casos de teste .

Explicação

Para cada par de dígitos, o código calcula o dobro da soma do módulo 3. O processo é repetido quantas vezes o comprimento da 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

Experimente online!

Repete-se nas sublistas, excluindo o primeiro e o último elementos, respectivamente.

Isso seria mais limpo no Python 3 se realmente pudesse ser descompactado f=lambda a,*b,c:....

Emojicode , 242 bytes

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

Usa o mesmo algoritmo da minha resposta C. Experimente online!

Geléia , 9 bytes

+2\N$Ḋ¿%3

Experimente online!

Usando o algoritmo Husk de Martin Ender.

Haskell , 36 bytes

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

Experimente online!

Economiza 1 byte sobre o mais simétrico:

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

Experimente online!

A idéia é simples: calcule recursivamente a função nas sublistas, excluindo o primeiro e o último elemento, respectivamente, e combine-os com \a b -> mod(-a-b)3. Isso parece mais curto do que zipWithessa função.

Haskell , 44 bytes

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

Experimente online!

C (gcc) , 91 88 84 bytes

-1 byte graças 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;}

Obtém a matriz e o comprimento. Experimente online!

J, 23 15 bytes

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

Graças a @miles

Solução antiga:

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

Inspirado na solução de Martin Ender:

Explicação

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%

Usa expansão binomial. Como o @MartinEnder aponta, a soma deve ser negada (módulo 3) se o número de valores (que são contados no primeiro loop) for par, então nestiver definido como um 1ou de 2acordo. O segundo loop calcula a soma pelos coeficientes binomiais.

APL (Dyalog) , 17 bytes

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

Experimente online!

Quão?

2+/⍵ - soma cada dois itens adjacentes

3- - subtrair vetorizado de três

3| - módulo vetorizado por três

⍣ - repetir até...

1=≢⍺ - resta apenas um item

APL + WIN, 30 28 bytes

2 bytes salvos, cortesia de Uriel.

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

Explicação:

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.

Essa é uma maneira de escrever código de loop no APL em uma única linha.

Javascript (ES6), 58 bytes

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