Der Rundown

Erstellen Sie ein Programm, das ein Array mit zufälliger Länge und Zufallszahlen generiert, und wenden Sie dann eine Reihe von Regeln an, die das Array ändern. Nachdem die Regeln angewendet wurden, drucken Sie die Summe des Arrays, sofern nicht anders angegeben

Array-Setup

Das Array muss eine zufällige Länge zwischen 5 und 10 einschließlich haben, mit zufälligen ganzen Zahlen zwischen 1 und 20 einschließlich. Jede Array-Länge sollte die gleiche Wahrscheinlichkeit haben und jede Ganzzahl sollte die gleiche Wahrscheinlichkeit haben, pro Element ausgewählt zu werden.

Die 7 Regeln

Die Regeln sollten so funktionieren, als ob sie nacheinander angewendet würden (z. B. Regel 1 handelt vor Regel 2) und werden nur einmal angewendet. Zum Nachweis der Regelanwendung muss das Array nach jeder Regelanwendung und einmal vor dem Anwenden von Regeln auf die Konsole gedruckt werden.

1. Wenn das Array eine 7 enthält, subtrahieren Sie 1 von jedem Element
2. Wenn Regel 1 angewendet wird und das Array jetzt eine 0 enthält, fügen Sie jedem Element 1 hinzu
3. Wenn das Array eine 13 enthält, schließen Sie die 13 und alle folgenden Elemente aus dem Array aus
4. Wenn das Array eine 2 enthält, schließen Sie alle ungeraden Zahlen aus
5. Wenn das Array eine 20 enthält und das dritte Element gerade ist, geben Sie 20 als Summe zurück und beenden Sie dann. Wenn eine 20 vorhanden ist und das dritte Element ungerade ist, geben Sie das 20-fache der Länge des Arrays als Summe zurück und beenden Sie dann.
6. Wenn die Summe größer als 50 ist, entfernen Sie das letzte Element wiederholt, bis es kleiner oder gleich 50 ist
7. Wenn das Array eine 16 enthält, drucken Sie die Summe sowohl dezimal als auch hexadezimal aus.

Beispiel

Hier ist ein erstes Array:

[20, 2, 5, 7, 14, 8]

Regel 1 kann angewendet werden:

[19, 1, 4, 6, 13, 7]

Als nächstes wird Regel 3 angewendet:

[19, 1, 4, 6]

Es sind keine weiteren Regeln erforderlich, daher gibt das Programm 30 als Summe zurück.

Anmerkungen

• Ich bin kein erfahrener Code-Golfer, obwohl ich sagen kann, dass mein persönlicher Datensatz in Python 3 mit 369 Bytes ist .
• Die Regeln müssen nicht in der richtigen Reihenfolge angewendet werden, sondern müssen so tun, als ob sie es getan hätten.

Python 3, 294 301 287 356 Bytes

import random as r
r=r.randint
k=[r(i)+1for i in[20]*r(5,11)]
p=print
if 7in k:k=[i-1for i in k]
p(k)
if 0in k:k=[i+1for i in k]
p(k)
i=k.find(13)
if not~i:k=k[:i]
p(k)
if 2in k:k=[i for i in k if~i%2]
p(k)
a=0
z=len(k)>2and k[2]%2
if 20in k:a=20*len(k)**z
if~z:p(k)
while sum(k)>50:k=k[:-1]
if~z:p(k)
if a:p(a)
else:a=sum(k);p(a,hex(a)*(16in k))
if~z:p(k)

Ich weiß nicht, wie Sie verhindern sollen, dass Leute die Regeln umgehen, aber dieser verwendet das angegebene Verfahren.

+7 Bytes; danke an @YamB für das Speichern einiger Bytes; Es wurde viel mehr hinzugefügt, um einen vorherigen Fehler zu beheben.
-14 Bytes danke an @RootTwo und mich und korrigierte auch den Fehler.
+83 Bytes; Das wird schrecklich lang, weil OP die Regeln ständig ändert. -Einige Anzahl von Bytes dank @ZacharyT

05AB1E , 91 Bytes

