태그 보관물: expression-building

expression-building

공식 Dyalog APL 2016 년 게임 수 있습니다. 어떤 언어로든 답변

이것이 재미 있지만 너무 많은 일이라고 생각한다면, 이 작은 도전에 참여하는 것을 고려하십시오 .

2016 년 약간의 재미 (그리고 아마도 좌절!) … Dyalog의 “올해의 퍼즐” . 즐겨!

목표

숫자 0에서 100까지의 순서로 숫자 2 0 1 6을 정확하게 포함하는 Dyalog APL ( download ) 표현식 (다른 언어는 허용, 아래의 자격 참조)을 찾으십시오 . 예를 들면 다음과 같습니다.

20=16
×2016
2⌊016
2+0+1*6
…

목표는 각 표현식에서 가능한 한 적은 문자를 사용하는 것입니다 (표현의 최소 문자 수는 5 – 4 자리 숫자 2 0 1 6 및 단일 기본 함수 / 연산자).

규칙

  • 각 표현식은 숫자 2 0 1 6 (순서대로)을 포함하고 다른 숫자는 포함하지 않아야합니다. 사전 설정된 상수 및 변수도 허용되지 않습니다.
  • 4 자리 숫자 2 0 1 6 외에도 내장 기호 및 이름, 괄호 / 괄호, 공백, 높은 빼기 부호 및 소수점 만 사용할 수 있습니다. 결과 표현식은 결정적이어야합니다 (즉, 반복 평가에서 동일한 결과를 제공해야 함). APL이 아닌 경우 이름이있는 기능 / 연산자도 허용됩니다. 여기 와 같은 규칙 .
  • 언어에 대한 모든 기본 설정을 가정하십시오. Dyalog APL의 경우 이는 1을 의미 ⎕ML하며 10입니다.⎕IO⎕PP
  • 0에서 100까지의 모든 숫자에 대한 올바른 표현식으로 구성된 각 항목은 중복 공백을 제외한 해당 표현식에 사용 된 문자 수에 따라 등급이 매겨집니다 (모든 101 표현식에 대해 최소 505).

적임

누구나 들어갈 수 있습니다. 어떤 언어로든 답변 할 수 있지만 APL 답변 만 수락됩니다. APL 이외의 다른 언어를 사용하는 경우 스 니펫, 프로그램, 함수 등을 표현식 대신 사용할 수 있으며 코드를 직접 입력하는 한 인쇄 가능한 숫자를 액세스 가능한 메모리 위치에 그대로 두거나 결과를 반환 할 수 있습니다. 언어의 표준 숫자 데이터 형식으로 원하는 숫자로 평가합니다.

마감일

2016 년 11 월 30 일.

상금

  • 당신의 대답을 받아들이십시오
  • Dyalog의 2016 명예의 전당에서 불멸의 상태가 되십시오!

출품작 제출

2016 년 11 월 30 일 이후, 나는 가장 짧은 답변을 받아들이고 귀하의 이름으로 Dyalog의 2016 명예의 전당 에 귀하 의 답변을 제출할 것 입니다.

