Oto pikselowa czcionka 5 na 7 dla cyfr od 0 do 9:

.███.
█...█
█...█
█...█
█...█
█...█
.███.

..█..
███..
..█..
..█..
..█..
..█..
█████

.███.
█...█
....█
...█.
..█..
.█...
█████

.███.
█...█
....█
..██.
....█
█...█
.███.

█..█.
█..█.
█..█.
█████
...█.
...█.
...█.

█████
█....
█....
.███.
....█
█...█
.███.

.███.
█...█
█....
████.
█...█
█...█
.███.

█████
....█
....█
...█.
...█.
..█..
..█..

.███.
█...█
█...█
.███.
█...█
█...█
.███.

.███.
█...█
█...█
.████
....█
█...█
.███.

(Ta czcionka i ta strona będzie prawdopodobnie wyglądać lepiej, jeśli uruchomić ten kod w konsoli JavaScipt przeglądarek lub w pasku adresu URL z prefiksem javascript:: $('#question pre,.answer pre').css('line-height',1)).

Napisz dwa prostokątne bloki tekstu o równej wielkości, jeden reprezentujący puste spacje ( .) w powyższej czcionce, a drugi reprezentujący wypełnione spacje ( █).

Kiedy te dwa bloki tekstowe są ułożone w ten sam wzór 5 × 7, co jedna z powyższych cyfr, powstały duży blok tekstowy powinien być programem, który wypisuje tę cyfrę na standardowe wyjście. Powinno to działać dla wszystkich 10 cyfr.

Na przykład, jeśli .blok tekstu był