5TŸ.RF20©L.R})=D7åi<=D0åi>=}}D13åiD13k£=}D2åiDÈÏ=}D®åiDgs2èÉ®si*},q}[DO50›_#¨=]D16åiDOH,}O,

Probieren Sie es online aus! oder Mit Eingabe

Javascript (ES6), 344 342 340 342 335 331 333 313 311 305 298 297 290 289 283 279 Bytes

Huzzah! Endlich mit Beat Arnauld verbunden !

Nach diesem Austausch * in den Kommentaren der Herausforderung und nach langem Überlegen habe ich mich entschieden, new Datestattdessen den Startwert für den Zufallszahlengenerator zu verwenden Math.random(). Dies bedeutet, dass alle Ganzzahlen im Array den gleichen Wert haben.

_=>(l=alert,r=new Date,l(a=[...Array(r%6+5)].map(x=>r%20+1)),i=v=>~a.indexOf(v),i(7)&&l(a=a.map(x=>--x)),i(0)&&l(a=a.map(x=>++x)),i(13)&&l(a=a.slice(0,~i(13))),i(2)&&l(a=a.filter(x=>x%2)),i(t=20)?a[2]%2?t*a.length:t:l(a=a.filter(x=>s+x<51?s+=x:0,s=0))|i(16)?[s,s.toString(16)]:s)

Versuch es

f=
_=>(l=alert,r=new Date,l(a=[...Array(r%6+5)].map(x=>r%20+1)),i=v=>~a.indexOf(v),i(7)&&l(a=a.map(x=>--x)),i(0)&&l(a=a.map(x=>++x)),i(13)&&l(a=a.slice(0,~i(13))),i(2)&&l(a=a.filter(x=>x%2)),i(t=20)?a[2]%2?t*a.length:t:l(a=a.filter(x=>s+x<51?s+=x:0,s=0))|i(16)?[s,s.toString(16)]:s)
alert(f())

• 2 Bytes wurden gespeichert, indem nur die in Regel 6 geöffneten Elemente protokolliert wurden.
• Gespeicherte 2 Bytes durch den Austausch Array(x).fill()mit [...Array(x)].
• 2 Bytes hinzugefügt, weil ich Regel 5 durcheinander gebracht hatte!
• 7 Bytes gespeichert, um das Durcheinander zu beheben. Ich habe versucht, das vorherige Durcheinander zu beheben!
• Dank Arnauld, der mir bei der Heilung eines Brainfarts nach Regel 2 geholfen hat, wurden 3 Bytes gespeichert und ein zusätzliches Byte durch Ersetzen von a +1durch a gespeichert ~.
• Es wurden 2 Bytes hinzugefügt, um sicherzustellen, dass 0für ein leeres Array zurückgegeben wird.
• Sparte 20 Bytes, indem Sie endlich herausfinden, wie Sie diese Fehlerschleife loswerden können while.
• Sparte 2 Bytes, indem die ,zwischen den letzten 2 Anweisungen durch a ersetzt |und das Gehäuse entfernt wurden ().
• Gespeicherte 6 Bytes durch Ersetzen console.logdurch alert.
• 7 Bytes durch Verbesserung der Verknüpfung von gespeichert a.includes().
• 1 Byte durch Bearbeiten der Implementierung von Regel 3 gespeichert.
• 7 Bytes durch Abwracken includes()und nur indexOf()durchgehend gespeichert .
• 1 Byte wurde gespeichert, indem die ursprüngliche Deklaration der sVariablen an einen Ort verschoben wurde, an dem kein Komma erforderlich war.
• Gespeicherte 6 Bytes durch Ersetzen Math.random()durch new Date.
• 4 Bytes wurden durch Entfernen der (jetzt redundanten) Rundung der Zufallszahlen gespeichert.

Lesbare und testbare Version

• Zeilenumbrüche und Kommentare zum Code hinzugefügt
• Wird console.loganstelle alertIhrer geistigen Gesundheit verwendet! (Am besten in der Konsole Ihres Browsers anzeigen)
• Die aktuelle Regelnummer wurde zur Ausgabe hinzugefügt.
• Auskommentierte zufällige Array-Generierung, um das Testen durch Eingabe einer durch Kommas getrennten Liste von Zahlen zu ermöglichen.

f=a=>(
    // Alias alert as l
    // (console.log used for this demo)
    l=(s,a)=>console.log(s+JSON.stringify(a))/*alert*/,
    // Alias new Date as r
    r=new Date,
    // Initiate an array of random length
    // Destructure array
    // Map a random value to each array element
    // (Above all commented out to allow testing your own arrays)
    // Log the initial array
    l("Initial: ",a/*=[...Array(r%6+5)].map(x=>r%20+1)*/),
    // Assign a.indexOf to shortcut i
    i=v=>~a.indexOf(v),
    // Check for the presesnce of 7
    // Invoke the first rule, decrementing the value of each element by 1
    // Log the resulting array
    i(7)&&l("Rule 1: ",a=a.map(x=>--x)),
    // Check for the presesnce of 0
    // Invoke the second rule, incrementing the value of each element by 1
    // Log the resulting array
    i(0)&&l("Rule 2: ",a=a.map(x=>++x)),
    // Check for the presence of 13
    // Invoke the third rule, slicing the array to the index of 13
    // Log the resulting array
    i(13)&&l("Rule 3: ",a=a.slice(0,~i(13))),
    // Check for the presence of 2
    // Invoke the fourth rule, removing all elements whose value have a remainder when divided by 2
    // Log the resulting array
    i(2)&&l("Rule 4:",a=a.filter(x=>x%2)),
    // Assign 20 to variable t
    // (Note: this does not yet save any bytes, but it doesn't cost any either)
    // Check for the presence of 20
    // Invoke the fifth rule, returing 20 times the array length ...
    // ... if the third element (2 in a 0 based index) leaves a remainder when divided by 2 ...
    // ... or just 20, if not
    i(t=20)?"Rule 5: "+(a[2]%2?t*a.length:t):
    // Assign the sum of the array to variable s
    // Invoke the sixth rule by filtering through the array, ...
    // ... adding the value of each element to s, as long as the result is less than 51 ...
    // ... otherwise remove the element from the array
    // Log the current array
    l("Rule 6 :",a=a.filter(x=>s+x<51?s+=x:0,s=0))|
    // Check for the presence of 16
    // If present, invoke the seventh rule, returning the sum and its hex value (as an array)
    // Otherwise simply return the sum
    i(16)?"Rule 7: "+[s,s.toString(16)]:"Sum: "+s
);

document.querySelector`button`.addEventListener(`click`,_=>(console.clear(),console.log(f(document.querySelector`input`.value.split`,`.map(eval)))))

<input><button>Test</button>

* Screenshot, falls gelöscht:

C (gcc) , 621 619 593 585 570 562 557 552 529 517 500 482 461 444 442 441 438 Bytes

Hier ist eine Menge Golf erforderlich ... Es wurde ein Fehler behoben, durch den das Hexidezimal für jede 16 in der Liste einmal gedruckt wurde ...

Besonderer Dank geht an ZacharyT mit der Golfhilfe

#define R r[i]
#define P printf("%d "
#define L for(d=i=0;i<l;i++)
d,i,j,l,r[11];p(i){L P,R);puts("");}main(){srand(time(0));for(l=5+rand()%5;i<l;R=1+rand()%20,i++);for(p();i--;)if(R==7){L--R;j=i=1;}for(p();j&&i<l;i++)if(!R){L++R;j=i=l;}p();L if(R==13)l=i;p();L if(R==2)for(d=1;d;)L if(R&1)for(d=1,--l;i<=l;i++)R=r[i+1];p();L if(R==20)return P,r[3]&1?20*l:20);for(j=i=0;i<l&&j+R<51;j+=R,i++);l=i;p();P,j);L if(R==16)printf("0x%x",j,i=l);}

