Machen Sie einen # -Interpreter

62

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: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Fizz Buzz bis zu 100

Caird Coinheringaahing
quelle
1
Ist es akzeptabel, wenn ein Interpreter seine Ausführung nicht am Ende der Eingabe beendet, sondern eine unbegrenzte Schleife durchläuft, ohne eine zusätzliche Ausgabe zu erzeugen?
Leo
5
Das zweite Beispiel lässt mich über ein Programm nachdenken, das ein Programm codiert, um eine Ausgabe zu erzeugen ... rekursive Kompilierung!
Frarugi87
@Leo Ja, das ist in Ordnung
Caird Coinheringaahing
1
@iamnotmaynard Semikolon Hash
caird coinheringaahing
2
Vielleicht lässt sich Wink Hash leichter sagen
James Waldby - jwpat7

Antworten:

17

JavaScript (ES6), 76 82 80 Byte

s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)

Demo

Rekursive Version, 82 77 Bytes

5 Bytes gespart dank Neil

Dieser stürzt wahrscheinlich bei großen Eingaben ab, wie z. B. im Fizz Buzz-Beispiel.

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""
Arnauld
quelle
Ich denke, f(s,a+(c==';'))könnte drei Bytes aus Ihrer rekursiven Version klopfen.
Neil
@Neil Spart tatsächlich 5 Bytes. :-)
Arnauld
Ich fühle mich jetzt wirklich albern. Ich hatte ursprünglich eine fehlerhafte Version und subtrahierte 2 Bytes, um den Fehler zu beheben. Aber ich hatte falsch gezählt und die Buggy-Version sparte tatsächlich 7 Bytes ...
Neil
12

Retina , 336 63 67 65 66 62 59 Bytes

T`;#-ÿ`¯_
;{127}|;+$

(^|¯)
¯
+T`-~`_-`[^¯]
T\`¯`

Probieren Sie es online!

Lesbare Version mit hypothetischer Escape-Syntax:

T`;#\x01-ÿ`\x01¯_
;{127}|;+$

(^|¯)\x01\x01
¯\x02
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
T\`¯`

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 .

