Wybierz dowolne pięć znaków obsługiwanych przez Twój język. Jest 5! = 5 × 4 × 3 × 2 × 1 = 120 sposobów, na które można je ułożyć w ciąg 5 znaków, który zawiera każdy znak jeden raz; 120 permutacji .

Wybierz swoje postacie tak, aby po uruchomieniu każdego ze 120 ciągów w twoim języku, wyprodukowanych 120 wyjść będzie miało jak najwięcej unikalnych liczb całkowitych od 1 do 120 (włącznie), jak to możliwe.

Oznacza to, że dla każdego ze 120 permutacji twoich 5 znaków, które generują uruchamialny kod, który generuje pojedynczy numer, chcesz, aby zestaw wszystkich tych liczb był jak najbliższy zestawowi liczb całkowitych od 1 do 120.

Idealnie byłoby 1, gdyby twoja pierwsza permutacja wyszła , następna 2, następna 3, aż do 120. Ale ten ideał jest prawdopodobnie niemożliwy dla większości języków i postaci.

Ciągi 5 znaków mogą być uruchamiane jako:

• program bez wkładu
• funkcja bez argumentów
• REPL komenda

W razie potrzeby różne ciągi znaków można uruchamiać na różne sposoby

Aby dane wyjściowe mogły się liczyć, musi to być wyjście w postaci jednej liczby całkowitej w normalny sposób, na przykład:

• drukowane na standardowe wyjście
• zwrócone przez funkcję
• wynik wyrażenia REPL

Kod powinien kończyć się normalnie (co może wiązać się z błędem, dopóki numer zostanie podany jako pierwszy). Kod, który w ogóle nie działa, jest w porządku, tylko (nieistniejące) wyjście się nie liczy. Dane wyjściowe liczb powinny być dziesiętne, chyba że inna podstawa jest normą dla twojego języka.

Zgłoszenie, które generuje najbardziej wyraźne liczby od 1 do 120 wygrywa. Wcześniejsze zgłoszenie wygrywa w przypadku remisu.

Notatki

• Twoje 5 znaków nie musi być różne, ale oczywiście powielenie znaków zmniejsza efektywną liczbę permutacji.
• Wyjścia zmiennoprzecinkowe, takie jak 32.0liczenie, a także zwykłe 32. (Ale 32.01nie chciałbym.)
• Zera wiodące, takie jak 032liczenie, a także zwykłe 32.
• Prawidłowe wyniki powinny być deterministyczne i niezmienne w czasie.
• Mamy do czynienia ze znakami , a nie bajtami.

Przykład

Znaki 123+*są rozsądnym pierwszym wyborem dla REPL Pythona (lub wielu języków). Wynikowe 120 permutacji i wyników to:

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

Wygenerowano 36 liczb, wszystkie na szczęście od 1 do 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

Jednak tylko 8 z nich jest wyjątkowych:

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

Tak więc takie zgłoszenie uzyskałoby jedynie 8 punktów z maksymalnej 120.

Python3, 21 27 wartości

Postacie: 3479%

Unikalne liczby: [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]

Zgodnie z żądaniem oto permutacje, które zawierały się w przedziale [1, 120] . Wypróbuj 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 liczb

4·>Ìn

Generuje unikalne liczby:

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

Wykorzystuje stałą 4z operacjami +1, +2, *2i ^2.

Python, 18 liczb

237#-

Daje jako prawidłowe wyniki:

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

EDYCJA: Mogę potwierdzić, że rozwiązanie TuukkaX jest optymalne dla Pythona. Uruchomiłem następujący kod brutalnie wymuszając wszystkie możliwe kombinacje 5 drukowalnych znaków 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')

Wyniki (po działa prawie 7 godzin) wykazała, że optymalne rozwiązanie jest w rzeczywistości 27 różnych liczb, wykonane w trzech różnych rozwiązań przy czym wszystkie cztery cyfry, a mod ( %) %3479, %5679i %5789.

Java 8, 2 4 liczby

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

Nie spodziewałeś się odpowiedzi w języku Java, prawda?

Jest to lambda, którą można ustawić tylko na dwa sposoby (i dowolne dwie różne cyfry!) Dla dwóch unikalnych liczb. Cała reszta nie jest prawidłową lambda.