Probieren Sie es online aus!

JavaScript (ES6), 296 295 290 289 Byte

Ein vollständiges Programm, das das anfängliche Array, die Zwischenergebnisse und die endgültige Summe in der Konsole protokolliert.

f="z=[...Array(5+6j)]Z1+20jw7`-1w0`+1w13_qi+1<-kw2_qn&1^1w20_z[2]&1?a.length*20:20);else{q(s+=n)<51,s=0w16_b.toString(16_;b)}zconsole.log(aw_;if(k=~a.indexOf(v((n,i)=>qz=a.filtervj*Math.random()|0bz.reducevn+i,0)`_z=aZn_))Z.mapv";for(g of "Z_`bjqvwz")e=f.split(g),f=e.join(e.pop());eval(f)

Wie es funktioniert

Dies wurde mit diesem JS-Packer komprimiert .

Nervenzusammenbruch:

• Gepackte Zeichenfolge: 226 225 Bytes
• Code entpacken: 69 64 Bytes

Unten finden Sie den Original-Quellcode mit einigen zusätzlichen Leerzeichen und Zeilenvorschüben zur besseren Lesbarkeit. Anstatt Standard-Golf-Tricks anzuwenden, wurde es so geschrieben, dass so viele sich wiederholende Saiten wie möglich erzeugt werden, um dem Packer zu gefallen. Zum Beispiel wird die Syntax if(k=~a.indexOf(N))überall dupliziert, obwohl sie knur in der 3. Regel verwendet wird.

