Hacer un intérprete;

62

Recientemente creé un nuevo lenguaje llamado ;#(pronunciado "Semicolon Hash") que solo tiene dos comandos:

; agregue uno al acumulador

#module el acumulador por 127, convierta a carácter ASCII y salga sin una nueva línea. Después de esto, restablezca el acumulador a 0. Sí, 127 es correcto.

Cualquier otro personaje es ignorado. No tiene ningún efecto sobre el acumulador y no debe hacer nada.

¡Su tarea es crear un intérprete para este poderoso lenguaje!

Debe ser un programa completo o una función que tome un ;#programa como entrada y produzca la salida correcta.

Ejemplos

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 hasta 100

caird coinheringaahing
fuente
1
¿Es aceptable si un intérprete no finaliza su ejecución al final de la entrada, sino que continúa en bucle indefinidamente sin producir una salida adicional?
Leo
55
El segundo ejemplo me hace preguntarme acerca de un programa para codificar un programa para producir una salida ... ¡compilación recursiva!
frarugi87
@Leo sí, eso está bien
caird coinheringaahing
1
@iamnotmaynard Semicolon Hash
caird coinheringaahing
2
Quizás Wink Hash sería más fácil de decir
James Waldby - jwpat7

Respuestas:

17

JavaScript (ES6), 76 82 80 bytes

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

Manifestación

Versión recursiva, 82 77 bytes

Guardado 5 bytes gracias a Neil

Es probable que este bloquee para entradas grandes como el ejemplo de Fizz Buzz.

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""
Arnauld
fuente
Creo que f(s,a+(c==';'))podría eliminar tres bytes de su versión recursiva.
Neil
@Neil En realidad ahorra 5 bytes. :-)
Arnauld
Me siento realmente tonto ahora. Originalmente tenía una versión con errores, y restaba 2 bytes para corregir el error. Pero había contado mal y la versión con errores realmente ahorró 7 bytes ...
Neil
12

Retina , 336 63 67 65 66 62 59 bytes

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

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

Pruébalo en línea!

Versión legible con sintaxis de escape hipotética :

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

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

No imprime bytes NUL, porque TIO no los permite en el código fuente. También imprime una nueva línea adicional al final, pero supongo que no puede hacer otra cosa. Nueva línea final suprimida gracias a @Leo .

-273 (!) Bytes gracias a @ETHproductions .

-2 bytes gracias a @ovs .

-3 bytes gracias a @Neil . Echa un vistazo a su maravillosa solución de 34 bytes .