자주하는 질문

  • 됩니다 J(예 : 37 = ⌈⍟!20J16) 허용?
  • 아니요 : 4 자리 숫자 2 0 1 6 외에도 내장 기호 및 이름, 괄호 / 괄호, 공백, 높은 빼기 부호 및 소수점 만 사용할 수 있습니다.
  • 문자열로 출력 할 수 있습니까?
  • 아니요 : 0에서 100까지의 숫자와 같습니다.
  • 물리 숫자 또는 데이터 숫자?
  • OP에 따른 데이터 자릿수 : 여기 와 동일한 규칙 ( 여기서 예 중 하나에 포함) LOG10(.
  • 변수를 할당 한 다음 표현식의 일부로 사용 a+16+a←20합니까 (예 : 56 = )?
  • 예. 그러나 한 표현식에서 다른 표현식으로 할당을 사용할 수 없습니다.

본인은이 챌린지의 원래 작성자로부터이 챌린지를 게시 할 수있는 명시적인 서면 허가를 받았습니다. 제공된 링크 를 따르고 저자에게 연락하여 자유롭게 확인 하십시오. 내가 게시 한 1 분 안에 원본 경쟁자에게이 페이지에 대한 링크를 주었다. 그래서 그들은 누군가의 답변을 내 자신의 것으로 제출했는지 확인할 수있다.

답변

젤리, 686 바이트

20=16
20>16
2+0%16
201%6
20%16
20%16‘
201a6
20>1+6
20%16Ḥ
2016DS
20Ho16
2016BL
20:1.6
20_1_6
20×1_6
20+1_6
20&16
20:+16
2+0+16
20+1^6
20|16
20|16‘
20|16‘‘
20%16!’
20%16!
20²:16
20H+16
20+1+6
20×1_6Ḥ
20×1_6Ḥ‘
20+1_6Ḥ
2016&½’
2016&½
201:6
201:6‘
20Cạ16
20+16
20+16‘
20+1^6Ḥ
20|16Ḥ’
20|16Ḥ
20|16Ḥ‘
20|16‘Ḥ
2016½Ḟ’
2016½Ḟ
2016½Ċ
2016½Ċ‘
20Ḥ+1+6
2r0×16S
201a6‘²
20²:16Ḥ
2r016+S
201ÆC+6
20&16ÆN
20H_1×6
20ạC+16
20Ḥ+16
20_1×6H
20_1×6H‘
20_1×6H‘‘
20+1_6ḤḤ
2+0+16ÆN
20:.16H
20+1×6H
2²+0×16
201:6Ḥ’
201:6Ḥ
201Ḥ:6
201Ḥ:6‘
20Cạ16Ḥ’
20Cạ16Ḥ
20+16Ḥ’
20+16Ḥ
20+16Ḥ‘
20+16Ḥ‘‘
20+ÆN_16
20+1^6ḤḤ
20+1^6ḤḤ‘
20×16HH’’
20×16HH’
20×16HH
20×16HH‘
20|16Ḥ‘Ḥ
20|16Ḥ‘Ḥ‘
20|16‘ḤḤ
201½×6Ḟ
201½×6Ċ
20ÆN+16
2016½ḞḤ
20Æn16¡
20r16S
20r16S‘
20r16S‘‘
20Ḥ+1+6Ḥ’
20Ḥ+1+6Ḥ
20ḤḤ+16’
20ḤḤ+16
20ḤḤ+16‘
201a6‘²Ḥ
201’Ho6’
201’Ho6

나는 이것들 중 약 50 개를 썼고, 필요에 따라 Ḥ(× 2)와 ‘’(± 1)을 추가하여 나머지를 자동 생성했다 . 나중에 개선하겠습니다!

답변

헥사 고니 , 888 바이트

자, 누군가 Hexagony에 대한 몇 가지 기본 규칙이 있습니다.

  • “스 니펫”을 현재 및 인접 메모리 에지가 0 인 경우 충분히 큰 프로그램에 덤프 할 수있는 선형 코드 조각으로 해석하고 있습니다.
  • 스 니펫은 왼쪽에서 입력하고 오른쪽에서 종료해야합니다. 나는 그것없이 꽤 많은 바이트를 절약 할 수있을 것입니다 (예 : 2|01622), 그것은 도전의 정신에서 가장 보입니다.
  • 스 니펫은 실행 후 메모리 에지 (현재는 아닐 수도 있음)가 해당 값을 보유하는 경우 지정된 수를 “생성”합니다.
  • 스 니펫의 다른 숫자를 금지하는 규칙은 16 진수의 정수 리터럴로 효과적으로 작용하기 때문에 다른 숫자와 문자 모두에 영향을 미칩니다. (이것은 많은 바이트를 절약 할 수 있습니다.)

여기에 목록이 있습니다. 나는 대부분을 테스트했지만 전부는 아닙니다 (일부는 사소한 수정입니다). 내가 실수를하지 않기를 바랍니다.

2016
20&1}6
2}016
2)}016
20{16'-
201}6(
201}6
201}6)
2}016":
2(0(}16
2(0}16
2(0)}16
)2}016
)2)}016
20}16((
20}16(
20}16
20}16)
20}16))
20(}16
20}16
20)}16
20))}16
20)))}16
20}1)6((
20}1)6(
20}1)6
20}1)6)
201{6)':
2)0(}16
2)0}16
2)0)}16
2{016'*
201{6':
2{016)'*
20}1))6(
20}1))6
20}1))6)
20}1))6))
2))0(}16
2))0}16
2))0)}16
2))0))}16
2))0)))}16
20)){1)'6*
2){016('*
2){016('*)
2){016'*(
2){016'*
2){016'*)
2)))0}16
2){016)'*
2){016)'*)
2{01)6)'*(
2{01)6)'*
2{01)6)'*)
2{01)6)'*))
2{01)6)'*)))
2))))0((}16
2))))0(}16
2))))0}16
2))))0)}16
2)0){1)'6*
2)){016'*(
2)){016'*
2)){016'*)
2)){016'*))
2)){016'*)))
2{01))6('*(
2{01))6('*
2{01))6'*((
2{01))6'*(
2{01))6'*
2{01))6'*)
2{01))6)'*
2){01)6('*
2){01)6'*((
2){01)6'*(
2){01)6'*
2){01)6'*)
20{1)))'6*
2){01)6)'*
2){01)6)'*)
2){01)6)'*))
2){01)6))'*
2){01)6))'*)
2){01)6))'*))
2){01)6)))'*
2{01)))6(('*
2{01)))6('*(
2{01)))6('*
2{01)))6'*(
2{01)))6'*
2{01)))6'*)
2{01)))6)'*
2{01)))6)'*)
2{01)))6))'*
2(01((((}16
2(01(((}16
2(01((}16
2(01(}16

나는 끝쪽으로 조금 게으르다. 그래서 이것이 최적이 아니라고 확신한다. 이들을 무차별하게하는 것이 흥미롭고 가능할 수 있습니다.

답변

J, 1041 … 838 바이트

981 961 952 860 859

나는 약간 게으르다. 그러나 그것은 더 적은 것보다 더 고정되어야한다. 나는 내가 Hexagony를 능가한다고 생각하지 않지만, 당신은 결코 모른다! 육각형을 치고! Zgarb 덕분에 9 바이트가 절약되었습니다! 그리고 린에게 훨씬 더!

20=16
*2016
2[016
2+01[6
20-16
p:2[016
201]6
2+0-1-6
-:20]16
2+01+6
-:20[16
p:20-16
+/2$01]6
<:20-1]6
20-1]6
<:20]16
20]16
p:201]6
2+016
20-1[6
20[16
20+1[6
20++~1[6
+/q:2016
20-(+:1)-6
<:20+1]6
20+1]6
20+1+6
+:20-1]6
p:2+01+6
-2-+:016
<:2*016
2*016
>.201%6
<.201%6
<:20+16
20+16
20+>:16
+~20-1[6
-20-p:16
+:20[16
p:2*01*6
>:p:2*01*6
<:<.%:2016
<.%:2016
>.%:2016
+/q:*:2016
p:20-1]6
>:p:20-1]6
*:2+0-1-6
+:20-1-6
20++:16
<.%:20^%:1+6
20+#i:i:16
*/2,01]$~-:6
<:<.o.2+016
<.o.2+016
>.o.2+016
<:p:20]16
p:20]16
>:p:20]16
2+p:016
<.o.20[16
<:2^01]6
2^01]6
>:2^01]6
<:p:2+016
p:2+016
>:p:2+016
>:>:p:2+016
<:p:20-1[6
p:20-1[6
+/+~20 16
p:20[16
>:p:20[16
>:>:p:20[16
-:+/2+i.016
<:<:p:20+1[6
<:p:20+1[6
20+p:16
20*.16
*:2+01+6
>:*:2+01+6
p:20++~1[6
<.o.20+1+6
>.o.20+1+6
>:>.o.20+1+6
<.o.+:20-1]6
>.o.+:20-1]6
p:+/q:2016
>:p:+/q:2016
<.o.p:2+01+6
>.o.p:2+01+6
(*:-:20)-1+6
>:(*:-:20)-1+6
<:(++:)2*016
(++:)2*016
p:20-(+:1)-6
2**~p:-:01]6
<:*:-:20[16
*:-:20[16

하이라이트 및 메모

나는 이것에 소수를 많이 사용 했습니다. 사실, 나는 이것에 p:(N 번째 프라임) 기능을 37 번 사용했습니다.

 *:-:20[16

90은 포크를 사용하여 만들어졌습니다. 예이! 대략적인 내용입니다.

(*+&1)2+01+6

로 번역

inc =: + &1
mul =: *
nin =: 2 + 1 + 6
NB. since (f g) y = y f (g y):
  (mul inc) nin   = nin mul (inc y)
                  =  9   *    9+1
                  =  90

54는 쉐이빙 라벨을 사용합니다!

*/2,01]$~-:6

에 해당

*/ 2 , $~ -:6
*/ 2 , -:6 $ -:6
*/ 2 , 3 $ 3
*/ 2 , 3 , 3 , 3
   2 * 3 * 3 * 3
   54

답변

자바 스크립트, 1021 바이트

Charlie Wynn 과 ETHProductions 덕분에 2 바이트를 수정하고 저장 했습니다 .

201&6
-~!2016
2%016
201%6
20%16
2^0^1^6
2*0*1+6
2|0|1|6
2*01+6
2-~01+6
~2+016
~2+016
2^016
20-1-6
2|016
20+1-6
20&16
2-~016
2.0+16
20^1+6
20|16
-~20|16
20*1|6
20|1|6
-2*~01*6
20-1+6
20+1*6
20+1+6
2*016
-~(2*016)
2*-~016
~-(2.0*16)
2.0*16
-~(2.0*16)
2.0*-~16
~-20+16
20+16
-~20+16
-~-~20+16
-~2*~-016
20*-~1.6
~-(-~2*016)
-~2*016
~-~-(~2*~016)
~-(~2*~016)
~2*~016
20<<1|6
20*-~1-~6
~2*~-~016
-~(~2*~-~016)
~-~(~-~2*~-016)
~2*~-~-~016
-~-~2*~-016
20*-~-~1+~6
20*-~-~1-6
20*-~-~1-~-6
-~-~2*016
-~20*-~-~1-6
-~-~(-~-~2*016)
~-(20*~-~(1-6))
~-~2*~016
-~(20*~-~(1-6))
-~-~(20*~-~(1-6))
-~20*~-~(1-6)
~-~2*~-~016
20*-~-~1+~-6
20*-~-~1+6
20*-~-~1-~6
~-~2*~16
-~20*-~-~1+6
-~-~-~2*016
~-(~-~2*~-~16)
~-~2.0*~-~16
-~(~-~2*~-~16)
20*-~-~-~1-6
~-~-~2*~016
~-20*~(1-6)
-~(~-20*~(1-6))
~-~-(20*~(1-6))
~-(20*~(1-6))
20*~(1-6)
-~(20*~(1-6))
~-~-(~20*-~(1-6))
~-(~20*-~(1-6))
~20*-~(1-6)
20*-~-~-~1+~-6
20*-~-~-~1+6
20*-~-~-~1+-~6
20*-~-~-~1+-~-~6
~-(~-~-20*-(1-6))
~-~-20*-(1-6)
-~(~-~-20*-(1-6))
~-~-~-(~-20*-(1-6))
~-~-(~-20*-(1-6))
~-(~-20*-(1-6))
~-20*-(1-6)
-~(~-20*-(1-6))
~-~-~-(20*-(1-6))
~-~-(20*-(1-6))
~-(20*-(1-6))
20*-(1-6)

답변

자바 스크립트 (ES7), 836 바이트

새로운 **연산자 를 사용하는 81, 88 및 97을 제외한 모든 브라우저에서 모든 것이 작동합니다 .

여기에있는 모든 것은 손으로 이루어졌습니다. 나는 개선 할 수있는 모든 것을 향상시키기 위해 무차별 대입 작업을 해왔다. 현재 다양한 항목에 103 바이트를 저장했습니다.

  0: 201&6
  1: 2-01%6
  2: 2%016
  3: 201%6
  4: 20%16
  5: 201%~6
  6: 2%01+6
  7: 2-01+6
  8: 2*01+6
  9: 2+01+6
 10: 2-~01+6
 11: ~2+016
 12: 2^016
 13: 20-1-6
 14: 2|016
 15: 20+1-6
 16: 2+016
 17: 2-~016
 18: 2+0+16
 19: 20-1%6
 20: 20|16
 21: 20+1%6
 22: 20*1|6
 23: 20+1|6
 24: 20+~1+6
 25: 20-1+6
 26: 20*1+6
 27: 20+1+6
 28: 2*016
 29: 20-~1-~6
 30: -2*~016
 31: 20|~-16
 32: 20*1.6
 33: 20*~1^~6
 34: -20*~1-6
 35: 20+~-16
 36: 20+16
 37: 20-~16
 38: 20-~-~16
 39: -~2*~-016
 40: 20<<1%6
 41: -20*~1-~!6
 42: ~2*-016
 43: ~20^-1<<6
 44: ~20*~1^6
 45: ~2*~016
 46: 20<<1|6
 47: -20*~1-~6
 48: ~20*~1+6
 49: ~20*~1-~6
 50: ~2/.01/-6
 51: ~2.0*~16
 52: 20|1<<~-6
 53: -20*~-~1+~6
 54: ~2.0*~-~16
 55: -20*~-~1-~-6
 56: ~-~2*-016
 57: ~20*~-~1-6
 58: -20*~-~1^6
 59: ~(20/~1*6)
 60: -20/~1*6
 61: ~2^0-1<<6
 62: -2^0-1<<6
 63: ~20/~1*6
 64: 2-01<<6
 65: 2+~0|1<<6
 66: 2|01<<6
 67: 2-~0|1<<6
 68: 2*~!0*~16
 69: ~20*~-~1+6
 70: 20/~1*~6
 71: -~(20/~1*~6)
 72: 2+~0/.1*~6
 73: -20<<-~1^~6
 74: -20<<-~1^-6
 75: ~-~-~2*~016
 76: ~-20*(~1+6)
 77: ~-~20/~1*-~6
 78: ~-20<<-~1|6
 79: -20<<-~1^~!6
 80: 20*(~1+6)
 81: ~2*~0**(~1+6)
 82: ~-~-20|1<<6
 83: ~-20|1<<6
 84: 20|1<<6
 85: -~20|1<<6
 86: 20<<-~1|6
 87: 20<<-~1|-~6
 88: .2**~!0|1<<6
 89: ~20*~-~-~1+~-6
 90: ~2*~!0*~-16
 91: ~20*~-~-~1-~6
 92: ~-2/.01+~-~6
 93: ~-2/.01+~6
 94: ~-2/.01-6
 95: ~-20*1*~-6
 96: 2+01<<~-6
 97: ~2+.01**~.6
 98: ~-2/.01^6
 99: ~-2/.01+~.6
100: 20*1*~-6

무차별 대입

가장 예쁜 코드는 아니지만 이러한 부분에서는 중요하지 않습니다.

경고 : 브라우저 / 엔진이 몇 분 동안 정지 할 준비가되어 있지 않으면 실행 하지 마십시오 . 아무도 7 개의 중첩 루프를 계산하는 것을 좋아하지 않습니다.

var a=new Array().fill("000000000000000000000000000"), // An array of non-solutions to start
    time=new Date(),                                   // For timing how long this takes
    o=["","+","-","*","/","%","&","|","^",".","<<"],   // Operators for between numbers
    p=["",".","~.","-","~","~-","-~","~-~","~-~-","~!"];        // Prefixes for each number
for(i=0;i<o.length;i++)
for(j=0;j<o.length;j++)
for(k=0;k<o.length;k++)
for(I=0;I<p.length;I++)
for(J=0;J<p.length;J++)
for(K=0;K<p.length;K++)
for(L=0;L<p.length;L++) {      // 7 nested loops = O(len(o)^3 * len(p)^4)
    z=      p[I]+2
      +o[i]+p[J]+0
      +o[j]+p[K]+1
      +o[k]+p[L]+6;            // Put all the current chars in one string. 
    try { v=eval(z) }          // Try setting v to the evaluated value of z.
    catch(e) { v=-1 }          // If an error occurs, set v to -1.
    if( (v === (v|0)) &&       // If v is an integer, and
        v>=0 && v<=100 &&      // v is between 0 and 100, inclusive, and
        z.length<a[v].length ) // z is shorter than the current entry,
        a[v]=z;                // overwrite the current entry.
}

console.log("time: " + ((new Date()-time)/1e3) + "seconds\n"
           + "length: " + (a.join("").length) + "\n"
           + a.map((x,y) => y + ": " + x).join("\n"))

답변

PowerShell v3 +, 1575 1499 바이트

2*0*16
2*0+1%6
2%016
201%6
20%16
2*0+-1+6
2*0+1*6
2*0+1+6
2+0*1+6
2+01+6
2*(0-1+6)                #10
2*($a=01)*6-$a           ################################## First variable
2*01*6
20-1-6
20*1-6
20+1-6
2*0+16
!!20+16                  ################################## First Boolean not
2+016
2+!0+16
20+!16                   #20
20+1+!6
!2+0x16                  ################################## First use of 0x16
(20+1)-bor6              ################################## First binary or
2+0x16
20-1+6
20*1+6
20+1+6
20+($a=1)+6+$a
20+($a=1)+6+$a+$a
2*-bnot-016              #30 ############################## First binary not
-bnot(-2*016)
2*016
-(-bnot(2*016))
-2*-bnot016
-bnot(-20)+16
20+16
20-(-bnot16)
-(-bnot20)-(-bnot16)
(20-shl1)-!!6            ################################## First binary shl
(20-shl1)+!6             #40
(20-shl1)+!!6
($a=2)*0x16-$a
($a=2)*0x16-$a/$a
2*0x16
-(-bnot2)*(-bnot-016)
(20-shl1)+6
$a=20;$b=1;$a+$a+$b+6
-(-bnot2*016)
2*0+($a=1+6)*$a
(20-shr($a=1))*(6-$a)    #50
(-bnot2)*(-bnot016)
20+($a=16)+$a
($b=20*($a=1)+6)+$b+$a
($a=20+1+6)+$a
($a=20+($b=1)+6)+$a+$b
($a=20)+16+$a
(($a=(2+!0))+16)*$a
(20-shr($a=1))*6-$a-$a
(20-shr($a=1))*6-$a
(20-shr1)*6              #60
(20-shr($a=1))*6+$a
(($a=2)*0+1-shl6)-$a
-bnot-(2*0+1-shl6)
2*0+1-shl6
(2*0+($a=1)-shl6)+$a
(-bnot2)*-0x16
($a=201)/($a%6)
20+($a=16)+$a+$a
20+($a=16)+$a+$a+$a/$a
-($a=2)*-bnot016*$a+$a   #70
2*01*($a=6)*$a-$a/$a
2*01*($a=6)*$a
($a=2+01+6)*$a-$a+$a/$a
($a=2)*01*($b=6)*$b+$a
($a=20)+16+$a+$a-$a/$a
($a=20)+16+$a+$a
($a=20)+16+$a+$a+$a/$a
2*01*($a=6)*$a+$a
($a=20)%16*$a-$a/$a
($a=20)%16*$a            #80
($a=2+01+6)*$a
($a=2)*0x16*$a-$a*$a-$a
20+(($a=1)-shl6)-$a
20+(1-shl6)
20+(($a=1)-shl6)+$a
($a=2)*0x16*$a-$a
($a=2)*0x16*$a-$a/$a
($a=2)*0x16*$a
($a=2)*0x16*$a+$a/$a
($a=2)*0x16*$a+$a        #90
($a=2)*0x16*$a+$a+$a/$a
($a=2)*0x16*$a+$a+$a
20*(-1+($a=6))-$a-$a/$a
20*(-1+($a=6))-$a
20*($a=-1+6)-$a
2*(!0+1+($a=6))*$a
20*(($a=-1)+6)+$a+$a+$a
($a=2)*($b=01+6)*$b
20*(($a=-1)+6)+$a
20*(-1+6)                #100

100 % 수동 골프-무차별 대입 프로그램이나 기타 보조기구가 없습니다.
나는 1500하다고 생각 어쩌면 범위 내에서
하위-1500 달성! 이것을 낮추는 데 얼마나 잘 할 수 있는지 봅시다. (NB-이것은 v4에서만 테스트되었지만 수정없이 v3 및 v5에서 작동합니다. 해당 버전에 비트 시프트 연산자가 없으므로 v2 또는 v1에서는 작동하지 않습니다.)

##.hashes.##위 코드에는 요점이 표시되어 있습니다.

# 11 은 variable에 대한 첫 번째 할당 $a입니다. 다른 언어와 달리 변수는 구문 분석을 위해 사전 초기화 할 필요가 없으며 실행 중에 만 변수가 해결됩니다. 이 때문에 ($a=01)괄호로 둘러싸여 먼저 평가이고 그래서 제는 -$a동일하다 -1. 이것은 여기서부터 광범위하게 사용되며 바이트 수를 유지하는 가장 큰 것 중 하나입니다.

# 17 은 !Boolean not 에 대한 첫 번째 사용법을 보여줍니다 . PowerShell에서 유형은 상당히 느슨하게 캐스팅되므로 캐스팅을 암시 할 수 있으면 작동합니다. 여기, 우리는 사실을 사용하고 그 !!20동등 !$false하다, $true암시 적으로 캐스팅 될 수있다 [int]1, 어떤 결과 17. 이것은 다른 것을 얻 1거나 부분을 만들기 위해 여러 번 사용 됩니다 0.

# 22 진열장 0x진수 캐스트 연산자, 여기에 회전 0x16에 22. 그러나 0x16우리가 얻을 수있는 유일한 숫자 이기 때문에 그 유용성은 제한적입니다.

# 23 에는 -bor“이진 또는”연산자 가 있습니다. 그러나 두 이후 -bor및 -bxor이 낮은 우선 순위 를 사용하여 간단한 산술 연산자보다는 보통 심각한 유용성을 제한 괄호가 필요합니다. 이것은 바이너리 또는 연산자를 사용하는 것이 더 짧은 곳에서 찾은 유일한 것입니다 ( -bxor22 에서 연산자를 제거했습니다 ).

# 30 은 -bnot운영자가 처음 소개됩니다. 이것은 “이진이 아닌”연산자이며 ~JavaScript 와 같은 기능을 수행 합니다. 그러나 부정은 --bnot구문 분석 / 구문 오류 로 표시되고 구문 분석 / 구문 오류가 발생 하기 때문에 일반적으로 구문 분석이 필요합니다 ~.

# 39 우리의 바이너리 시프트 연산자의 첫 번째 사용하는 것입니다, -shl하고 -shr. 이것들은 다른 언어 와 비슷 <<하거나 >>다른 언어이지만 명시 적으로 이색적이므로 작동하기 위해서는 양쪽에 숫자가 필요 하므로이 도전에 대한 유용성이 제한됩니다. 또한 우선 순위가 문서에서 명시 적으로 언급되지는 않지만 테스트는 단순 산술보다 낮다는 것을 보여줍니다. 즉, Parens를 자유롭게 사용해야하므로 다른 언어 답변 에서처럼 외모를 많이 나타내지 않습니다.

답변

CJam, 792 791 바이트

나는 끝 부분에 게으르다. 많은 사람들이 방금 증가하고 줄어 들었다. 골프를 타야 할 시간이 여전히 남아 있습니다.

# 40 주위에는 약간의 거친 얼굴이 있습니다.)

2016!          e# 0
2016g
2016g)
201 6%
20 16-
20)16-
20 1>6*
20 1>6+
201mQ6-
201mQ6-)
2 01 6*(*      e# 10
2 01*6*(
2 01*6*
2~016+
-2 016+
2)016(|
20;16
2(016+
2 016+
2)016+
20 16|         e# 20
20)16|
20 1*6|
20 1|6|
20 16mQ+
20_*16/
20 1 6*+
20 1+6+
20 1)6++
20)1)6++
2 016(*        e# 30
2 016*(
2 016*
201 6/
2 016)*
20(16+
20 16+
20)16+
20)16)+
20_+16;(
20_+16;        e# 40
20_+16;)
20)_+16;
20)_+16;)
20(1m<6+
2)016(*
20 1m<6+
2)016*(
2)016*
2)016*)
2)016)*(       e# 50
2)016)*
20 16_++
20)1 6(m<+
20(_16++
20_16++(
20_16++
20_16++)
20)_16++
20)_16++)
20 16mQ(*      e# 60
20 16mQ(*)
2 01*6#((
2 01*6#(
2 01*6#
2 01*6#)
201_+6/(
201_+6/
201_+6/)
201mQ6(*(
201mQ6(*       e# 70
20_16_+++(
20_16_+++
20_16_+++)
20)_16_+++
20(16mQ*(
20(16mQ*
20(16mQ*)
20_16^*((
20_16^*(
20_16^*        e# 80
2)016mQ#
201mQ6*((
201mQ6*(
201mQ6*
201mQ6*)
201mQ6*))
201mQ6*)))
[20_16__]:+
[20_16__]:+)
[20)_16__]:+   e# 90
[20_16)__]:+
[20__16_]:+
20(1*6(*((
20(1*6(*(
20(1*6(*
20(1*6(*)
201mQ6)*(
201mQ6)*
20 1*6(*(
20 1*6(*       e# 100