console.log(a=[...Array(5+6*Math.random()|0)].map((n,i)=>1+20*Math.random()|0));
if(k=~a.indexOf(7))
  console.log(a=a.map((n,i)=>n-1));
if(k=~a.indexOf(0))
  console.log(a=a.map((n,i)=>n+1));
if(k=~a.indexOf(13))
  console.log(a=a.filter((n,i)=>i+1<-k));
if(k=~a.indexOf(2))
  console.log(a=a.filter((n,i)=>n&1^1));
if(k=~a.indexOf(20))
  console.log(a[2]&1?20*a.length:20);
else {
  console.log(a=a.filter((n,i)=>(s+=n)<51,s=0));
  if(k=~a.indexOf(16))
    console.log(a.reduce((n,i)=>n+i,0).toString(16));
  console.log(a.reduce((n,i)=>n+i,0))
}

Methoden zum Auspacken

Der ursprüngliche Auspackcode lautet:

f="packed_string";for(i in g="ABCDEFGHI")e=f.split(g[i]),f=e.join(e.pop());eval(f)

Alle folgenden ES6-Varianten haben genau die gleiche Größe:

eval([..."ABCDEFGHI"].reduce((f,g)=>(e=f.split(g)).join(e.pop()),"packed_string"))
[..."ABCDEFGHI"].map(g=>f=(e=f.split(g)).join(e.pop()),f="packed_string")&&eval(f)
eval([..."ABCDEFGHI"].map(g=>f=(e=f.split(g)).join(e.pop()),f="packed_string")[8])

Der einzige Weg, den ich bisher gefunden habe, um ein paar Bytes zu sparen, ist die Verwendung von for ... of:

f="packed_string";for(g of "ABCDEFGHI")e=f.split(g),f=e.join(e.pop());eval(f)

Versuchen Sie es zuerst mit Code Golf!

Bereits von anderen Javascriptern geschlagen! Dangit! Ich werde mich bessern!!! =)

Javascript -> 550 402 Bytes

Könnte definitiv verbessert werden. Jetzt komprimiert:

f="ba=[];bl;yz5+5`^=0;i<y;i++)a[i]z20+1|~7j-1|~0j+1|}}~13_l=indexOf(13`ql,y-l-Y_^ in a)if(a[i]%2)qi,Y0)&&(!a[3]%2_k'20'`throw new Error(`}do{l=Vreduce((X,num)=>X+num`ifW)qy-1,1`}whileW|kl`~16))kl.toString(16)`~if(Vincludes(|`ka`z=Zound(Zandom()*yVlengthqVsplice(kalert(j_Vmap((i)=>ibvar `);_)){^for(biZMath.rY1|}~2XtotalW(l>50Va.";for(i in g="VWXYZ^_`bjkqyz|~")e=f.split(g[i]),f=e.join(e.pop());eval(f)

Original:

var a=[];var l;a.length=Math.round(Math.random()*5+5);for(var i=0;i<a.length;i++)a[i]=Math.round(Math.random()*20+1);alert(a);if(a.includes(7)){a.map((i)=>i-1);alert(a);if(a.includes(0)){a.map((i)=>i+1);alert(a);}}if(a.includes(13)){l=indexOf(13);a.splice(l,a.length-l-1);alert(a);}if(a.includes(2)){for(var i in a)if(a[i]%2)a.splice(i,1);alert(a);}if(a.includes(20)&&(!a[3]%2)){alert('20');throw new Error();}do{l=a.reduce((total,num)=>total+num);if(l>50)a.splice(a.length-1,1);}while(l>50);alert(a);alert(l);if(a.includes(16))alert(l.toString(16));

Java 7, 622 619 618 Bytes

import java.util.*;void c(){Random r=new Random();List<Long>l=new ArrayList();int i=0,c=r.nextInt(6)+5;for(;i++<c;l.add(r.nextInt(20)+1L));p(l);if(l.contains(7)){for(i=0;i<c;l.set(i,l.get(i++)-1));p(l);}if(l.contains(0)){for(i=0;i<c;l.set(i,l.get(i++)+1));p(l);}if((i=l.indexOf(13))>=0){for(;i<l.size();l.remove(i));p(l);}if(l.contains(2)){for(i=0;i<l.size();)if(l.get(i)%2>0)l.remove(l.get(i));else i++;p(l);}if(l.contains(20)){p(20*(l.get(2)%2<1?1:l.size()));return;}i=0;for(long x:l)i+=x;for(;i>50;)i-=l.remove(l.size()-1);p(l);if(l.contains(16))p(Byte.valueOf(i+"",16));p(i);}<T>void p(T t){System.out.println(t);}

