Zrób tłumacza;

62

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

Fizz Buzz do 100

Cairney Coheringaahing
źródło
1
Czy jest dopuszczalne, jeśli interpreter nie przerywa wykonywania na końcu wejścia, ale zamiast tego zapętla się w nieskończoność bez generowania dodatkowego wyjścia?
Leo
5
Drugi przykład sprawia, że ​​zastanawiam się nad programem do kodowania programu w celu wygenerowania wyjściowej ... kompilacji rekurencyjnej!
frarugi87
@Leo tak, w porządku
caird coinheringaahing
1
@iamnotmaynard Semicolon Hash
caird coinheringaahing
2
Może łatwiej powiedzieć Wink Hash
James Waldby - jwpat7

Odpowiedzi:

17

JavaScript (ES6), 76 82 80 bajtów

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

Próbny

Wersja rekurencyjna, 82 77 bajtów

Zaoszczędź 5 bajtów dzięki Neilowi

Ten najprawdopodobniej ulegnie awarii przy dużych wejściach, takich jak przykład Fizz Buzz.

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""
Arnauld
źródło
Myślę, że f(s,a+(c==';'))może zrzucić trzy bajty z twojej rekurencyjnej wersji.
Neil
@ Neil To faktycznie oszczędza 5 bajtów. :-)
Arnauld
Czuję się teraz naprawdę głupio. Pierwotnie miałem wadliwą wersję i odjąłem 2 bajty, aby naprawić błąd. Ale pomyliłem rachunki, a wersja buggy faktycznie uratowała 7 bajtów ...
Neil
12

Retina , 336 63 67 65 66 62 59 bajtów

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

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

Wypróbuj online!

Wersja do odczytu przy użyciu hipotetycznej składni ucieczki:

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

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

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 .

eush77
źródło
1
Och, moje słowo. Ale czy nie możesz zaoszczędzić tysiąca bajtów +T`\x01-~`_\x03-\x7f`[^\x01¯]\x01? (w tym oczywiście niedrukowalne jako pojedyncze znaki)
ETHproductions
@ETHproductions Oczywiście, że możesz. Dziękuję Ci! :)
eush77
1
Obecnie ostatnia litera jest zawsze na wyjściu, nawet jeśli #na wejściu nie ma końca. Można go naprawić, zmieniając swoją drugą scenę(;{127}|;+$)
OVS
1
Czy potrzebujesz + `w trzeciej linii? Po usunięciu całego dopasowania nie powinno być już nic do zastąpienia w drugiej iteracji.
ovs
1
Myślę, że mogę to zrobić w 34 bajtach: 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.
Neil
12

Java 8, 100 bajtów

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

Wypróbuj online!

Mas
źródło
3
Witamy na stronie! :)
DJMcMayhem
Dodałem link do tłumacza online z przykładem FizzBuzz dla ciebie (tekst linku był zbyt długi, aby zmieścił się w komentarzu)
Jonathan Allan
Java używa UTF-16 do swoich programów . To nie jest 100 bajtów, ale 100 znaków .
Gerold Broser
5
@GeroldBroser Unicode to zestaw znaków: UTF-8 i UTF-16 to dwa kodowania tego zestawu znaków. Źródło ASCII jest całkowicie poprawne jako program Java, a ja mam wiele plików źródłowych Java zakodowanych w ASCII (który jest również poprawny UTF-8, stąd też kodowanie Unicode).
1
Całkowicie grał w golfa, przez 81 bajtów jako 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 bajtów

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

Po niej jest niezadrukowany znak \ x7f %#. Przetestuj online!

Jak to działa

®   è'; %#   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
ETHprodukcje
źródło
1
Nie, powinienem był sprawdzić odpowiedzi! Po prostu poświęciłem temu trochę czasu, by odkryć, że pobiłeś mnie do samego końca. q'# ®è'; u# dì¯Jdziała również dla tego samego wyniku.
Kudłaty
11

Python , 65 bajtów

To jest golf tej wcześniejszej odpowiedzi.

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

Wypróbuj online! Python2

Wypróbuj online! Python3

Wyjaśnienie

Jest to dość prosta odpowiedź, określamy, ile ;s jest między nimi, #i wypisujemy chrmod 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.

Kreator pszenicy
źródło
1
Byłem zajęty, aby uzyskać wszystkie testy w jednym łączu TIO. Był chr dla chr oprócz ti x.
Jonathan Allan
9

