Le récapitulatif

Créez un programme qui génère un tableau de longueur aléatoire avec des nombres aléatoires, puis appliquez une série de règles qui modifient le tableau. Une fois les règles appliquées, imprimez la somme du tableau, sauf indication contraire

Configuration de la baie

Le tableau doit avoir une longueur aléatoire comprise entre 5 et 10 inclus, avec des entiers aléatoires compris entre 1 et 20 inclus. Chaque longueur de tableau doit avoir une probabilité égale de se produire et chaque entier doit avoir une probabilité égale d'être sélectionné par élément.

Les 7 règles

Les règles doivent agir comme si elles étaient appliquées dans l'ordre (par exemple: la règle 1 agit avant la règle 2) et ne sont appliquées qu'une seule fois. Pour prouver l'application des règles, le tableau doit être imprimé sur la console après chaque application de règles et une fois avant l'application des règles.

1. Si le tableau contient un 7, soustrayez 1 de chaque élément
2. Si la règle 1 est appliquée et que le tableau contient maintenant un 0, ajoutez 1 à chaque élément
3. Si le tableau contient un 13, excluez le 13 et tous les éléments qui suivent du tableau
4. Si le tableau contient un 2, excluez tous les nombres impairs
5. Si le tableau contient un 20 et que le troisième élément est pair, retournez 20 comme somme, puis terminez. Si un 20 est présent et que le troisième élément est impair, renvoyez 20 fois la longueur du tableau comme somme puis terminez.
6. Si la somme est supérieure à 50, supprimez le dernier élément à plusieurs reprises jusqu'à ce qu'il soit inférieur ou égal à 50
7. Si le tableau contient un 16, imprimez la somme en décimal et en hexadécimal.

Exemple

Voici un tableau initial,

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

La règle 1 peut être appliquée:

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

La règle 3 s'applique ensuite:

[19, 1, 4, 6]

Aucune autre règle n'est nécessaire, le programme renvoie donc 30 comme somme.

Remarques

• Je ne suis pas un golfeur de code expérimenté, bien que je puisse dire que mon dossier personnel est en Python 3 avec 369 octets .
• Les règles ne doivent pas réellement être appliquées dans l'ordre, mais doivent agir comme si elles le faisaient.

Python 3, 294 301 287 356 octets

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)

Je ne sais pas comment vous allez empêcher les gens de contourner les règles, mais celui-ci utilise la procédure spécifiée.

+7 octets; merci à @YamB pour avoir économisé quelques octets; ajouté beaucoup plus pour corriger une erreur précédente.
-14 octets grâce à @RootTwo et moi-même et également corrigé l'erreur.
+83 octets; cela devient horriblement long car OP continue de changer les règles. -un certain nombre d'octets grâce à @ZacharyT

05AB1E , 91 octets

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

Essayez-le en ligne! ou avec entrée

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

Huzzah! Enfin à égalité avec battre Arnauld !

À la suite de cet échange * dans les commentaires du défi et après de nombreuses délibérations, j'ai décidé d'utiliser new Datecomme graine pour le générateur de nombres aléatoires au lieu de Math.random(). Cela signifie que tous les entiers du tableau auront la même valeur.

_=>(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)

Essayez-le

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())

• Enregistré 2 octets en enregistrant uniquement les éléments sautés dans la règle 6.
• Enregistré 2 octets en le remplaçant Array(x).fill()par [...Array(x)].
• Ajout de 2 octets car je me suis trompé sur la règle 5!
• 7 octets enregistrés pour réparer le désordre que j'ai fait en essayant de réparer le désordre précédent!
• Enregistré 3 octets grâce à Arnauld qui m'a aidé à guérir un brainfart sur la règle 2 et enregistré un octet supplémentaire en remplaçant a +1par a ~.
• Ajout de 2 octets garantissant le 0retour d'un tableau vide.
• Économisé 20 octets en trouvant enfin comment abandonner cette whileboucle.
• Enregistré 2 octets en remplaçant ,entre les 2 dernières instructions par un |et en supprimant le boîtier ().
• Enregistré 6 octets en remplaçant console.logpar alert.
• Sauvegardé 7 octets en améliorant le raccourci de a.includes().
• 1 octet enregistré en modifiant l'implémentation de la règle 3.
• Enregistré 7 octets en abandonnant includes()et en utilisant indexOf()tout au long.
• Enregistré 1 octet en déplaçant la déclaration initiale de la svariable dans un endroit où elle n'a pas besoin d'une virgule.
• Enregistré 6 octets en remplaçant Math.random()par new Date.
• 4 octets enregistrés en supprimant l'arrondi (désormais redondant) des nombres aléatoires.

Version lisible et testable

• Ajout de sauts de ligne et de commentaires au code
• Utilisé console.logau lieu de alertpour votre santé mentale! (Meilleur affichage dans la console de votre navigateur)
• Ajout du numéro de règle actuel à la sortie.
• Mise en commentaire de la génération de tableaux aléatoires pour permettre les tests par entrée d'une liste de nombres séparés par des virgules.

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>

* Capture d'écran, au cas où elle serait supprimée:

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

Il y a beaucoup de golf nécessaire ici ... Correction d'un bug où il imprimait l'hexidécimal une fois pour chaque 16 dans la liste ...

