귀하의 언어가 지원하는 5 가지 문자를 선택하십시오. 5 개가 있습니다! = 5 × 4 × 3 × 2 × 1 = 120 가지 방법으로 각 문자를 한 번 포함하는 5 문자열로 배열 할 수 있습니다. 120 순열 .

120 개의 문자열 각각이 귀하의 언어로 실행될 때 생성 된 120 개의 출력이 가능한 한 1에서 120까지의 많은 고유 정수가되도록 문자를 선택하십시오.

즉, 단일 숫자를 출력하는 실행 가능한 코드를 생성하는 5 개의 문자 중 120 개의 순열 각각에 대해 모든 숫자 세트가 가능한 한 1에서 120까지의 정수 세트와 일치하기를 원합니다.

따라서 이상적으로는 첫 번째 순열이 다음 , 최대, 1다음 순으로 출력 됩니다 . 그러나 대부분의 언어와 문자에는 이상적이지 않을 수 있습니다.23120

5 자 문자열은 다음과 같이 실행될 수 있습니다.

• 입력이없는 프로그램
• 인수가없는 함수
• REPL의 명령

원하는 경우 다른 문자열을 다른 방식으로 실행할 수 있습니다

출력을 계산하려면 다음 과 같은 일반적인 방식으로 단일 정수 출력이어야합니다 .

• 표준 출력으로 인쇄
• 함수에 의해 반환
• REPL 표현식의 결과

코드는 정상적으로 종료되어야합니다 ( 숫자가 먼저 출력 되는 한 오류 가 발생할 수 있습니다 ). 전혀 실행되지 않는 코드는 괜찮으며 (존재하지 않은) 출력 만 계산되지 않습니다. 언어의 기준이 다른 경우가 아니면 숫자 출력은 10 진수 여야합니다.

1에서 120 사이의 가장 뚜렷한 숫자를 생성하는 제출이 승리합니다. 동점 일 경우 이전 제출물이 이깁니다.

노트

• 5 개의 문자가 모두 다를 필요는 없지만 물론 중복 문자가 있으면 효과적인 순열 수가 줄어 듭니다.
• 32.0수뿐만 아니라 일반 과 같은 부동 출력 32. (그러나 32.01그렇지 않습니다.)
• 032count 및 plain 과 같은 선행 0 32.
• 유효한 출력은 결정적이고 시간이 변하지 않아야합니다.
• 우리는 바이트가 아닌 문자를 다루고 있습니다.

예

이 문자 123+*는 파이썬 (또는 많은 언어) REPL에 적합한 첫 번째 선택입니다. 결과 120 개의 순열 및 출력은 다음과 같습니다.

123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a

운 좋게도 1에서 120 사이에 36 개의 숫자가 생성됩니다.

36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63

그러나 이들 중 8 개만 고유합니다.

36, 26, 7, 5, 23, 32, 63, 62

따라서 이러한 제출물은 최대 120 점 중 8 점에 불과합니다.

Python3, 21 27 개 값

캐릭터 : 3479%

고유 번호 : [1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]

요청한대로 [1, 120] 범위에 속하는 순열은 다음과 같습니다 . 온라인으로 사용해보십시오!

347%9   5
349%7   6
34%79   34
34%97   34
374%9   5
379%4   3
37%49   37
37%94   37
394%7   2
397%4   1
39%47   39
39%74   39
3%479   3
3%497   3
3%749   3
3%794   3
3%947   3
3%974   3
437%9   5
439%7   5
43%79   43
43%97   43
473%9   5
479%3   2
47%39   8
47%93   47
493%7   3
497%3   2
49%37   12
49%73   49
4%379   4
4%397   4
4%739   4
4%793   4
4%937   4
4%973   4
734%9   5
739%4   3
73%49   24
73%94   73
743%9   5
749%3   2
74%39   35
74%93   74
793%4   1
794%3   2
79%34   11
79%43   36
7%349   7
7%394   7
7%439   7
7%493   7
7%934   7
7%943   7
934%7   3
937%4   1
93%47   46
93%74   19
943%7   5
947%3   2
94%37   20
94%73   21
973%4   1
974%3   2
97%34   29
97%43   11
9%347   9
9%374   9
9%437   9
9%473   9
9%734   9
9%743   9