-1 Byte dank @Poke

Erläuterung:

import java.util.*;                      // Imports used for List, ArrayList and Random

void c(){                                // Main method
  Random r=new Random();                 //  Random generator
  List<Long>l=new ArrayList();           //  The list
  int i=0,                               //  Temp index we use multiple times
      q=r.nextInt(6)+5;                  //  Random size of the list (5-10)
  for(;i++<q;l.add(r.nextInt(20)+1L));   //  Fill the list with random long-integers (1-20)
  p(l);                                  //  Print the initial list
  if(l.contains(7)){                     //  If the list contains a 7
    for(i=0;i<c;l.set(i,l.get(i++)-1));  //   Decrease each number in the list by 1
    p(l);                                //   And then print the list again
  }                                      //  End of if
  if(l.contains(0)){                     //  If the list now contains a 0
    for(i=0;i<c;l.set(i,l.get(i++)+1));  //   Increase each number in the list by 1
    p(l);                                //   And then print the list again
  }                                      //  End of if
  if((i=l.indexOf(13))>=0){              //  If the list contains a 13 (and save it's index in `i` at the same time)
    for(;i<l.size();l.remove(i));        //   Remove everything from that index and onward
    p(l);                                //   And then print the list again
  }                                      //  End of if
  if(l.contains(2)){                     //  If the list now contains a 2
    for(i=0;i<l.size();)                 //   Loop over the list
      if(l.get(i)%2>0)                   //    If the current list item is odd
        l.remove(l.get(i));              //     Remove it
      else                               //    If it's even instead
        i++;                             //     Go to the next item
                                         //   End of loop (implicit / single-line body)
    p(l);                                //   And print the list again
  }                                      //  End of if
  if(l.contains(20)){                    //  If the list now contains a 20
    p(20*(l.get(2)%2<1?1:l.size()));     //   Print 20 if the third item in the list is odd, or 20*size if it's even instead
    return;                              //   And then terminate the method
  }                                      //  End of if
  i=0;                                   //  Reset `i` to 0
  for(long x:l)i+=x;                     //  And calculate the total sum of the list (stored in `i`)
  for(;i>50;)                            //  Loop as long as this list's sum is above 50
    i-=l.remove(l.size()-1);             //   Subtract the last item from this sum, and then remove it from the list
                                         //  End of loop (implicit / single line body)
  p(l);                                  //  And print the list again
  if(l.contains(16))                     //  If the list now contains a 16
    p(Byte.valueOf(i+"",16));            //   Print the sum (still stored in `i`) as hexadecimal
                                         //  End of if (implicit / single-line body)
  p(i);                                  //  And print the sum as integer either way
}                                        // End of main method

<T>void p(T t){                          // Separate method with a generic parameter
  System.out.println(t);                 //  Print the given parameter including a new-line
}                                        // End of separated method

Beispielausgaben:
Kommentare hinter den Beispielausgaben werden nicht gedruckt, aber ich habe sie zur Verdeutlichung hinzugefügt.

Probieren Sie es hier aus.

[17, 5, 3, 1, 16, 17, 11, 7, 13]   // Initial print (size 9)
[16, 4, 2, 0, 15, 16, 10, 6, 12]   // Rule 1 (contains a 7)
[17, 5, 3, 1, 16, 17, 11, 7, 13]   // Rule 2 (contains a 0)
[17, 5, 3, 1, 16, 17, 11, 7]       // Rule 3 (contains a 13)
[17, 5, 3, 1, 16]                  // Rule 6 (sum must be <= 50)
66                                 // Rule 7 (contains a 16 -> print as Hexadecimal)
42                                 // Print sum as integer

[4, 18, 17, 12, 11, 8]             // Initial print (size 6)
[4, 18, 17]                        // Rule 6 (sum must be <= 50)
39                                 // Print sum as integer

[4, 14, 6, 14, 7, 20, 2, 2]        // Initial print (size 8)
[3, 13, 5, 13, 6, 19, 1, 1]        // Rule 1 (contains a 7)
[3]                                // Rule 3 (contains a 13)
[3]                                // Print is always done after rule 6
3                                  // Print sum as integer

Ruby 2.4, 260 Bytes

Ruby 2.4 wird benötigt für Enumerable#sum.

