Bieg do dołu

Utwórz program, który generuje tablicę o losowej długości z liczbami losowymi, a następnie zastosuj szereg reguł, które zmieniają tablicę. Po zastosowaniu reguł wydrukuj sumę tablicy, chyba że określono inaczej

Konfiguracja macierzy

Tablica musi mieć losową długość od 5 do 10 włącznie, z losowymi liczbami całkowitymi od 1 do 20 włącznie. Każda długość tablicy powinna mieć jednakowe prawdopodobieństwo wystąpienia, a każda liczba całkowita powinna mieć równe prawdopodobieństwo pobrania na element.

7 zasad

Reguły powinny działać tak, jakby były stosowane kolejno (np. Reguła 1 działa przed regułą 2) i są stosowane tylko raz. W celu potwierdzenia zastosowania reguły tablica musi zostać wydrukowana w konsoli po każdej aplikacji reguły i raz przed zastosowaniem jakichkolwiek reguł.

1. Jeśli tablica zawiera 7, odejmij 1 od każdego elementu
2. Jeśli reguła 1 zostanie zastosowana, a tablica zawiera teraz 0, dodaj 1 do każdego elementu
3. Jeśli tablica zawiera 13, wyklucz 13 i wszystkie kolejne elementy z tablicy
4. Jeśli tablica zawiera 2, wyklucz wszystkie nieparzyste liczby
5. Jeśli tablica zawiera 20, a trzeci element jest parzysty, zwróć 20 jako sumę, a następnie zakończ. Jeśli występuje 20, a trzeci element jest nieparzysty, zwróć 20 razy długość tablicy jako sumę, a następnie zakończ.
6. Jeśli suma jest większa niż 50, usuwaj ostatni element wielokrotnie, aż będzie mniejszy lub równy 50
7. Jeśli tablica zawiera 16, wypisz sumę zarówno w systemie dziesiętnym, jak i szesnastkowym.

Przykład

Oto tablica początkowa,

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

Regułę 1 można zastosować:

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

Następnie stosuje się zasadę 3:

[19, 1, 4, 6]

Żadne inne reguły nie są potrzebne, więc program zwraca 30 jako sumę.

Notatki

• Nie jestem doświadczonym golfistą, chociaż mogę powiedzieć, że mój osobisty rekord znajduje się w Pythonie 3 z 369 bajtami .
• Reguły nie muszą być faktycznie stosowane w kolejności, ale muszą działać tak, jakby miały.

Python 3, 294 301 287 356 bajtów

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)

Nie wiem, w jaki sposób zapobiegniesz obchodzeniu reguł przez ludzi, ale w tym przypadku wykorzystano określoną procedurę.

+7 bajtów; dzięki @YamB za zaoszczędzenie kilku bajtów; dodano wiele więcej, aby naprawić poprzedni błąd.
-14 bajtów dzięki @RootTwo i mnie, a także poprawiłem błąd.
+83 bajtów; robi się to strasznie długo, ponieważ OP ciągle zmienia zasady. - pewna liczba bajtów dzięki @ZacharyT

05AB1E , 91 bajtów

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

Wypróbuj online! lub z wejściem

JavaScript (ES6), 344 342 340 342 335 331 333 313 311 305 298 297 290 289 283 279 bajtów

Huzzah! Wreszcie związany z dudnienia Arnauld !

Po tej wymianie * w komentarzach wyzwania i po długich rozważaniach postanowiłem użyć new Datejako źródła dla generatora liczb losowych zamiast Math.random(). Oznacza to, że wszystkie liczby całkowite w tablicy będą miały tę samą wartość.

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

Spróbuj

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

• Zapisano 2 bajty, rejestrując tylko wyskakujące elementy w regule 6.
• Zapisano 2 bajty, zastępując Array(x).fill()je [...Array(x)].
• Dodano 2 bajty, bo zawiodłem na regule 5!
• Zapisałem 7 bajtów naprawiając bałagan, który zrobiłem próbując naprawić poprzedni bałagan!
• Zapisany 3 bajty dzięki Arnaulda pomaga mi wyleczyć brainfart na regułę 2 i zapisane dodatkowy bajt przez wymieniając +1z ~.
• Dodano 2 bajty zapewniające 0zwrócenie pustej tablicy.
• Zaoszczędź 20 bajtów, w końcu zastanawiając się, jak porzucić tę whilepętlę.
• Zaoszczędzono 2 bajty, zastępując ,ostatnie 2 instrukcje a |i usuwając załączające ().
• Zaoszczędzono 6 bajtów, zastępując console.logje alert.
• Zaoszczędzono 7 bajtów, poprawiając skrót do a.includes().
• Zapisano 1 bajt, edytując implementację reguły 3.
• Zaoszczędzono 7 bajtów, porzucając includes()i wykorzystując indexOf()cały czas.
• Zaoszczędzono 1 bajt, przenosząc początkową deklarację szmiennej do miejsca, w którym nie potrzebował przecinka.
• Zaoszczędzono 6 bajtów, zastępując Math.random()je new Date.
• Zaoszczędzono 4 bajty, usuwając (teraz nadmiarowe) zaokrąglanie liczb losowych.

Wersja do odczytu i testowania

• Dodano podział wiersza i komentarze do kodu
• Używane console.logzamiast alertdla twojego zdrowia psychicznego! (Najlepiej oglądać w konsoli przeglądarki)
• Dodano bieżący numer reguły do ​​wyniku.
• Skomentowano losowe generowanie tablic, aby umożliwić testowanie poprzez wprowadzenie listy liczb oddzielonych przecinkami.

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>

* Zrzut ekranu, w przypadku jego usunięcia:

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

