Dilinizin desteklediği beş karakteri seçin. 5 tane var! = 5 × 4 × 3 × 2 × 1 = 120 yolla bunların bir kez her karakteri içeren 5 karakterli bir dizge halinde düzenlenmesi; 120 permütasyon .

Karakterlerinizi, 120 dizenin her biri kendi dilinizde çalıştırıldığında, üretilen 120 çıkışın mümkün olduğunca 1 ila 120 (dahil) kadar benzersiz tam sayılar olacağı şekilde seçin.

Diğer bir deyişle, tek bir sayı çıkaran çalıştırılabilir kod üreten 5 karakterinizin 120 permütasyonunun her biri için, tüm bu sayılar kümesinin, 1 ile 120 arasındaki tam sayı kümesine olabildiğince yakın olmasını istersiniz.

Bu yüzden, ideal olarak, ilk permütasyonunuz 1, bir sonraki 2, bir sonraki 3, sonuna kadar çıkacaktı 120. Ancak bu ideal çoğu dil ve karakter için mümkün değildir.

5 karakterli dizeler şu şekilde çalıştırılabilir:

• girişi olmayan bir program
• tartışmasız bir işlev
• bir REPL komutu

İstenirse farklı dizeler farklı şekillerde çalıştırılabilir

Çıkışın sayılması için normal şekilde tek bir tamsayı çıkışı olmalıdır , örneğin:

• stdout'a yazdırılıyor
• işlev tarafından döndürüldü
• REPL ifadesinin sonucu

Kod normal olarak sonlandırılmalıdır (bu sayı ilk önce çıktığı sürece hata vermeyi içerebilir ). Hiç çalışmayan kod iyi, sadece (var olmayan) çıktı sayılmaz. Sayılar çıktısı, diliniz için farklı bir temel olmadıkça ondalık olmalıdır.

1 ile 120 arasında en belirgin sayıları üreten gönderim kazanır. Erken başvuru, beraberlik durumunda kazanır.

notlar

• 5 karakterinizin hepsinin farklı olması gerekmez, ancak yinelenen karakterlerin olması elbette etkili permütasyon sayısını azaltır.
• 32.0Sayma gibi düz çıkışlar 32. (Ama 32.01olmaz.)
• 032Sade olduğu kadar sayım gibi önde gelen sıfırlar 32.
• Geçerli çıktılar deterministik ve zamanla değişmez olmalıdır.
• Baytlarla değil , karakterlerle uğraşıyoruz .

Örnek

Karakterler 123+*Python'un (veya birçok dilin) ​​REPL'i için makul bir ilk tercihtir. Elde edilen 120 permütasyon ve çıktı:

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

Üretilen 36 sayı var, hepsi 1 ila 120 arasında.

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

Ancak, yalnızca 8 tanesi benzersizdir:

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

Böylece böyle bir sunum sadece en fazla 120 puan üzerinden 8 puan alır.

Python3, 21 27 değerleri

Karakterler: 3479%

Benzersiz numaralar: [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]

Talep edildiği gibi, işte menzilde düşen permütasyonlar [1, 120] . Çevrimiçi deneyin!

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 sayılar

4·>Ìn

Benzersiz sayıları oluşturur:

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

Sabit kullanır 4operasyonlarla +1, +2, *2ve ^2.

Python, 18 sayılar

237#-

Geçerli sonuçlar olarak üretir:

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

EDIT: TuukkaX'ın çözümünün Python için en uygun çözüm olduğunu söyleyebilirim . Yazdırılabilir 5 ASCII karakterinin olası tüm kombinasyonlarını bulmak için aşağıdaki kodu kullandım:

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

(Yaklaşık 7 saat çalıştıktan sonra) Sonuçlar en iyi çözüm aslında üç farklı çözümler dört numaraları kullanarak ve mod (üretilen 27 farklı sayılar, olduğunu göstermiştir %:) %3479, %5679ve %5789.

Java 8, 2 4 sayıları

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

Java cevabı beklemiyor muydun?

Bu, toplam iki benzersiz sayı için yalnızca iki yoldan birini (ve iki farklı basamağı!) Düzenleyebilen bir lambdadır. Geriye kalan her şey geçerli bir lambda değil.

