Pilih lima karakter yang didukung bahasa Anda. Ada 5! = 5 × 4 × 3 × 2 × 1 = 120 cara ini dapat disusun menjadi string 5 karakter yang berisi setiap karakter sekali; 120 permutasi .

Pilih karakter Anda sehingga, ketika masing-masing dari 120 string dijalankan dalam bahasa Anda, 120 output yang dihasilkan akan sebanyak mungkin bilangan bulat unik dari 1 hingga 120 (inklusif) sebanyak mungkin.

Yaitu, untuk masing-masing dari 120 permutasi dari 5 karakter Anda yang menghasilkan kode runnable yang menghasilkan satu angka, Anda ingin set semua angka itu cocok sedekat mungkin dengan set bilangan bulat dari 1 hingga 120.

Jadi, idealnya, permutasi pertama Anda akan output 1, berikutnya 2, berikutnya 3, semua jalan sampai ke 120. Tetapi cita-cita itu kemungkinan tidak mungkin bagi kebanyakan bahasa dan karakter.

String 5-karakter dapat dijalankan sebagai:

• sebuah program tanpa input
• sebuah fungsi tanpa argumen
• a REPL perintah

String yang berbeda dapat dijalankan dengan cara yang berbeda jika diinginkan

Agar output dapat dihitung, itu harus berupa output integer tunggal dengan cara normal , seperti:

• dicetak ke stdout
• dikembalikan oleh fungsi
• hasil dari ekspresi REPL

Kode harus diakhiri secara normal (yang mungkin melibatkan kesalahan selama nomor telah di-output terlebih dahulu). Kode yang tidak berjalan sama sekali baik-baik saja, hanya output (tidak ada) tidak dihitung. Output angka harus dalam desimal kecuali jika basis yang berbeda adalah norma untuk bahasa Anda.

Kiriman yang menghasilkan angka paling berbeda dari 1 hingga 120 menang. Pengajuan sebelumnya menang dalam kasus seri.

Catatan

• 5 karakter Anda tidak semua harus berbeda, tetapi tentu saja memiliki karakter duplikat mengurangi jumlah permutasi yang efektif.
• Output float seperti 32.0count dan juga plain 32. (Tapi 32.01tidak mau.)
• Nol terkemuka seperti 032menghitung dan juga polos 32.
• Output yang valid harus deterministik dan tidak berubah-ubah waktu.
• Kami berurusan dengan karakter , bukan byte.

Contoh

Karakter 123+*adalah pilihan pertama yang masuk akal untuk REPL Python (atau banyak bahasa). 120 permutasi dan output yang dihasilkan adalah:

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

Ada 36 angka yang dihasilkan, semua untungnya dalam 1 hingga 120:

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

Namun, hanya 8 yang unik:

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

Jadi pengajuan seperti itu hanya akan skor 8 dari maksimal 120.

Nilai Python3, 21 27

Karakter: 3479%

Nomor unik: [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]

Seperti yang diminta, berikut adalah permutasi yang termasuk dalam kisaran [1, 120] . Cobalah online!

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 angka

4·>Ìn

Menghasilkan angka unik:

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

Menggunakan konstan 4dengan operasi +1, +2, *2dan ^2.

Python, 18 angka

237#-

Menghasilkan sebagai hasil yang valid:

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

EDIT: Saya bisa membuktikan bahwa solusi TuukkaX adalah optimal untuk Python. Saya menjalankan kode berikut untuk memaksa semua kemungkinan kombinasi 5 karakter ASCII yang dapat dicetak:

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

Hasil (setelah berjalan selama hampir 7 jam) menunjukkan bahwa solusi optimal pada kenyataannya 27 nomor yang berbeda, yang dihasilkan oleh tiga solusi yang berbeda semua menggunakan empat angka dan mod ( %): %3479, %5679dan %5789.

Java 8, 2 4 angka

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

Bukankah Anda mengharapkan jawaban Java, bukan?

Ini adalah lambda yang hanya dapat diatur satu dari dua cara (dan dengan dua digit berbeda!) Dengan total dua angka unik. Yang lainnya bukan lambda yang valid.