Potrzebna jest tutaj cała gra w golfa ... Naprawiono błąd, w którym drukowałby szesnastkowy raz na każde 16 na liście ...

Specjalne podziękowania dla ZacharyT z pomocą golfa

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

Wypróbuj online!

JavaScript (ES6), 296 295 290 289 bajtów

Pełny program, który rejestruje tablicę początkową, wyniki pośrednie i ostateczną sumę do konsoli.

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)

Jak to działa

Zostało to skompresowane przy użyciu tego pakera JS .

Awaria:

• Pakowany ciąg: 226 225 bajtów
• Kod rozpakowywania: 69 64 bajtów

Poniżej znajduje się oryginalny kod źródłowy z dodatkowymi białymi znakami i wierszami dla zwiększenia czytelności. Zamiast stosowania standardowych sztuczek golfowych, został napisany w taki sposób, aby uzyskać jak najwięcej powtarzających się ciągów, aby zadowolić pakującego. Na przykład składnia if(k=~a.indexOf(N))jest powielana wszędzie, chociaż kjest używana tylko w trzeciej regule.

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

Metody rozpakowywania

Oryginalny kod rozpakowywania to:

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

Wszystkie następujące warianty ES6 mają dokładnie ten sam rozmiar:

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

Jedyny sposób, w jaki do tej pory udało mi się ogolić kilka bajtów, to użycie for ... of:

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

Najpierw spróbuj golfa code!

Już pobity przez innych javascripters! Cholera! Ulepszę!!! =)

JavaScript -> 550 402 bajtów

Zdecydowanie można poprawić. Skompresowane teraz:

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)

Pierwotny:

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 bajtów

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 bajt dzięki @Poke

Wyjaśnienie:

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

Przykładowe wyniki:
Komentarze za przykładowymi wynikami nie są drukowane, ale dodałem je jako wyjaśnienie.

Wypróbuj tutaj.

[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 bajtów

Wymagany jest Ruby 2.4 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)

Wypróbuj online! (Ani repl.it ani tio.run nie obsługują jeszcze Ruby 2.4, więc ta wersja online zamienia sumsię na inject(:+), która ma takie samo zachowanie.)

R (3.3.1), 325 bajtów

Całkiem naiwne wdrożenie; Myślę, że prawdopodobnie mogę to trochę skrócić.

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 bajtów

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

Wypróbuj online!

Chciałem spróbować tego, choć doszedłem do wniosku, że już tutaj nie pobiję odpowiedzi: PI próbowałem jeszcze zagrać w golfa, jestem pewien, że jest to możliwe przy mniejszej liczbie bajtów. Znalazłem lepszą metodę dla heksów, ale prawdopodobnie mogłaby się jeszcze poprawić.

Musiałem rzucić $ana ciąg tyle razy, że lepiej było stworzyć dla niego filtr ...

Było kilka łatwych golfów, za którymi tęskniłem, takich jak nawiasy i spacje. Czy nadal może być jakiś?

Nieco łatwiejszy do odczytania kod:

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 bajtów

Pierwotnie planowałem być może odpowiedź na jedno-liniowe oktawę, ale wymaganie danych wyjściowych od wszystkich zastosowanych reguł pokrzyżowało moje plany. Zamiast tego dość prosta odpowiedź MATLAB z kilkoma interesującymi optymalizacjami, np. Użycie cumsumzamiast oczywistej whiledla reguły 6. Mimo to wiele s bajtów marnuje się na ifs, aby zapobiec wyjściu, jeśli reguła nie zostanie zastosowana.

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

Wypróbuj online!

Scala 587 bajtów jedna wkładka

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 bajtów, jak jest

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 bajtów

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

Spowoduje to zastosowanie wszystkich reguł w kolejności, drukując wartość tablicy po każdym kroku.

Program zawiesi się na zasadzie 5, jeśli wynikowa liczba elementów jest mniejsza niż trzy. Obecnie nie ma nic do powiedzenia, co powinno się stać, jeśli nie ma trzeciego elementu, więc zakładam, że awaria jest dopuszczalna.Program wydrukuje teraz 20, jeśli jest mniej niż 3 elementy, a jeden lub więcej to 20.

Co ciekawe krok 2 można zastosować niezależnie od tego, czy był to krok 1. Wynika to z faktu, że tablica wejściowa nigdy nie będzie miała wartości 0, co oznacza, że ​​jeśli w tablicy znajdują się jakieś zera, musi to wynikać z kroku 1.

Wszystkie reguły są stosowane kolejno, aż do 5, nawet jeśli nie zostaną wprowadzone żadne zmiany. W rezultacie tablica zostanie wydrukowana na początku, a następnie po każdym kroku do 5. Po kroku 5 albo otrzymasz sumę, jeśli zostanie zastosowana, albo nie otrzymasz danych wyjściowych do kroku 6. Dodatkowy wiersz zawierający amożna dodać po instrukcja else, aby upewnić się, że wartość tablicy jest drukowana po kroku 5 kosztem 2 bajtów.

Chciałbym również wspomnieć, że nie spojrzałem na inne odpowiedzi, dopóki nie napisałem tego. Widzę teraz, że istnieje inna odpowiedź MATLAB z pewnymi podobieństwami - wszystkie są przypadkowe.

Python 3, 297 293 289,278 bajtów

Jak zauważył Arnauld, nie możesz dostać 0, chyba że zastosowana zostanie reguła 1, co zaoszczędziło wcięcia. Dziękujemy wszystkim innym, którzy również komentowali sugestie.

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

Wypróbuj online

Perl 6 , 246 bajtów

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

Nie golfowany:

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 bajtów

Tutaj tablica jest reprezentowana jako wspólna lista 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))))))

Jak zwykle duże zastosowanie andi orjako struktury kontrolne.

(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