Yorumlardan gelen yardımlar sayesinde cevabı gerçekten iyileştirdik! 0'ın geçerli olmadığını ve değişkenlerin birden fazla karakter olabileceğini unutmadık. 4 tane aldık!

Daha da kötüsü bir çözüm

()->1

Ancak, parlak tarafta, Java'da iki benzersiz cevap!

Jöle, 26 30 32 sayılar

‘’3²Ḥ

Bu (ve anagramları), girdi almayan ve standart çıktıda çıktı üreten tam programlardır.

120 programın çıktıları, eğer programın permütasyonlarını oluşturmasını isterseniz, Jelly bunları sıralamasına göre sıralar:

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

Benzersiz çıktıları sayısal sırayla alırsanız, şunları elde edersiniz:

-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

Bunların birçoğu çok küçük ve 135'ü çok büyük, fakat yine de menzilde 32 tane var.

Temel fikir, çoğunlukla monadik komutlar kullanmaktır (sadece monad ve nilad içeren bir programda, her biri önceki çıktıyı dönüştürür) ve değerin hızla birbirinden ayrılmasına izin verenler. Bunun istisnası 3nilad olan (sabit değer 3). Programın başlangıcında belirirse, tüm işlemler 3'ten itibaren yapılacaktır. Ortada görünüyorsa, programı her biri bir tamsayı çıkaran iki yarıya böler (ve her biri standart çıktıya yazdırırken, sonuçlar bitiştirilir, bu nedenle sayıları oluşturmak için ek bir işlem olarak "birleştirmemizi" sağlar).

Burada sahip olduğumuz işlemler, programın kendi içinde ürettiği bağlamda: artış; indirimi; sabit 3; Meydan; ve çift. Artış ve azalış maalesef zıtlıklardır ve azalmanın, ilk bölümde -1 veya -2 üretme şanssız bir eğilimi vardır (bu nedenle, genel olarak negatif bir sayıya yol açar), ancak bu yine de, denedim. . Özellikle, sayının hem ilk hem de ikinci yarısının oldukça iyi bir şekilde yayılmasını sağlarız ( 3programın ilk karakteri ise ilk yarının boş dize olabileceğini unutmayın ).

JavaScript, 27 numara

TuukkaX'ın cevabına çok benzer , başka bir rakam grubuyla.

5789%

27 farklı değer:

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 sayılar

3+*^-

Bu, aşağıdaki sayıları verir: [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]

açıklama

• 3 Açıkçası, tamsayı 3'tür.
• + artış
• * çift
• ^ kare
• - azalış

Programın basitçe hata yaptığı bir çok durum var: örneğin “0 al, ikiye katla, arttır, kare, o karenin sonucu 3, azal”,*+^3- diye sorar. yanlış olduğu açıktır.

İle biten herhangi bir program 3ya çıkacaktır3 da çalışmayacak.

*3Başlayan herhangi bir program bir hatadan dolayı sonsuz döngüde çalışacaktır (Brachylog, ürünün 3'te sonuçlanması mümkün olmayan bir liste listesi bulmaya çalışıyor).

Vim, 16 sayı

i1234

baskı

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

IA-32 makine kodu, 8 numara

Onaltılık bayt değerleri:

2c 40 48 b0 c3

Kod, değeri döndüren bir işlev olarak çalıştırılır al.

Geçerli permütasyonlar:

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)

Aşağıdaki kısıtlamalarla bir kaba kuvvet araştırması yaptım:

• İlk bayt b0- alkayıt defterini başlatmak için
• Son bayt c3- dönüş; aşağıdaki baytlar atılır
• Olası opcode byte'ları:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Bu, maksimum 15 olası sonuçla yalnızca 3 değiştirilebilir bayt bırakır. Bunlardan en fazla 9 farklı olabilir (aslında, bu sadece bir bayt kümesi için gerçekleşir!). Değerlerden biri aralık dışında olduğu için 8 değer kalıyor. Başka bir bayt kümesi var

34 40 48 b0 c3

Bu da 8 farklı değer verir - Programlar, bunun subyerine xorolası çıktıların ikisini aynı kılan dışında aynıdır.

