Niedawno stworzyłem nowy język o nazwie ;#
(wymawiany jako „Semicolon Hash”), który ma tylko dwa polecenia:
;
dodaj jeden do akumulatora
#
modulo akumulator o 127, przekonwertuj na znak ASCII i wyjmij bez nowego wiersza. Następnie zresetuj akumulator na 0. Tak, wartość 127 jest poprawna.
Każda inna postać jest ignorowana. Nie ma wpływu na akumulator i nie powinien nic robić.
Twoim zadaniem jest stworzenie tłumacza dla tego potężnego języka!
Powinien to być pełny program lub funkcja, która pobierze ;#
program jako dane wejściowe i wygeneruje poprawne wyjście.
Przykłady
Output: Hello, World!
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
Output: ;#
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
Output: 2d{ (unprintable characters here; should have 4 `\000` bytes between the `d` and the `{` and 3 after the `{`)
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o
Output: Fizz Buzz output
Program: link below
Output: !
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
code-golf
interpreter
Cairney Coheringaahing
źródło
źródło
Odpowiedzi:
Python 3 ,
6968 bajtów-1 bajt dzięki @WheatWizard
Wypróbuj online!
źródło
if
. Wypróbuj online!JavaScript (ES6),
768280 bajtówPróbny
Pokaż fragment kodu
Wersja rekurencyjna,
8277 bajtówZaoszczędź 5 bajtów dzięki Neilowi
Ten najprawdopodobniej ulegnie awarii przy dużych wejściach, takich jak przykład Fizz Buzz.
źródło
f(s,a+(c==';'))
może zrzucić trzy bajty z twojej rekurencyjnej wersji.Retina ,
336636765666259 bajtówWypróbuj online!
Wersja do odczytu przy użyciu hipotetycznej składni ucieczki:
Nie drukuje bajtów NUL, ponieważ TIO nie pozwala na to w kodzie źródłowym.
Drukuje również dodatkową linię nowego na końcu, ale myślę, że nie może inaczej.Końcowy znak nowej linii został stłumiony dzięki @Leo .-273 (!) Bajtów dzięki produktom @ETH .
-2 bajty dzięki @ovs .
-3 bajty dzięki @Neil . Sprawdź ich wspaniałe 34-bajtowe rozwiązanie .
źródło
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
? (w tym oczywiście niedrukowalne jako pojedyncze znaki)#
na wejściu nie ma końca. Można go naprawić, zmieniając swoją drugą scenę(;{127}|;+$)
T`;#\x01-ÿ`\x80\x7F_
\x80+$
(pusta linia)\+T`\x7Fo`\x01-\x80_`\x80[^\x80]
(używając znaków szesnastkowych do reprezentowania niedrukowalnych). Wyprowadza \ x7F zamiast zera.Java 8, 100 bajtów
Wypróbuj online!
źródło
Consumer<char[]>
:s->{char i=0;for(int b:s){if(b==59)i++;if(b==35){System.out.print(i%=127);i=0;}}}
Japt , 18 bajtów
Po niej jest niezadrukowany znak \ x7f
%#
. Przetestuj online!Jak to działa
źródło
q'# ®è'; u# dì¯J
działa również dla tego samego wyniku.Python , 65 bajtów
To jest golf tej wcześniejszej odpowiedzi.
Wypróbuj online! Python2
Wypróbuj online! Python3
Wyjaśnienie
Jest to dość prosta odpowiedź, określamy, ile
;
s jest między nimi,#
i wypisujemychr
mod 127. Jedyne, co może być nieco dziwne, to[:-1]
. Musimy opuścić ostatnią grupę, ponieważ nie będzie#
po niej żadnej .Na przykład
Zostanie podzielony na
Ale nie chcemy ostatniego,
;;;
ponieważ nie ma#
po nim wypisania wartości.źródło
t
ix
.> <> , 35 bajtów
Wypróbuj online! Zamień na
␡
0x7F^?
lub „usuń”.Główna pętla
Pobiera znak input (
i
), sprawdza, czy jest mniejszy od zera, tj. EOF (:0(
) i kończy program, jeśli jest (?;
). W przeciwnym razie sprawdź, czy dane wejściowe są równe#
(:'#'=
). Jeśli tak, rozgałęzić się i zrestartować pętlę (?v
...^ ... <
).Logika przeciwna
Sprawdź, czy wartość wejściowa jest równa
;
(';'=
). Jeśli tak, naciśnij a0
. W przeciwnym razie nie rób nic. Spowoduje to ponowne uruchomienie głównej pętli.Logika drukowania
Gdy znakiem wejściowym jest
#
, usuń dane wejściowe ze stosu (~
), uzyskaj liczbę elementów na stosie (l
), naciśnij 127 ('␡'
) i weź moduł (%
). Następnie wyślij go jako znak (o
) i rozpocznij nowy stos ([0
). To „zeruje” licznik. Następnie pętla uruchomi się ponownie.źródło
:0(
:(Python 3, 69 bajtów
Ulepszony dzięki @Wheat Wizard, @Uriel
źródło
:
s.';'==c
oszczędza miejsce, ale w ogóle nieużywanieif
instrukcji byłoby krótsze.Röda ,
443938 bajtów5 bajtów zapisanych dzięki @fergusq
Wypróbuj online!
Anonimowa funkcja pobierająca dane wejściowe ze strumienia.
Jeśli inne postacie nie muszą być ignorowane, otrzymuję to:
Röda , 20 bajtów
źródło
Ruby,
413534 znaków(
403433 znaki kod + opcja wiersza poleceń 1 znak)Dzięki:
putc
nie wymagającego wyraźnej konwersji za pomocą.chr
(6 znaków)Przykładowy przebieg:
Wypróbuj online!
źródło
putc()
. Dziękuję, @Jordan05AB1E ,
161514 bajtówKod:
Wyjaśnienie:
Wykorzystuje kodowanie 05AB1E. Wypróbuj online!
źródło
Galareta , 13 bajtów
Wypróbuj online!
Jak to działa
źródło
semicola
nie istnieje, tosemicolons
.Kod maszynowy x86 na MS-DOS - 29 bajtów
Skomentowany montaż:
źródło
05AB1E ,
252119 bajtów-2 bajty dzięki Adnan
Wyjaśnienie:
Wypróbuj online!
źródło
i>}
przez+
.Retina , 34 bajty
Wypróbuj online! Obejmuje przypadek testowy. Edycja: Zapisano 2 bajty z pewną pomocą @MartinEnder. Uwaga: Kod zawiera niedrukowalne, a używanie
&#x;
kodów generuje nieprawidłowe wyniki, ponieważ przeglądarka używa Windows-1252 zamiast ISO-8859-1. Wyjaśnienie: Pierwsza linia sprząta wejście:;
zmienia się na\x80
,#
aby\x7F
(z powodu Tio ograniczeniami) i wszystko inne zostanie usunięty. Następnie, gdy zobaczymy coś,\x80
co nie jest wcześniejsze\x80
, usuwamy go i cyklicznie zwiększamy kod dowolnego następnego znaku. Jest to powtarzane, dopóki nie\x80
pozostanie więcej znaków. Oryginalny kod, który obsługuje bajty zerowe, w zasadzie odejmuje 1 od bajtów niedrukowalnych, z wyjątkiem pierwszego wiersza gdzie . Z ucieczkami dla czytelności:\xFF
jest niezmieniony i\x7F
staje się\x00
źródło
\x80([^\x80]|$)
ostatnim etapem.\s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?
że oszczędza tylko jeden bajt.[^\x80]|\x80$
myślę , że oszczędza dwa bajty.s
jest denerwujące.R,
97908684 bajtówFunkcja:
Kiedy R zaczyna się,
F
jest zdefiniowane jakoFALSE
(numerycznie0
).Nie golfowany:
źródło
pryr
jest to pakiet R, nadal jest to kod R.import
podczas gdy w R możesz używać::
do bezpośredniego dostępu do funkcji w pakietach. Często można zobaczyć użycie dodatkowych pakietów tutaj (np. Dla Python i Java). Jednak zmieniłem swój poprzedni post, ponieważ nie chcę brać udziału w dyskusji.Python, 82 bajty
źródło
Zwykły TeX, 156 bajtów
Czytelny
źródło
C (gcc) , 58 bajtów
Wypróbuj online! (Wskazówka: kliknij ▼ Stopka, aby ją zwinąć.)
źródło
Perl, 25 bajtów
Uruchom z
perl -043pe
(liczony jako 4 bajty, ponieważperl -e
jest standardem).Objaśnienie:
-043
ustawia terminator linii na#
(ASCII 043).-p
iteruje po wejściowych „liniach” (obecnie # -delimitowanych ciągów).y%;%%
zlicza liczbę;
w każdej „linii”.x/#/
upewnia się, że nie drukujemy dodatkowego znaku dla programów, które nie kończą się na # (jak trzecia walizka testowa).%127
powinno być dość oczywiste.$_=
jest zwykłą płytą grzewczą.źródło
;;#;;;
ponieważ generuje # 5 zamiast # 2.echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxd
poprawnie wyprowadza00000000: 02
na moim komputerze. Jeśli zrezygnowałeś ze043
strony kodowej lub używasz strony kodowej, w której#
nie ma kodu ASCII 043, to wyjaśniłoby twój wynik.CJam, 27 bajtów
Wyjaśnienie:
Alternatywne rozwiązanie, 18 bajtów
Wyjaśnienie:
źródło
;
usunąć akumulator?F #,
799193 bajtówBez golfa
Wypróbuj online!
Edycja: Traktowałem dowolny znak inny niż „;” tak jak '#'. Zmieniono go tak, aby ignorował nieprawidłowe znaki.
Alternatywny
F #,
107104 bajtówZastosowanie komórki referencyjnej pozwala zaoszczędzić 3 bajty
Bez golfa
Wypróbuj online
źródło
Processing.js (wersja Khanacademy), 118 bajtów
Wypróbuj online!
Ponieważ w używanej wersji przetwarzania nie ma żadnych metod wprowadzania, dane wejściowe są umieszczane w n.
źródło
keyTyped=function(){ ... }
: PLabirynt ,
6147 bajtówWypróbuj online!
Wyjaśnienie
Wykonywanie kodu rozpoczyna się w lewym górnym rogu, a pierwszy średnik odrzuca niejawne zero ze stosu i kontynuuje w prawo.
Pomarańczowy
_36
popycha 36 na stos. Służy to do porównania danych wejściowych#
}
przenosi wierzch stosu na drugi stos,
wypycha wartość całkowitą znaku na stosie)
zwiększa stos (jeśli jest to koniec danych wejściowych, spowoduje to, że stos będzie 0, a przepływ programu przejdzie do@
i zakończy działanie){
przesuwa górną część stosu dodatkowego na szczyt stosu podstawowego-
pop y, pop x, push x - y. Służy to do porównania danych wejściowych z#
(35 w ascii). Jeśli dane wejściowe były#
kod, kod przejdzie do sekcji fioletowej (ponieważ górna część stosu ma wartość 0, adres IP kontynuuje w kierunku, w którym się poruszał), w przeciwnym razie przejdzie do sekcji zielonej.Purpurowy
127
pchnij 127 na stos%
pop x, pop y, push x% y.
pop na górze stosu (akumulator) i wyjmij jako postaćStąd szary kod przenosi nas do lewego górnego rogu programu, nie pozostawiając nic na stosie.
Zielony
_24
pchnij 24 na stos-
pop x, pop y, push xy. 24 to różnica między,#
a;
więc sprawdza, czy dane wejściowe były;
. Jeśli tak,;
kod jest kontynuowany bezpośrednio w kierunku)
. W przeciwnym razie zwróci się do#
który przesuwa wysokość stosu (zawsze liczba dodatnia, zmuszając program do skrętu w prawo przy następnym skrzyżowaniu i pominięcia kodu, który zwiększa akumulator);
odrzuć wierzch stosu)
zwiększ górną część stosu, która jest albo niejawnym zerem, albo jest wcześniej zwiększonym zerem działającym jako akumulator wyjściowyStąd szary kod przenosi nas do lewego górnego rogu programu ze stosem z tylko akumulatorem.
Szary
Cudzysłowy to brak operacji,
_
wypycha 0 na stos i;
odrzuca górną część stosu. Wszystko to jest po prostu kodem, który wymusza prawidłowy przepływ kontroli i odrzuca wszystko, co dodatkowe z góry stosu.źródło
MATL , 29 bajtów
Dane wejściowe to ciąg ujęty w pojedyncze cudzysłowy.
Wypróbuj online!
Program FizzBuzz jest zbyt długi dla tłumaczy internetowych; zobacz, jak działa offline w tym gifie:
Wyjaśnienie
Wartość akumulatora jest realizowana jako liczba elementów w stosie. Powoduje to, że program działa wolniej niż gdyby wartość akumulatora była pojedynczą liczbą na stosie, ale oszczędza kilka bajtów.
źródło
Alice , 22 bajty
Wypróbuj online!
Wyjaśnienie
Trzymamy na stosie tylko jeden licznik z iloma
;
napotkaliśmy. Gdy stos jest pusty (np. Na początku programu), domyślnie jest to 0.Krótszą, ale nie kończącą się wersję tego programu można znaleźć tutaj .
źródło
~h
.JS (ES6),
9792 bajtówPróbowałem przyjąć inne podejście niż odpowiedź Kudłaty . No cóż.
źródło
; # + , 59 bajtów, niekonkurujące
Język powstał po tym wyzwaniu.
Wypróbuj online!Wejście jest zakończone bajtem zerowym.
Wyjaśnienie
Generowanie jest takie samo jak z mojego generowania; # odpowiedź kodu . Jedyną różnicą jest tutaj iteracja.
Iteracja
źródło
Bash + coreutils,
4639 bajtówWypróbuj online!
Wyjaśnienie
(Dzięki Cows Quack za -7 bajtów!)
Ta
tr
część usuwa wszystkie obce znaki (mógłbym wstawić tosed
do dokładnie tego samego bajtu, ale wtedy nie obsługuje poprawnie znaku wysuwu linii, ponieważsed
pozostawia je idc
przechodzi do pierwszego wysuwu wiersza z?
)sed
bierze resztę i budujedc
program:Ciągi
;
stają się ciągami1
(długiego literału)#
staje się.ZC7%P
(jeśli następuje po ciągu1
,.
znak dziesiętny oznacza brak operacji. Ale jeśli jest na początku programu lub po innym#
, jest literałem0
. Następnie bierze długość liczby, modyfikuje ją, i drukuje odpowiedni ASCII.)źródło
;
wnętrza'...'
i możesz po prostu zmienićdc -ez?
nadc
. Poza tym, zamiast;
dodawać 1 do stosu, możesz pogrupować je razem i uzyskać ich długość za pomocąZ
osiągnięcia tego tio.run/##S0oszvj/… .dc -ez?
było konsekwencją potrzeby dodatkowego zera, aby uruchomić program) Ale twój program dodaje dodatkowe dane wyjściowestderr
w przypadku kolejnych#
lub wejściowych, które się nie kończą#
(w obu przypadkach mam na myśli po usunięciu obcych znaków) . Nie wiem, czy istnieje konsensus, ale wydaje mi się, że dodatkowe wyjście unieważnia rozwiązanie. Zaadaptowałem jednak twój pomysł i skończyłem o jeden bajt więcej niż twoja sugestia, niedc
rzucając błędów!#
s ponieważZ
od0
znaczy1
, tak wyprowadza 0x01 zamiast 0x00 (wpadłem w tą samą pułapkę, jak również, ale moja przeglądarka wyświetla unprintables jak ich hexcodes więc złapałem tego).DO,
65 6460 bajtów(-2 dzięki ceilingcat)
źródło
c
do zera, aby funkcja mogła być ponownie użyta .c=0
i nie chciałbym oszukiwać, kopiując odpowiedź Dennisa.