p a=(1..s=5+rand(5)).map{1+rand(19)}
a.map!{|i|i-1}if a.index 7
p a
a.map!{|i|i+1}if a.index 0
p a
a.pop s-(a.index(13)||s)
p a
a.reject! &:odd?if a.index 2
p a
a.index(20)?p(20*[1,s][(a[2]||1)%2]):((a.pop;p a)while a.sum>50
p m=a.sum;puts"%x"%m if a.index 16)

Probieren Sie es online aus! (Weder repl.it noch tio.run Unterstützung Ruby - 2.4 noch, so dass diese Online - Version ersetzt summit inject(:+), die das gleiche Verhalten hat.)

R (3.3.1), 325 Bytes

Ziemlich naive Umsetzung; Ich denke, ich kann es wahrscheinlich etwas kürzer machen.

s=sample(1:20,sample(5:10,1));print(s);if(7%in%s){s=s-1;print(s);if(0%in%s)s=s+1;print(s)};if(13%in%s){s=s[1:(which(s==13)-1)];print(s)};if(2%in%s){s=s[!(s%%2)];print(s)};if(20%in%s){if(s[3]%%2){20*length(s);print(s)}else{20;print(s)}};while(sum(s)>50){s=s[-length(s)];print(s)};if(16%in%s){print(as.hexmode(sum(s)))};sum(s)

PowerShell , 525 413 Byte

filter a{"$a"};0..(4..9|random)|%{$a+=@(1..20|random)};a;if(7-in$a){$a=($a|%{$_-1});a;if(0-in$a){$a=($a|%{$_+1});a}}$b=$a;$a=@();foreach($z in $b){if($z-ne13){$a+=@($z)}else{a;break}}if(2-in$a){$a=($a|?{$_%2-eq0});a}if(20-in$a){if($a[2]%2){20*$a.count;exit}else{20;exit}}while(($h=$a-join'+'|iex)-gt50){$a=$a[0..($a.count-2)];a}if(16-in$a){$l=0..9+'a b c d e f'-split' ';$q=[math]::floor($h/16);"$q"+$l[$h%16]};$h

Probieren Sie es online aus!

Ich wollte es versuchen, obwohl ich dachte, ich würde die Antworten hier schon nicht übertreffen: PI hat immer noch versucht, dies zu verbessern, ich bin sicher, dass es mit weniger Bytes möglich ist. Fand eine bessere Methode für Hex, könnte sich aber wahrscheinlich noch verbessern.

Musste $aso oft in einen String umwandeln, dass es besser war, einen Filter dafür zu erstellen ...

Es gab einige einfache Golfplätze, die ich vermisst habe, wie Klammern und Leerzeichen. Könnte es noch welche geben?

Etwas einfacher zu lesender Code:

filter a{"$a"};0..(4..9|random)|%{$a+=@(1..20|random)};a;
if(7-in$a){$a=($a|%{$_-1});a;if(0-in$a){$a=($a|%{$_+1});a}}
$b=$a;$a=@();foreach($z in $b){if($z-ne13){$a+=@($z)}else{a;break}}
if(2-in$a){$a=($a|?{$_%2-eq0});a}
if(20-in$a){if($a[2]%2){20*$a.count;exit}else{20;exit}}
while(($h=$a-join'+'|iex)-gt50){$a=$a[0..($a.count-2)];a}
if(16-in$a){$l=0..9+'a b c d e f'-split' ';$q=[math]::floor($h/16);"$q"+$l[$h%16]};$h

MATLAB, 275 Bytes

Ich hatte ursprünglich eine einzeilige Octave-Antwort geplant, aber die Ausgabe aller angewandten Regeln verlangte meine Pläne. Stattdessen eine ziemlich einfache MATLAB-Antwort mit einigen interessanten Optimierungen, z. B. die Verwendung von cumsumanstelle der offensichtlichen whilefür Regel 6. Dennoch wird ein Großteil der Byteanzahl für ifs verschwendet , um die Ausgabe zu verhindern, wenn eine Regel nicht angewendet wird.

A=randi(20,1,randi(6)+4)
if any(A==7)
A=A-1
if any(~A)
A=A+1
end;end
q=find(A==13,1);if q
A=A(1:q-1)
end
if any(A==2)
A=A(2:2:end)
end
if any(A==20)
if mod(A(3),2)
20*length(A)
else
20
end;return;end
q=cumsum(A)<51;if any(~q)
A=A(q)
end
q=sum(A)
if(any(A==16))
dec2hex(q)
end

