言語がサポートする5文字を選択します。5つあります！= 5×4×3×2×1 = 120個の方法で、これらを各文字を1回ずつ含む5文字の文字列に配置できます。120の順列。

120の各文字列が言語で実行されるときに、生成される120の出力が1から120までの一意の整数になるように、文字を選択します。

つまり、単一の数値を出力する実行可能コードを生成する5文字の120個の順列のそれぞれについて、それらすべての数値のセットが1から120までの整数のセットにできるだけ近く一致するようにします。

したがって、理想的には、最初の順列はを出力し1、次2、次3、次へと続きます120。しかし、その理想はほとんどの言語と文字にとっておそらく不可能です。

5文字の文字列は次のように実行できます。

• 入力のないプログラム
• 引数なしの関数
• REPLのコマンド

必要に応じて、異なる方法で異なる文字列を実行できます

出力をカウントするには、次のような通常の方法での単一の整数出力である必要があります。

• 標準出力に印刷される
• 関数によって返された
• REPL式の結果

コードは正常に終了するはずです（最初に数値が出力されている限り、エラーが発生する可能性があります）。まったく実行されないコードでも問題ありません。（存在しない）出力だけはカウントされません。異なる出力が言語の標準でない限り、出力される数値は10進数でなければなりません。

1から120の最も明確な数字を生成するサブミッションが勝ちます。同点の場合は、以前の提出が優先されます。

ノート

• 5つのキャラクターがすべて異なる必要はありませんが、もちろんキャラクターが重複していると、順列の効果的な数が減ります。
• 32.0countやplain などのフロート出力32。（しかし、32.01そうではありません。）
• 032countやplain などの先行ゼロ32。
• 有効な出力は確定的であり、時間に対して不変である必要があります。
• バイトではなく文字を扱っています。

例

文字123+*は、Python（または多くの言語）の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。

Python、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時間実行した後）の結果は、最適解が実際にすべての4つの数字とMODを（使用して三つの異なるソリューションによって生成さ27点の異なる数、であることを示した%）%3479、%5679および%5789。

Javaの8、2つの 4の番号

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

Javaの答えを期待していませんでしたか？

これは、合計2つの一意の番号に対して2つの方法のいずれか（および任意の2つの異なる数字）でのみ配置できるラムダです。それ以外は有効なラムダではありません。

コメントからの助けのおかげで、実際に答えを改善しました！0が無効であることに気づかず、変数が複数の文字になる可能性があることを忘れていました。4つあります！

さらに悪い解決策

()->1

しかし、明るい面では、Javaの2つのユニークな答えです！

ゼリー、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個あります。

基本的な考え方は、主にモナド命令（モナドとニラドのみを備えたプログラムで、これらはそれぞれ前の出力を変換するだけです）と、値をすばやく発散させる命令を使用することです。例外はで3、これはnilad（定数値3）です。プログラムの先頭に表示される場合、すべての操作は3から行われます。中央に表示される場合、プログラムは2つの半分に分割され、それぞれが整数を出力します（それぞれが標準出力に出力されるため、結果は連結されるため、数値を生成するための追加操作として「連結」が行われます）。

プログラムが生成するコンテキストでの操作は次のとおりです。デクリメント; 定数3; 平方; とダブル。インクリメントとデクリメントは残念ながら正反対であり、デクリメントは最初のセクションで-1または-2を生成する残念な傾向があります（したがって全体的に負の数になります）が、これは私が試した他のものよりも大きな出力の広がりを与えました。特に、数値の前半と後半の両方にかなりの広がりがあります（3プログラムの最初の文字が前半である場合は、前半がヌル文字列になる可能性があることに注意してください）。

JavaScript、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です。
• + 増分です
• * 二重です
• ^ 正方形です
• - デクリメントです

プログラムが単純にエラーを起こす状況はたくさんあります。たとえば、「0を2倍、インクリメント、スクエア、そのスクエアの結果が3、デクリメント」*+^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-return; 次のバイトは破棄されます
• 可能なオペコードバイトは次のとおりです。
  • 0x04- add
  • 0x0c- or
  • 0x24- and
  • 0x2c- sub
  • 0x34- xor
  • 0xd4- aad
  • 0x40- inc
  • 0x48- dec

これにより、3つの変更可能なバイトのみが残り、最大15の結果が得られます。これらのうち、最大9個まで区別できます（実際、これは1セットのバイトに対してのみ発生します！）。値の1つが範囲外であるため、8つの値が残ります。別のバイトのセットがあります

34 40 48 b0 c3

また、8つの異なる値が得られます。プログラムは同じです。ただし、にsub置き換えられxor、2つの可能な出力が同一になります。