05AB1E , 27 38 41 번호

4·>Ìn

고유 한 숫자를 생성합니다.

[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]

상수를 사용하여 4작업으로 +1, +2, *2와 ^2.

파이썬, 숫자 18 개

237#-

유효한 결과로 생성합니다.

1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73

편집 : TuukkaX의 솔루션 이 Python에 최적 이라는 것을 증명할 수 있습니다 . 인쇄 가능한 5 ASCII 문자의 가능한 모든 조합을 다음과 같이 무차별 처리했습니다.

from itertools import permutations,combinations_with_replacement

def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])

best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')

(약 7 시간 동안 실행 후) 결과는 최적의 솔루션은 사실상 세 가지 해결책 모두 네 개의 숫자를 사용하여 개조 (제조 27 개 가지 숫자 인 것으로 나타났다 %:) %3479, %5679및 %5789.

자바 8, 2 4 숫자

n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1

Java 답변을 기대하지 않았습니까?

이것은 총 두 개의 고유 숫자에 대해 두 가지 방법 중 하나 (및 두 개의 다른 숫자로만)를 정렬 할 수있는 람다입니다. 다른 모든 것은 유효한 람다가 아닙니다.

의견의 도움으로 실제로 답변이 개선되었습니다! 0이 유효하지 않다는 것을 보지 못했고 변수가 둘 이상의 문자가 될 수 있음을 잊었습니다. 우리는 4를 얻었다!

더 나쁜 해결책

()->1

그러나 밝은면에서 Java의 두 가지 고유 답변!

젤리, 26 30 32 숫자

‘’3²Ḥ

이것 (그리고 그 아나그램)은 완전한 프로그램이며, 입력을받지 않고 표준 출력에서 ​​출력을 생성합니다.

120 개의 프로그램의 출력은 프로그램의 순열을 생성하도록 요청하면 Jelly가 생성하는 순서대로 나타납니다.

018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03

고유 한 출력을 숫자 순서대로 가져 가면 다음과 같은 결과가 나타납니다.

-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135

이들 중 다수가 너무 작고 135가 너무 크지 만 여전히 범위 내에있는 32 개가 있습니다.

기본 아이디어는 대부분 모나드 명령어 (모나드 및 nilads 만있는 프로그램에서 각각 이전 출력을 변환 함)와 값을 빠르게 분기 할 수있는 명령어를 사용하는 것입니다. 을 제외하고는 3nilad입니다 (상수 값 3). 프로그램 시작 부분에 표시되면 모든 작업이 3에서 수행됩니다. 중간에 표시되면 프로그램을 두 부분으로 나누고 정수를 출력합니다 (각각 표준 출력으로 인쇄 할 때, 결과는 연결되어 결과적으로 숫자를 생성하는 추가 작업으로 "연결"됩니다.

프로그램이 생성하는 맥락에서 여기에있는 작업은 다음과 같습니다. 감소; 상수 3; 광장; 그리고 두 배. 증가와 감소는 불행하게 반대이며, 감소는 불행하게도 첫 번째 섹션에서 -1 또는 -2를 생성하는 경향이 있습니다 (따라서 전체적으로 음수로 이어짐). 그러나 이것은 내가 시도한 다른 것보다 여전히 많은 결과를 낳았습니다. . 특히, 우리는 숫자의 첫 번째와 두 번째 절반을 꽤 잘 분산 3시킵니다 (프로그램의 첫 번째 문자 인 경우 첫 번째 절반은 null 문자열이 될 수 있습니다 ).

자바 스크립트, 숫자 27 개

TuukkaX의 답변 과 매우 유사 하며 다른 숫자 세트가 있습니다.

5789%

27 개의 고유 한 값은 다음과 같습니다.

589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87

Brachylog , 26 숫자

3+*^-

다음과 같은 숫자가 출력됩니다. [2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]

설명

• 3 분명히 정수 3입니다.
• + 증분이다
• * 두배
• ^ 정사각형
• - 감소하다

단순히 프로그램 오류 상황이 많이있다 : 예를 위해 *+^3-그것을 요구하기 때문에 오류 ", 사각형 증가를,을, 0을 가지고 두 번이, 그 광장의 결과는 3, 감소이다" 분명히 잘못된 것입니다.

로 끝나는 모든 프로그램 3은 출력 3되거나 작동하지 않습니다.

*3버그로 인해 시작하는 모든 프로그램 은 버그로 인해 무한 반복 됩니다 (Brachylog는 제품으로 인해 3이 될 수없는 하위 목록의 목록을 찾으려고합니다).

Vim, 16 자리 숫자

i1234

인쇄

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

IA-32 기계 코드, 8 자리 숫자

16 진 바이트 값 :

2c 40 48 b0 c3

코드는 값을 반환하는 함수로 실행됩니다. al .

유효한 순열 :

b0 2c c3 xx xx => 2c (mov al, 2c)

b0 40 c3 xx xx => 40 (mov al, 40)

b0 48 c3 xx xx => 48 (mov al, 48)

b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)