> <> , 35 bajtów

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

Wypróbuj online! Zamień na 0x7F ^?lub „usuń”.

Główna pętla

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

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

              ';'=?0
              

Sprawdź, czy wartość wejściowa jest równa ;( ';'=). Jeśli tak, naciśnij a 0. W przeciwnym razie nie rób nic. Spowoduje to ponowne uruchomienie głównej pętli.

Logika drukowania

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

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.

Conor O'Brien
źródło
3
Zły> <>. To smutne :0(:(
caird coinheringaahing
9

Python 3, 69 bajtów

Ulepszony dzięki @Wheat Wizard, @Uriel

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))
MrGeek
źródło
3
Witamy w Programowaniu zagadek i Code Golf! Celem jest, aby kod był jak najkrótszy (w bajtach), więc musisz podać liczbę bajtów w nagłówku :).
Adnan
Dzięki za wyjaśnienie, nie wiedziałem o tym. Potem nad tym popracuję.
MrGeek
2
Możesz usunąć spację po :s.
Pavel
1
Liczę 74 bajty. tio.run/nexus/…
Dennis
2
Ponadto ';'==coszczędza miejsce, ale w ogóle nieużywanie ifinstrukcji byłoby krótsze.
Dennis
9

Röda , 44 39 38 bajtów

5 bajtów zapisanych dzięki @fergusq

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

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

{(_/`#`)|chr #_%127}
Kritixi Lithos
źródło
8

Ruby, 41 35 34 znaków

( 40 34 33 znaki kod + opcja wiersza poleceń 1 znak)

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

Dzięki:

  • Jordan za zasugerowanie użycia putcnie wymagającego wyraźnej konwersji za pomocą .chr(6 znaków)
  • Kirill L. za znalezienie niepotrzebnego nawiasu (1 znak)

Przykładowy przebieg:

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

Wypróbuj online!

człowiek w pracy
źródło
Doh Chociaż na początku pracowałem jako C, zupełnie zapomniałem putc(). Dziękuję, @Jordan
manatwork
1
Ku memu zdziwieniu możesz faktycznie upuścić nawiasy po policzeniu, aby zapisać bajt
Kirill L.
Niezły chwyt, @KirillL., Dziękuję.
manatwork,
7

05AB1E , 16 15 14 bajtów

Kod:

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

Wyjaśnienie:

'#¡              # 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

Wykorzystuje kodowanie 05AB1E. Wypróbuj online!

Adnan
źródło
7

Galareta , 13 bajtów

ṣ”#Ṗċ€”;%127Ọ

Wypróbuj online!

Jak to działa

ṣ”#Ṗċ€”;%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
źródło
1
Słowo semicolanie istnieje, to semicolons.
Erik the Outgolfer,
@EriktheOutgolfer en.m.wiktionary.org/wiki/semicola
Dennis
Hmm, dziwne słowo.
Erik the Outgolfer,
@EriktheOutgolfer Ktoś na Wikisłowniku prawdopodobnie próbował sprawić, by łacińska liczba mnoga była ważna w języku angielskim, ale pisownia coli i średników powinna być zakazana.
Cœur
7

Kod maszynowy x86 na MS-DOS - 29 bajtów

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

Skomentowany montaż:

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

05AB1E , 25 21 19 bajtów

-2 bajty dzięki Adnan

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

Wyjaśnienie:

Î                       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

Wypróbuj online!

Okx
źródło
1
Myślę, że można zastąpić i>}przez +.
Adnan
6

Retina , 34 bajty

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

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ś, \x80co nie jest wcześniejsze \x80, usuwamy go i cyklicznie zwiększamy kod dowolnego następnego znaku. Jest to powtarzane, dopóki nie \x80pozostanie 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 \x7Fstaje się\x00

T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$
Neil
źródło
Możesz zapisać bajt, łącząc dwa ostatnie etapy z \x80([^\x80]|$)ostatnim etapem.
Martin Ender
@MartinEnder Thanks! Irytujące jest to, \s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?że oszczędza tylko jeden bajt.
Neil
Ach, ale [^\x80]|\x80$myślę , że oszczędza dwa bajty.
Neil
Ach miło, tak, ostatni działa. Próbowałem też z negatywnym spojrzeniem w przyszłość, ale to sjest denerwujące.
Martin Ender
6

R, 97 90 86 84 bajtów

Funkcja:

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

Kiedy R zaczyna się, Fjest zdefiniowane jako FALSE(numerycznie 0).