Diğer tüm bayt setleri 7 veya daha az olası sonuç verir.

Jöle , 33 numara

Ḥ23+c

Ḥ(sol), çift;
2değişmez 2;
3değişmez 3;
+ekle (sol, sağ); ve
c (sol, sağ) seçimini yapın, yani bir sol nesne koleksiyonundan doğru nesneleri seçme yollarını seçin.

Örnek bir programla elde edilen sayılar:

 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

Ayrıştırmak kolay olanları seçmeye çalıştım, ancak bazıları nadir ve ayrıştırmak için biraz garip, örneğin 23:

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

... ve 72ve 13gizli baskı kullanın:

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)

Bunun içinde Ḥ34+cde 33benzersiz değerler ürettiğini unutmayın [1,120].

Beyin Flak 1

(())#

Brain-Flak dengeli diş teli gerektirir, bu yüzden 5 karakterlik bir program ancak karakterlerden biri yorum yapmaya başlarsa geçerlidir. Bu bizi çalışmak için 4 karakterle bırakır. Bunlardan 2 tanesi olmalı (ve )aksi halde hiçbir şey yığının üzerine itilmeyecekti. Bunların ilk ve dördüncü yorumlarıyla gitmeleri gerekiyor ( (..)#). Şimdi koyabilirsiniz (), {}, <>, veya []içeride. {},, <>ve []her biri 0 olarak değerlendirilir, ancak ()1'dir. Bu (())#, geçerli bir Brain-Flak programı üreten tek 5 karakterli dize olduğu anlamına gelir .

Çevrimiçi Deneyin!

Eğer soru bunun yerine " en güçlü 6 karakter (){}[]hangisi " olsaydı, cevap , Beyin-Flak'ın sadece bu altkümeyi kullanarak tamamladığı gibi olurdu .

Altıgen , 13 numara

)24!@

Bunlar, her biri için bir olası programa sahip 13 basılabilir numaradır:

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

Programlar oldukça açıklamalı olmalıdır. @programı sonlandırır, !geçerli değeri yazdırır, )arttırır 2ve 4kendilerini geçerli değere ekler (başlangıç ​​değerinin olduğu yer 0). Kaynak kodunun asıl altıgen düzeninin burada önemi yoktur, programlar soldan sağa okunabilir.

Bu etmelidir yerine rağmen, optimal 2ve 4herhangi çifti basamak alabilirsiniz xve yöyle ki 2 ≤ x ≤ y-2.

Yukarıdaki çözüm (neredeyse yorucu) kaba kuvvet tarafından bulundu, bunlardan birini !(aksi halde hiçbir şey yazmaz), birini @(aksi takdirde program sonlandırmayacak) ve kalan üç karakteri herhangi bir (tekrarlanan) kombinasyonla doldurma aşağıdaki karakter kümesini:

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

Diğer komutlardan herhangi birinin nasıl daha fazla çeşitlilik üretebileceğini göremiyorum.

Perl, 27 numara

3479%

Perl'de yerleşik bir REPL yoktur, yani Devel :: REPL'den kullanabilirsiniz re.pl. .

Sonuçlar:

%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

Aşağıdaki programı kullanarak zorla zorla:

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 sayı

Çok büyük bir sayı değildir, ancak R ile yapılabilecek en iyi olabilir. Rakamların 0..9, operatörlerin + - * / ^ve yorum satırının tüm kombinasyonlarını #ve takip eden sekizinin 1 ile 120 arasında 18 benzersiz tam sayı çıktısını aradım .

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

Örnek olarak, haydi alalım -#146. İşte alabileceğimiz 18 tam sayı:

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

Olası tüm kombinasyonları test etmek için kullanılan (çirkin) kodu merak ediyorsanız, işte burada. Geçerli çalışma dizinindeki "datafile" adlı bir dosyaya 5 uzunluğunun her karakter birleşimi için 1 ile 120 arasındaki benzersiz tam sayıların sayısını verir.

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

Octave, 18

Bu, sembollerde bruteforce araması kullanılarak bulundu *+-/0123456789:;<\^|~%. Ama hesaplanması çok uzun sürdü ...