Probieren Sie es online aus!

Scala 587 Bytes ein Liner

import scala.util.Random;object A{def main(args:Array[String])={val s=5+Random.nextInt(6);var a=new Array[Int](s);for(i<-1 to s){a(i-1)=1+Random.nextInt(20)};p(a);if(a.contains(7)&& !a.contains(1)){a.map(a=>a-1);p(a)};if(a.contains(13)){if(a(0)==13)a=new Array[Int](0)else a=a.slice(0,a.indexOf(13));p(a)};if(a.contains(2)){a=a.filter(pred=>pred%2==0);p(a)};if(a.contains(20)){if(a(2)%2==0)println(20)else println(20*a.length)}else{while(a.sum>50)a=a.dropRight(1);val u=a.sum;if(a.contains(16))println(Integer.toHexString(u));println(u)}};def p[T](a: Array[T])=println(a.mkString(","))}

Scala, 763 Bytes wie es ist

import scala.util.Random
object TA {
  def main(args:Array[String])={
    val s=5+Random.nextInt(6)
    var a=new Array[Int](s)
    for (i<-1 to s)
      a(i-1)=1+Random.nextInt(20)
    p(a)
    if(a.contains(7) && !a.contains(1)){
      a.map(a=>a-1)
      p(a)
    }
    if(a.contains(13)){
      if (a(0)==13) a=new Array[Int](0) else a=a.slice(0,a.indexOf(13))
      p(a)
    }
   if(a.contains(2)){
      a=a.filter(pred=>pred%2== 0)
      p(a)
    }
    if(a.contains(20)){
      if (a(2)%2==0) println(20) else println(20*a.length)
    }else{
      while(a.sum>50)
        a=a.dropRight(1)
      val u =a.sum
      if (a.contains(16)) println(Integer.toHexString(u))
      println(u)
    }
  }
  def p[T](a: Array[T])={
    println(a.mkString(","))
  }
}

MATLAB, 228 241 Byte

a=randi(20,1,randi(6)+4)
b=@any; 
a=a-b(a==7)
a=a+b(a==0)
a(find(a==13,1):end)=[]
a(and(mod(a,2),b(a==2)))=[]
if b(a==20)
a=[a 0 0 0];
s=20*(1+mod(a(3),1)*(numel(a)-4))
else
a(cumsum(a)>50)=[]
s=sum(a)
if b(a==16)
h=['0x' dec2hex(s)]
end
end

Dadurch werden alle Regeln der Reihe nach angewendet und der Array-Wert nach jedem Schritt gedruckt.

Das Programm stürzt nach Regel 5 ab, wenn die resultierende Anzahl von Elementen weniger als drei beträgt. Es gibt derzeit nichts zu sagen, was passieren soll, wenn es kein drittes Element gibt, daher gehe ich davon aus, dass ein Absturz akzeptabel ist. Das Programm druckt jetzt 20, wenn weniger als 3 Elemente vorhanden sind und eines oder mehrere eine 20 sind.

Interessanterweise kann Schritt 2 angewendet werden, unabhängig davon, ob Schritt 1 war. Dies liegt daran, dass das Eingabearray niemals eine 0 enthält, was bedeutet, dass, wenn das Array 0 enthält, dies das Ergebnis von Schritt 1 sein muss.

Alle Regeln werden nacheinander bis 5 angewendet, auch wenn keine Änderungen vorgenommen wurden. Infolgedessen wird das Array zu Beginn und dann nach jedem Schritt bis 5 gedruckt. Nach Schritt 5 erhalten Sie entweder die Summe, wenn sie angewendet wird, oder erst nach Schritt 6 eine Ausgabe. Eine zusätzliche Zeile mit akann danach hinzugefügt werden die else-Anweisung, um sicherzustellen, dass der Array-Wert nach Schritt 5 auf Kosten von 2 Bytes gedruckt wird.

Ich möchte auch erwähnen, dass ich mir die anderen Antworten erst angesehen habe, nachdem ich dies geschrieben hatte. Ich sehe jetzt, dass es eine andere MATLAB-Antwort mit einigen Ähnlichkeiten gibt - die alle zufällig sind.

Python 3, 297 293 289 , 278 Bytes

Wie Arnauld bemerkte, können Sie nur dann 0 erhalten, wenn Regel 1 angewendet wurde, die beim Einrücken gespeichert wurde. Vielen Dank an alle anderen, die ebenfalls Vorschläge gemacht haben.

