런 다운

난수로 임의 길이의 배열을 생성하는 프로그램을 작성한 다음 배열을 변경하는 일련의 규칙을 적용하십시오. 규칙을 적용한 후 별도로 지정하지 않는 한 배열의 합계를 인쇄하십시오.

배열 설정

배열은 5에서 10 사이의 임의의 길이 여야하며 1에서 20 사이의 임의의 정수 여야 합니다. 각 배열 길이는 발생 확률이 같아야하며 각 정수는 요소 당 선택할 확률이 동일해야합니다.

7 가지 규칙

규칙은 순서대로 적용된 것처럼 작동해야합니다 (예 : 규칙 1은 규칙 2보다 먼저 작동). 한 번만 적용됩니다. 규칙 적용 증명을 위해 각 규칙 적용 후 규칙이 적용되기 전에 한 번 배열을 콘솔에 인쇄해야합니다.

1. 배열에 모든 요소에서 1을 빼면 1이 빼기
2. 규칙 1이 적용되고 배열에 0이 포함 된 경우 각 요소에 1을 추가하십시오.
3. 배열에 13이 포함 된 경우 배열에서 13과 그 뒤에 나오는 모든 요소를 ​​제외합니다.
4. 배열에 2가 포함 된 경우 모든 홀수를 제외
5. 배열에 20이 포함되어 있고 세 번째 요소가 짝수이면 합으로 20을 반환 한 다음 종료합니다. 20이 있고 세 번째 요소가 홀수이면 배열 길이의 20 배를 합으로 반환 한 다음 종료합니다.
6. 합이 50보다 크면 마지막 요소가 50보다 작거나 같을 때까지 반복적으로 제거하십시오.
7. 배열에 16이 포함되어 있으면 10 진수와 16 진수로 합계를 인쇄하십시오.

예

초기 배열은 다음과 같습니다.

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

규칙 1을 적용 할 수 있습니다.

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

다음에 규칙 3이 적용됩니다.

[19, 1, 4, 6]

다른 규칙은 필요하지 않으므로 프로그램 은 합계 로 30 을 반환합니다 .

메모

• 내 개인 기록이 369 바이트 인 Python 3에 있다고 말할 수는 있지만 경험이 풍부한 코드 골퍼는 아닙니다 .
• 규칙을 실제로 순서대로 적용 할 필요는 없지만 마치 규칙처럼 행동해야합니다.

파이썬 3 294 301 287 356 바이트

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)

사람들이 규칙을 우회하는 것을 어떻게 막을 지 모르겠지만 지정된 절차를 사용합니다.

+7 바이트; 몇 바이트를 절약 한 @YamB 덕분에; 이전 오류를 수정하기 위해 훨씬 더 추가했습니다.
@RootTwo와 나 덕분에 -14 바이트와 오류를 수정했습니다.
+83 바이트; OP가 규칙을 계속 변경하기 때문에 끔찍하게 길어지고 있습니다. @ZacharyT 덕분에 일부 바이트 수

05AB1E , 91 바이트

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

온라인으로 사용해보십시오! 또는 입력

자바 (ES6) 344 342 340 342 335 331 333 313 311 305 298 297 290 289 283 279 바이트

후자! 비트 Arnauld 와 마지막으로 묶여 !

이 교환에 이어 챌린지의 의견과 많은 심의 후에 나는 new Date대신 난수 생성기의 시드 로 사용하기로 결정했습니다 Math.random(). 그렇게하면 배열의 모든 정수가 같은 값을 갖게됩니다.

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

시도 해봐

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

• 규칙 6에서 팝된 요소 만 로깅하여 2 바이트를 절약했습니다.
• 로 교체 Array(x).fill()하여 2 바이트를 절약 했습니다 [...Array(x)].
• 규칙 5에서 엉망이 되었기 때문에 2 바이트가 추가되었습니다!
• 이전 엉망진창을 고치려고했던 난장판 수정 7 바이트를 저장했습니다!
• Arnauld 덕분에 3 바이트를 절약하고 규칙 2에서 브레인 파트를 치료할 수있게했으며을로 바꾸어 추가 바이트를 절약 +1했습니다 ~.
• 0빈 배열에 대해 2 바이트 보장 이 추가되었습니다 .
• Fecking while루프 를 버리는 방법을 마침내 알아내어 20 바이트를 절약했습니다 .
• ,마지막 2 개의 문 사이를 a 로 바꾸고 |둘러싸는 것을 제거하여 2 바이트를 절약했습니다 ().
• 로 교체 console.log하여 6 바이트를 절약 했습니다 alert.
• 바로 가기를 개선하여 7 바이트를 절약했습니다 a.includes().
• 규칙 3의 구현을 편집하여 1 바이트를 절약했습니다.
• 도랑 당하고 전체를 includes()사용하여 7 바이트를 절약 indexOf()했습니다.
• s변수 의 초기 선언을 쉼표가 필요없는 곳 으로 이동하여 1 바이트를 절약 했습니다.
• 로 교체 Math.random()하여 6 바이트를 절약 했습니다 new Date.
• 난수의 (이중화) 반올림을 제거하여 4 바이트를 절약했습니다.

읽기 및 테스트 가능한 버전

• 코드에 줄 바꿈 및 주석 추가
• 당신의 정신을 console.log대신 사용 합니다 alert! (브라우저 콘솔에서 가장 잘 보입니다)
• 현재 규칙 번호를 출력에 추가했습니다.
• 쉼표로 구분 된 숫자 목록을 입력하여 테스트 할 수 있도록 임의 배열 생성을 주석 처리했습니다.

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>

