L'idée vient principalement de BIO 2017 q1 . J'ai eu l'idée de publier ce défi à partir de mon défi Binary Sequences , car beaucoup de gens semblaient l'aimer.

C'est aussi le premier défi que j'ai publié sans publier sur le bac à sable. Je vais le supprimer si personne ne l'aime.

Règles

Prenez une séquence de chiffres en ternaire (base 3); il peut s'agir d'une chaîne, d'un tableau ou de la valeur numérique avec le nombre de zéros précédents.

Pour chaque ligne du triangle, une ligne ci-dessous est générée jusqu'à ce qu'il n'y ait qu'un seul chiffre dans la dernière ligne. Pour trouver un chiffre en dessous de deux autres chiffres, le chiffre sera le même que deux au-dessus si ces deux autres chiffres ci-dessus sont égaux. Sinon, ce sera le chiffre qui n'est égal à aucun d'eux. Voici un exemple:

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

Vous devez uniquement renvoyer la dernière ligne.

Faites votre code court.

Cas de test

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

Coque , 9 octets

%3←ΩεẊo_+

Essayez-le en ligne!

Explication

L'idée principale est de calculer le mappage de deux chiffres à un comme f (a, b) = (-ab)% 3 . Pour le golf, nous pouvons retarder le modulo jusqu'à la fin.

   Ωε       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 principe, il est également possible de calculer le résultat directement en multipliant chaque élément par le coefficient binomial correspondant et en multipliant la somme par -1 pour les listes de longueur paire, mais je ne connais pas de moyen de le faire en moins d'octets.

MATL , 10 octets

td"HYCEsI\

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Pour chaque paire de chiffres, le code calcule deux fois la somme modulo 3. Le processus est répété autant de fois que la longueur de l'entrée moins 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 octets

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

Essayez-le en ligne!

Revient sur les sous-listes en supprimant respectivement le premier et le dernier élément.

Ce serait plus propre dans Python 3 s'il pouvait réellement déballer f=lambda a,*b,c:....

Emojicode , 242 octets

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

Utilise le même algorithme que ma réponse C. Essayez-le en ligne!

Gelée , 9 octets

+2\N$Ḋ¿%3

Essayez-le en ligne!

Utilisation de l'algorithme Husk de Martin Ender.

Haskell , 36 octets

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

Essayez-le en ligne!

Enregistre 1 octet sur le plus symétrique:

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

Essayez-le en ligne!

L'idée est simple: calculer récursivement la fonction sur les sous-listes en supprimant respectivement le premier et le dernier élément, et les combiner avec \a b -> mod(-a-b)3. Cela semble plus court que zipWithcette fonction.

Haskell , 44 octets

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

Essayez-le en ligne!

C (gcc) , 91 88 84 octets

-1 octet grâce à @ 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;}

Obtient le tableau et la longueur. Essayez-le en ligne!

J, 23 15 octets

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

Merci à @miles

Ancienne solution:

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

Inspiré par la solution de Martin Ender:

Explication

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

Lot, 122 octets

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

Utilise l'expansion binomiale. Comme le souligne @MartinEnder, la somme doit être annulée (modulo 3) si le nombre de valeurs (qui sont comptées dans la première boucle) est pair, elle nest donc définie sur l'un 1ou l' autre ou en 2conséquence. La deuxième boucle calcule ensuite la somme via les coefficients binomiaux.

APL (Dyalog) , 17 octets

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

Essayez-le en ligne!

Comment?

2+/⍵ - additionnez chacun deux éléments adjacents

3- - soustraire vectorisé de trois

3| - modulo vectorisé par trois

⍣ - Répète jusqu'à...

1=≢⍺ - il ne reste qu'un article

APL + WIN, 30 28 octets

2 octets enregistrés avec l'aimable autorisation d'Uriel.

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

Explication:

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.

C'est une façon d'écrire du code en boucle dans APL sur une seule ligne.

Javascript (ES6), 58 octets

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