-139%

Olası çıkışlar:

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

Oktav, 15 numara

Övünecek fazla bir şey yok, ama bu Octave'da alabileceğim en iyisi:

124+%

Sayıları verir:

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

Ben de 16 tane aldım, ama görünüşe göre Sefa'nın cevabı aynı.

1234%

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

PHP, 15 sayılar

1230\r

PHP'nin kendi etiketlerinin dışında herhangi bir şeyi sözlü yazdırması gerçeğini kullanır (bunu kullanmadan tam olarak 1 sayı yapabilirsin <?=1;). Ayrıca, yerine gerçek bir satır başı karakteri kullanır \r.

Oluşturur (sıralanır, baştaki 0s kaldırılır):

 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

geçerli benzersiz sayılardan bazıları:

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

Cubix , 7 sayılar

"2)@O

Bu sayıları çıkarır:

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

Bu zorluk için geçerli olan herhangi bir Cubix programının Obir tamsayı @çıkarması ve bir programı sonlandırması gerekir (Cubix, "hataları" bile duymamıştır). Bu bize en çok çıktı üretmek için uğraşmamız gereken 3 karakter verir. Ayrıca, Cubix'in bir küp üzerinde kod düzenleme şekli nedeniyle, diğerlerinden biri yönlü bir karakter olmadıkça ilk karakter işe yaramaz olacaktır.

Birden fazla sayı üretmenin en etkili yolu, "bir dizi char kodunu yığına itmek için kullanmaktır . Dikkatlice yeniden düzenlemeyle, son noktaya birkaç karakter sığdırabilir ve karakter kodlarını çıkartabiliriz. )Üst öğeyi artırmak için kullanarak , bu düzenlemelerin birkaçından ekstra çıktılar yaratabiliriz.

Burada kullanılan iki temel program tipi vardır. Bunlardan ilki:

"2)O@

hangi genişler

  "
2 ) O @
  .

Sonuçta ortaya çıkan program 2yığına iter , arttırır ), çıktısını verir Ove sonlandırır @.

İkincisi şudur:

2")O@

hangi genişler

  2
" ) O @
  .

Elde edilen programı char kodlarını iter ), Ove @, son bir artırır )çıktıların, Ove sona erer @.

> <> , 6 sayı

Teal Pelikan sayesinde 2 sayı kazanıldı

1ln";

Eşsiz sayıları üretir [1, 4, 5, 49, 59, 108]

Biz ihtiyacımız nbir numara yazdırmak için. Sonlandırmamız
gerek ;.

Bu bize çalışmak için sadece 3 karakter bırakır.

Birkaç farklı kombinasyonlar valueve operatorbirlikte "6 benzersiz değerler üretmek için teyit ama bundan daha iyi bir şey bulamadım.

Groovy, 10 Numara

Man JVM çözümleri bunun için kötü niyetli ... Kim biliyordu?

1200+

Sonuçlar:

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

Bir dakika ne? 17 sormanı nasıl sağlar?

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.

Ticari sır, Groovy / Java içinde tamsayılar 0 ile gelen bir oktaldir. Groovy'yi test etmek için kullandığım kod, birinin beni dövmek istemesi nedeniyle cevapları:

("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 sayılar

0123%

% yorum operatörü olduğu için, mümkün olan tüm yerlerde bir kez "keser", verilen rakamların ve alt gruplarının tüm olası kombinasyonlarını oluşturmaya yardımcı olur:

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

J, 16 Sayı

1234]

Hiçbir şey fantezi, sadece test edildi 1234 makul tüm 1 karakter fiiller ile . ]onun doğru argümanını seçer.

Üretilen benzersiz sayılar

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

bunlardan 16'sı:

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

[1,120] aralığında.

İle test edildi

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

Japt , 41 numara

Hemen hemen sadece deneme yanılma bu yüzden daha iyi bir çözüm olabilir. Tamsayıları 3ve 4kareleri almak, eklemek 1ve çarpmak için Japt kısayollarını kullanır 2. 120 programın tamamı bir tamsayı çıktı, >0ancak yalnızca 78'i <=120ve bunların 41'i benzersiz.