Nie golfowany:

function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }
Sven Hohenstein
źródło
Czy nie powinien to być R + pryr?
L3viathan
@ L3viathan Ponieważ pryrjest to pakiet R, nadal jest to kod R.
Sven Hohenstein
Jest to kod R, ale wymaga instalacji dodatkowej biblioteki.
L3viathan
@ L3viathan Czy uważasz, że moja odpowiedź jest nieprawidłowa? Czy powinienem unikać używania dodatkowych pakietów?
Sven Hohenstein
2
@BLT Nie ma różnicy. Moim zdaniem nie ma problemu z użyciem dodatkowych pakietów, które zostały utworzone przed wyzwaniem. Dotyczy to wszystkich języków. W Pythonie musisz używać, importpodczas 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.
Sven Hohenstein
5

Python, 82 bajty

lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])
Uriel
źródło
1
@WheatWizard, ponieważ już opublikowałeś to jako odpowiedź, uważam, że właściwym działaniem byłoby dla mnie głosowanie zamiast aktualizacji
Uriel
4

Zwykły TeX, 156 bajtów

\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

Czytelny

\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
źródło
Czy może drukować znaki symbolicznie?
eush77
4

C (gcc) , 58 bajtów

a;f(char*s){a+=*s^35?*s==59:-putchar(a%127);a=*s&&f(s+1);}

Wypróbuj online! (Wskazówka: kliknij ▼ Stopka, aby ją zwinąć.)

Dennis
źródło
4

Perl, 25 bajtów

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

Uruchom z perl -043pe(liczony jako 4 bajty, ponieważ perl -ejest standardem).

Objaśnienie: -043ustawia terminator linii na #(ASCII 043). -piteruje 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). %127powinno być dość oczywiste. $_=jest zwykłą płytą grzewczą.

Umorusany
źródło
Imponujące jedno, choć występuje usterka: ;;#;;;ponieważ generuje # 5 zamiast # 2.
manatwork
Jak uzyskałeś ten wynik? echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxdpoprawnie wyprowadza 00000000: 02na moim komputerze. Jeśli zrezygnowałeś ze 043strony kodowej lub używasz strony kodowej, w której #nie ma kodu ASCII 043, to wyjaśniłoby twój wynik.
Brudny
1
Ups Przepraszam, miałem literówkę w teście. Twój kod działa idealnie.
manatwork
4

CJam, 27 bajtów

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

Wyjaśnienie:

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

Alternatywne rozwiązanie, 18 bajtów

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

Wyjaśnienie:

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
źródło
Business Cat To nie ignoruje nieprawidłowych znaków.
Esolanging Fruit
dlaczego musisz ;usunąć akumulator?
caird coinheringaahing
@RandomUser Więc nie kończy się to, że na końcu zostanie wyprowadzony ciąg znaków.
ETHprodukcje
4

F #, 79 91 93 bajtów

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

Bez golfa

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

Wypróbuj online!

Edycja: Traktowałem dowolny znak inny niż „;” tak jak '#'. Zmieniono go tak, aby ignorował nieprawidłowe znaki.

Alternatywny

F #, 107 104 bajtów

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

Zastosowanie komórki referencyjnej pozwala zaoszczędzić 3 bajty

Bez golfa

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
        |_->()
    ]

Wypróbuj online

Brunner
źródło
4

Processing.js (wersja Khanacademy), 118 bajtów

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;}}

Wypróbuj online!

Ponieważ w używanej wersji przetwarzania nie ma żadnych metod wprowadzania, dane wejściowe są umieszczane w n.

Krzysztof
źródło
Możesz technicznie wykuć własną metodę wprowadzania za pomocą keyTyped=function(){ ... }: P
ETHprodukcje
@ETHproductions To obrzydzenie.
Christopher
@RandomUser yay! Zrobiłem to! Lubię odpowiadać w Przetwarzaniu (sprawdź moje odpowiedzi)
Christopher
2
@RandomUser Nie tylko 1000 powtórzeń, ale 2 ^ 10 powtórzeń (͡ ° ͜ʖ ͡ °)
@Midnightas Ohhh tak
Christopher
4

Labirynt , 61 47 bajtów

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

Wypróbuj online!

Wyjaśnienie

kolorowy kod rozwiązania

Wykonywanie kodu rozpoczyna się w lewym górnym rogu, a pierwszy średnik odrzuca niejawne zero ze stosu i kontynuuje w prawo.