* 삭제 된 경우 스크린 샷 :

C (GCC) , 621 (619) 593 585 570 562 557 552 529 517 500 482 461 444 442 441 438 바이트

여기에 많은 골프가 필요합니다 ... 목록의 16 개마다 16 진수를 한 번 인쇄하는 버그가 수정되었습니다 ...

골프의 도움으로 ZacharyT에게 특별한 감사

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 296 295 290 289 바이트

초기 배열, 중간 결과 및 최종 합계를 콘솔에 기록하는 전체 프로그램.

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)

작동 원리

이것은 이 JS 패커를 사용하여 압축되었습니다 .

고장:

• 압축 문자열 : 226225 바이트
• 포장 풀기 코드 : 69 64 바이트

아래는 가독성을 위해 추가 공백 및 줄 바꿈이있는 원본 소스 코드입니다. 표준 골프 트릭을 적용하는 대신 패커를 기쁘게하기 위해 가능한 한 많은 반복 현을 생성하는 방식으로 작성되었습니다. 예를 들어, 세 번째 규칙에서만 사용 if(k=~a.indexOf(N))되지만 구문 은 모든 곳에 복제 k됩니다.

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

포장 풀기 방법

원래 포장 풀기 코드는 다음과 같습니다.

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

다음 ES6 변형은 모두 동일한 크기를 갖습니다.

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

지금까지 내가 찾은 유일한 방법은 몇 바이트를 제거하는 것입니다 for ... of.

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

먼저 코드 골프를보십시오!

다른 자바 스크립트 사용자가 이미 이겼습니다! 단깃! 나는 개선 할 것이다 !!! =)

자바 스크립트-> 550402 바이트

확실히 향상 될 수 있습니다. 지금 압축 :

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)

원산지 :

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

자바 7, 622 619 618 바이트

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

@Poke 덕분에 -1 바이트

설명:

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

샘플 출력 : 샘플 출력
뒤에 주석이 인쇄되지 않지만 설명으로 추가했습니다.

여기에서 시도하십시오.

[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

루비 2.4, 260 바이트

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

온라인으로 사용해보십시오! repl.it 또는 tio.run은 아직 Ruby 2.4를 지원하지 않으므로이 온라인 버전은 sum으로 대체 되며 inject(:+)동일한 동작을 갖습니다.

R (3.3.1), 325 바이트

꽤 순진한 구현; 아마 조금 더 짧게 만들 수 있다고 생각합니다.

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 바이트

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

온라인으로 사용해보십시오!

나는 이미 여기에서 대답을 이길 수 없다고 생각했지만 이것을 시도하고 싶었다. 16 진수에 대한 더 나은 방법을 찾았지만 여전히 향상 될 수 있습니다.

$a문자열을 너무 많이 캐스팅 해야 필터를 만드는 것이 더 좋았습니다 ...

괄호와 공백과 같이 놓친 쉬운 골프가 몇 개있었습니다. 아직도 거기 있을지도 몰라?

다소 읽기 쉬운 코드 :

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 바이트

원래 한 줄짜리 Octave 답변을 계획했지만 모든 적용된 규칙의 출력을 요구하면 계획이 좌절되었습니다. 대신 규칙 6 cumsum에 대한 명백한 대신 사용하는 몇 가지 흥미로운 최적화를 통해 상당히 간단한 MATLAB의 대답입니다 while. 그럼에도 불구 if하고 규칙이 적용되지 않으면 출력을 방지하기 위해 많은 바이트 수가 낭비 됩니다.

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

온라인으로 사용해보십시오!

스칼라 587 바이트 한 라이너

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(","))}

스칼라, 763 바이트

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 241bytes

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

각 단계 후에 배열 값을 인쇄하여 모든 규칙을 순서대로 적용합니다.

결과 요소 수가 3보다 작 으면 규칙 5에서 프로그램이 충돌합니다. 현재 세 번째 요소가 없으면 어떻게해야할지 말할 것이 없으므로 충돌이 허용되는 것으로 가정합니다. 요소가 3 개 미만이고 하나 이상이 20 인 경우 프로그램은 이제 20을 인쇄합니다.

흥미롭게도 2 단계는 1 단계 여부에 관계없이 적용될 수 있습니다. 입력 배열에 0이 없기 때문에 배열에 0이 있으면 1 단계가 발생한 결과 여야합니다.

변경 사항이 없더라도 모든 규칙은 5까지 계속 적용됩니다. 결과적으로, 어레이의 시작에 인쇄되고 다음 단계 후 제 여분 라인이 함유 전까지가 적용되는 경우는 어느 합을 얻을 5 단계 후 5 일까지 각 단계까지, 또는 전혀 출력 a후에 첨가 될 수있다 else 문은 5 단계 후에 2 바이트의 비용으로 배열 값이 인쇄되도록합니다.

나는 이것을 작성하기 전까지 다른 답변을 보지 않았다고 언급하고 싶습니다. 필자는 일부 유사점에 대한 또 다른 MATLAB 답변이 있음을 알았습니다.

파이썬 3, 297 293 289 , 278 바이트

Arnauld가 발견했듯이 들여 쓰기로 저장되는 규칙 1이 적용되지 않으면 0을 얻을 수 없습니다. 의견을 말한 다른 사람들에게도 감사합니다.

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

온라인으로 사용해보십시오

펄 6 , 246 바이트

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

언 골프 드 :

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

공통 리스프, 490 바이트

여기서 배열은 공통 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))))))

평소 and와 or같이 제어 구조를 많이 사용 합니다.

(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