Sebenarnya meningkatkan jawabannya, terima kasih atas bantuan dari komentar! Tidak melihat bahwa 0 tidak valid, dan lupa bahwa variabel bisa, Anda tahu, lebih dari satu karakter. Kami punya 4!

Solusi yang lebih buruk

()->1

Tapi, sisi baiknya, dua jawaban unik di Jawa!

Jelly, 26 30 32 angka

‘’3²Ḥ

Ini (dan anagramnya) adalah program lengkap, yang tidak mengambil input, dan menghasilkan output pada output standar.

Output dari 120 program adalah, dalam urutan yang dihasilkan Jelly jika Anda memintanya untuk menghasilkan permutasi program:

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

Jika Anda hanya mengambil output unik dalam urutan numerik, Anda mendapatkan:

-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

Banyak dari ini terlalu kecil, dan 135 terlalu besar, tetapi masih ada 32 yang berada dalam jangkauan.

Ide dasarnya adalah menggunakan sebagian besar instruksi monadik (dalam sebuah program dengan hanya monad dan nilad, masing-masing hanya mengubah output sebelumnya), dan yang memungkinkan nilai berbeda dengan cepat. Pengecualiannya adalah dengan 3, yang merupakan nilad (nilai konstan 3). Jika muncul di awal program, semua operasi akan dilakukan dari 3. Jika muncul di tengah, itu membagi program menjadi dua bagian, masing-masing menghasilkan bilangan bulat (dan masing-masing mencetak ke output standar, hasilnya akhirnya digabungkan, sehingga memberi kita "menyatukan" sebagai operasi tambahan untuk menghasilkan angka).

Operasi yang kami miliki di sini, dalam konteks program menghasilkannya, adalah: kenaikan; pengurangan; konstan 3; kotak; dan ganda. Sayangnya, kenaikan dan penurunan adalah berlawanan, dan penurunan memiliki kecenderungan untuk menghasilkan -1 atau -2 di bagian pertama (sehingga mengarah ke angka negatif secara keseluruhan), tetapi ini masih memberikan penyebaran output yang lebih besar daripada hal-hal lain yang saya coba . Secara khusus, kami mendapatkan penyebaran yang cukup baik dari bagian pertama dan kedua dari nomor (perhatikan bahwa paruh pertama dapat menjadi string nol, jika 3merupakan karakter pertama dalam program).

JavaScript, 27 angka

Sangat mirip dengan jawaban TuukkaX , dengan seperangkat digit lainnya.

5789%

27 nilai yang berbeda adalah:

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 angka

3+*^-

Ini menghasilkan angka-angka berikut: [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]

Penjelasan

• 3 adalah bilangan bulat 3, jelas.
• + adalah kenaikan
• * ganda
• ^ persegi
• - adalah penurunan

Ada banyak situasi di mana program hanya kesalahan: misalnya *+^3-kesalahan karena meminta "Ambil 0, gandakan, kenaikan, kuadrat, hasil kuadrat itu adalah 3, pengurangan" yang jelas salah.

Program apa pun yang berakhir dengan 3akan menghasilkan 3atau tidak berfungsi.

Program apa pun yang dimulai dengan *3akan berulang tanpa henti karena bug (Brachylog sedang berusaha menemukan daftar sublists yang menghasilkan produk 3 yang tidak mungkin).

Vim, 16 angka

i1234

mencetak

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

Kode mesin IA-32, 8 angka

Nilai byte heksadesimal:

2c 40 48 b0 c3

Kode dijalankan sebagai fungsi yang mengembalikan nilai dalam al.

Permutasi yang valid:

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)

Saya melakukan pencarian brute-force, dengan batasan berikut:

• Byte pertama adalah b0- untuk menginisialisasi alregister
• Byte terakhir adalah c3- kembali; byte berikut dibuang
• Bytes opcode yang mungkin adalah:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Ini hanya menyisakan 3 byte yang dapat diubah dengan maksimal 15 hasil yang mungkin. Dari jumlah tersebut, maksimum 9 dapat berbeda (pada kenyataannya, ini terjadi hanya untuk satu set byte!). Salah satu nilai berada di luar jangkauan, jadi ini menyisakan 8 nilai. Ada satu set byte lainnya