34²ÄÑ

Sayıları üretir:

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

Görüntüle numaraların listesini veya geçerli programların koleksiyon

açıklama

Burada ilgili olan Japt hakkında not edilmesi gereken birkaç şey:

1. Bir program (bu durumda) rakamlardan biriyle başlamazsa, ardından Uvarsayılan olan ilk giriş değişkeni .0 otomatik olarak başlangıçta eklenir,
2. Rakamlardan biri veya her ikisi de derhal bir matematiksel işlem için kısayollardan birini takip ederse, buna eklenirler (örneğin 3Ä4 = 3+14 = 17ve benzer şekilde,4Ѳ = 4*2**2 = 16 ) ve
3. Rakamlardan biri derhal takip ederse, ²o zaman ²ve önceki her şey, esasen dikkate alınmaz.

Programların (üretme birkaç için açıklamalar 1, 3, 37ve 93sırasıyla):

²Ñ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 sayılar

Befunge biraz sınırlıdır, çünkü yalnızca tek haneli değişmezleri destekler. Bu yüzden bulabildiğim en iyi rakam 11 sayıydı, hesaplamanın yığında bir ve sadece bir sayı bırakması gerektiğini varsayar.

En iyi karakterler: 358*%

Üretilen sayılar: (her birine yalnızca bir örnek)

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 sayılar

1234#

Tüm gereksiz numaraları yorumlamak için # kullanır.

dc, 19 sayılar

*3zO+

Çıktı yığının tepesindedir ve hatalar (yığın alt akışı dahil) dikkate alınmaz. Geçerli izinler:

+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

İşte bu sonuçları göstermek için kullandığım Python programı:

#!/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 aynı puanı veren diğer iki dize 32d+*ve *4zO+.

Smalltalk, 26 sayı

1235r

Açıklama: 12r35, radix 12'yi kullanmak için kullanılan bir nottur ve bu nedenle 3 * 12 + 5'tir.
Bu, Squeak'te doğrulanabilir:

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

verir:

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

Son satırı şu şekilde değiştirirsek:

    sorted: #value ascending)

sonra ifadeleri alırız:

'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 'de r' de ki bir metodu tanımlamak istedim

Integer>>r
    ^self \\ 120 + 1

Ne yazık ki, derleyici 1235r'yi keser, çünkü 1235'e gönderilen bir mesajdan ziyade tamamlanmamış bir sayıyı tanır
. Derleyiciyi de kolayca değiştirebilirdim, ama bu da benim zevkime hileli bir parça.

Mathematica, 16 sayılar

;1234

Çok ilginç değil, ama aritmetik kullanarak daha iyi bir şey bulamıyorum. Tek şey olabilir çalışmak kullanıyor !faktöryel veya çift faktöriyele için, ama bu kaba kuvvet imkansız masif sayılar üreterek çok eğilimli.

Yukarıdaki 5 karakterden üretilebilecek 16 sayı (aralık içinde):

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

Runik Büyüleri, 19 sayı

234p@

Temelde 3 hazır bilgi, pow operatörü ve "tüm yığını yazdır ve sonlandır" komutu. 234p@812 yazdırır (2 ile birleştirilmiş 3 ^ 4). Tam permütasyon listesi , her sonuç arasında yeni bir satır oluşturmak amacıyla @değiştirildi ak@ve >her satırın bağımsız olarak çalışmasını sağlamak için bir not eklendi. Ayrıca, çıktıların kendilerini oluşturan programlarla aynı sırada olmadığına dikkat edin (bazı programlar daha hızlı sona erebilir).

Birçok permütasyon hiçbir şey basmaz (ör. @234pVeya p234@), ancak 19 izin verilen aralıkta çıktı ile sonuçlanır.

Mümkün sayılar (ve bununla sonuçlanan olası bir program; .bu konumların yürütülmeyen kalan karakterlerden biri olabileceğini gösterir):

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 sayı

23+4!

Büyük olasılıkla daha iyi bir kombinasyon var, ancak bulamadım.

Herşey $24$ geçerli izinler aşağıdaki gibidir:

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

Hangileri var $12$ benzersiz değerler:

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