---
'''

a twój █blok tekstowy był

ABC
123

następnie program

---ABCABCABC---
'''123123123'''
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
---ABCABCABC---
'''123123123'''

powinien wyjść 0. Podobnie program

------ABC------
''''''123''''''
ABCABCABC------
123123123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
ABCABCABCABCABC
123123123123123

powinien wypisywać 1i tak dalej aż do programu dla 9.

Za pomocą tego fragmentu stosu możesz tworzyć programy w kształcie cyfr:

<style>textarea{font-family:monospace;}</style><script>function go(){var t=parseInt(document.getElementById("digit").value[0]);if(isNaN(t))return void alert("Invalid digit.");for(var e=document.getElementById("empty").value.split("\n"),n=document.getElementById("filled").value.split("\n"),l=[],o=0;o<7*e.length;o++){l[o]="";for(var d=0;5>d;d++)l[o]+=font[t][Math.floor(o/e.length)][d]?n[o%n.length]:e[o%e.length]}document.getElementById("output").value=l.join("\n")}font=[[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,0,1,0,0],[1,1,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[1,1,1,1,1]],[[0,1,1,1,0],[1,0,0,0,1],[0,0,0,0,1],[0,0,0,1,0],[0,0,1,0,0],[0,1,0,0,0],[1,1,1,1,1]],[[0,1,1,1,0],[1,0,0,0,1],[0,0,0,0,1],[0,0,1,1,0],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[1,0,0,1,0],[1,0,0,1,0],[1,0,0,1,0],[1,1,1,1,1],[0,0,0,1,0],[0,0,0,1,0],[0,0,0,1,0]],[[1,1,1,1,1],[1,0,0,0,0],[1,0,0,0,0],[0,1,1,1,0],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,0],[1,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[1,1,1,1,1],[0,0,0,0,1],[0,0,0,0,1],[0,0,0,1,0],[0,0,0,1,0],[0,0,1,0,0],[0,0,1,0,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,1],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]]]</script><textarea id='empty' rows='8' cols='32' placeholder='empty space text block...'></textarea><textarea id='filled' rows='8' cols='32' placeholder='filled space text block...'></textarea><br>Digit <input id='digit' type='text' value='0'> <button type='button' onclick='go()'>Generate</button><br><br><textarea id='output' rows='16' cols='64' placeholder='output...' style='background-color: #eee;' readonly></textarea>

Detale

• Żaden z 10 dużych programów blokujących tekst nie powinien wymagać wprowadzania danych. Wyprowadzaj tylko jedną cyfrę plus opcjonalny znak nowej linii. Wyjście do standardowego wyjścia lub podobnej alternatywy.
• Żaden z programów nie może czytać ani uzyskiwać dostępu do własnego kodu źródłowego. Traktuj to jak surowe wyzwanie quine .
• Bloki tekstowe mogą nie być identyczne i muszą mieć niezerowe wymiary.
• Bloki tekstowe mogą zawierać dowolne znaki oprócz terminatorów linii .
• 10 programów musi być pełnoprawnymi programami napisanymi w tym samym języku, nie są to fragmenty REPL . Możesz opcjonalnie dodać końcowy znak nowej linii do nich wszystkich lub żadnego z nich.

Punktacja

Twój wynik to obszar (szerokość razy wysokość) jednego z bloków tekstowych. (Są tego samego rozmiaru, więc nie ma sensu liczyć obu bloków.) Obszar przykładu wynosi 3 na 2, co daje wynik 6.

Najniższy wynik wygrywa. W przypadku remisu wygrywa najlepiej głosowana odpowiedź.

CJam, 20 18 14 13 12 * 1 = 12

Wypróbuj online: 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9

Pusty blok

];BG*K+ :BD%

Solidny blok

];B9+33%:B4/

Wyjaśnienie

Zastosowałem strategię podobną do rozwiązania Sp3000 , tak że każdy blok wykonuje mnożenie, dodawanie i (ewentualnie) operację modulo na zmiennej i zapisuje wartość z powrotem. Aby znaleźć optymalne rozwiązanie, użyłem starej dobrej brutalnej siły. Napisałem program, który przeszukuje przestrzeń wszystkich możliwych wartości początkowych (początkowych wartości zmiennych CJam) i wielu milionów możliwych par funkcji transformacji, dzięki czemu dane wyjściowe dla każdej postaci cyfr są unikalne. Następnie przefiltrowałem wyniki dla takich, że końcowy wynik dla postaci cyfr kończących się pustym blokiem, których jest 8, można odwzorować z powrotem na poprawny wynik za pomocą innej formuły mnożenia, dodawania i modulo.

Po kilku dniach przeszukiwania procesora najlepszy jak dotąd wynik spadł do rozmiaru 12! To rozwiązanie zaczyna się od wartości 11, funkcja transformacji pustego bloku jest x * 16 + 20, funkcja wyniku pustego bloku jest x % 13, funkcja transformacji pełnego bloku jest (x + 9) % 33, a funkcja wyniku bloku jest x / 4.

> <> (Ryby) , 5 * 10 = 50

Pusty blok

   \   !9 
4n;    n/ 
1n;\      
       \  
0n;n7\\\  

Solidny blok

   \; n8/ 
     /!/!v
     \  ;6
3n;\ ! /nn
2n;n5<  8;

Ten kod nie zawiera żadnej logiki ani arytmetyki, wykorzystuje jedynie statyczne przekierowania wskaźnika 2D instrukcji> <> z „zwierciadłami” ( /i \) i dwiema „strzałkami” ( <i v). Jedynym innym kontrolerem przepływu jest „trampolina” ( !), która przeskakuje przez następny znak.

Adres IP zaczyna się od lewego górnego rogu na wschód. Po niektórych przekierowaniach osiąga liczbę, którą jest wypychany na stos i drukowany za pomocą, na program kończy się za pomocą ;.

Przebieg programu

Blok „rozpoznaje” bieżący stan programu na podstawie tego, w którym punkcie przyszedł adres IP i na podstawie tego stanu decyduje, w którym kierunku powinien wypuścić wskaźnik (który blok powinien zostać wykonany w następnej kolejności) i w której dokładnie pozycji wskaźnik powinien opuścić (co będzie nowym stanem). Oczywiście bloki nie mają żadnej logiki, całe to zachowanie pochodzi od przekierowań.

CJam, 23 22 19 * 1 = 19

Pusty blok:

];G)B%:G"73860594"=

Solidny blok:

];GW*B+3*D%:G    7-

Wypróbuj online .

Staram się mieć szczęście z matematycznymi przypadkami i porażkami, więc oto nieco inne podejście do mapowania wyjątkowości niż rozwiązanie Martina.

Zacznij od 16. Puste bloki dodaj 1 i weź modulo 11. Solidne bloki pomnóż przez -1, dodaj 11, pomnóż przez 3, a następnie weź modulo 13. To magicznie odwzorowuje 03456789(cyfry, które kończą się na pustym bloku), do 41753026którego używamy indeksowania zrobić dobrze. 12porządnie odwzorowuje mapy 89, które możemy naprawić, odejmując 7.

CJam, 28 27 x 1 = 27

Oto początek.

Pusty blok

U):U;                       

Solidny blok

];U):UW+:WF%"1302986_7_54"=

Sprawdź to tutaj. Nie mogę podać bezpośredniego linku do kodu, ponieważ kod jest za długi, więc musisz skopiować go ręcznie z fragmentu w wyzwaniu.

Pomysł polega na haszowaniu kształtu w następujący sposób:

• Dla każdego przyrostu „piksela” licznik U.
• Dla każdego czarnego „piksela” dodaj Udo bieżącej sumy W(która zaczyna się od -1). Na koniec bierzemy to modulo 15, które daje unikalne wyniki, które służą do indeksowania w łańcuch wyszukiwania.