34 40 48 b0 c3

yang juga memberikan 8 nilai berbeda - programnya sama, kecuali subdiganti oleh xor, yang membuat dua kemungkinan keluaran identik.

Semua set byte lainnya memberikan 7 atau lebih sedikit kemungkinan hasil.

Jelly , 33 angka

Ḥ23+c

Ḥganda (kiri);
2literal 2;
3literal 3;
+tambah (kiri, kanan); dan
cpilih (kiri, kanan), yaitu sejumlah cara untuk memilih objek yang benar dari kumpulan objek kiri.

Angka yang dihasilkan dengan contoh program:

 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

Saya mencoba memilih yang mudah diurai, tetapi ada yang jarang dan agak aneh untuk diurai, misalnya 23adalah:

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

... dan 72dan 13gunakan pencetakan implisit:

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)

Catatan yang Ḥ34+cjuga menghasilkan 33nilai unik di [1,120].

Brain-Flak 1

(())#

Brain-Flak membutuhkan kawat gigi seimbang, jadi program 5 karakter hanya valid jika salah satu karakter memulai komentar. Itu membuat kita dengan 4 karakter untuk dikerjakan. Dari mereka, 2 harus (dan )tidak ada yang akan didorong ke tumpukan. Mereka harus pergi dulu dan keempat dengan komentar last ( (..)#). Sekarang kita dapat menempatkan (), {}, <>, atau []dalam. {},, <>dan []masing - masing mengevaluasi ke 0, tetapi ()adalah 1. Itu berarti bahwa (())#hanya 5 karakter string yang menghasilkan program Brain-Flak yang valid.

Cobalah secara Online!

Jika pertanyaannya adalah "apa saja 6 karakter paling kuat", jawabannya akan (){}[]seperti Brain-Flak sedang menyelesaikan lengkap hanya menggunakan subset ini.

Hexagony , 13 angka

)24!@

Ini adalah 13 angka yang dapat dicetak dengan satu program yang memungkinkan untuk masing-masingnya:

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

Program harus cukup jelas. @menghentikan program, !mencetak nilai saat ini, )menambahnya, 2dan 4menambahkan sendiri ke nilai saat ini (di mana nilai awal berada 0). Tata letak heksagonal sebenarnya dari kode sumber tidak relevan di sini, program-programnya hanya dapat dibaca dari kiri ke kanan.

Ini harus optimal, meskipun alih-alih 2dan 4Anda dapat memilih digit pasangan apa pun xdan ysedemikian rupa 2 ≤ x ≤ y-2.

Solusi di atas ditemukan oleh brute force (hampir lengkap), membutuhkan satu !(jika tidak akan mencetak apa-apa), satu @(jika tidak program tidak akan berakhir), dan mengisi tiga karakter yang tersisa dengan kombinasi (berulang) dari serangkaian karakter berikut:

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

Saya tidak dapat melihat bagaimana perintah lain dapat menghasilkan lebih banyak variasi.

Perl, 27 angka

3479%

Perl tidak memiliki REPL bawaan, sehingga Anda dapat menggunakan re.pldari Devel :: REPL .

Hasil:

%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

Dipaksa menggunakan program berikut:

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 angka

Bukan jumlah yang besar tetapi mungkin yang terbaik yang bisa dilakukan dengan R. Saya mencari semua kombinasi angka 0..9, operator + - * / ^dan komentar karakter #, dan berikut delapan semua output 18 bilangan bulat unik antara 1 dan 120.

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

Sebagai contoh, mari kita ambil -#146. Berikut adalah 18 bilangan bulat yang bisa kita dapatkan:

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

Jika Anda penasaran dengan kode (jelek) yang digunakan untuk menguji semua kemungkinan kombinasi, ini dia. Ini menghasilkan jumlah bilangan bulat unik antara 1 dan 120 untuk setiap kombinasi karakter dengan panjang 5 ke file yang disebut "datafile" di direktori kerja saat ini.

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

Oktaf, 18

Ini ditemukan menggunakan pencarian bruteforce pada simbol *+-/0123456789:;<\^|~%. Tapi terlalu lama untuk menghitung ...

-139%

Output yang mungkin:

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