Pomarańczowy

  • _36popycha 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ściowy

Stą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.

Robert Hickman
źródło
Z ciekawości, jak wygenerowałeś obraz wyjaśnień? Czy sam to stworzyłeś?
Stefnotch,
2
@Stefnotch, użyłem edytora tekstu, aby umieścić tabulację między każdym znakiem, a następnie wkleiłem kod do programu Microsoft Excel, który umieścił każdy znak w osobnej komórce. Wybrałem wszystkie komórki, aby nadać im jednakową szerokość i wysokość. Następnie poprawiłem kolory i obramowania i zrobiłem zrzut ekranu.
Robert Hickman,
3

MATL , 29 bajtów

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

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:

wprowadź opis zdjęcia tutaj

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.

';#'       % 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
źródło
3

Alice , 22 bajty

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

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.

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

Krótszą, ale nie kończącą się wersję tego programu można znaleźć tutaj .

Lew
źródło
Potwierdził to tutaj
Cairair coinheringaahing
Przepraszam za złe formatowanie, opublikowałem to z mojego telefonu, naprawię to, jak tylko dostanę komputer
Leo
Programy muszą zostać zakończone, chyba że w wyzwaniu określono inaczej.
Martin Ender
Możesz zapisać bajt, używając dosłownie 0x7F zamiast ~h.
Martin Ender
@MartinEnder spowodowało zakończenie. Nie udało mi się wstawić 0x7F do kodu, ale myślę, że ta alternatywna modyfikacja i tak jest bardziej interesująca :)
Leo
3

JS (ES6), 97 92 bajtów

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

Próbowałem przyjąć inne podejście niż odpowiedź Kudłaty . No cóż.


źródło
3

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

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   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
źródło
3

Bash + coreutils, 46 39 bajtów

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

Wypróbuj online!

Wyjaśnienie

(Dzięki Cows Quack za -7 bajtów!)

Ta trczęść usuwa wszystkie obce znaki (mógłbym wstawić to seddo dokładnie tego samego bajtu, ale wtedy nie obsługuje poprawnie znaku wysuwu linii, ponieważ sedpozostawia je i dcprzechodzi do pierwszego wysuwu wiersza z ?)

sed bierze resztę i buduje dc program:

Ciągi ;stają się ciągami 1(długiego literału)

#staje się .ZC7%P(jeśli następuje po ciągu 1, .znak dziesiętny oznacza brak operacji. Ale jeśli jest na początku programu lub po innym #, jest literałem 0. Następnie bierze długość liczby, modyfikuje ją, i drukuje odpowiedni ASCII.)

Sophia Lechner
źródło
Nie musisz uciekać z ;wnętrza '...'i możesz po prostu zmienić dc -ez?na dc. Poza tym, zamiast ;dodawać 1 do stosu, możesz pogrupować je razem i uzyskać ich długość za pomocą Zosiągnięcia tego tio.run/##S0oszvj/… .
Kritixi Lithos
@ Cowsquack To dobrze, dziękuję! (i dc -ez?było konsekwencją potrzeby dodatkowego zera, aby uruchomić program) Ale twój program dodaje dodatkowe dane wyjściowe stderrw 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, nie dcrzucając błędów!
Sophia Lechner,
Zgodnie z tym stderr można zignorować, chyba że wyzwanie wyraźnie stwierdza jako takie, więc jest to bardzo przydatne dla dc. Należy również pamiętać, że obecne rozwiązanie nie działa z rzędu #s ponieważ Zod 0znaczy 1, 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).
Kritixi Lithos,
3

DO, 65 64 60 bajtów

(-2 dzięki ceilingcat)

c;f(char*s){for(c=0;*s;s++)c+=*s-35?*s==59:-putchar(c%127);}
hvd
źródło
Musisz zainicjować cdo zera, aby funkcja mogła być ponownie użyta .
Conor O'Brien
@ ConorO'Brien Naprawiono. Niestety nie udało mi się wymyślić niczego krótszego niż zwykłe dodanie c=0i nie chciałbym oszukiwać, kopiując odpowiedź Dennisa.
hvd
@ceilingcat Dzięki jeszcze raz udało mi się zdjąć trzy kolejne bajty. Wykorzystuje to sztuczkę w odpowiedzi Dennisa (sprawdzonej po edycji), ale tym razem minęło tyle czasu, że zapomniałem o tym i sam to wymyśliłem.
hvd