eush77
quelle
1
Oh mein Wort. Aber kann man mit nicht tausend Bytes sparen +T`\x01-~`_\x03-\x7f`[^\x01¯]\x01? (Einschließlich der Unprintables als einzelne Zeichen natürlich)
ETHproductions
@ETHproductions Natürlich kannst du. Danke! :)
eush77
1
Derzeit befindet sich der letzte Buchstabe immer in der Ausgabe, auch wenn #in der Eingabe kein Trailing vorhanden ist . Sie können das Problem beheben , indem Sie Ihre zweite Stufe an sich ändernde(;{127}|;+$)
ovs
1
Benötigen Sie das Pluszeichen in der dritten Zeile? Wenn Sie das gesamte Match entfernen, sollte in der zweiten Iteration nichts mehr zu ersetzen sein.
Ovs
1
Ich denke, ich kann dies in 34 Bytes tun: 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.
Neil
12

Java 8, 100 Bytes

s->{int i=0;for(byte b:s.getBytes()){if(b==59)i++;if(b==35){System.out.print((char)(i%127));i=0;}}};

Probieren Sie es online!

Mas
quelle
3
Willkommen auf der Seite! :)
DJMcMayhem
Ich habe einen Link zu einem Online-Dolmetscher mit dem FizzBuzz-Beispiel für Sie hinzugefügt (der Linktext war zu lang, um in einen Kommentar zu passen)
Jonathan Allan
Java verwendet UTF-16 für seine Programme . Das sind also nicht 100 Bytes, sondern 100 Zeichen .
G.Broser sagt Reinstate Monica
5
@GeroldBroser Unicode ist ein Zeichensatz: UTF-8 und UTF-16 sind zwei Kodierungen dieses Zeichensatzes. ASCII-Quellcode ist als Java-Programm vollkommen gültig, und ich habe viele Java-Quelldateien, die in ASCII codiert sind (was auch für UTF-8 gilt, also auch für Unicode).
1
Völlig golfen, für 81 Bytes als Consumer<char[]>:s->{char i=0;for(int b:s){if(b==59)i++;if(b==35){System.out.print(i%=127);i=0;}}}
Olivier Grégoire
11

Japt , 18 Bytes

®è'; %# d}'# ë ¯J

Es folgt ein nicht druckbares \ x7f-Zeichen %#. Online testen!

Wie es funktioniert

®   è'; %#   d}'# ë ¯  J
mZ{Zè'; %127 d}'# ë s0,J
                         // Implicit: operate on input string
mZ{           }'#        // Split the input at '#'s, and map each item Z to
   Zè';                  //   the number of semicolons in Z,
        %127             //   mod 127,
             d           //   turned into a character.
m              '#        // Rejoin the list on '#'. At this point the Hello, World! example
                         // would be "H#e#l#l#o#,# #W#o#r#l#d#!#" plus an null byte.
                  ë      // Take every other character. Eliminates the unnecessary '#'s. 
                    ¯J   // Slice off the trailing byte (could be anything if there are
                         // semicolons after the last '#').
                         // Implicit: output result of last expression
ETHproductions
quelle
1
D'oh, hätte die Antworten überprüfen sollen! Hab nur ein bisschen Zeit damit verbracht, nur um herauszufinden, dass du mich bis zum Anschlag geschlagen hast. q'# ®è'; u# dì¯Jfunktioniert auch für die gleiche Partitur.
Shaggy
11

Python , 65 Bytes

Dies ist ein Golf dieser früheren Antwort.

lambda t:''.join(chr(x.count(';')%127)for x in t.split('#')[:-1])

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 den chrMod 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.

Weizen-Assistent
quelle
1
Ich war damit beschäftigt, alle Tests in einem TIO-Link abzurufen. War chr für chr außer tund x.
Jonathan Allan
9

> <> , 35 Bytes

>i:0(?;:'#'=?v';'=?0
^   [0o%'␡'l~<

Probieren Sie es online! Ersetzen Sie durch 0x7F ^?, oder "delete".

Hauptschleife

>i:0(?;:'#'=?v      
^            <

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

              ';'=?0
              

Überprüfen Sie, ob die Eingabe gleich ;( ';'=) ist. Wenn ja, drücken Sie a 0. Sonst nichts tun. Dies startet die Hauptschleife neu.

Drucklogik

>       '#'=?v      
^   [0o%'␡'l~<

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.

Conor O'Brien
quelle
3
Schlecht> <>. Es ist traurig :0(:(
Caird Coinheringaahing
9

Python 3, 69 Bytes

Verbessert dank @Wheat Wizard, @Uriel

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))
MrGeek
quelle
3
Willkommen bei Programming Puzzles und Code Golf! Das Ziel hier ist es, den Code so kurz wie möglich (in Bytes) zu machen, also müssen Sie die Anzahl der Bytes in den Header aufnehmen :).
Adnan
Danke fürs Erklären, wusste das nicht. Ich werde dann daran arbeiten.
MrGeek
2
Sie können das Leerzeichen nach dem :s entfernen .
Pavel
1
Ich zähle 74 Bytes. tio.run/nexus/…
Dennis
2
Auch ';'==cspart ein Platz, aber die Verwendung von ifAnweisungen überhaupt wäre noch kürzer.
Dennis
9

Röda , 44 39 38 Bytes

5 Bytes gespart dank @fergusq

{(_/`#`)|{|d|d~="[^;]",""chr #d%127}_}

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

