Crédito

Mi agradecimiento a la pregunta basada en cartas de Rand Al'Thor por la inspiración para este desafío de código de golf.

Antecedentes

La naturaleza de este desafío se basa en el algoritmo mencionado por Rand en su "Un triángulo formado por tres letras":

• Comience con una secuencia de 10 letras, cada una de las cuales es X, Y o Z.
• Debajo de cada fila, construya la siguiente fila de la siguiente manera. Si dos letras adyacentes son iguales, escriba la misma letra debajo de ellas; Si son diferentes, escriba la tercera letra debajo de ellos.

Luego repetirías el paso anterior hasta que tengas una letra en tu décima fila.

Desafío

Vamos a darle un giro matemático al algoritmo anterior:

• Comencemos con una secuencia de 10 dígitos, cada uno separado por un espacio, y cada uno de los cuales es 1, 2 o 3.
• Debajo de cada fila, construya la siguiente fila de la siguiente manera. Si dos dígitos adyacentes son iguales, escriba el mismo dígito debajo de ellos; si son diferentes, escriba el tercer dígito debajo de ellos.
• Repita el paso anterior hasta que tenga un número final.

Entonces, siguiendo este algoritmo, si comienza con la fila 1 2 3 3 1 3 1 3 1 2, por ejemplo, se genera el siguiente triángulo:

Input: 1 2 3 3 1 3 1 3 1 2

Output:

1 2 3 3 1 3 1 3 1 2
 3 1 3 2 2 2 2 2 3 
  2 2 1 2 2 2 2 1  
   2 3 3 2 2 2 3   
    1 3 1 2 2 1    
     2 2 3 2 3     
      2 1 1 1      
       3 1 1       
        2 1        
         3         

También tengo curiosidad por saber la suma de todos los dígitos en el triángulo numérico, así que agregue todos estos dígitos y coloque este total en la undécima fila, justificada a la derecha hasta el último dígito en la primera fila. Entonces, nuestro triángulo numérico tendrá un aspecto similar al siguiente (los espacios en mi ejemplo están representados a continuación por el .carácter para mostrar el formato).

Input: 1 2 3 3 1 3 1 3 1 2

Output:

1.2.3.3.1.3.1.3.1.2
.3.1.3.2.2.2.2.2.3.
..2.2.1.2.2.2.2.1..
...2.3.3.2.2.2.3...
....1.3.1.2.2.1....
.....2.2.3.2.3.....
......2.1.1.1......
.......3.1.1.......
........2.1........
.........3.........
................109

Su desafío es escribir código que pueda comenzar con una cadena / matriz / etc. de diez dígitos, según mi ejemplo, y luego aplique el algoritmo para generar las diez filas que crearían el triángulo numérico, seguido de una fila 11 que mostrará el total de todos los dígitos con justificación a la derecha.

Pruebas

La prueba de esta cadena se puede realizar con una cadena generada aleatoriamente de diez dígitos de su elección, o una generada a partir del fragmento a continuación ...

c1=()=>('1331123221'+(Math.random()*(1<<24)|0).toString(4)).replace(/0/g, "").slice(-10).split("").join(" ");

$("#btn").click(function(){
  $("#str").val(c1());
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<input type="text" id="str"><button id="btn">Get numbers</button>
<br>
Please use this snippet to generate a starting row for testing your code. Alternatively, you can also use a string of your choice, so long as it's ten digits (ranging from 1 to 3), separated by single spaces.

Reglas

1. Se aplican las reglas de código de golf, por lo que el menor número de bytes gana el desafío. En el caso de que haya dos entradas con el mismo puntaje bajo, el ganador se otorgará en función del número de votos positivos.
2. Básicamente, lo que buscamos son 11 filas, 19 caracteres de largo ... La forma en que renderiza su salida final depende completamente de usted: matriz, consola, salida de archivo, STDOUT, etc., así que use el método de salida que desee trabaja a tu favor. La única regla en el resultado es que tenemos 11 filas con 19 caracteres en cada fila en un formato similar al anterior ...
3. Si ayuda a su código, use cualquier separador para los dígitos ... Solo recuerde que la legibilidad puede ser un factor contribuyente.
4. No hay escapatorias tontas .
5. La codificación rígida de la entrada no está permitida. El propósito de este código es tal que puede usarse para producir resultados diferentes cada vez con una entrada variable. La codificación rígida de, 1 1 1 1 1 1 1 1 1 1por ejemplo, niega por completo el punto completo del algoritmo.

¡Esperamos ver lo que todos ustedes pueden inventar!

05AB1E , 32 26 bytes

DvÐOˆðýðN×.ø,ü+3%3^}\¯O19j

Explicación

D                 # duplicate input
v                 # for y,N in input,len(input): (10 times do)
 Ð                # triplicate current list
 Oˆ               # sum one copy and add it to global array
 ðý               # merge one copy on spaces
   ðN×.ø          # surround it with N spaces
        ,         # and print it
 ü+               # reduce one copy by addition
   3%             # modulus 3
     3^           # XOR 3
                  # this is the list sent to the next iteration
}                 # end loop
\                 # drop empty list left over from last iteration of loop
 ¯O               # sum the global array giving the triangles total sum
   19j            # join with spaces up to 19 chars