Naprawdę poprawiłem odpowiedź, dzięki pomocy z komentarzy! Nie widziałem, że 0 jest niepoprawne i zapomniałem, że zmienne mogą być więcej niż jednym znakiem. Mamy 4!

Jeszcze gorsze rozwiązanie

()->1

Ale z drugiej strony dwie wyjątkowe odpowiedzi w Javie!

Galaretka, 26 30 32 numery

‘’3²Ḥ

To (i jego anagramy) są pełnymi programami, które nie pobierają danych wejściowych i generują dane wyjściowe na standardowym wyjściu.

Dane wyjściowe ze 120 programów są w kolejności, w jakiej Jelly je generuje, jeśli poprosisz o wygenerowanie permutacji programu:

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

Jeśli po prostu weźmiesz unikalne dane wyjściowe w kolejności numerycznej, otrzymasz:

-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

Wiele z nich jest za małych, a 135 za dużych, ale wciąż są 32 w zasięgu.

Podstawową ideą jest używanie głównie instrukcji monadycznych (w programie zawierającym tylko monady i nilady, każda z nich po prostu przekształca poprzednie dane wyjściowe) oraz tych, które pozwalają na szybką zmianę wartości. Wyjątek stanowi „ 3nilad” (stała wartość 3). Jeśli pojawi się na początku programu, wszystkie operacje zostaną wykonane od 3. Jeśli pojawi się w środku, program dzieli się na dwie połowy, z których każda wypisuje liczbę całkowitą (i każda drukuje na standardowe wyjście, wyniki kończą się konkatenacją, co daje nam „konkatenację” jako dodatkową operację generowania liczb).

Operacje, które mamy tutaj, w kontekście, w którym program je generuje, to: przyrost; ubytek; stała 3; kwadrat; i podwójne. Przyrost i spadek są niestety przeciwieństwami, a spadek ma niefortunną tendencję do wytwarzania -1 lub -2 w pierwszej sekcji (co prowadzi do ogólnej liczby ujemnej), ale wciąż daje to większy rozkład wyników niż inne rzeczy, których próbowałem . W szczególności uzyskujemy całkiem dobry rozkład zarówno pierwszej, jak i drugiej połowy liczby (zauważ, że pierwsza połowa może być łańcuchem zerowym, jeśli 3jest to pierwszy znak w programie).

JavaScript, 27 liczb

Bardzo podobny do odpowiedzi TuukkaX , z innym zestawem cyfr.

5789%

27 różnych wartości to:

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 liczb

3+*^-

Daje to następujące liczby: [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]

Wyjaśnienie

• 3 jest oczywiście liczba całkowita 3.
• + jest przyrostem
• * jest podwójny
• ^ jest kwadratowy
• - jest zmniejszeniem

Istnieje wiele sytuacji, w których program po prostu popełnia błędy: na przykład *+^3-błędy, ponieważ pyta „Weź 0, podwoj to, przyrost, kwadrat, wynik tego kwadratu to 3, zmniejszenie”, co jest oczywiście błędne.

Każdy program, który kończy się 3, albo wyświetli, 3albo nie będzie działać.

Każdy program, który zaczyna się od *3, zapętla się w nieskończoność z powodu błędu (Brachylog próbuje znaleźć listę podlist, których wynik to 3, co nie jest możliwe).

Vim, 16 liczb

i1234

wydrukować

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

Kod maszynowy IA-32, 8 cyfr

Szesnastkowe wartości bajtów:

2c 40 48 b0 c3

Kod jest uruchamiany jako funkcja zwracająca wartość w al.

Prawidłowe permutacje:

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)

Przeprowadziłem wyszukiwanie metodą brutalnej siły, z następującymi ograniczeniami:

• Pierwszy bajt to b0- aby zainicjować alrejestr
• Ostatni bajt to c3- return; następujące bajty są odrzucane
• Możliwe bajty opcodu to:
  • 0x04 - add
  • 0x0c - or
  • 0x24 - and
  • 0x2c - sub
  • 0x34 - xor
  • 0xd4 - aad
  • 0x40 - inc
  • 0x48 - dec

