Ich habe kürzlich eine neue Sprache namens ;#
(ausgesprochen "Semikolon-Hash") erstellt, die nur zwei Befehle enthält:
;
füge eins zum Akku hinzu
#
Modulieren Sie den Akku um 127, konvertieren Sie ihn in ASCII-Zeichen und geben Sie ihn ohne Zeilenumbruch aus. Danach den Akku auf 0 zurücksetzen. Ja, 127 ist korrekt.
Alle anderen Zeichen werden ignoriert. Es hat keine Auswirkung auf den Akku und sollte nichts tun.
Ihre Aufgabe ist es, einen Dolmetscher für diese mächtige Sprache zu erstellen!
Es sollte entweder ein vollständiges Programm oder eine Funktion sein, die ein ;#
Programm als Eingabe verwendet und die richtige Ausgabe erzeugt.
Beispiele
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
Caird Coinheringaahing
quelle
quelle
Antworten:
Python 3 ,
6968 Bytes-1 Byte dank @WheatWizard
Probieren Sie es online!
quelle
if
. Probieren Sie es online!JavaScript (ES6),
768280 ByteDemo
Code-Snippet anzeigen
Rekursive Version,
8277 Bytes5 Bytes gespart dank Neil
Dieser stürzt wahrscheinlich bei großen Eingaben ab, wie z. B. im Fizz Buzz-Beispiel.
quelle
f(s,a+(c==';'))
könnte drei Bytes aus Ihrer rekursiven Version klopfen.Retina ,
336636765666259 BytesProbieren Sie es online!
Lesbare Version mit hypothetischer Escape-Syntax:
Druckt keine NUL-Bytes, da TIO sie im Quellcode nicht zulässt.
Gibt am Ende auch einen zusätzlichen Zeilenumbruch aus, aber ich schätze, es geht nicht anders.Newline unterdrückt dank @Leo .-273 (!) Bytes dank @ETHproductions .
-2 Bytes dank @ovs .
-3 Bytes dank @Neil . Schauen Sie sich ihre wunderbare 34-Byte-Lösung an .
quelle
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
? (Einschließlich der Unprintables als einzelne Zeichen natürlich)#
in der Eingabe kein Trailing vorhanden ist . Sie können das Problem beheben , indem Sie Ihre zweite Stufe an sich ändernde(;{127}|;+$)
T`;#\x01-ÿ`\x80\x7F_
\x80+$
(leere Zeile)\+T`\x7Fo`\x01-\x80_`\x80[^\x80]
(unter Verwendung von hexadezimalen Escapezeichen, um nicht druckbare Zeichen darzustellen). Gibt \ x7F anstelle von Nullen aus.Java 8, 100 Bytes
Probieren Sie es online!
quelle
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 Bytes
Es folgt ein nicht druckbares \ x7f-Zeichen
%#
. Online testen!Wie es funktioniert
quelle
q'# ®è'; u# dì¯J
funktioniert auch für die gleiche Partitur.Python , 65 Bytes
Dies ist ein Golf dieser früheren Antwort.
Probieren Sie es online! Python2
Probieren Sie es online! Python3
Erläuterung
Dies ist eine ziemlich einfache Antwort, wir bestimmen, wie viele
;
s zwischen jedem stehen#
und drucken denchr
Mod 127. Das einzige, was ein bisschen seltsam sein könnte, ist der[:-1]
. Wir müssen die letzte Gruppe fallen lassen, weil es danach keine geben wird#
.Zum Beispiel
Wird aufgeteilt in
Aber wir wollen nicht das Letzte,
;;;
weil es kein hinterher gibt#
, um den Wert zu drucken.quelle
t
undx
.> <> , 35 Bytes
Probieren Sie es online! Ersetzen Sie
␡
durch 0x7F^?
, oder "delete".Hauptschleife
Dies nimmt ein Zeichen von input (
i
) an, prüft, ob es kleiner als Null ist, dh EOF (:0(
), und beendet das Programm, wenn es (?;
) ist. Andernfalls prüfen Sie, ob die Eingabe gleich#
(:'#'=
) ist. Wenn dies der Fall ist, verzweigen Sie nach unten und starten Sie die Schleife neu (?v
...^ ... <
).Zählerlogik
Überprüfen Sie, ob die Eingabe gleich
;
(';'=
) ist. Wenn ja, drücken Sie a0
. Sonst nichts tun. Dies startet die Hauptschleife neu.Drucklogik
Wenn das Eingabezeichen ist
#
, lassen Sie die Eingabe vom Stapel fallen (~
), ermitteln Sie die Anzahl der Elemente auf dem Stapel (l
), drücken Sie 127 ('␡'
) und nehmen Sie den Modul (%
). Gib es dann als Zeichen aus (o
) und beginne einen neuen Stapel ([0
). Dies "nullt" den Zähler aus. Dann startet die Schleife neu.quelle
:0(
:(Python 3, 69 Bytes
Verbessert dank @Wheat Wizard, @Uriel
quelle
:
s entfernen .';'==c
spart ein Platz, aber die Verwendung vonif
Anweisungen überhaupt wäre noch kürzer.Röda ,
443938 Bytes5 Bytes gespart dank @fergusq
Probieren Sie es online!
Anonyme Funktion, die die Eingabe aus dem Stream übernimmt.
Wenn andere Zeichen nicht ignoriert werden müssen, erhalte ich Folgendes:
Röda , 20 Bytes
quelle
Ruby,
413534 Zeichen(
403433 Zeichen Code + 1 Zeichen Befehlszeilenoption)Dank an:
putc
keine explizite Konvertierung mit.chr
(6 Zeichen) zu verwendenProbelauf:
Probieren Sie es online!
quelle
putc()
. Vielen Dank, @Jordan05AB1E ,
161514 BytesCode:
Erläuterung:
Verwendet die 05AB1E- Kodierung. Probieren Sie es online!
quelle
Gelee , 13 Bytes
Probieren Sie es online!
Wie es funktioniert
quelle
semicola
existiert nicht, es istsemicolons
.x86-Computercode unter MS-DOS - 29 Byte
Kommentierte Versammlung:
quelle
05AB1E ,
252119 Bytes-2 Bytes dank Adnan
Erläuterung:
Probieren Sie es online!
quelle
i>}
durch+
.Retina , 34 Bytes
Probieren Sie es online! Beinhaltet einen Testfall. Bearbeiten: 2 Bytes mit Hilfe von @MartinEnder gespeichert. Hinweis: Code enthält nicht druckbare Dateien, und die Verwendung von
&#x;
Codes führt zu falschen Ergebnissen, da der Browser Windows-1252 anstelle von ISO-8859-1 verwendet. Erläuterung: Die erste Zeile bereinigt die Eingabe:;
wird geändert in\x80
,#
bis . Mit Ausbrüchen zur besseren Lesbarkeit:\x7F
(durch TIO Einschränkungen) und alles andere wird gelöscht. Wenn wir dann ein Zeichen sehen\x80
, das nicht vor einem anderen steht\x80
, löschen wir es und erhöhen zyklisch den Code eines beliebigen nächsten Zeichens. Dies wird solange wiederholt, bis keine\x80
Zeichen mehr übrig sind. Ursprünglicher Code, der Null-Bytes unterstützt, subtrahiert grundsätzlich 1 von den nicht druckbaren Bytes, außer in der ersten Zeile, in der\xFF
unverändert bleibt und\x7F
wird\x00
quelle
\x80([^\x80]|$)
der letzten Stufe kombinieren .\s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?
spart auch nur ein Byte.[^\x80]|\x80$
spart zwei Bytes, denke ich.s
nervt.R
97908684 BytesEine Funktion:
Wenn R startet,
F
wird alsFALSE
(numerisch0
) definiert.Ungolfed:
quelle
pryr
es sich um ein R-Paket handelt, handelt es sich immer noch um R-Code.import
während Sie in R::
direkt auf Funktionen in Paketen zugreifen können. Sie können hier häufig die Verwendung zusätzlicher Pakete sehen (z. B. für Python und Java). Ich habe jedoch meinen früheren Posten geändert, weil ich mich nicht auf Diskussionen einlassen möchte.Python, 82 Bytes
quelle
Plain TeX, 156 Bytes
Lesbar
quelle
C (gcc) , 58 Bytes
Probieren Sie es online! (Hinweis: Klicken Sie auf ▼ Footer, um es zu minimieren .)
quelle
Perl, 25 Bytes
Ausführen mit
perl -043pe
(wird seitdem als 4 Byte gezähltperl -e
Standard ist).Erläuterung:
-043
Setzt den Zeilenabschluss auf#
(ASCII 043).-p
iteriert über die Eingabe "Zeilen" (tatsächlich # -begrenzte Zeichenfolgen, jetzt).y%;%%
zählt die Anzahl von;
in jeder "Zeile".x/#/
stellt sicher, dass für Programme, die nicht mit einem # enden (wie der dritte Testfall), kein zusätzliches Zeichen ausgegeben wird.%127
sollte ziemlich offensichtlich sein.$_=
ist die übliche Kesselplatte.quelle
;;#;;;
gibt es # 5 anstelle von # 2.echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxd
richtig ausgibt00000000: 02
auf meinem Rechner. Wenn Sie die043
Codepage weggelassen haben oder eine Codepage verwenden, die#
nicht ASCII 043 ist, würde dies Ihr Ergebnis erklären.CJam, 27 Bytes
Erläuterung:
Alternative Lösung, 18 Bytes
Erläuterung:
quelle
;
gelöscht werdenF #,
799193 BytesUngolfed
Probieren Sie es online!
Bearbeiten: Behandelte ein anderes Zeichen als ';' wie '#'. Es wurde so geändert, dass ungültige Zeichen ignoriert werden.
Alternative
F #,
107104 BytesDie Verwendung einer Referenzzelle spart 3 Bytes
Ungolfed
Probieren Sie es online aus
quelle
Processing.js (Khanacademy-Version), 118 Byte
Probieren Sie es online!
Da die verwendete Verarbeitungsversion keine Eingabemethoden hat, wird die Eingabe in n gestellt.
quelle
keyTyped=function(){ ... }
: PLabyrinth ,
6147 BytesProbieren Sie es online!
Erläuterung
Die Codeausführung beginnt in der oberen linken Ecke und das erste Semikolon verwirft eine implizite Null vom Stapel und setzt sich nach rechts fort.
Orange
_36
schiebt 36 auf den Stapel. Dies dient zum Vergleichen der Eingabe mit#
}
Verschiebt die Oberseite des Stapels zum Sekundärstapel,
schiebt den ganzzahligen Wert des Zeichens auf dem Stapel)
Inkrementiert den Stack (wenn es das Ende der Eingabe ist, wird der Stack auf 0 gesetzt und der Programmfluss geht zum@
und zum Ende){
Verschiebt die Oberseite des Sekundärstapels an die Oberseite des Primärstapels-
pop y, pop x, drücke x - y. Dies dient zum Vergleichen der Eingabe mit#
(35 in ASCII). Wenn die Eingabe war#
, fährt der Code mit dem violetten Bereich fort (da die Oberseite des Stapels 0 ist, fährt die IP in der Richtung fort, in der sie sich zuvor bewegt hat), andernfalls fährt sie mit dem grünen Bereich fort.Lila
127
Drücke 127 auf den Stapel%
pop x, pop y, drücke x% y.
Pop der Spitze des Stapels (der Akkumulator) und Ausgabe als ZeichenVon hier aus führt uns der graue Code in die obere linke Ecke des Programms, ohne dass sich etwas auf dem Stapel befindet.
Grün
_24
24 auf den Stapel schieben-
pop x, pop y, push xy. 24 ist der Unterschied zwischen#
und;
dies prüft, ob die Eingabe war;
. Wenn ja, geht;
der Code geradeaus weiter in Richtung)
. Andernfalls dreht es sich zu dem,#
der die Höhe des Stapels verschiebt (immer eine positive Zahl, die das Programm zwingt, an der nächsten Kreuzung nach rechts abzubiegen und den Code zu verpassen, der den Akkumulator inkrementiert).;
Werfen Sie die Oberseite des Stapels weg)
Inkrementieren Sie die Spitze des Stapels, die entweder eine implizite Null ist oder eine zuvor inkrementierte Null, die als Akkumulator für die Ausgabe fungiertVon hier aus führt uns der graue Code in die obere linke Ecke des Programms mit dem Stapel, auf dem sich nur der Akku befindet.
Grau
Anführungszeichen sind No-Ops,
_
drücken eine 0 auf den Stapel und;
verwerfen den oberen Teil des Stapels. All dies ist nur Code, um den Kontrollfluss auf die richtige Art und Weise zu erzwingen und alles Weitere von der Oberseite des Stapels zu verwerfen.quelle
MATL , 29 Bytes
Die Eingabe ist eine Zeichenfolge in einfachen Anführungszeichen.
Probieren Sie es online!
Das FizzBuzz-Programm ist für die Online-Dolmetscher zu lang. siehe es funktioniert offline in diesem GIF:
Erläuterung
Der Akkumulatorwert wird als Anzahl der Elemente im Stapel implementiert. Dadurch wird das Programm langsamer, als wenn der Akkumulatorwert eine einzelne Zahl im Stapel wäre, es werden jedoch einige Bytes gespart.
quelle
Alice , 22 Bytes
Probieren Sie es online!
Erläuterung
Wir behalten auf dem Stapel nur einen einzigen Zähler der Anzahl, auf die
;
wir gestoßen sind. Wenn der Stack leer ist (zB beim Start des Programms), ist dies implizit eine 0.Eine kürzere, aber nicht terminierende Version dieses Programms finden Sie hier .
quelle
~h
.JS (ES6),
97-92BytesVersuchte einen anderen Ansatz als Shaggys Antwort . Naja.
quelle
; # + , 59 Bytes, nicht konkurrierend
Die Sprache wurde nach dieser Herausforderung gemacht.
Probieren Sie es online! Die Eingabe wird mit einem Null-Byte abgeschlossen.
Erläuterung
Die Generierung ist die gleiche wie bei meiner Antwort mit dem Code "Generieren; #" . Der einzige Unterschied ist die Iteration.
Wiederholung
quelle
Bash + Coreutils,
4639 BytesProbieren Sie es online!
Erläuterung
(Danke Cows Quack für -7 Bytes!)
Der
tr
Teil entfernt alle überflüssigen Zeichen (ich könnte diessed
für genau das gleiche bytecount eingeben, aber dann wird das Zeilenvorschubzeichen nicht richtig behandelt, da ersed
sie einlässt unddc
nur bis zum ersten Zeilenvorschub mit einlädt?
).sed
Nimmt den Rest und erstellt eindc
Programm:Strings of
;
werden zu Strings of1
(ein langes Literal)#
wird.ZC7%P
(wenn dies auf eine Zeichenfolge von folgt1
,.
ist dies ein Dezimalpunkt für ein No-Op. Wenn es sich jedoch am Anfang des Programms befindet oder einem anderen folgt#
, ist es ein Literal0
. Dann nimmt es die Länge der Zahl an, modifiziert sie, und druckt das entsprechende ASCII.)quelle
;
innen'...'
und kann einfach änderndc -ez?
zudc
. Anstatt;
1 zum Stapel hinzuzufügen, können Sie sie auch gruppieren und ihre Länge ermittelnZ
, um diese tio.run/##S0oszvj/… zu erreichen .dc -ez?
war die Folge der Notwendigkeit einer zusätzlichen Null, um das Programm zu starten.) Ihr Programm fügt jedochstderr
entweder in den Fällen aufeinanderfolgender#
Eingaben oder Eingaben, die nicht enden, zusätzliche Ausgaben hinzu#
(in beiden Fällen meine ich, nachdem überflüssige Zeichen entfernt wurden). . Ich weiß nicht, ob es einen Konsens gibt, aber ich habe das Gefühl, dass die zusätzliche Ausgabe die Lösung ungültig macht. Ich habe Ihre Idee jedoch angepasst und bin mit nur einem Byte mehr als Ihrem Vorschlagdc
gelandet, ohne Fehler zu werfen!#
aufgrundZ
von0
is mit aufeinanderfolgenden s fehlschlägt1
, sodass 0x01 anstelle von 0x00 ausgegeben wird.C,
65 6460 Bytes(-2 dank ceilingcat)
quelle
c
auf Null , um die Funktion zu machen wiederverwendbar .c=0
, und ich möchte nicht schummeln, indem ich die Antwort von Dennis kopiere.