b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)

b0 40 48 c3 2c => 3f (mov al, 40; dec eax)

b0 48 40 c3 2c => 49 (mov al, 48; inc eax)

b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)

다음과 같은 제약 조건으로 무차별 검색을 수행했습니다.

• 첫 번째 바이트는 b0-al 레지스터
• 마지막 바이트는 c3 . 다음 바이트는 버려집니다
• 가능한 opcode 바이트는 다음과 같습니다.
  • 0x04- add
  • 0x0c- or
  • 0x24- and
  • 0x2c- sub
  • 0x34- xor
  • 0xd4- aad
  • 0x40- inc
  • 0x48- dec

이것은 최대 15 개의 가능한 결과와 함께 3 개의 변경 가능한 바이트 만 남습니다. 이 중 최대 9 개를 구별 할 수 있습니다 (사실, 이는 한 세트의 바이트에만 발생합니다!). 값 중 하나가 범위를 벗어 났으므로 8 개의 값이 남습니다. 다른 바이트 세트가 있습니다

34 40 48 b0 c3

또한 8 개의 고유 한 값을 제공합니다.- sub로 대체되는 것을 제외하고는 프로그램이 xor동일하므로 가능한 두 출력을 동일하게 만듭니다.

다른 모든 바이트 세트는 7 개 이하의 가능한 결과를 제공합니다.

젤리 , 숫자 33 개

Ḥ23+c

Ḥ 더블 (왼쪽);
2리터럴 2;
3리터럴 3;
+추가 (왼쪽, 오른쪽); 및
c(왼쪽, 오른쪽) 선택 방법, 즉 수는 왼쪽 개체의 컬렉션 오른쪽에서 객체를 선택합니다.

예제 프로그램으로 얻은 숫자 :

 1 +32Ḥc   18 3Ḥc2+    45 2+3Ḥc
 2 c3Ḥ+2   20 2+Ḥc3    47 23c+Ḥ
 3 c2Ḥ+3   21 2Ḥ+3c    48 c+23Ḥ
 4 +2Ḥc3   22 3Ḥc+2    53 2c+Ḥ3
 5 2+3cḤ   23 23cḤ+    56 3Ḥ+2c
 6 3c+2Ḥ   24 cḤ+23    63 c+2Ḥ3
 8 2c+3Ḥ   30 3+c2Ḥ    65 32c+Ḥ
 9 3c2+Ḥ   32 32cḤ+    66 c+32Ḥ
12 +3cḤ2   33 cḤ+32    72 3c+Ḥ2
13 +2cḤ3   36 3+Ḥc2    82 c+3Ḥ2
15 +3Ḥc2   42 cḤ3+2   120 3+2Ḥc

구문 분석하기 쉬운 것을 선택하려고했지만 구문 분석하기가 드물고 약간 이상합니다 23. 예를 들면 다음 과 같습니다.

23cḤ+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23

... 72그리고13 암시 인쇄를 사용 :

3c+Ḥ2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)

+2cḤ3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)

의 고유 한 값 Ḥ34+c도 생성 33합니다 [1,120].

브레인 플락 1

(())#