Pozostawia to tylko 3 zmienne bajty z maksymalnie 15 możliwymi wynikami. Spośród nich maksymalnie 9 może być różnych (w rzeczywistości dzieje się tak tylko dla jednego zestawu bajtów!). Jedna z wartości jest poza zakresem, więc pozostawia 8 wartości. Istnieje inny zestaw bajtów

34 40 48 b0 c3

co daje również 8 różnych wartości - programy są takie same, z wyjątkiem subzastąpionych przezxor , co czyni identyczne dwa z możliwych wyjść.

Wszystkie pozostałe zestawy bajtów dają 7 lub mniej możliwych wyników.

Galaretka , 33 liczby

Ḥ23+c

Ḥpodwójny (lewy);
2dosłowny 2;
3dosłowny 3;
+dodaj (lewy, prawy); i
c wybierz (lewy, prawy), tj. liczbę sposobów wyboru odpowiednich obiektów z kolekcji lewych obiektów.

Liczby uzyskane w przykładowym programie:

 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

Próbowałem wybrać te łatwe do przeanalizowania, ale niektóre są rzadkie i nieco dziwne, na przykład 23:

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

... a 72i 13korzystać z drukowania niejawny:

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)

Zauważ, że Ḥ34+cprodukuje również 33unikalne wartości w [1,120].

Brain-Flak 1

(())#

Brain-Flak wymaga zrównoważonych nawiasów klamrowych, więc program składający się z 5 znaków jest ważny tylko wtedy, gdy jedna z postaci rozpoczyna komentarz. Dzięki temu mamy do dyspozycji 4 postacie. Spośród nich, 2 muszą być (i )inaczej nic by się nasunąć na stosie. Muszą one zająć pierwsze i czwarte miejsce z komentarzem last ( (..)#). Teraz możemy umieścić (), {}, <>, lub []wewnątrz. {}, <>i []każda z nich ma wartość 0, ale ()wynosi 1. Oznacza to, że (())#jest to jedyny 5-znakowy ciąg, który tworzy prawidłowy program Brain-Flak.

Wypróbuj online!

Gdyby pytanie brzmiało „jakie są 6 najpotężniejszych postaci”, odpowiedź brzmiałaby tak, (){}[]jakby Brain-Flak dobiegał końca przy użyciu tylko tego podzbioru.

Sześciokąt , 13 liczb

)24!@

Oto 13 liczb do wydrukowania z jednym możliwym programem dla każdego z nich:

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

Programy powinny być dość zrozumiałe. @kończy program, !drukuje bieżącą wartość, )zwiększa ją 2i 4dołącza do bieżącej wartości (gdzie wartość początkowa to0 ). Rzeczywisty sześciokątny układ kodu źródłowego jest tutaj nieistotny, programy można po prostu czytać od lewej do prawej.

To powinna być optymalna, chociaż zamiast 2i 4można odebrać żadnych cyfr pary xi ytakie, że2 ≤ x ≤ y-2 .

Powyższe rozwiązanie zostało znalezione przez (prawie wyczerpującą) brutalną siłę, wymagając jednej !(inaczej nic by nie wydrukowało), jednej @(inaczej program się nie skończy) i wypełniając pozostałe trzy znaki dowolną (powtarzaną) kombinacją z następujący zestaw znaków:

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

Nie widzę, w jaki sposób inne polecenia mogłyby generować większą różnorodność.

Perl, 27 liczb

3479%

Perl nie ma wbudowanej REPL, więc możesz korzystać re.plz Devel :: REPL .

Wyniki:

%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

Brute-force przy użyciu następującego programu:

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 liczb

Nie jest to duża liczba, ale może być najlepsza, jaką można zrobić za pomocą R. Przeszukałem wszystkie kombinacje cyfr 0..9, operatorów + - * / ^i znaku komentarza #, a kolejne osiem wszystkich zwraca 18 unikatowych liczb całkowitych od 1 do 120.

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

Jako przykład weźmy -#146. Oto 18 liczb całkowitych, które możemy uzyskać:

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

Jeśli jesteś ciekawy (brzydkiego) kodu używanego do testowania wszystkich możliwych kombinacji, oto on. Wyświetla liczbę unikalnych liczb całkowitych od 1 do 120 dla każdej kombinacji znaków o długości 5 do pliku o nazwie „plik danych” w bieżącym katalogu roboczym.

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

