Anerkennung

Mein Dank geht an Rand Al'Thor's Brief-basierte Frage für die Inspiration für diese Code-Golf-Herausforderung.

Hintergrund

Die Art dieser Herausforderung basiert auf dem Algorithmus, den Rand in seinem "Ein aus drei Buchstaben gebildetes Dreieck" erwähnt hat:

• Beginnen Sie mit einer Folge von 10 Buchstaben, von denen jeder X, Y oder Z ist.
• Konstruieren Sie unter jeder Zeile die nächste Zeile wie folgt. Wenn zwei benachbarte Buchstaben gleich sind, schreiben Sie denselben Buchstaben darunter. Wenn sie unterschiedlich sind, schreiben Sie den dritten Buchstaben darunter.

Sie würden dann den vorherigen Schritt wiederholen, bis Sie einen Buchstaben in Ihrer zehnten Zeile haben.

Herausforderung

Wir werden dem obigen Algorithmus eine mathematische Wendung geben:

• Beginnen wir mit einer Folge von 10 Ziffern, die jeweils durch ein Leerzeichen getrennt sind und jeweils 1, 2 oder 3 sind.
• Konstruieren Sie unter jeder Zeile die nächste Zeile wie folgt. Wenn zwei benachbarte Ziffern identisch sind, schreiben Sie dieselbe Ziffer darunter. Wenn sie unterschiedlich sind, schreiben Sie die dritte Ziffer darunter.
• Wiederholen Sie den vorherigen Schritt, bis Sie eine endgültige Nummer haben.

Wenn Sie also nach diesem Algorithmus mit der Zeile beginnen 1 2 3 3 1 3 1 3 1 2, wird beispielsweise das folgende Dreieck generiert:

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         

Ich bin auch neugierig, die Summe aller Ziffern im Zahlendreieck zu kennen. Addieren Sie also alle diese Ziffern und setzen Sie diese Summe in eine elfte Zeile, rechtsbündig zur letzten Ziffer in der ersten Zeile. Unser Zahlendreieck sieht also ungefähr so ​​aus (Leerzeichen in meinem Beispiel werden unten durch das .Zeichen dargestellt, um die Formatierung anzuzeigen.)

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

Ihre Herausforderung besteht darin, Code zu schreiben, der mit einem eingegebenen String / Array / etc. Beginnen kann. aus zehn Ziffern gemäß meinem Beispiel, und wenden Sie dann den Algorithmus an, um die zehn Zeilen zu generieren, die das Zahlendreieck erstellen würden, gefolgt von einer elften Zeile, in der die Summe aller Ziffern mit der richtigen Begründung angezeigt wird.

Testen

Das Testen dieser Zeichenfolge kann mit einer zufällig generierten Zeichenfolge mit zehn Ziffern Ihrer Wahl oder einer aus dem folgenden Snippet generierten Zeichenfolge durchgeführt werden ...

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.

Regeln

1. Es gelten die Code-Golf-Regeln, sodass die niedrigste Anzahl von Bytes die Herausforderung gewinnt. Bei zwei Einsendungen mit derselben niedrigen Punktzahl wird der Gewinner anhand der Anzahl der Up-Votes vergeben.
2. Was wir im Grunde suchen, sind 11 Zeilen, 19 Zeichen lang ... Wie Sie Ihre endgültige Ausgabe rendern, liegt ganz bei Ihnen: Array, Konsole, Dateiausgabe, STDOUT usw. Verwenden Sie also bitte eine beliebige Ausgabemethode arbeiten zu Ihrem Vorteil. Die einzige Regel in der Ausgabe ist, dass wir 11 Zeilen mit 19 Zeichen in jeder Zeile in einem ähnlichen Format wie oben haben ...
3. Wenn es Ihrem Code hilft, verwenden Sie ein beliebiges Trennzeichen für die Ziffern ... Denken Sie daran, dass die Lesbarkeit möglicherweise einen Beitrag dazu leistet.
4. Keine dummen Lücken .
5. Eine Hardcodierung der Eingabe ist nicht zulässig. Der Zweck dieses Codes besteht darin, dass er verwendet werden kann, um jedes Mal unterschiedliche Ergebnisse mit unterschiedlichen Eingaben zu erzielen. Die Hardcodierung von 1 1 1 1 1 1 1 1 1 1beispielsweise negiert den gesamten Punkt des Algorithmus vollständig.

Freuen Sie sich darauf zu sehen, was Sie sich alles einfallen lassen können!

05AB1E , 32 26 Bytes

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

Erläuterung

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

Probieren Sie es online aus!

Mathematica, 104 97 90 94 Bytes

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

Erläuterung

Partition[#,2,1]

Partitioniert die Eingabe in Partitionen der Länge 2 und versetzt 1.

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

Nimmt jede Partition und berechnet die entsprechende Ausgabe.

Ein Trick, um den es hier geht. Ich addierte die beiden Zahlen, nahm Mod 3 und subtrahierte das Ergebnis von 3. Das ergibt die gewünschte Zahl. (zB 3 - ((2 + 1) mod 3) = 3)

NestList[ ... ,9]

Wiederholt den obigen Vorgang neunmal und gibt alle Iterationen als Ausgabe an.

Grid[List@*Row/@#]

Formatieren Sie jede Iteration in Zeilen und platzieren Sie das gesamte Objekt in einer Spalte (mittig ausgerichtet), um ein Dreieck zu erstellen.

#~Total~2

Nehmen Sie die Summe aller Zahlen.

{...}~Column~Right

Kombinieren Sie das Dreieck und die Summe und richten Sie das gesamte Objekt nach rechts aus (das Dreieck ist bereits ausgerichtet, sodass seine Ausrichtung nicht beeinträchtigt wird).

JavaScript (ES6), 143 142 Byte

1 Byte dank @Neil gespeichert

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)

Ich habe versucht, verschiedene Teile zu kombinieren, aber es dauerte 5 Bytes länger:

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, 134 101 Bytes

Mit dem Modulo-Trick von 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(:+)}

Siehe es auf eval.in: https://eval.in/649993

CJam ,  44  40 Bytes

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

Probieren Sie es online aus!

Erläuterung

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

Eine relativ einfache iterative Lösung.

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

Probieren Sie es online aus

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 Byte

Nimmt ein Array als Eingabe und erstellt rekursiv ein durch Kommas getrenntes Dreieck.

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)