Un merci spécial à ZacharyT avec l'aide du golf

#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);}

Essayez-le en ligne!

JavaScript (ES6), 296 295 290 289 octets

Un programme complet qui enregistre le tableau initial, les résultats intermédiaires et la somme finale sur la console.

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)

Comment ça fonctionne

Cela a été compressé à l'aide de ce packer JS .

Panne:

• Chaîne compressée: 226 225 octets
• Code de déballage: 69 64 octets

Vous trouverez ci-dessous le code source d'origine avec des espaces supplémentaires et des sauts de ligne pour plus de lisibilité. Plutôt que d'appliquer des tours de golf standard, il a été écrit de manière à produire autant de cordes répétitives que possible afin de plaire à l'emballeur. Par exemple, la syntaxe if(k=~a.indexOf(N))est dupliquée partout mais kn'est utilisée que dans la 3e règle.

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))
}

Méthodes de déballage

Le code de déballage d'origine est:

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

Toutes les variantes ES6 suivantes ont exactement la même taille:

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])

La seule façon que j'ai trouvée jusqu'à présent pour raser quelques octets est d'utiliser for ... of:

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

Essayez d'abord le code golf!

Déjà battu par d'autres javascript! Dangit! J'améliorerai!!! =)

Javascript -> 550 402 octets

Pourrait certainement être amélioré. Comprimé maintenant:

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 octets

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 octet grâce à @Poke

Explication:

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

Exemples de sorties: Les
commentaires derrière les exemples de sorties ne sont pas imprimés, mais je les ai ajoutés à titre de clarification.

Essayez-le ici.

[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 octets

Ruby 2.4 est requis pour 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)

Essayez-le en ligne! (Ni repl.it ni tio.run ne prennent en charge Ruby 2.4 pour le moment, donc cette version en ligne remplace sumpar inject(:+), qui a le même comportement.)

R (3.3.1), 325 octets

Implémentation assez naïve; Je pense que je peux probablement le raccourcir un peu.

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 octets

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

Essayez-le en ligne!

Je voulais essayer celui-ci même si je pensais que je ne battrais pas déjà les réponses ici: PI a essayé de jouer au golf encore, je suis sûr que c'est possible avec moins d'octets. Trouvé une meilleure méthode pour l'hexagone, mais pourrait probablement encore s'améliorer.

J'ai dû transtyper $aune chaîne tellement de fois qu'il valait mieux créer un filtre pour elle ...

Il y a eu pas mal de golfs faciles, comme les parenthèses et les espaces. Pourrait-il encore y en avoir?

Code un peu plus facile à lire:

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 octets

À l'origine, j'avais prévu une réponse Octave à une ligne, mais exiger la sortie de toutes les règles appliquées a contrecarré mes plans. Au lieu de cela, une réponse MATLAB assez simple avec quelques optimisations intéressantes, par exemple l'utilisation de cumsumau lieu de l'évidence whilepour la règle 6. Pourtant, une grande partie du nombre d'octets est gaspillée en ifs pour empêcher la sortie si une règle n'est pas appliquée.

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

Essayez-le en ligne!

Scala 587 octets un 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 octets en l'état

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 octets

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

Cela appliquera toutes les règles dans l'ordre, en imprimant la valeur du tableau après chaque étape.

Le programme plantera sur la règle 5 si le nombre d'éléments résultant est inférieur à trois. Il n'y a actuellement rien pour dire ce qui devrait arriver s'il n'y a pas de troisième élément, donc je suppose qu'un crash est acceptable. Le programme imprimera maintenant 20 s'il y a moins de 3 éléments et un ou plusieurs est un 20.

Il est intéressant de noter que l'étape 2 peut être appliquée, que l'étape 1 le soit ou non. Cela est dû au fait que le tableau d'entrée n'aura jamais de 0, ce qui signifie que s'il y a des 0 dans le tableau, cela doit être le résultat de l'étape 1.

Toutes les règles sont appliquées à tour de rôle, jusqu'à 5, même si aucune modification n'est apportée. Par conséquent, le tableau sera imprimé au début, puis après chaque étape jusqu'à 5. Après l'étape 5, vous obtiendrez la somme si elle est appliquée, ou aucune sortie jusqu'à après l'étape 6. Une ligne supplémentaire contenant apourrait être ajoutée après l'instruction else pour garantir que la valeur du tableau est imprimée après l'étape 5 au prix de 2 octets.

Je voudrais également mentionner que je n'ai pas regardé les autres réponses avant d'avoir écrit cela. Je vois maintenant qu'il y a une autre réponse MATLAB avec quelques similitudes - qui sont toutes fortuites.

Python 3, 297 293 289 , 278 octets

Comme Arnauld l'a repéré, vous ne pouvez obtenir 0 que si la règle 1 a été appliquée, ce qui a permis d'économiser lors du retrait. Merci à tous ceux qui ont également commenté leurs suggestions.

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))

Essayez-le en ligne

Perl 6 , 246 octets

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 $/

Non golfé:

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

Lisp commun, 490 octets

Ici, le tableau est représenté comme une liste Common Lisp.

(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))))))

Comme d'habitude, grande utilisation de andet orcomme structures de contrôle.

(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