Oktawa, 18 lat

Zostało to znalezione przy użyciu brutalnego wyszukiwania symboli *+-/0123456789:;<\^|~%. Ale obliczenie trwało zbyt długo ...

-139%

Możliwe wyniki:

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

Oktawa, 15 liczb

Nie ma się czym chwalić, ale to najlepsze, co mogę dostać w Octave:

124+%

Daje liczby:

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

Też mam 16, ale wygląda na to, że jest identyczna z odpowiedzią Sefy ...

1234%

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

PHP, 15 liczb

1230\r

Wykorzystuje fakt, że php wypisuje wszystko poza swoimi znacznikami dosłownie (bez użycia tego możesz zrobić dokładnie 1 liczbę za pomocą czegoś takiego <?=1;). Używa również rzeczywistego znaku powrotu karetki zamiast \r.

Tworzy (posortowane, usunięte początkowe 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

z których prawidłowe unikalne liczby to:

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

Cubix , 7 liczb

"2)@O

Wysyła te liczby:

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

Każdy prawidłowy program Cubix dla tego wyzwania musi mieć Ona wyjście liczbę całkowitą i@ zakończenie programu (Cubix nigdy nie słyszał o „błędach”). To daje nam 3 znaki do zabawy, aby wygenerować jak najwięcej wyników. Ponadto, ze względu na sposób, w jaki Cubix porządkuje kod na kostce, pierwszy znak będzie bezużyteczny, chyba że jeden z pozostałych znaków będzie znakiem kierunkowym.

Najbardziej wydajnym sposobem, w jaki udało mi się wygenerować wiele liczb, jest "wypchnięcie ciągu znaków do stosu. Dzięki starannej rearanżacji możemy zmieścić kilka znaków w ostatnim miejscu i po prostu wyprowadzić ich kody znaków. Używając) do zwiększania najwyższej pozycji, możemy stworzyć dodatkowe wyniki z kilku z tych aranżacji.

Istnieją tutaj dwa podstawowe typy programów. Pierwszy to:

"2)O@

który rozwija się do

  "
2 ) O @
  .

Wynikowy program wypycha 2stos, zwiększa go ), wypisuje Oi kończy przy pomocy @.

Drugi to:

2")O@

który rozwija się do

  2
" ) O @
  .

Otrzymany programu popycha char-kody ), Oi @, zwiększa się z ostatnią z ), z wyjść Oi jest zakończony @.

> <> , 6 liczb

Zdobył 2 liczby dzięki Teal Pelican

1ln";

Tworzy unikalne liczby [1, 4, 5, 49, 59, 108]

Musimy nwydrukować numer.
Musimy ;rozwiązać.

To pozostawia nam tylko 3 znaki do pracy.

Kilka różnych kombinacji value& operatorwraz z "potwierdzonymi daje 6 unikalnych wartości, ale nie znalazłem nic lepszego.

Groovy, 10 liczb

Rozwiązania Man JVM są ZŁE dla tego ... Kto wiedział?

1200+

Prowadzi do:

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

Czekaj, co? Jak, u diabła, sprawia, że ​​pytasz 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.

Tajemnica handlowa, w liczbach całkowitych Groovy / Java poprzedzonych cyfrą 0 są ósemki. Kod, którego użyłem do testowania odpowiedzi Groovy, jeśli ktoś chce mnie pokonać:

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

0123%

% jest operatorem komentarza, więc „wycina” go we wszystkich możliwych miejscach jeden raz, pomagając stworzyć wszystkie możliwe kombinacje danych cyfr i ich podzbiorów:

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

J, 16 cyfr

1234]

Nic szczególnego, tylko przetestowane 1234 ze wszystkimi sensownymi czasownikami 1-znakowymi. ]wybiera właściwy argument.

Wyprodukowano unikalne liczby

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

z czego 16:

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

Są w zakresie [1,120].

Testowane z

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

Japt , 41 liczb