他のすべてのバイトセットでは、7以下の結果が得られます。

ゼリー、33の数字

Ḥ23+c

Ḥdouble（左）;
2リテラル2;
3リテラル3;
+add（left、right）; そして、
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]

Brain-Flak 1

(())#

Brain-Flakはバランスのとれたブレースを必要とするため、5文字のプログラムは、いずれかのキャラクターがコメントを開始する場合にのみ有効です。これにより、作業する4文字が残ります。それらのうち、2つ(で)なければなりません。そうでなければ、スタックには何もプッシュされません。それらは最後にコメントを付けて最初に、4番目に行かなければなりません（(..)#）。今、私たちは置くことができ()、{}、<>、または[]内部。{}、<>、そして[]それぞれが0に評価されますが、()それは意味1です。(())#有効な脳高射砲プログラムを生成のみ5文字の文字列です。

オンラインでお試しください！

質問が代わりに「最も強力な6人のキャラクターは何か」である場合(){}[]、Brain-Flakはこのサブセットのみを使用して完全にチューリングしているので、答えは次のようになります。

六角形、13の数字

)24!@

これらは、印刷可能な13個の数字で、それぞれに1つのプログラムがあります。

)!@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。

上記の解決策は（ほぼ網羅的な）ブルートフォースによって発見され!、1つ@（それ以外の場合は何も出力しません）、1つ（そうでない場合はプログラムは終了しません）、残りの3文字を（繰り返し）の組み合わせで埋めます次の文字セット：

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

他のコマンドがどのようにさらに多様性を生み出す可能性があるのか​​わかりません。

Perl、27の数字

3479%

PerlにはREPLが組み込まれていないためre.pl、Devel :: REPLから使用できます。

結果：

%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、演算子+ - * / ^、コメント文字のすべての組み合わせを検索し#、次の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

すべての可能な組み合わせをテストするために使用される（ugい）コードに興味がある場合は、ここにあります。長さ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桁の数字

自慢することはあまりありませんが、これはOctaveで得られる最高のものです。

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つの数値を実行できます<?=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

キュビス、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つの基本的なプログラムタイプがあります。最初はこれです：

"2)O@

に展開します

  "
2 ) O @
  .

結果のプログラム2はスタックにプッシュし、でインクリメントし、)で出力しO、で終了し@ます。

2番目はこれです。

2")O@

に展開します

  2
" ) O @
  .

得られたプログラムは、チャーコードを押し)、O、および@、と最後の増分)との出力を、Oおよびで終了します@。

> <>、6つの数字

ティールペリカンのおかげで2つの数字を獲得

1ln";

一意の番号を生成します [1, 4, 5, 49, 59, 108]

n数字を印刷する必要があります。終了
する必要;があります。

残り3文字しか使用できません。

value＆のいくつかの異なる組み合わせは、6つの一意の値を生成することoperatorを"確認しましたが、それ以上良いものは見つかりませんでした。

Groovy、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回「カット」し、指定された数字とそのサブセットの可能なすべての組み合わせを作成するのに役立ちます。

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

Japt、41の数字

ちょうど試行錯誤なので、より良い解決策があるかもしれません。整数3＆4およびJaptショートカットを使用して、平方、加算、1乗算を行い2ます。120個のプログラムはすべて整数を出力しますが、>078個<=120だけが一意で、そのうち41個だけが一意です。

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. プログラムが（この場合）数字の1つで始まらない場合、最初の入力変数U（デフォルトは0）が先頭に自動的に挿入され、
2. 数字のいずれかまたは両方が数学演算のショートカットの1つの直後に続く場合、それらはそれに追加されます（たとえば3Ä4 = 3+14 = 17、同様に、4Ѳ = 4*2**2 = 16）、
3. 数字の1がすぐに続く場合²、その後²その前に、すべては、基本的に、無視されます。

（生産プログラムのいくつかについての説明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は1桁のリテラルのみをサポートするため、少し制限されています。したがって、計算でスタック上に1つだけの数字を残さなければならない場合、11の数字が最良でした。

最高のキャラクター： 358*%

生成された数値：（それぞれの1つの例）

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

Python、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+。

Smalltalk、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

私はチートし、整数のメソッドrを次のように定義したかった

Integer>>r
    ^self \\ 120 + 1

残念ながら、コンパイラは、1235に送信されたメッセージrではなく、基数を持つ未完成の数字を認識するため、1235rをチョップします
。

Mathematica、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は出力を許容範囲内にします。

可能な数字（および結果となる可能性のある1つのプログラム。.これらの位置は、実行されない残りの文字のいずれかであることを示します）：

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$