Oktaf, 15 angka

Tidak banyak yang bisa dibanggakan, tapi ini yang terbaik yang bisa saya dapatkan di Octave:

124+%

Ini memberi angka:

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

Saya mendapat 16 juga, tetapi sepertinya itu identik dengan jawaban Sefa ...

1234%

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

PHP, 15 angka

1230\r

Menggunakan fakta bahwa php mencetak apa pun di luar tagnya kata demi kata (tanpa menggunakan ini, Anda dapat melakukan persis 1 angka dengan sesuatu seperti <?=1;). Juga menggunakan karakter carriage return yang sebenarnya daripada \r.

Menciptakan (diurutkan, dihapus 0s terkemuka):

 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

di mana angka unik yang valid adalah:

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

Cubix , 7 angka

"2)@O

Keluarkan angka-angka ini:

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

Setiap program Cubix yang valid untuk tantangan ini harus memiliki Ooutput integer, dan @untuk mengakhiri program (Cubix bahkan belum pernah mendengar "kesalahan"). Ini memberi kita 3 karakter untuk bermain-main untuk menghasilkan output terbanyak. Selain itu, karena cara Cubix mengatur kode pada sebuah kubus, karakter pertama tidak akan berguna kecuali salah satu yang lain adalah karakter directional.

Cara paling efisien yang saya temukan untuk menghasilkan banyak angka adalah menggunakan "untuk mendorong serangkaian kode-kode ke stack. Dengan penataan ulang yang hati-hati, kita dapat memasukkan beberapa karakter di tempat terakhir dan hanya menampilkan kode-kode mereka. Dengan menggunakan )untuk menambah item teratas, kami dapat membuat output tambahan dari beberapa pengaturan ini.

Ada dua jenis program dasar yang digunakan di sini. Yang pertama adalah ini:

"2)O@

yang diperluas ke

  "
2 ) O @
  .

Program yang dihasilkan mendorong 2ke tumpukan, menambahnya dengan ), keluaran dengan O, dan berakhir dengan @.

Yang kedua adalah ini:

2")O@

yang diperluas ke

  2
" ) O @
  .

Program yang dihasilkan mendorong char-kode ), O, dan @, increment yang terakhir dengan ), output dengan O, dan berakhir dengan @.

> <> , 6 angka

Memperoleh 2 angka berkat Teal Pelican

1ln";

Menghasilkan angka unik [1, 4, 5, 49, 59, 108]

Kami perlu nmencetak nomor.
Kita harus ;mengakhiri.

Itu membuat kita hanya memiliki 3 karakter untuk dikerjakan.

Beberapa kombinasi berbeda dari value& operatorbersama dengan "dikonfirmasi untuk menghasilkan 6 nilai unik, tapi saya belum menemukan yang lebih baik dari itu.

Groovy, 10 Angka

Solusi Man JVM BURUK untuk ini ... Siapa yang tahu?

1200+

Hasil dalam:

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

Tunggu apa? Bagaimana ini membuatmu bertanya?

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.

Rahasia dagang, di Groovy / Java integer yang diawali dengan 0 adalah oktal. Kode yang saya gunakan untuk menguji jawaban Groovy jika seseorang ingin mengalahkan saya:

("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 angka

0123%

% adalah operator komentar, jadi itu akan "memotong" di semua tempat yang mungkin sekali, membantu untuk membuat semua kombinasi yang mungkin dari digit dan himpunan bagian dari mereka yang diberikan:

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

J, 16 Angka

1234]

Tidak ada yang mewah, hanya diuji 1234dengan semua kata kerja 1-karakter yang masuk akal. ]memilih argumen yang benar.

Angka unik yang dihasilkan adalah

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 di antaranya:

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

Berada dalam kisaran [1.120].

Diuji dengan

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

Japt , 41 angka

Cukup banyak coba-coba sehingga mungkin ada solusi yang lebih baik. Menggunakan bilangan bulat 3& 4dan pintasan Japt untuk mengkuadratkan, menambahkan 1& mengalikan dengan 2. Semua 120 program menghasilkan bilangan bulat >0tetapi hanya 78 yang <=120dan hanya 41 yang unik.