Prawie tylko próby i błędy, więc może być lepsze rozwiązanie. Używa liczb całkowitych 3i 4oraz Japt skróty do kwadratury, dodawanie 1i mnożenie przez 2. Wszystkie 120 programów generuje liczbę całkowitą, >0ale tylko 78 jest, <=120a tylko 41 z nich jest unikatowych.

34²ÄÑ

Generuje liczby:

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

Wyświetl listę numerów lub kolekcję prawidłowych programów

Wyjaśnienie

Kilka ważnych informacji o Japt, które są tutaj istotne, to:

1. Jeśli program nie rozpoczyna się (w tym przypadku) jedną z cyfr, wówczas pierwsza zmienna wejściowa U, domyślnie ustawiona 0, jest automatycznie wstawiana na początku,
2. Jeśli jedna lub obie cyfry natychmiast następują po jednym ze skrótów operacji matematycznej, są do niego dołączane (np. 3Ä4 = 3+14 = 17I podobnie4Ѳ = 4*2**2 = 16 ), i,
3. Jeśli jedna z cyfr następuje bezpośrednio za, ²wtedy ²i wszystkie poprzedzające ją są zasadniczo ignorowane.

Objaśnienia do kilku programów (produkcja 1, 3, 37i 93, odpowiednio):

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

Befunge jest nieco ograniczony, ponieważ obsługuje tylko literały jednocyfrowe. Więc najlepsze, co mogłem wymyślić, to 11 liczb, zakładając, że obliczenia muszą pozostawić nam jedną i tylko jedną liczbę na stosie.

Najlepsze postacie: 358*%

Wygenerowane liczby: (tylko jeden przykład każdego)

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 liczb

1234#

Używa # do komentowania wszystkich niepotrzebnych liczb.

dc, 19 liczb

*3zO+

Dane wyjściowe znajdują się na szczycie stosu, a błędy (w tym niedopełnienie stosu) są ignorowane. Prawidłowe permutacje to:

+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

Oto program Python, którego użyłem, aby pokazać te wyniki:

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

Dwa inne ciągi, które dają ten sam wynik 19, to 32d+*i *4zO+.

Smalltalk, 26 numerów

1235r

Objaśnienie: 12r35 jest notacją używającą podstawki 12, a zatem wynosi 3 * 12 + 5.
Można to zweryfikować w 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

daje:

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

Jeśli zastąpimy ostatnią linię:

    sorted: #value ascending)

otrzymujemy wyrażenia:

'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

Chciałem oszukać i zdefiniować metodę rw Integer jako

Integer>>r
    ^self \\ 120 + 1

Niestety, kompilator przerywa na 1235r, ponieważ rozpoznaje niedokończoną liczbę za pomocą radix zamiast wiadomości r wysłanej na 1235 ...
Mógłbym łatwo zmienić kompilator, ale to trochę za dużo oszukiwać według mojego gustu.

Matematyka, 16 liczb

;1234

Niezbyt interesujące, ale nie mogę znaleźć niczego lepszego za pomocą arytmetyki. Jedyne, co może działać, to używanie! silni lub podwójnej silni, ale jest to tak podatne na generowanie ogromnych liczb, że niemożliwe jest brutalne użycie siły.

16 liczb (w zakresie), które można wygenerować z powyższych 5 znaków, to:

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

Runiczne Zaklęcia, 19 liczb

234p@

Zasadniczo 3 literały, operator pow i polecenie „wydrukuj cały stos i zakończ”. 234p@drukuje 812 (3 ^ 4 skonkatenowane 2). Pełna lista permutacji , zauważ, że @została zastąpiona przez ak@, aby wygenerować nowy wiersz między każdym wynikiem a a> dodano, aby zapewnić, że każda linia działa niezależnie. Zauważ też, że wyjścia nie są w tej samej kolejności co programy, które je wygenerowały (ponieważ niektóre programy mogą zakończyć się szybciej).

Wiele permutacji nie drukuje nic (np. @234pLub p234@), ale 19 daje wynik w dopuszczalnym zakresie.

Możliwe liczby (i jeden możliwy program, który z tego wynika; .wskazuje, że tymi pozycjami może być dowolny z pozostałych znaków, ponieważ nie jest wykonywany):

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 liczb

23+4!

Prawdopodobnie istnieje lepsza kombinacja, ale nie udało mi się jej znaleźć.

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