{(_/`#`)|chr #_%127}
Kritixi Lithos
quelle
8

Ruby, 41 35 34 Zeichen

( 40 34 33 Zeichen Code + 1 Zeichen Befehlszeilenoption)

gsub(/.*?#/){putc$&.count ?;%127}

Dank an:

  • Jordan für den Vorschlag, putckeine explizite Konvertierung mit .chr(6 Zeichen) zu verwenden
  • Kirill L. für das Auffinden der unnötigen Klammer (1 Zeichen)

Probelauf:

bash-4.4$ ruby -ne 'gsub(/.*?#/){putc$&.count ?;%127}' < '2d{.;#' | od -tad1
0000000    2  etb    d  nul  nul  nul  nul    {  nul  nul  nul
          50   23  100    0    0    0    0  123    0    0    0
0000013

Probieren Sie es online!

Mann bei der Arbeit
quelle
Doh. Obwohl ich in meinen frühen Jahren C gemacht habe, habe ich es komplett vergessen putc(). Vielen Dank, @Jordan
manatwork
1
Zu meiner eigenen Überraschung können Sie Klammern nach der Zählung löschen, um ein Byte
Kirill L.
Netter Fang, @KirillL., Danke.
Manatwork
7

05AB1E , 16 15 14 Bytes

Code:

'#¡¨ʒ';¢127%ç?

Erläuterung:

'#¡              # Split on hashtags
   ¨             # Remove the last element
    ʒ            # For each element (actually a hacky way, since this is a filter)
     ';¢         #   Count the number of occurences of ';'
        127%     #   Modulo by 127
            ç    #   Convert to char
             ?   #   Pop and print without a newline

Verwendet die 05AB1E- Kodierung. Probieren Sie es online!

Adnan
quelle
7

Gelee , 13 Bytes

ṣ”#Ṗċ€”;%127Ọ

Probieren Sie es online!

Wie es funktioniert

ṣ”#Ṗċ€”;%127Ọ  Main link. Argument: s (string)

ṣ”#            Split s at hashes.
   Ṗ           Pop; remove the last chunk.
    ċ€”;       Count the semicola in each chunk.
        %127   Take the counts modulo 127.
            Ọ  Unordinal; cast integers to characters.
Dennis
quelle
1
Das Wort semicolaexistiert nicht, es ist semicolons.
Erik der Outgolfer
@EriktheOutgolfer de.m.wiktionary.org/wiki/semicola
Dennis
Hmm, komisches Wort.
Erik der Outgolfer
@EriktheOutgolfer Jemand in Wiktionary hat wahrscheinlich versucht, den lateinischen Plural in Englisch gültig zu machen , aber die Schreibweisen für Cola und Semicola sollten verboten werden.
Cœur
7

x86-Computercode unter MS-DOS - 29 Byte

00000000  31 d2 b4 01 cd 21 73 01  c3 3c 3b 75 06 42 80 fa  |1....!s..<;u.B..|
00000010  7f 74 ed 3c 23 75 eb b4  02 cd 21 eb e3           |.t.<#u....!..|
0000001d

Kommentierte Versammlung:

bits 16
org 100h

start:
    xor dx,dx       ; reset dx (used as accumulator)
readch:
    mov ah,1
    int 21h         ; read character
    jnc semicolon
    ret             ; quit if EOF
semicolon:
    cmp al,';'      ; is it a semicolon?
    jne hash        ; if not, skip to next check
    inc dx          ; increment accumulator
    cmp dl,127      ; if we get to 127, reset it; this saves us the
    je start        ; hassle to perform the modulo when handling #
hash:
    cmp al,'#'      ; is it a hash?
    jne readch      ; if not, skip back to character read
    mov ah,2        ; print dl (it was choosen as accumulator exactly
    int 21h         ; because it's the easiest register to print)
    jmp start       ; reset the accumulator and go on reading
Matteo Italia
quelle
6

05AB1E , 25 21 19 Bytes

-2 Bytes dank Adnan

Îvy';Q+y'#Qi127%ç?0

Erläuterung:

Î                       Initialise stack with 0 and then push input
 v                      For each character
  y';Q+                 If equal to ';', then increment top of stack
       y'#Qi            If equal to '#', then
            127%        Modulo top of stack with 127
                ç       Convert to character
                 ?      Print without newline
                  0     Push a 0 to initialise the stack for the next print

Probieren Sie es online!

Okx
quelle
1
Ich glaube , Sie ersetzen i>}durch +.
Adnan
6

Retina , 34 Bytes

T`;#-ÿ`_
\+T`o`-_`[^]|$

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 \x80Zeichen 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 \xFFunverändert bleibt und \x7Fwird\x00

T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$
Neil
quelle
Sie können ein Byte speichern, indem Sie die letzten beiden Stufen mit \x80([^\x80]|$)der letzten Stufe kombinieren .
Martin Ender
@ MartinEnder Danke! Ärgerlicherweise \s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?spart auch nur ein Byte.
Neil
Ah, aber [^\x80]|\x80$spart zwei Bytes, denke ich.
Neil
Ah, schön, ja, der letzte funktioniert. Ich hatte auch den negativen Lookahead ausprobiert, aber der snervt.
Martin Ender
6

R 97 90 86 84 Bytes

Eine Funktion:

function(s)for(i in utf8ToInt(s)){F=F+(i==59);if(i==35){cat(intToUtf8(F%%127));F=0}}

Wenn R startet, Fwird als FALSE(numerisch 0) definiert.

Ungolfed:

function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }
Sven Hohenstein
quelle
Sollte das nicht R + pryr sein?
L3viathan
@ L3viathan Da pryres sich um ein R-Paket handelt, handelt es sich immer noch um R-Code.
Sven Hohenstein
Es ist R-Code, erfordert jedoch die Installation einer zusätzlichen Bibliothek.
L3viathan
@ L3viathan Glaubst du, meine Antwort ist ungültig? Sollte ich die Verwendung zusätzlicher Pakete vermeiden?
Sven Hohenstein
2
@BLT Es gibt keinen Unterschied. Meiner Meinung nach ist es kein Problem, zusätzliche Pakete zu verwenden, die vor der Herausforderung erstellt wurden. Dies gilt für alle Sprachen. In Python müssen Sie verwenden, importwä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.
Sven Hohenstein
5

Python, 82 Bytes

lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])
Uriel
quelle
1
@ WheatWizard, da Sie dies bereits als Antwort gepostet haben, glaube ich, dass die richtige Aktion für mich darin besteht, es zu verbessern und nicht zu aktualisieren
Uriel,
4

Plain TeX, 156 Bytes

\newcount\a\def\;{\advance\a by 1\ifnum\a=127\a=0\fi}\def\#{\message{\the\a}\a=0}\catcode`;=13\catcode35=13\let;=\;\let#=\#\loop\read16 to\>\>\iftrue\repeat

Lesbar

\newcount\a

\def\;{
  \advance\a by 1
  \ifnum \a=127 \a=0 \fi
}
\def\#{
  \message{\the\a}
  \a=0
}

\catcode`;=13
\catcode35=13

\let;=\;
\let#=\#

\loop
  \read16 to \> \>
  \iftrue \repeat
Uriel
quelle
Kann es Zeichen symbolisch drucken?
Eush77
4

Perl, 25 Bytes

$_=chr(y%;%%%127)x/#/

Ausführen mit perl -043pe(wird seitdem als 4 Byte gezähltperl -e Standard ist).

Erläuterung: -043Setzt den Zeilenabschluss auf #(ASCII 043). -piteriert ü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. %127sollte ziemlich offensichtlich sein. $_=ist die übliche Kesselplatte.

Grimmig
quelle
Beeindruckende, obwohl es Panne gibt: dafür ;;#;;;gibt es # 5 anstelle von # 2.
manatwork
Wie sind Sie zu diesem Ergebnis gekommen? echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxdrichtig ausgibt 00000000: 02auf meinem Rechner. Wenn Sie die 043Codepage weggelassen haben oder eine Codepage verwenden, die #nicht ASCII 043 ist, würde dies Ihr Ergebnis erklären.
Grimmy
1
Hoppla. Entschuldigung, ich hatte einen Tippfehler in meinem Test. Ihr Code funktioniert einwandfrei.
manatwork
4

CJam, 27 Bytes

0q{";#"#") 127%co0 "S/=~}%;

Erläuterung:

0                            e# Push 0
 q                           e# Push the input
  {                          e# For each character in the input:
   ";#"#                     e#   Index of character in ";#", -1 if not found
        ") 127%co0 "S/       e#   Push this string, split on spaces
                      =      e#   Array access (-1 is the last element)
                       ~     e#   Execute as CJam code. ")" increments the accumulator,
                             e#     and "127%co0" preforms modulo by 127, converts to character, pops and outputs, and then pushes 0.
                        }%   e# End for
                          ;  e# Delete the accumulator

Alternative Lösung, 18 Bytes

q'#/);{';e=127%c}%

Erläuterung:

q                   e# Read the whole input
 '#/                e# Split on '#'
    );              e# Delete the last element
      {             e# For each element:
       ';e=         e#   Count number of ';' in string
           127%     e#   Modulo by 127
               c    e#   Convert to character code
                }%  e# End for
Esolanging Fruit
quelle
Geschäftskatze, die ungültige Zeichen nicht ignoriert.
Esolanging Fruit
warum muss der akku ;gelöscht werden
Caird Coinheringaahing
@RandomUser Es wird also nicht am Ende mit dem String ausgegeben.
ETHproductions
4

F #, 79 91 93 Bytes

let rec r a=function|[]->()|';'::t->r(a+1)t|'#'::t->printf"%c"(char(a%127));r 0 t|_::y->r a y

Ungolfed

let rec run acc = function
    | [] -> ()
    | ';'::xs ->
        run (acc + 1) xs
    | '#'::xs ->
        printf "%c" (char(acc % 127))
        run 0 xs
    | x::xs -> run acc xs

Probieren Sie es online!

Bearbeiten: Behandelte ein anderes Zeichen als ';' wie '#'. Es wurde so geändert, dass ungültige Zeichen ignoriert werden.

Alternative

F #, 107 104 Bytes

let r i=
 let a=ref 0
 [for c in i do c|>function|';'->a:=!a+1|'#'->printf"%c"(!a%127|>char);a:=0|_->()]

Die Verwendung einer Referenzzelle spart 3 Bytes

Ungolfed

let run i =
    let a = ref 0;
    [for c in i do
        match c with
        | ';' -> a := !a + 1
        | '#' ->
            printf "%c" (char(!a % 127))
            a := 0
        |_->()
    ]

Probieren Sie es online aus

Brunner
quelle
4

Processing.js (Khanacademy-Version), 118 Byte

var n="",a=0;for(var i=0;i<n.length;i++){if(n[i]===";"){a++;}if(n[i]==="#"){println(String.fromCharCode(a%127));a=0;}}

Probieren Sie es online!

Da die verwendete Verarbeitungsversion keine Eingabemethoden hat, wird die Eingabe in n gestellt.

Christopher
quelle
Sie könnten Ihre eigene Eingabemethode technisch fälschen mit keyTyped=function(){ ... }: P
ETHproductions
@ETHproductions Dies ist ein ekelhafter Blick.
Christopher
@ RandomUser yay! Ich habe es getan! Ich beantworte gerne in Bearbeitung (überprüfe meine Antworten)
Christopher
2
@RandomUser Nicht nur 1000 Wiederholungen, sondern 2 ^ 10 Wiederholungen (͡ ° ͜ʖ ͡ °)
@Midnightas Ohhh ja
Christopher
4

Labyrinth , 61 47 Bytes

_36},)@
;    {
; 42_-
"#-  1
_ ; 72
_ ) %
"""".

Probieren Sie es online!

Erläuterung

Farbcodiertes Bild des Lösungscodes

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

  • _36schiebt 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 Zeichen

Von 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 fungiert

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

Robert Hickman
quelle
Wie haben Sie aus Neugier das Erklärungsbild generiert? Hast du es selbst erstellt?
Stefnotch
2
@Stefnotch, ich habe einen Texteditor verwendet, um einen Tabulator zwischen jedes Zeichen zu setzen, und dann den Code in Microsoft Excel eingefügt, wodurch jedes Zeichen in eine eigene Zelle eingefügt wurde. Ich habe alle Zellen ausgewählt, um ihnen die gleiche Breite und Höhe zu geben. Dann habe ich Farben und Ränder angepasst und einen Screenshot gemacht.
Robert Hickman
3

MATL , 29 Bytes

';#'&mXz!"@o?T}vn127\c&YD]]vx

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:

Bildbeschreibung hier eingeben

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.

';#'       % Push this string
&m         % Input string (implicit). Pushes row vector array of the same size with 
           % entries 1, 2 or 0 for chars equal to ';', '#' or others, respectively
Xz         % Remove zeros. Gives a column vector
!          % Transpose into a row vector
"          % For each entry
  @        %   Push current entry
  o?       %   If odd
    T      %     Push true. This increases the accumulator (number of stack elements)
  }        %   Else
    v      %     Concatenate stack into a column vector
    n      %     Number of elements
    127\   %     Modulo 127
    c      %     Convert to char
    &YD    %     Display immediately without newline
  ]        %   End
]          % End
vx         % Concatenate stack and delete. This avoids implicit display
Luis Mendo
quelle
3

Alice , 22 Bytes

I!?';-n+?h$'@u%?'#-n$O

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.

I!?';-n+?h$'@u%?'#-n$O
I                      Push codepoint of next char from input
 !?                    store it on the tape and reload it right away
   ';-n+               add 1 to the counter if this char is a semicolon,
                       0 otherwise
        ?h$'           If the input char was -1 (EOF) execute the next command,
                       otherwise push its codepoint
            @          Terminate the program (or push 64)
             u         Set all bits up to the most significant as equal to 1
                       this turns 64 (1000000b) into 127 (1111111b)
              %        Compute modulo
               ?       reload the input char from the tape
                '#-n$O if it is a hash, pop the counter and print
                       the corresponding character
                       wrap back to the start of the line

Eine kürzere, aber nicht terminierende Version dieses Programms finden Sie hier .

Löwe
quelle
Bestätigt es hier
Caird Coinheringaahing
Entschuldigung für die schlechte Formatierung, ich habe dies von meinem Handy aus gepostet. Ich werde es beheben, sobald ich einen PC in den Händen habe
Leo
Programme müssen beendet werden, sofern in der Challenge nichts anderes angegeben ist.
Martin Ender
Sie können ein Byte speichern, indem Sie stattdessen ein Literal 0x7F verwenden ~h.
Martin Ender
@MartinEnder hat es beendet. Ich konnte kein 0x7F in den Code einfügen, aber ich denke diese alternative Modifikation ist trotzdem interessanter :)
Leo
3

JS (ES6), 97-92 Bytes

c=>(a=0,y="",c.split``.map(x=>x=="#"?(a%=127,y+=String.fromCharCode(a),a=0):x==";"?a++:0),y)

Versuchte einen anderen Ansatz als Shaggys Antwort . Naja.


quelle
3

; # + , 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

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   take input while != 0
  ~                                    swap
   <                                   read value from memory (;)
    :                                  move forward to the accumulator memory spot (AMS)
     -                                 flip Δ
      +                                subtract two accumulators into A
       !                               flip A (0 -> 1, else -> 0)
        (     (;))                     if A is nonzero, or, if A == ';'
         <                             read from AMS
          -;-                          increment
             >                         write to AMS
                  ::                   move to cell 0 (#)
                    <                  read value from memory (#)
                     +                 subtract two accumulators into A
                      -                flip Δ
                       ::              move to AMS
                         !(   )        if A == '#'
                           <           read from AMS
                            #          output mod 127, and clear
                             >         write to AMS
                               -:-     move back to initial cell
Conor O'Brien
quelle
3

Bash + Coreutils, 46 39 Bytes

tr -dc \;#|sed 'y/;/1/;s/#/.ZC7%P/g'|dc

Probieren Sie es online!

Erläuterung

(Danke Cows Quack für -7 Bytes!)

Der trTeil entfernt alle überflüssigen Zeichen (ich könnte dies sedfür genau das gleiche bytecount eingeben, aber dann wird das Zeilenvorschubzeichen nicht richtig behandelt, da er sedsie einlässt und dcnur bis zum ersten Zeilenvorschub mit einlädt ?).

sedNimmt den Rest und erstellt ein dcProgramm:

Strings of ;werden zu Strings of 1(ein langes Literal)

#wird .ZC7%P(wenn dies auf eine Zeichenfolge von folgt 1, .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 Literal 0. Dann nimmt es die Länge der Zahl an, modifiziert sie, und druckt das entsprechende ASCII.)

Sophia Lechner
quelle
Sie brauchen nicht auf die entkommen ;innen '...'und kann einfach ändern dc -ez?zu dc. Anstatt ;1 zum Stapel hinzuzufügen, können Sie sie auch gruppieren und ihre Länge ermitteln Z, um diese tio.run/##S0oszvj/… zu erreichen .
Kritixi Lithos
@Cowsquack Das ist gut, danke! (und das dc -ez?war die Folge der Notwendigkeit einer zusätzlichen Null, um das Programm zu starten.) Ihr Programm fügt jedoch stderrentweder 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 Vorschlag dcgelandet, ohne Fehler zu werfen!
Sophia Lechner
Nach dieser stderr kann ignoriert werden , wenn die Herausforderung heißt es ausdrücklich als solche, so dass ist sehr praktisch für dc. Beachten Sie auch, dass diese aktuelle Lösung #aufgrund Zvon 0is mit aufeinanderfolgenden s fehlschlägt 1, sodass 0x01 anstelle von 0x00 ausgegeben wird.
Kritixi Lithos
3

C, 65 64 60 Bytes

(-2 dank ceilingcat)

c;f(char*s){for(c=0;*s;s++)c+=*s-35?*s==59:-putchar(c%127);}
hvd
quelle
Sie müssen initialisiert werden cauf Null , um die Funktion zu machen wiederverwendbar .
Conor O'Brien
@ ConorO'Brien Behoben. Leider habe ich es nicht geschafft, etwas kürzeres zu finden, als einfach das hinzuzufügen c=0, und ich möchte nicht schummeln, indem ich die Antwort von Dennis kopiere.
HDV
@ceilingcat Nochmals vielen Dank, ich konnte danach drei weitere Bytes entfernen. Dies ist ein Trick in Dennis 'Antwort (nach der Bearbeitung überprüft), aber diesmal war so viel Zeit vergangen, dass ich alles vergessen und es mir selbst ausgedacht hatte.
HDV