34²ÄÑ

Menghasilkan angka:

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

Lihat daftar angka atau kumpulan program yang valid

Penjelasan

Beberapa hal yang perlu diperhatikan tentang Japt yang relevan di sini adalah:

1. Jika suatu program tidak memulai dengan (dalam hal ini) salah satu digit maka variabel input pertama U, yang defaultnya 0, secara otomatis dimasukkan di awal,
2. Jika salah satu atau kedua digit segera mengikuti salah satu cara pintas untuk operasi matematika maka mereka ditambahkan padanya (misalnya 3Ä4 = 3+14 = 17dan, sama, 4Ѳ = 4*2**2 = 16), dan,
3. Jika salah satu digit segera mengikuti ²maka ²dan segala sesuatu sebelum itu, pada dasarnya, diabaikan.

Penjelasan untuk beberapa program (memproduksi 1, 3, 37dan 93, masing-masing):

²Ñ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

Di luar, 11 angka

Befunge agak terbatas karena hanya mendukung satu digit literal. Jadi yang terbaik yang bisa saya dapatkan adalah 11 angka, dengan asumsi perhitungan harus meninggalkan kita dengan satu dan hanya satu angka di tumpukan.

Karakter terbaik: 358*%

Angka yang dihasilkan: (hanya satu contoh dari masing-masing)

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 angka

1234#

Gunakan # untuk mengomentari semua nomor yang tidak perlu.

dc, 19 angka

*3zO+

Output ada di atas stack, dan kesalahan (termasuk stack underflow) diabaikan. Permutasi yang valid adalah:

+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

Inilah program Python yang saya gunakan untuk menunjukkan hasil itu:

#!/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))

Dua string lain yang memberikan skor sama adalah 19 adalah 32d+*dan *4zO+.

Smalltalk, 26 angka

1235r

Penjelasan: 12r35 adalah notasi untuk menggunakan radix 12, dan karenanya 3 * 12 + 5.
Ini dapat diverifikasi dalam mencicit:

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

memberi:

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

Jika kami mengganti baris terakhir dengan:

    sorted: #value ascending)

kami kemudian mendapatkan ungkapan:

'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

Saya ingin menipu dan mendefinisikan metode r dalam Integer sebagai

Integer>>r
    ^self \\ 120 + 1

Sayangnya, compiler memotong pada 1235r karena mengenali nomor yang belum selesai dengan radix daripada pesan r dikirim ke 1235 ...
Saya bisa dengan mudah mengubah kompiler juga, tapi itu sedikit terlalu banyak cheat sesuai selera saya.

Mathematica, 16 angka

;1234

Tidak terlalu menarik, tetapi sepertinya saya tidak dapat menemukan sesuatu yang lebih baik menggunakan aritmatika. Satu-satunya hal yang mungkin berhasil adalah menggunakan !faktorial atau faktorial ganda, tetapi ini sangat rentan untuk menghasilkan angka besar sehingga tidak mungkin untuk memaksa.

16 angka (dalam kisaran) yang dapat dihasilkan dari 5 karakter di atas adalah:

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

Pesona Rahasia, 19 angka

234p@

Pada dasarnya 3 literal, operator pow, dan perintah "cetak seluruh tumpukan dan akhiri". 234p@mencetak 812 (3 ^ 4 dikoneksikan dengan 2). Daftar permutasi penuh , catatan yang @telah diganti olehak@ untuk menghasilkan baris baru antara setiap hasil dan >telah ditambahkan untuk memastikan bahwa setiap baris dieksekusi secara independen. Perhatikan juga bahwa output tidak dalam urutan yang sama dengan program yang menghasilkannya (karena beberapa program dapat berakhir lebih cepat).

Banyak permutasi yang tidak mencetak apa-apa (mis. @234p Atau p234@), tetapi 19 menghasilkan output dalam rentang yang diizinkan.

Angka mungkin (dan satu kemungkinan program yang menghasilkannya; .menunjukkan bahwa posisi itu mungkin salah satu karakter yang tersisa karena tidak dijalankan):

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 angka

23+4!

Kemungkinan besar ada kombinasi yang lebih baik, tetapi saya tidak dapat menemukannya.

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