from random import*
p=print
a=b=sample(range(1,20),randint(5,10))
p(a)
if 7in a:a=[i-1for i in a];p(a)
if 0in a:a=b;p(a)
if 13in a:a=a[:a.index(13)];p(a)
if 2in a:a=[i for i in a if~i%2];p(a)
if 20in a and~a[2]%2:a=[20]
while sum(a)>50:a=a[:-1]
b=sum(a)
p(b)
if 16in a:p(hex(b))

Probieren Sie es online aus

Perl 6 , 246 Bytes

my&f={.grep($^a)};my&s=->{.say};$_=[(1..20).pick xx(5..10).pick];s;$_»--
if f 7;s;$_»++ if f 0;s;.splice(.first(13):k//+$_);s;$_=[f*%%2]if f 2;
s;say(20*(.[2]%%2||$_)),exit if $_>2&&f 20;s;.pop while
.sum>49;$/=f 16;$_=.sum;s;.base(16).say if $/

Ungolfed:

my &f = { .grep($^a) };  # Helper function: search $_ for something
my &s = -> { .say };     # Helper function: print $_
$_ = [ (1..20).pick xx (5..10).pick ];  # Generate the initial array
s;  # Print the array
$_»-- if f 7;  # Decrement all elements if it contains a 7
s;  # Print the array
$_»++ if f 0;  # Increment all elements if a zero is found
s;  # Print the array
.splice(.first(13):k // +$_);  # Splice out everything from the first 13 onward
s;  # Print the array
$_ = [ f *%%2 ] if f 2;  # Remove all odd elements if a 2 is found
s;  # Print the array
say(20*(.[2] %% 2 || $_)), exit if $_ > 2 && f 20;  # Print and exit, maybe
s;  # Print the array
.pop while .sum > 49;  # Remove elements from the end until sum is below 50
$/ = f 16;  # Save in $/ whether $_ contains a 16
$_ = .sum;  # Set $_ to its own sum
s;  # Print the sum
.base(16).say if $/  # Print the sum in hexadecimal if the last array contained a 16

Common Lisp, 490 Bytes

Hier wird das Array als Common Lisp-Liste dargestellt.

(let((a(loop for i from 1 to(+ 5(random 5))collect(1+(random 19)))))(flet((p()(format t"~a~%"a))(m(x)(member x a))(h(x)(map-into a x a)))(p)(and(m 7)(h'1-))(p)(and(m 0)(h'1+))(p)(let((p(position 13 a)))(and p(setf a(butlast a (-(length a)p)))))(p)(and(m 2)(setf a(remove-if'oddp a)))(p)(or(and(m 20)(or(and(third a)(oddp(third a))(* 20(length a)))20))(p)(and(setf a(loop for x in a sum x into s while (<= s 50) collect x)) nil)(p)(let((s(reduce'+ a)))(print s)(and(m 16)(format t"~x"s))))))

Wie üblich großer Einsatz von andund orals Kontrollstrukturen.

(let ((a (loop for i from 1 to (+ 5 (random 5))  ; create initial list
            collect (1+ (random 19)))))
  (flet ((p () (format t "~a~%" a))     ; auxiliary functions: print list
         (m (x) (member x a))           ; check membership
         (h (x) (map-into a x a)))      ; operate on elements
    (p)
    (and (m 7) (h '1-))                 ; if 7 is present decrement all values
    (p)
    (and (m 0) (h '1+))                 ; if 0 is now present increment all values
    (p)
    (let ((p (position 13 a)))          ; remove from 13 (if exists)
      (and p (setf a (butlast a (- (length a) p)))))
    (p)
    (and (m 2) (setf a (remove-if 'oddp a)))   ; if 2 is present remove odd values
    (p)
    (or (and (m 20)                            ; if 20 is present
             (or (and (third a)                ;    when third is present
                      (oddp (third a))         ;         and it is odd
                      (* 20 (length a)))       ;         return 20 times the length
                 20))                          ;    otherwise return 20
        (p)                                    ; otherwise (20 is not present)
        (and (setf a (loop for x in a sum x into s ; compute sum of elements
                        while (<= s 50)            ; limited to 50
                        collect x))                ; and return those elements
             nil)                                  ; (to execute the rest of the code)
        (p)
        (let ((s (reduce '+ a)))                   ; compute the final sum
          (print s)                                ; print the result in decimal
          (and (m 16) (format t "~x" s))))))       ; if 16 is present print also in hexadecimal