Brain-Flak은 밸런스 괄호를 요구하므로 5 자 프로그램은 문자 중 하나가 주석을 시작하는 경우에만 유효합니다. 그것은 우리와 함께 일할 4 명의 캐릭터를 남겨둔다. 이 중 2는해야 (하고 ), 그렇지 않으면 아무것도 스택으로 푸시하지 얻을 것입니다. 의견이 마지막 ( (..)#) 인 첫 번째와 네 번째로 이동해야합니다 . 이제 우리는 넣을 수 있습니다 (), {}, <>, 또는 []내부. {}, <>및 []각각 0으로 평가되지만 ()1입니다.(())# 유효한 Brain-Flak 프로그램을 생성하는 유일한 5 개의 문자열입니다.

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

질문이 " 가장 강력한 6 명 "인 경우 (){}[]Brain-Flak이이 부분 집합 만 사용하여 완성 된 것입니다.

Hexagony , 13 개 번호

)24!@

다음은 각각 하나의 가능한 프로그램이있는 13 개의 인쇄 가능한 숫자입니다.

)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52

프로그램은 설명이 명확해야합니다. @프로그램이 종료 !전류 값을 출력 )을 증가시키고, 2및 4(초기 값은 현재 값에 자신을 추가 0). 소스 코드의 실제 육각형 레이아웃은 여기서 관련이 없으며 프로그램을 왼쪽에서 오른쪽으로 간단하게 읽을 수 있습니다.

이렇게 해야 대신하지만, 최적 2그리고 4당신이 어떤 쌍 자리 선택할 수 x및 y그러한가 2 ≤ x ≤ y-2.

위의 해결책은 (거의 철저한) 무차별 대입에 의해 발견되었으며 !, 하나는 @( 아무것도 인쇄하지 않을 것), 하나는 (그렇지 않으면 프로그램이 종료되지 않음) 나머지 3자는 (반복 된) 조합으로 채워집니다. 다음 문자 세트 :

#[]\/_|<>)!0123456789$

다른 명령이 어떻게 더 다양하게 생성 될 수 있는지 알 수 없습니다.

펄, 27 개 숫자

3479%

Perl에는 REPL이 내장되어 있지 않으므로 Devel :: REPLre.pl 에서 사용할 수 있습니다 .

결과 :

%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A

다음 프로그램을 사용하는 무차별 대입 :

use strict;
use warnings 'all';
use 5.010;

use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);

my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;

while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);

    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}

say "$max -> @best";

sub count_valid {
    my ($chars) = @_;

    my $iter = Algorithm::Permute->new($chars);
    my %results;

    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';

        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }

    return scalar keys %results;
}

R, 15 18 개 숫자

큰 숫자는 아니지만 R로 수행 할 수있는 최선의 방법 일 수 있습니다. 나는 모든 숫자 0..9, 연산자 + - * / ^및 주석 char 조합을 검색 #했으며 다음 8 개는 1에서 120 사이의 18 개의 고유 정수를 출력했습니다.

-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568

예를 들어 봅시다 -#146. 우리가 얻을 수있는 18 개의 정수는 다음과 같습니다.

1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64

가능한 모든 조합을 테스트하는 데 사용되는 (추악한) 코드가 궁금하다면 여기 있습니다. 길이 5의 각 문자 조합에 대해 1-120 사이의 고유 정수 수를 현재 작업 디렉토리의 "datafile"파일로 출력합니다.

allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))

        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)

옥타브, 18

이것은 기호에 대한 무차별 검색을 사용하여 발견되었습니다 *+-/0123456789:;<\^|~%. 그러나 계산하는 데 너무 오래 걸렸습니다 ...

-139%

가능한 출력 :

1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93

옥타브, 숫자 15 개

자랑 할 것이 많지 않지만 이것이 옥타브에서 얻을 수있는 최선의 방법입니다.

124+%

그것은 숫자를 제공합니다 :

1    2    3    4    5    6   12   14   16   21   24   25   41   42   43

나는 16도 얻었지만 Sefa의 대답과 같은 것 같습니다 ...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43

PHP, 15 자리 숫자

1230\r