eush77
fuente
1
Oh mi palabra. ¿Pero no puedes guardar mil bytes con +T`\x01-~`_\x03-\x7f`[^\x01¯]\x01? (incluidos los no imprimibles como caracteres únicos, por supuesto)
ETHproductions
@ETHproductions Por supuesto que puedes. ¡Gracias! :)
eush77
1
Actualmente, la última letra siempre está en la salida, incluso si no hay seguimiento #en la entrada. Puede solucionarlo cambiando su segunda etapa a(;{127}|;+$)
2017
1
¿Necesita el + `en la tercera línea? A medida que elimine la coincidencia completa, no debe quedar nada para reemplazar en la segunda iteración.
ovs
1
Creo que puedo hacer esto en 34 bytes: T`;#\x01-ÿ`\x80\x7F_ \x80+$(línea vacía) \+T`\x7Fo`\x01-\x80_`\x80[^\x80](usando escapes hexadecimales para representar no imprimibles). Salidas \ x7F en lugar de nulos.
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;}}};

Pruébalo en línea!

Mas
fuente
3
Bienvenido al sitio! :)
DJMcMayhem
Agregué un enlace a un intérprete en línea con el ejemplo de FizzBuzz para usted (el texto del enlace era demasiado largo para caber en un comentario)
Jonathan Allan
Java usa UTF-16 para sus programas . Entonces, estos no son 100 bytes sino 100 caracteres .
G.Broser dice Restablecer a Monica
55
@GeroldBroser Unicode es un conjunto de caracteres: UTF-8 y UTF-16 son dos codificaciones de ese conjunto de caracteres. La fuente ASCII es perfectamente válida como programa Java, y tengo muchos archivos fuente Java codificados en ASCII (que también es UTF-8 válido, por lo tanto, también una codificación Unicode).
1
Completamente golf, para 81 bytes como 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

Hay un \ x7f char no imprimible después %#. ¡Pruébelo en línea!

Cómo funciona

®   è'; %#   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
ETHproducciones
fuente
1
¡Oh, debería haber verificado las respuestas! Solo pasé un tiempo en esto solo para descubrir que me habías golpeado hasta el golpe. q'# ®è'; u# dì¯JTambién funciona para el mismo puntaje.
Shaggy
11

Python , 65 bytes

Este es un golf de esta respuesta anterior.

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

Pruébalo en línea! Python2

Pruébalo en línea! Python3

Explicación

Esta es una respuesta bastante sencilla. Determinamos cuántos ;s hay entre cada uno #e imprimimos el chrmod 127. Lo único que puede ser un poco extraño es el [:-1]. Necesitamos eliminar el último grupo porque no habrá más #después.

Por ejemplo

;;#;;;;#;;;;;#;;;

Se dividirá en

[';;',';;;;',';;;;;',';;;']

Pero no queremos el último ;;;porque no hay #después para imprimir el valor.

Asistente de trigo
fuente
1
Estaba ocupado tratando de hacer todas las pruebas en un enlace TIO. Fue chr por chr excepto ty x.
Jonathan Allan
9

> <> , 35 bytes

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

Pruébalo en línea! Reemplace con 0x7F, ^?o "eliminar".

Bucle principal

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

Esto toma un carácter de input ( i), comprueba si es menor que cero, es decir, EOF ( :0() y finaliza el programa si es ( ?;). De lo contrario, verifique si la entrada es igual a #( :'#'=). Si es así, bájese y reinicie el bucle ( ?v... ^ ... <).

Contra lógica

              ';'=?0
              

Compruebe si la entrada es igual a ;( ';'=). Si es así, presione a 0. De lo contrario, no hagas nada. Esto reinicia el bucle principal.

Lógica de impresión

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

Cuando el carácter de entrada es #, retire la entrada de la pila ( ~), obtenga el número de miembros en la pila ( l), presione 127 ( '␡') y tome el módulo ( %). Luego, escríbalo como un carácter ( o) e inicie una nueva pila ( [0). Esto "pone a cero" el contador. Luego, el bucle se reinicia.

Conor O'Brien
fuente
3
Pobre> <>. Es triste :0(:(
caird coinheringaahing
9

Python 3, 69 bytes

Mejorado, gracias a @Wheat Wizard, @Uriel

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))
MrGeek
fuente
3
¡Bienvenido a Programming Puzzles y Code Golf! El objetivo aquí es hacer que el código sea lo más corto posible (en bytes), por lo que debe incluir el recuento de bytes en el encabezado :).
Adnan
Gracias por explicar, no lo sabía. Trabajaré en eso entonces.
MrGeek
2
Puede eliminar el espacio después del :s.
Pavel
1
Cuento 74 bytes. tio.run/nexus/…
Dennis
2
Además, ';'==cahorra un espacio, pero no usar ifdeclaraciones en absoluto sería aún más corto.
Dennis
9

Röda , 44 39 38 bytes

5 bytes guardados gracias a @fergusq

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

Pruébalo en línea!

Función anónima que toma la entrada de la secuencia.


Si otros personajes no tienen que ser ignorados, obtengo esto:

Röda , 20 bytes

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

Ruby, 41 35 34 caracteres

( 40 34 código de 33 caracteres + opción de línea de comando de 1 carácter)

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

Gracias a:

  • Jordan por sugerir usar putcpara no necesitar conversión explícita con .chr(6 caracteres)
  • Kirill L. por encontrar el paréntesis innecesario (1 personaje)

Ejecución de muestra:

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

Pruébalo en línea!

hombre trabajando
fuente
Doh Aunque hice C en mis primeros años, lo olvidé por completo putc(). Gracias, @Jordan
manatwork
1
Para mi sorpresa, puedes dejar los paréntesis después del conteo para guardar un byte
Kirill L.
Buena captura, @KirillL., Gracias.
manatwork
7

05AB1E , 16 15 14 bytes

Código:

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

Explicación:

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

Utiliza la codificación 05AB1E . Pruébalo en línea!

Adnan
fuente
7

Jalea , 13 bytes

ṣ”#Ṗċ€”;%127Ọ

Pruébalo en línea!

Cómo funciona

ṣ”#Ṗċ€”;%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
fuente
1
La palabra semicolano existe es semicolons.
Erik the Outgolfer
@EriktheOutgolfer en.m.wiktionary.org/wiki/semicola
Dennis
Hmm, palabra rara.
Erik the Outgolfer
@EriktheOutgolfer Alguien en Wiktionary probablemente estaba tratando de hacer que el latín plural fuera válido en inglés, pero las ortografías de cola y semicola deberían prohibirse.
Cœur
7

Código de máquina x86 en MS-DOS: 29 bytes

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

Asamblea comentada:

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
fuente
6

05AB1E , 25 21 19 bytes

-2 bytes gracias a Adnan

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

Explicación:

Î                       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

Pruébalo en línea!

Okx
fuente
1
Creo que puedes reemplazar i>}por +.
Adnan
6

Retina , 34 bytes

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

Pruébalo en línea! Incluye estuche de prueba. Editar: guardado 2 bytes con ayuda de @MartinEnder. Nota: El código incluye no imprimibles, y el uso de &#x;códigos genera resultados incorrectos ya que el navegador usa Windows-1252 en lugar de ISO-8859-1. Explicación: La primera línea limpia la entrada: ;se cambia a \x80, #a \x7F(debido a las limitaciones de TIO) y se elimina todo lo demás. Luego, cada vez que vemos un \x80que no está antes que otro \x80, lo eliminamos e incrementamos cíclicamente el código de cualquier carácter siguiente. Esto se repite hasta que no quedan más \x80caracteres. El código original que admite bytes nulos básicamente resta 1 de los bytes no imprimibles, excepto en la primera línea donde no \xFFse modifica y se \x7Fconvierte en\x00. Con escapes para la lectura:

T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$
Neil
fuente
Puede guardar un byte combinando las dos últimas etapas con \x80([^\x80]|$)la última etapa.
Martin Ender
@MartinEnder Gracias! Molesto, \s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?también solo guarda un byte.
Neil
Ah, pero [^\x80]|\x80$ahorra dos bytes, creo.
Neil
Ah bien, sí, el último funciona. También había intentado el lookahead negativo, pero ses molesto.
Martin Ender
6

R, 97 90 86 84 bytes

Una función:

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

Cuando R comienza, Fse define como FALSE(numérico 0).

Sin golf:

function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }
Sven Hohenstein
fuente
¿No debería ser esto R + pryr?
L3viathan
@ L3viathan Dado que pryres un paquete R, sigue siendo el código R.
Sven Hohenstein
Es un código R, pero requiere la instalación de una biblioteca adicional.
L3viathan
@ L3viathan ¿Crees que mi respuesta no es válida? ¿Debo evitar usar paquetes adicionales?
Sven Hohenstein
2
@BLT No hay diferencia. En mi opinión, no es problema usar paquetes adicionales que se crearon antes del desafío. Esto es cierto para todos los idiomas. En Python tiene que usar importmientras que en R puede usar ::para acceder directamente a la función en paquetes. A menudo puede ver el uso de paquetes adicionales aquí (por ejemplo, para Python y Java). Sin embargo, cambié mi publicación anterior porque no quiero entablar una discusión.
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
fuente
1
@WheatWizard ya que publicaste esto como respuesta, creo que la acción correcta para mí sería votarlo en lugar de actualizarlo
Uriel
4

TeX simple, 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

Legible

\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
fuente
¿Puede imprimir caracteres simbólicamente?
eush77
4

C (gcc) , 58 bytes

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

Pruébalo en línea! (Sugerencia: haga clic en ▼ Pie de página para contraerlo).

Dennis
fuente
4

Perl, 25 bytes

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

Ejecutar con perl -043pe(contado como 4 bytes, ya que perl -ees estándar).

Explicación: -043establece el terminador de línea en #(ASCII 043). -pitera sobre las "líneas" de entrada (en realidad # delimitadas por cadenas, ahora). y%;%%cuenta el número de ;en cada "línea". x/#/se asegura de que no imprimimos un carácter adicional para los programas que no terminan en un # (como el tercer caso de prueba). %127Debería ser bastante obvio. $_=es el habitual repetitivo.

Mugriento
fuente
Impresionante, aunque hay fallas: para ;;#;;;que salga # 5 en lugar de # 2.
manatwork
¿Cómo obtuviste este resultado? echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxdsale correctamente 00000000: 02en mi máquina. Si dejó el 043, o está usando una página de códigos donde #no es ASCII 043, eso explicaría su resultado.
Grimmy
1
Ups Lo siento, tuve un error tipográfico en mi prueba. Tu código funciona perfectamente.
manatwork
4

CJam, 27 bytes

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

Explicación:

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

Solución alternativa, 18 bytes

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

Explicación:

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
Fruta Esolanging
fuente
Business Cat That no ignora los caracteres no válidos.
Esolanging Fruit
¿Por qué necesitas ;eliminar el acumulador?
caird coinheringaahing
@RandomUser Por lo tanto, no termina saliendo al final con la cadena.
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

Sin golf

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

Pruébalo en línea!

Editar: estaba tratando cualquier otro carácter que ';' como '#'. Lo cambió para que ignore los caracteres no válidos.

Alternativa

F #, 107104 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|_->()]

El uso de la celda de referencia ahorra 3 bytes

Sin golf

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

Pruébalo en línea

Brunner
fuente
4

Processing.js (versión Khanacademy), 118 bytes

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

Pruébalo en línea!

Como la versión de procesamiento utilizada no tiene ningún método de entrada, la entrada se coloca en n.

Christopher
fuente
Técnicamente, podría forjar su propio método de entrada con keyTyped=function(){ ... }: P
ETHproductions
@ETHproductions Esta es una mirada de asco.
Christopher
@RandomUser yay! ¡Lo he hecho! Me gusta responder en Procesamiento (verifique mis respuestas)
Christopher
2
@RandomUser No solo 1000 rep .. sino 2 ^ 10 rep (͡ ° ͜ʖ ͡ °)
@Midnightas Ohhh sí
Christopher
4

Laberinto , 61 47 bytes

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

Pruébalo en línea!

Explicación

imagen codificada por color del código de la solución

La ejecución del código comienza en la esquina superior izquierda y el primer punto y coma descarta un cero implícito de la pila y continúa hacia la derecha.

naranja

  • _36empuja 36 en la pila. Esto es para comparar la entrada con#
  • } mueve la parte superior de la pila a la pila secundaria
  • , empuja el valor entero del personaje en la pila
  • )incrementa la pila (si es el final de la entrada, esto hará que la pila sea 0 y el flujo del programa procederá a la @salida)
  • { mueve la parte superior de la pila secundaria a la parte superior de la pila primaria
  • -pop y, pop x, presione x - y. Esto es para comparar la entrada con #(35 en ascii). Si la entrada fue #el código continuará a la sección púrpura (porque la parte superior de la pila es 0, la IP continúa en la dirección en la que se movía antes), de lo contrario continuará a la sección verde.

Púrpura

  • 127 empujar 127 a la pila
  • % pop x, pop y, push x% y
  • . pop la parte superior de la pila (el acumulador) y la salida como un personaje

Desde aquí, el código gris nos lleva a la esquina superior izquierda del programa sin nada en la pila.

Verde

  • _24 empuje 24 en la pila
  • -pop x, pop y, presione xy. 24 es la diferencia entre #y ;entonces esto verifica si la entrada fue ;. Si fuera así, ;el código continúa directamente hacia el ). De lo contrario, se convertirá en el #que empuja la altura de la pila (siempre un número positivo, obligando al programa a girar a la derecha en la próxima intersección y perder el código que incrementa el acumulador)
  • ; descartar la parte superior de la pila
  • ) incremente la parte superior de la pila, que es un cero implícito o es un cero previamente incrementado que actúa como el acumulador para la salida

Desde aquí, el código gris nos lleva a la esquina superior izquierda del programa con la pila con solo el acumulador.

gris

Las cotizaciones no son operacionales, _empujan un 0 a la pila y ;descartan la parte superior de la pila. Todo esto es solo un código para forzar el flujo de control de la manera correcta y descartar cualquier cosa adicional de la parte superior de la pila.

Robert Hickman
fuente
Por curiosidad, ¿cómo generó la imagen explicativa? ¿Lo creaste tú mismo?
Stefnotch
2
@Stefnotch, utilicé un editor de texto para poner una pestaña entre cada carácter y luego pegué el código en Microsoft Excel que puso cada carácter en su propia celda. Seleccioné todas las celdas para darles el mismo ancho y alto. Luego ajusté los colores y los bordes y tomé una captura de pantalla.
Robert Hickman
3

MATL , 29 bytes

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

La entrada es una cadena entre comillas simples.

Pruébalo en línea!

El programa FizzBuzz es demasiado largo para los intérpretes en línea; verlo trabajando sin conexión en este gif:

ingrese la descripción de la imagen aquí

Explicación

El valor del acumulador se implementa como el número de elementos en la pila. Esto hace que el programa sea más lento que si el valor del acumulador fuera un solo número en la pila, pero ahorra algunos bytes.

';#'       % 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
fuente
3

Alice , 22 bytes

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

Pruébalo en línea!

Explicación

Mantenemos en la pila solo un contador de cuántos ;nos hemos encontrado. Cuando la pila está vacía (p. Ej. Al inicio del programa) esto es implícitamente un 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

Aquí se puede encontrar una versión más corta pero sin finalización de este programa .

León
fuente
Confirmado aquí
caird coinheringaahing
Perdón por el mal formato, publiqué esto desde mi teléfono, lo arreglaré tan pronto como tenga en mis manos una PC
Leo
Los programas tienen que finalizar a menos que se especifique lo contrario en el desafío.
Martin Ender
Puede guardar un byte utilizando un 0x7F literal en lugar de ~hsin embargo.
Martin Ender
@MartinEnder hizo que terminara. No pude lograr insertar un 0x7F en el código, pero creo que esta modificación alternativa es más interesante de todos modos :)
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)

Intenté adoptar un enfoque diferente al de la respuesta de Shaggy . Oh bien.


fuente
3

; # + , 59 bytes, sin competencia

El lenguaje se hizo después de este desafío.

;;;;;~+++++++>~;~++++:>*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)

Pruébalo en línea! La entrada termina con un byte nulo.

Explicación

La generación es la misma que la de mi Generar; # respuesta de código . La única diferencia aquí es la iteración.

Iteración

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   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
fuente
3

Bash + coreutils, 46 39 bytes

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

Pruébalo en línea!

Explicación

(¡Gracias Cows Quack por -7 bytes!)

La trparte elimina todos los caracteres extraños (podría poner esto en sedexactamente el mismo bytecount, pero luego no maneja el carácter de salto de línea correctamente, ya que los seddeja adentro y dcsolo llega hasta el primer salto de línea con ?)

sedtoma el resto y construye un dcprograma:

Cadenas de ;convertirse en cadenas de 1(un literal largo)

#se convierte en .ZC7%P(si esto sigue una cadena de 1, el .es un punto decimal para un no-op. Pero si está al comienzo del programa, o después de otro #, es un literal 0. Luego toma la longitud del número, lo modifica, e Imprime el ASCII correspondiente.)

Sophia Lechner
fuente
No necesita escapar del ;interior '...'y simplemente puede cambiar dc -ez?a dc. Además de eso, en lugar de ;agregar 1 a la pila, puede agruparlos y obtener su longitud usando Zpara alcanzar este tio.run/##S0oszvj/… .
Kritixi Lithos
@Cowsquack Eso está bien, ¡gracias! (y dc -ez?fue una consecuencia de la necesidad de un cero adicional para iniciar el programa) Pero su programa agrega una salida adicional stderren los casos consecutivos #o de entrada que no termina con #(en ambos casos, quiero decir después de que se eliminan los caracteres extraños) . No sé si hay consenso, pero siento que el resultado adicional invalida la solución. Sin embargo, ¡adapté tu idea y terminé en un byte más que tu sugerencia sin dcarrojar errores!
Sophia Lechner
De acuerdo con esto, se puede ignorar stderr a menos que el desafío explícitamente se establezca como tal, por lo que es muy útil para DC. También tenga en cuenta que esta solución actual falla con #s consecutivos debido Za 0is 1, por lo que genera 0x01 en lugar de 0x00 (también caí en la misma trampa, pero mi navegador muestra no imprimibles como sus códigos hexadecimales, así que capté eso).
Kritixi Lithos
3

C, 65 64 60 bytes

(-2 gracias a ceilingcat)

c;f(char*s){for(c=0;*s;s++)c+=*s-35?*s==59:-putchar(c%127);}
hvd
fuente
Deberá inicializar ca cero para que la función sea reutilizable .
Conor O'Brien
@ ConorO'Brien Fijo. Desafortunadamente, no pude encontrar algo más corto que simplemente agregar el c=0, y no quisiera hacer trampa copiando la respuesta de Dennis.
hvd
@ceilingcat Gracias de nuevo, pude quitar tres bytes más después de eso. Esto sí utiliza un truco en la respuesta de Dennis (verificado después de la edición), pero esta vez, había pasado tanto tiempo que lo había olvidado por completo y se me ocurrió por mi cuenta.
hvd