Jakie jest pięć najpotężniejszych znaków w twoim języku?

101

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.

Hobby Calvina
źródło
21
Chcę podjąć to wyzwanie, ale wydaje się NIEMOŻLIWE w cjęzykach podobnych do !!!
Mukul Kumar,
3
@MukulKumar Wierzę, że istnieją również REPL w języku podobnym do C (np. Gdb może być używany - do pewnego stopnia - jako REPL dla C), więc podejście zademonstrowane dla Pythona nadal byłoby opcją.
Martin Ender,
1
Powiązane (stały link).
Fatalize
3
@ETH Nie do prawdy. To jak zezwolenie na inną bazę.
Calvin's Hobbies
3
@ OldBunny2800 Prawidłowe dane wyjściowe powinny być deterministyczne i niezmienne w czasie.
Dennis

Odpowiedzi:

41

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
Yytsi
źródło
2
Czy nie uzyskałbyś lepszych wyników w Pythonie 2, gdzie /jest dzielenie liczb całkowitych?
Neil,
@Kade Me również. Największą próbowałem było coś w linii „0123456789 * - + & |% ^ 0123456789”
Yytsi
Istnieją jeszcze 2 alternatywy, z których wynika ta sama liczba wartości: 5679%oraz5789%
Gábor Fekete,
FYI - To (lub te 5679%i 5789%) są prawdopodobnie optymalne również dla PowerShell.
AdmBorkBork,
Otrzymałem tę odpowiedź (wraz z 5679%i 5798%) również poprzez wyczerpujące poszukiwanie wszystkich kombinacji 0123456789+-*/&|^#%z zamiennikiem. Zgadzam się, że są one prawdopodobnie optymalne.
JaredL,
34

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.

Emigna
źródło
Nie przetestowałem, ale czy -zamiast tego +przyniosłby szerszy zakres wyników w oparciu o jego nieprzemienną właściwość?
Osable,
@Osable: Testowałem -również, ale nigdy nie uzyskałem ponad 30 unikalnych numerów. Jednym z problemów jest to, że otrzymujesz również wartości ujemne, które wykraczają poza zakres. Może po zmianie niektórych operatorów może być lepiej, ale jak dotąd nie znalazłem poprawy.
Emigna
Racja, pominąłem część (choć pogrubioną czcionką), mówiąc, że wyjście musi mieścić się w zakresie [1,120]. Mój zły
Osable
Próbowałem przez chwilę i ograniczałem się do ~ 35 na wszystko inne.
Magic Octopus Urn
32

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.

Lew
źródło
25
@ TùxCräftîñg W rzeczywistości tak nie jest, zestaw jest nieuporządkowaną kolekcją.
Lew
2
@ TùxCräftîñg https://repl.it/El9V/0 oczywiście zestawy używają wewnętrznego sortowania do śledzenia elementów, chodzi o to, że nie można polegać na tym sortowaniu, ponieważ elementy niekoniecznie są sortowane w kolejności, w jakiej byś spodziewaj się, że będą
Leo
1
@TuukkaX Widzę, że jest to nieoczekiwane zachowanie i powoduje więcej problemów niż rozwiązuje, więc zredagowałem je. Przepraszamy za niedogodności :)
Leo
1
@ hBy2Py Jeśli nie wykonasz żadnej innej operacji na zestawie między dwiema iteracjami, myślę, że możesz założyć, że dwie iteracje będą miały tę samą kolejność. Jednak w ogólnym przypadku reguła jest taka, że ​​zbiory są nieuporządkowanymi kolekcjami, więc nigdy nie powinieneś polegać na ich kolejności.
Lew
3
@Leo Got it: zestawy są nitrogliceryną. W miarę stabilny, chyba że je zderzysz.
hBy2Py
23

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!

Xanderhall
źródło
2
Czy Java ma REPL? Może w ten sposób możesz użyć więcej symboli
Arturo Torres Sánchez,
Nie mam pojęcia. Skłaniam się do odmowy. Poza tym moja odpowiedź stałaby się po prostu
kopią
3
Java 9 będzie miała waniliową REPL !! Ale na razie utknęliśmy w rzeczach innych firm .
NielinioweOwoce
17
Myślę, że możesz sobie poradzić lepiej n->12. Daje to cztery różne odpowiedzi, które znajdują się w zakresie: n->12, n->21, n1->2, n2->1.
2
Java 9 i jej REPL są dziś dostępne we wczesnej wersji. Korzystając z niej, przesłałem odpowiedzi na inne pytania tutaj.
David Conrad,
18

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


źródło
@TuukkaX tak, zaimplementowałem zarówno monadyczny, jak Œ¿i dyadyczny œ¿(patrz u dołu strony atomów Wiki ), ale oba są dwubajtowymi diadami, które zmniejszą permutacje kodu, które robią to, co chcesz, a ponadto potrzebujesz wszystkie twoje dane wejściowe mają być listami ( 12nie jest listą).
Jonathan Allan,
16

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
Arnauld
źródło
czy użycie bitowego nie ~pomogłoby wcale? Jest to jednoargumentowa operacja, która może być przydatna.
JollyJoker,
1
@JollyJoker Cóż, co mogę znaleźć do tej pory ~znaczy 257&~, która produkuje 11 różnych wartości.
Arnauld,
Jestem trochę zaskoczony, ale wydaje mi się, że moja intuicja nie jest tutaj zbyt dobra.
JollyJoker,
15

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

Fatalizować
źródło
1
Fajna odpowiedź i idk na temat gry w golfa, ale jeśli chodzi o matematykę, możesz zdobyć dowolną liczbę do 121, dodając lub zmniejszając pierwsze pięć potęg 3. 3,3,9,27 i 81. Mam nadzieję, że to pomoże.
shyos,
11