PHP가 태그 외부의 모든 것을 그대로 인쇄한다는 사실을 사용합니다 (이를 사용하지 않으면 <?=1;. 또한 실제 캐리지 리턴 문자를 사용합니다.\r .

작성 (정렬, 제거 된 선행 0) :

 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210

유효한 고유 번호는 다음과 같습니다.

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120

Cubix , 7 자리 숫자

"2)@O

이 숫자를 출력합니다 :

")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65

이 도전에 대한 모든 유효한 Cubix 프로그램 O은 정수를 출력하고@ 하고 프로그램을 종료해야합니다 (Cubix는 "오류"에 대해 들어 본 적이 없습니다). 이를 통해 가장 많은 출력을 생성하기 위해 3 개의 문자를 재생할 수 있습니다. 또한 Cubix가 큐브에서 코드를 정렬하는 방식으로 인해 첫 번째 문자는 다른 문자 중 하나가 방향성 문자가 아닌 한 쓸모가 없습니다.

여러 숫자를 생성하는 가장 효율적인 방법 "은 문자열 코드 문자열을 스택에 푸시하는 데 사용 하는 것입니다. 신중하게 재 배열하면 마지막 자리에 여러 문자를 맞추고 단순히 문자 코드를 출력 할 수 있습니다. 사용하여)상위 항목을 증가시키는 데 이러한 여러 배열에서 추가 출력을 생성 할 수 있습니다.

여기에는 두 가지 기본 프로그램 유형이 사용됩니다. 첫 번째는 이렇습니다 :

"2)O@

어느쪽으로 확장

  "
2 ) O @
  .

결과 프로그램은 2스택으로 푸시하고을 사용 하여 증가 시키고을 사용 하여 )출력 O하고으로 종료합니다 @.

두 번째는 이것입니다 :

2")O@

어느쪽으로 확장

  2
" ) O @
  .

생성 된 프로그램의 문자 부호를 밀어 ), O그리고 @, 마지막으로 하나의 증가 )와 출력, O및로 종결 @.

> <> , 6 자리

청록 펠리칸 덕분에 2 개 숫자 획득

1ln";

고유 한 숫자를 생성합니다 [1, 4, 5, 49, 59, 108]

n숫자를 인쇄 해야 합니다.
우리는 필요; 종료 합니다.

작업 할 수있는 문자는 3 자뿐입니다.

몇 가지 value& 조합 과 operator함께 "6 개의 고유 한 값을 생성 하는 것으로 확인되었지만 그보다 더 나은 것을 찾지 못했습니다.

그루비, 10 자리

Man JVM 솔루션은 이것에 대해 나쁜 것입니다 ... 누가 알았습니까?

1200+

결과 :

[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]

무엇을 기다립니다? 도대체 어떻게 17 물어?

20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.

Groovy / Java에서 영업 비밀은 0이 앞에 오는 정수는 8 진입니다. 누군가 나를 때리고 싶을 때 Groovy 답변을 테스트하는 데 사용한 코드 :

("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();​

MATL, 15 자리

0123%

% 주석 연산자이므로 가능한 모든 위치에서 한 번 "잘라내어"주어진 숫자와 그 하위 집합의 모든 가능한 조합을 만드는 데 도움이됩니다.

1
2
3
10
12
13
20
21
23
30
31
32
102
103
120

J, 16 개의 숫자

1234]

아무 것도 멋진 것이 아니며 1234합리적인 모든 1 문자 동사로 테스트 했습니다.]올바른 인수를 선택합니다.

생산 된 고유 번호는

0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321

그 중 16 :

4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21

[1,120] 범위에 있습니다.

테스트

# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'

apt , 번호 41

시행 착오에 불과하므로 더 나은 해결책이있을 수 있습니다. 에 제곱, 더하기 및 곱하기 정수 3및 4Japt 단축키를 사용합니다 . 모든 120 개의 프로그램이 정수를 출력 하지만 78 개만 41 개만 고유합니다.12>0<=120

34²ÄÑ

숫자를 생성합니다.

1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93

보기 번호 목록 또는 유효한 프로그램의 모음

설명

여기에 관련된 Japt에 대해 유의해야 할 사항은 다음과 같습니다.

1. 프로그램이 숫자 중 하나 (이 경우)로 시작하지 않으면 첫 번째 입력 변수 U는 기본값입니다.0 )가 시작 부분에 자동으로 삽입됩니다.
2. 숫자 중 하나 또는 둘 다가 즉시 수학 연산에 대한 바로 가기 중 하나를 따르는 경우 숫자에 추가됩니다 (예 : 3Ä4 = 3+14 = 17및 유사하게 4Ѳ = 4*2**2 = 16).
3. 숫자 중 하나가 바로 뒤에 오는 ²경우 그 ²앞의 모든 것이 기본적으로 무시됩니다.