Pruébalo en línea!

Mathematica, 104 97 90 94 bytes

{Grid[List@*Row/@#],#~Total~2}~Column~Right&[NestList[3-Mod[+##,3]&@@@Partition[#,2,1]&,#,9]]&

Explicación

Partition[#,2,1]

Particiona la entrada en longitud 2, compensa 1 particiones.

3-Mod[+##,3]&@@@

Toma cada partición y calcula la salida correspondiente.

Un truco involucrado aquí. Agregué los dos números, tomé el mod 3 y resté el resultado de 3. Eso da el número deseado. (por ejemplo, 3 - ((2 + 1) mod 3) = 3)

NestList[ ... ,9]

Repite el proceso anterior nueve veces, dando todas las iteraciones como salida.

Grid[List@*Row/@#]

Formatee cada iteración en filas y coloque todo en una columna (alineada al centro), creando un triángulo.

#~Total~2

Toma el total de todos los números.

{...}~Column~Right

Combine el triángulo y el total, y alinee a la derecha todo (el triángulo ya está alineado, por lo que su alineación no se ve afectada).

JavaScript (ES6), 143 142 bytes

Guardado 1 byte gracias a @Neil

a=>a.map((_,i)=>(q=" ".repeat(i))+(a=a.map(c=>(x+=r=i&&p^(p=c)||c,r),p=i&&a.shift())).join` `+q,x=0).join`
`+`
`+(" ".repeat(18)+x).slice(-19)

Intenté combinar varias partes, pero terminó 5 bytes más:

a=>[...a.map((_,i)=>(a=a.map(c=>(x+=r=i&&p^(p=c)||c,r),p=i&&a.shift())).join` `+" ".repeat(i),x=0),x].map(q=>(" ".repeat(18)+q).slice(-19)).join`
`

Ruby, 134101 bytes

Usando el truco del módulo de JHM.

->a{b=*a
(0..8).map{|i|[" "*i,a=a.each_cons(2).map{|x,y|b<<n=3-(x+y)%3
n}]*" "}<<"%19d"%b.reduce(:+)}

Véalo en eval.in: https://eval.in/649993

CJam ,  44  40 bytes

l~{S*\_S*\2ew{:+3%3^}%2$N@}A%_s:~:+sJSe[

Pruébalo en línea!

Explicación

l~       e# Read and evaluate input.
{        e# Map this block over i in the range [0 1 ... 9].
  S*     e#   Get a string of i spaces (the indentation).
  \_     e#   Swap with the current line of trits and duplicate it.
  S*     e#   Join the trits with spaces.
  \2ew   e#   Swap with the other copy of the trits and get all consecutive pairs.
  {      e#   Map this block over the pairs...
    :+   e#     Sum the pair.
    3%   e#     Modulo 3.
    3^   e#     XOR 3.
         e#     This expression (x+y)%3 ^ 3 computes the required mapping.
  }%     e#   Now this is the next line.
  2$     e#   Copy the indentation (to pad the lines to equal length).
  N      e#   Push a linefeed.
  @      e#   Pull up the next line.
}A%      e# The result of this is a nested array whose string representation is
         e# the required triangle.
_s       e# Duplicate and flatten into a string.
:~       e# Eval each character which gives a list of all the trits.
:+       e# Sum that.
s        e# Turn the sum into a string.
JSe[     e# Left-pad it with spaces to width 19.

Python 2, 164 bytes

Una solución iterativa relativamente simple.

L=input()
s=0
for i in range(len(L)):
    print" "*-~i+" ".join(`L`[1::3]);s+=sum(L);N=L;L=[]
    for a,b in zip(N,N[1:]):L+=[list({1,2,3}-{a,b}),[a]][a==b]
print"%19s"%s

Pruébalo en línea

PHP, 143 bytes

<?for($t=$_GET[t];$i<181;$s+=$v,$i+=2)$t[$i+20]=($v=$t[$i])*($z=$t[$i+2])>0&$i!=18?($v+$z)%3^3:" ";echo chunk_split($t.str_pad($s,8," ",0),19);

JavaScript (ES6), 112 100 96 bytes

Toma una matriz como entrada y construye recursivamente un triángulo separado por comas.

f=(s,p=`
`,S=0)=>p+(s[0]?s+f(s.map((v,i)=>(S+=v,v^s[i-1]||v)).slice(1),p+' ',S):(p+S).slice(-9))

console.log(f([1,2,3,3,1,3,1,3,1,2])); // reference example
console.log(f([3,3,2,1,3,1,2,1,2,1])); // random example
console.log(f([1,1,1,1,1,1,1,1,1,1])); // all ones (test case for sum < 100)