Vim, 16 liczb

i1234

wydrukować

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
Sefa
źródło
1
@ymbirtt Skąd 3i 4iść? Potrzebujesz wszystkich permutacji długości 5.
Kade
i1234wypisuje „1234”, czy jest to jakiś skrypt lub naciśnięcie klawisza? Jeśli są naciśnięcia klawiszy, to nie działa.
Captain Man,
Rozwijając punkt @Captain Man, oczywistym sposobem uruchomienia permutacji jako skryptu byłoby: norma. Nie drukuje to jednak żadnych liczb w zakresie 1-120. Czy miałeś na myśli inną metodę?
Simon
Możesz umieścić je w internetowym
tłumaczu
4
@ nmjcman101 W tym przypadku wpada do dziury „głównie”, ponieważ 12i34 w V skutkuje 12 wystąpieniem 34, gdzie tak jakbyś wpisał go w vimie, po prostu daje ci 34 (przypuszczam, że V zakłada ostateczne esc)
Sefa
11

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.

anatolig
źródło
10

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

Jonathan Allan
źródło
10

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.

Riley
źródło
Słabo udokumentowana funkcja: @ijflaga debugowania wstrzymuje program i pozwala użytkownikowi wprowadzić kod rozbicia mózgu, który ma zostać uruchomiony w miejscu, w którym @ijpojawiła się flaga. Dość potężny, ale niestety wymaga wkładu użytkownika, więc nie jest tu przydatny.
0
Nieznaczna korekta: (){}[]uzyskałby 0. Zapomniałeś zasady permutacji;)
CalculatorFeline
8

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ść.

Martin Ender
źródło
Zamierzałem również opublikować odpowiedź na Labirynt, ale dokładnie ten sam zestaw rozwiązań również wydaje się tam optymalny (z efektywną tą samą semantyką).
Martin Ender,
7

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;
}
ThisSuitIsBlackNot
źródło
Perl faktycznie ma coś bardzo zbliżonego do wbudowanego REPL. Spróbuj uruchomić perl -de 1trochę czasu. To technicznie otwiera debugger w pustym programie, ale debugger ma wbudowaną wersję REPL. Niestety, musisz napisać p na początku każdej linii, aby rzeczywiście wydrukować wynik.
@ ais523 Dlatego o tym nie wspomniałem; nie możesz po prostu wpisać samego łańcucha i uzyskać wyniku, co jest jednym z wymagań.
ThisSuitIsBlackNot
7

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)
      }
)
rturnbull
źródło
Mówisz, że to brzydki kod ... Myślę, że jest piękny! Wiele zastosowań aplikacji nigdy nie przestaje mnie zadziwiać!
Sumner18
6

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
wada
źródło
5

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
Stewie Griffin
źródło
Według moich testów, optymalny wybór z 0123456789+-*.%na oktawę jest 139-%, która produkuje tablicę 18: 1 2 3 4 6 8 9 13 16 19 22 31 38 39 88 91 92 93. Możesz więc zdobyć kolejne 3 liczby :)
2
bardzo prymitywna brutalna siła, której użyłem, aby uzyskać 18-
2
Znalazłem też to rozwiązanie, ale było to po zobaczeniu poddania się Pythona i jest to w zasadzie to samo. Fajna robota kłopotliwa do napisania scenariusza brutalnej siły. 😊
Stewie Griffin,
4

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
użytkownik59178
źródło
3
To jednak tak naprawdę nie drukuje tych liczb. 12\r30drukuje 12\r30, terminal po prostu nadpisuje pierwsze dwa znaki.
Dennis,
@Dennis To tak, jakby powiedzieć, że w każdym wyzwaniu, które wymaga techniki znaków kontrolnych do zastąpienia tekstu, dane wyjściowe nie są tym, co widać na końcu, ale sumą zapisanych bajtów. Ponieważ \rnie można go wydrukować, wynikiem 12\r30jest 30.
kot
3
@cat Rozmawialiśmy o tym na meta ; używanie znaków kontrolnych jest dozwolone tylko wtedy, gdy wyzwanie jest związane ze sztuką ASCII.
Dennis,
4

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 @.

ETHprodukcje
źródło
3

> <> , 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.

Emigna
źródło
Próbowałem to rozwiązać, ale czy to nie daje tylko 4 liczb? ponieważ zakres wynosi 1-120, a nie 0-120?
Pelikan
@Tealpelican: Poprawnie. Zrozumiałem to w drodze do domu z pracy i właśnie miałem to naprawić.
Emigna
Przyjrzałem się trochę innym programom rybnym, takim jak quines i hello world itp., I wpadłem na pomysł. Coś wykorzystującego takie postacie; 1n; + ”wygenerowałoby 6+ na podstawie szybkiego obliczenia (używając naszej pętli i łańcuchów na naszą korzyść) - może być warte sprawdzenia z różnymi wartościami dla 1 i operacji.
Pelikan Teal
@Tealpelican: To dobry pomysł.
Emigna
3

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();​
Urna Magicznej Ośmiornicy
źródło
Wydaje mi się, że ta sama odpowiedź działałaby również w Javie.
Paŭlo Ebermann
3

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
Cedric Reichenbach
źródło
3

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]'
Bolce Bussiere
źródło
3

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
Kudłaty
źródło
2

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
James Holderness
źródło
2

Python, 16 liczb

1234#

Używa # do komentowania wszystkich niepotrzebnych liczb.

OldBunny2800
źródło
2

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+.

Toby Speight
źródło
2

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.

aka.nice
źródło
1

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
Martin Ender
źródło
Dlaczego nie; 6789?
David G. Stork
1

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
Draco18s
źródło
1

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

Tau
źródło