프로그램 (생산의 몇 가지에 대한 설명 1, 3, 37및 93각각) :

²Ñ34Ä  :Square 0, multiply by 234 and add 1
4ÄѲ3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3²Ä4Ñ  :Square 3 and add 14 multiplied by 2
4Ñ3IJ  :Multiply 4 by 23 and add 1 squared

Befunge, 11 자리 숫자

Befunge는 한 자리 리터럴 만 지원하므로 약간 제한적입니다. 계산에서 스택에 하나의 숫자 만 남겨 두어야한다고 가정하면 11 개의 숫자가 가장 좋습니다.

최고의 캐릭터 : 358*%

생성 된 숫자 : (각각 하나의 예만)

58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24

파이썬, 16 자리

1234#

#을 사용하여 모든 불필요한 숫자를 주석 처리하십시오.

dc, 19 자리

*3zO+

출력이 스택 맨 위에 있으며 오류 (스택 언더 플로 포함)는 무시됩니다. 유효한 순열은 다음과 같습니다.

+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers

그 결과를 보여주기 위해 사용한 Python 프로그램은 다음과 같습니다.

#!/usr/bin/python

import sys
import itertools
import subprocess

if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)

devnull = open("/dev/null", 'w');

r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass

for i in sorted(r):
    print("%5s: %3d" % (r[i], i))

print("TOTAL COUNT = %d numbers" % len(r))

같은 점수 19를주는 두 개의 다른 문자열은 32d+*및 *4zO+입니다.

스몰 토크, 26 자리

1235r

설명 : 12r35는 기수 12를 사용하는 표기법이므로 3 * 12 + 5입니다.
이것은 Squeak에서 확인할 수 있습니다.

((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted

제공합니다 :

#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)

마지막 줄을 다음과 같이 바꾸면 :

    sorted: #value ascending)

그런 다음 표현식을 얻습니다.

'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116

Integer에서 메소드 r을 속이고 정의하고 싶었습니다.

Integer>>r
    ^self \\ 120 + 1

불행히도 컴파일러는 1235r로 보내지는 메시지 r보다 기수로 미완성 된 숫자를 인식하기 때문에 1235r에서 잘립니다
. 컴파일러도 쉽게 바꿀 수는 있지만, 내 취향에 너무 치명적입니다.

매스 매 티카, 16 자리

;1234

그리 흥미롭지는 않지만 산술을 사용하여 더 나은 것을 찾을 수는 없습니다. 작동 할 수 있는 유일한 것은! 계승 또는 이중 계승에 사용하는 것이지만 이것은 엄청난 숫자를 생성하기 쉽기 때문에 무차별 대입이 불가능합니다.

위 5 자에서 생성 할 수있는 16 개의 숫자 (범위)는 다음과 같습니다.

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

룬문자 마법 부여, 19 개 숫자

234p@

본질적으로 3 개의 리터럴, pow 연산자 및 "전체 스택 인쇄 및 종료"명령. 234p@812를 인쇄합니다 (2로 3 ^ 4). 전체 순열 목록 , 각 결과 사이에 개행을 생성하기 위해 @대체되었습니다 ak@.> 각 줄이 독립적으로 실행되도록하기 위해가 추가되었습니다. 또한 출력은 출력을 생성 한 프로그램과 동일한 순서가 아닙니다 (일부 프로그램은 더 빨리 종료 될 수 있음).

많은 순열은 아무 것도 인쇄하지 않습니다 (예 : @234p또는p234@ ) 19는 허용 범위 내에서 출력됩니다.

가능한 숫자 (및 가능한 하나의 프로그램; .그 위치는 실행되지 않은 나머지 문자 중 하나 일 수 있음을 나타냅니다) :

2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94

TI-BASIC, 12 자리

23+4!

더 나은 조합이있을 수 있지만 찾을 수 없었습니다.

모두 $24$ 유효한 순열은 다음과 같습니다.

23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74

어느 것이 $12$ 고유 한 값 :

$10,11,16,26,30,36,45,47,48,51,56,74$