Relacionado con: Hacer un; # intérprete y Generar; # código

;# - Una guía de torbellino

Este es un lenguaje simple con dos comandos. Su única estructura de datos es un acumulador, que se inicializa a 0.

1. ; Incrementar el acumulador

2. #Calcule el valor del acumulador módulo 127 e imprima el carácter ASCII correspondiente. Luego, restablezca el acumulador a 0.

El código fuente puede contener caracteres adicionales (ASCII imprimible + espacio en blanco), pero estos se tratan como comentarios y no tienen efecto en la ejecución del programa.

Reto

Como la mayoría de las computadoras no vienen ;#preinstaladas, sería muy útil tener una herramienta que pueda convertir el ;#código a un idioma diferente. En este desafío, escribirás un programa para lograrlo.

Entrada

Algún ;#código fuente, tomado por argumento o STDIN. Este código fuente puede contener (comentar) caracteres distintos de ;o #.

Salida

Código, en el mismo idioma que su envío, que, cuando se ejecuta, imprime / devuelve la misma cadena que el ;#código original . Este código resultante puede generar una nueva línea final después de la cadena de destino, si eso es más conveniente para su idioma.

Notas

Una cosa a tener en cuenta son las secuencias de escape, como el código que imprime barras invertidas o comillas. También busque ;#código que pueda contener elementos que parecen palabras clave o comandos en su idioma.

Restricciones adicionales

Todos los programas deben finalizar (normalmente considero que esto es un valor predeterminado, pero alguien me preguntó al respecto, así que lo digo aquí)

Ejemplos

input: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
output (python): print(";#")
input: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
output (element): \'`

Python 2 , 76 69 bytes

Código

La entrada está rodeada de comillas.

for y in input('print').split("#")[:-1]:print`chr(y.count(";")%127)`,

Pruébalo en línea!

Explicación

La primera parte de la salida se realiza esencialmente mediante la entrada, usando input('print'). Dividimos la entrada en los hashtags y descartamos el último elemento. Imprimimos la representación de ord (y% 127) , donde y es el número de ocurrencias del punto y coma. Anexamos ,al final de la impresión para asegurarnos de que esto no imprima una nueva línea.

Esto daría el siguiente código de Python para el Hello, World!programa:

print'H' 'e' 'l' 'l' 'o' ',' ' ' 'W' 'o' 'r' 'l' 'd' '!'

Que se puede probar en línea .

brainfuck , 126 bytes

+++[->+++++<]>[->++++>+++<<],[+<++++++[-<++++>>------<]>[<]<<[>>>>>[--<--.++>]<+.-<.<<<<]>[->>-<<]>>[[-]<]>[>>++++[-->]<[<]],]

Pruébalo en línea!

El programa de salida fallará en la implementación de TIO si la ;#salida supera los 65536 caracteres. También hice una versión de 130 bytes que sale en [+]lugar de <evitar este problema:

++[------>++>+<<]>+++++<,[+<++++++[-<++++>>------<]>[<]<<[>>>>>[--<.>]<+++.---<.>.<++.--<<<<]>[->>-<<]>>[[-]<]>[>>++++[-->]<[<]],]

Explicación

+++[->+++++<]>[->++++>+++<<]        initialize tape with 60 and 45
,[                                  for each input byte:
  +<++++++[-<++++>>------<]         subtract 35 (#) from byte
  >[<]<<[                           if byte was #
         >>>>>[--<--.++>]           output + (43) a number of times equal to accumulator
         <+.-<.<<<<                 output . (46) and < (60)
  ]
  >[->>-<<]>>                       subtract 24 from what's left of byte
  [[-]<]                            check difference and clear if nonzero
  >[                                if byte was originally 59 (;)
   >>++++[-->]<[<]                  add 4 to accumulator cell, then subtract 2 if nonzero. Since BF cells are mod 256, this creates an accumulator mod 127.
  ]
,]

Espacio en blanco, 291 bytes

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Reemplace S por espacio, T por tabulación y N por una nueva línea.

Generar espacios en blanco en espacios en blanco no es lo más eficiente del mundo. La generación de cualquier tipo de código dinámico requiere un importante giro de bits que, en un lenguaje sin operaciones bit a bit, provocaría la explosión del tamaño del código. Por lo tanto, este programa no intenta hacer algo inteligente, sino que solo opta por traducir el programa fuente de uno a uno. Se desmonta a lo siguiente:

early:
    call S
    call S
    call N
start:
    push  0
    dup
    ichr
    get
    push  35
    sub
    dup
    jz    hash
    push  24
    sub
    jz    semi
    jmp   start
hash:
    pop
    call SSS
    call TTT
    call TTT
    call T
    call N
    call T
    call S
    call TTT
    call N
    call S
    call S
    jmp   early
semi:
    call SSS
    call T
    call N
    call T
    call SSS
    jmp   start
N:
    push 10
    pchr
    ret
SSS:
    call S
    call S
S:
    push 32
    pchr
    ret
TTT:
    call T
    call T
T:
    push 9
    pchr
    ret

El código generado por el programa se ve así:

push  0
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  127
mod
pchr
push  0
push  1
add
...

V , 19 20 28 bytes

Bugfix, se rompió si no había #al final

Bugfix, implementado mod 127

Í;û127}
éiA0Í#/0
ò/;
x

Pruébalo en línea!

Probar código generado

Explicación:

Í;û127}                            ' Delete runs of 127 `;`s (mod 127)
éi                                 ' Insert an `i` in front of input
  A<C-v><esc>0<esc>                ' Append <esc>0 to input
                   Í#/<C-v><C-v>0  ' Replace all `#` with `<C-v>0`
ò                                  ' Recursively
 /;                                ' Go to the next `;`
<C-a>                              ' Increment the next number come across

En V, en modo de inserción, cualquier carácter ASCII puede insertarse mediante código mediante el uso <C-v><Code>. El código V reemplaza todo #con <C-v>0, donde el cero es un pseudoacumulador por #. Cada uno #restablece el acumulador a 0, por lo que tener uno por cada funciona bien. Luego, el código hace un incremento para cada punto y coma encontrado, lo que simplemente incrementa el siguiente número que encuentra, que sería el próximo acumulador. El 0se agrega al final para que la instrucción no falle para ;s sin un seguimiento #.

Hexdump:

00000000: e969 4116 1b30 1bcd 232f 1616 300a f22f  .iA..0..#/..0../
00000010: 3b0a 7801                                ;.x.

05AB1E , 20 19 18 16 bytes

-1 gracias a Adnan
-2 gracias a carusocomputing
-2 gracias a Kevin Cruijssen

'#¡¨vy';¢ƵQ%„çJJ

Pruébalo en línea! (incluye salida del código 05AB1E ejecutado)

'#¡              # Split on #
   ¨             # remove the last element
    vy           # For each...
      ';¢        #   count the number of ;s
         ƵQ%     #   Mod by 127
            „çJ  #   Push çJ („çJ should work, but it doesn't for some reason)
               J # Join stack and output implicitly

Python 2 , 75 bytes

lambda s:"print"+`''.join(chr(x.count(';')%127)for x in s.split('#')[:-1])`

Pruébalo en línea! (incluye salida de la ejecución del código Python transpilado)

Gracias a ovs por muchos muchos bytes!

Explicación

Este programa transpila el #; código dividiendo en #s ( s.split('#')[:-1]), contando la cantidad de punto y coma en cada fragmento 127 ( x.count(';')%127for x in ...), y convirtiéndolo en el carácter ASCII respectivo ( chr(...)). Esa lista se concatena ( ''.join(...)), se convierte en una representación de Python de la cadena (los backticks) y se inserta en un programa esqueleto de Python para imprimir cadenas ( "print"+...).

Jalea ,  25 24  16 bytes

ṣ”#Ṗċ€”;%127;€”Ọ

Un programa completo que imprime el código Jelly equivalente (como enlace monádico, devuelve una lista de listas de tipos mixtos).

El primer ejemplo está en ¡ Pruébelo en línea! que produce este programa .

¿Cómo?

Cuenta la ;s en cada ejecución entre #s toma cada módulo 127 y agrega un reparto a la instrucción ordinal, el Ọátomo monádico , después de cada uno.

Jelly canaliza implícitamente cada valor a STDOUT a medida que se ejecuta a través de un programa como ese, es decir, 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọse imprimiría Hello, world!.

ṣ”#Ṗċ€”;%127;€”Ọ - Main link: list of characters
 ”#              - literal '#'
ṣ                - split the result at #s
   Ṗ             - pop (remove the last result, list of trailing non-# characters)
      ”;         - literal ';'
    ċ€           - count for €ach
        %127     - modulo 127 (vectorises)
              ”Ọ - literal 'Ọ' (Jelly's cast to ordinal monadic atom)
            ;€   - concatenate for €ach - making a list of lists like [[72,'Ọ],[101,'Ọ'],...]
                 - implicit print (this smashes, printing something like: 72Ọ101Ọ...)

Una nota con respecto a la entrada: Jelly toma la entrada de cadena en formato Python. El programa de vacío podría ser entrada como "", y los programas de hash sólo como "#", "##", etc. Otro manipulación puede ser necesaria para las barras invertidas que contienen de entrada y citas.

Cúbicamente , 138 137 bytes

+1/1+54@6:5+1/1+5@6/1+52@6:4/1+5@6:1/1+54@6:4/1+5@6:5+2/1+4@6(~-61/1=7&6+5/1+51=7?6{+3/1+5@6}:5+3/1+3=7?6{+52@6:5+1@6-1@6+1@6:5+2/1+4@6})

Pruébalo en línea!

Nota: Es posible que tenga que sustituir &6con ?6&para que funcione en TIO. &6Sin embargo, está en la especificación del idioma.

Cómo funciona

+1/1+54@6        Output 'R'
:5+1/1+5@6       Output '3'
/1+52@6          Output 'D'
:4/1+5@6         Output '1'
:1/1+54@6        Output 'R'
:4/1+5@6         Output '1'
:5+2/1+4@6       Output '+'
(                Loop indefinitely
  ~                Get next character
  -61/1=7&6        If input is -1 (EOF), exit program
  +5/1+51=7?6{     If input is `;`
    +3/1+5@6         Output '0'
  }                End if
  :5+3/1+3=7?6{   If input is '#'
    +52@6            Output '@'
    :5+1@6           Output '6'
    -1@6             Output '-'
    +1@6             Output '6'
    :5+2/1+4@6       Output '+'
  }                End if
)                End loop

Programa de salida:

R3D1R1           Set top face to 1
+00...           Add top face to notepad, aka increment notepad
@6               Output notepad as character
-6               Set notepad to 0
...

JavaScript (ES6), 101 bytes

s=>`_=>'${s.replace(/[^#;]/g,``)}'.replace(/;*(#|$)/g,(l,c)=>c&&String.fromCharCode(~-l.length%127))`

Dada una cadena de entrada, elimina todos los caracteres innecesarios, luego devuelve el origen de la siguiente función:

_=>'...'.replace(/;*(#|$)/g,(l,c)=>c&&String.fromCharCode(~-l.length%127))

Donde ...representa la ;#fuente limpia .

C, 98 96 99 98 97 bytes

^{+3 bytes porque olvidé que C no se interpreta :(}

c,a;f(){printf("f(){puts(\"");for(;~c;c=getchar())c==59?a++:c==35?a=!printf(&a):a;puts("\");}");}

Corriendo con:

echo ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#" | ./a.out

Imprimirá:

f(){puts("Hello, World!");}

Jalea , 26 bytes

”‘x
f”;L%127Ç;“Ọø”
ṣ”#Ç€ṙ-

Pruébalo en línea!

¡Y prueba ese código Jelly aquí!

ṣ”#Ç€ṙ-      Main link, input is a string of ";;;;;;#lala;;;;;;;;;#"
ṣ”#          Split input on char #
   ǀ        Call helper link 1 for each segment
     ṙ-      Rotate returns 1 to the right (SPLIT introduces an empty element which is moved up front)

f”;L%127Ç;“Ọø”  Helper link 1, determines the number of increments
f”;             Throw out all but semicolons
   L%127        Take the count mod 127
        Ç       Call helper 2
         ;“Ọø”  Add a Jelly link that prints characters and splits print statements

”‘x             Helper 2, receives the count of ;'s
”‘              Return the character ‘ (Jelly's increment command
  x             Once for each ; in the input

La salida Jelly se convierte en código Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, que imprime chr (13) + chr (10)

PHP, 72 bytes

for(;~$c=$argn[$i++];)echo[Z=>'$n++;',B=>'echo~$n=~chr($n%127);'][a^$c];

> <>, 106 81 77 bytes

¡Este es mi primer golf en> <> (pez)! Un lenguaje bastante interesante que tengo que decir. ¡Mucha diversión!

0n01.
>i:1+?!v:";"=?v"#"=?v
^ ;o";"<   .37<
^oo"1+"
^oooooooo'"~"1+%o0' <

C # 169 bytes

Golfizado:

class P{static int Main(string[] args){var r="Console.Write(";foreach(var y in args[0].Split('#')){r+=(char)(-1+y.Split(';').Length%127);}System.Console.Write(r+");");}}

Versión legible para humanos:

class P
{
    static int Main(string[] args)
    {
        var r="Console.Write(\"";
        foreach (var y in args[0].Split('#'))
        {
            r +=(char)(-1+y.Split(';').Length% 127);
        }
        System.Console.Write(r+"\");");
    }
}

Haskell , 106 102 bytes

';'!(x:a)=x+1:a;'#'!a=0:a;_!a=a;h s="main=putStr"++(show$""++(toEnum.(`mod`127)<$>init(foldr(!)[0]s)))

Pruébalo en línea!

Sin golf

step ';' (x:acc) = x+1:acc
step '#' acc = 0:acc
step _ acc = acc;

semicolonHash s = toEnum . (`mod` 127) <$> init (foldr step [0] s)

toHaskell s = "main = putStr " ++ (show $ "" ++ semicolonHash s)

Brachylog , 33 bytes

{";"∧"+₁"|"#"∧"%₁₂₇g~ạw0"}ˢ;"0"↔c

Pruébalo en línea!

Sintiéndome demasiado cansado para explicar esto en este momento, si alguien ve esto y se pregunta cómo funciona, deje un comentario para recordarme.

MathGolf , 17 bytes

⌡(¶{gÉ'8=£♣(%$''\

Pruébalo en línea!

Explicación

⌡                      decrement twice
 (                     decrement
                       this transforms ";;;#;;#" -> "888 88 "
  ¶                    split string on spaces
   {                   foreach...
    gÉ                 filter using next 3 characters
      '8               push single character "8"
        =              pop(a, b), push(a==b)
                       this filters out all non-";"
         £             length of array/string with pop
          ♣            push 128
           (           decrement
            %          modulo
             $         pop(a), push ord(a) or char(a) (gets character with code)
              ''       push single character "'"
                \      swap top elements

Dado que cualquier carácter se puede poner en la pila (y, por lo tanto, la salida) usando '<char>, esto generará una secuencia de tales bloques de código.

MATL , 32 28 bytes

35lF4$Yb"@g59=z]xv127\!&D99h

Pruébalo en línea!

Enfoque completamente diferente basado en strsplitun programa de tipo autómata.

      Yb % strsplit
    4$   %  with 4 inputs, namely:
35       %   Split on '#'
  lF     %   Do not (F) collapse delimiters (l).
         %   And of course the implicit program input.

"@g    ] % Loop over strings, convert each to a normal char array
   59=z  % How many equal to 59 ';'?

xv!127\  % Delete last element, concatenate and flip to horizontal, mod 127
&D       % Convert to MATL representation
  99h    % Append a 'c' to output ASCII.

En realidad , 25 bytes

'#@s⌠';@c7╙D@%⌡MdX$"♂cΣ"o

Pruébalo en línea! (incluye salida de la ejecución del código Transpiled Actually)

Explicación:

'#@s⌠';@c7╙D@%⌡MdX$"♂cΣ"o
'#@s                       split on "#"
    ⌠';@c7╙D@%⌡M           for each chunk:
     ';@c                    count ";"s
         7╙D@%               mod by 127 (2**7-1)
                dX         discard last value
                  $        stringify
                   "♂cΣ"o  append "♂cΣ":
                    ♂c       convert each value to an ASCII character
                      Σ      concatenate

shortC , 48 bytes

c,a;AR"AP\"");O;~c;c=G)c==59?a++:c==35?a=!R&a):a

Fourier, 32 bytes

$(I~S{59}{`^`}S{35}{`%127a0`}&i)

Pruébalo en FourIDE!

Este fue un desafío bastante fácil ya que Fourier es básicamente un superconjunto de; #:

;# command > Fourier equivalent
; > ^ (Increment the accumulator)
# > %127a0 (Modulo accumulator by 127, output corresponding code point and set accumulator to zero)

CJam, 14 bytes

q'#/);';fe=:c`

Explicación:

q               e# Read input
 '#/            e# Split on '#'
    );          e# Delete last element
      ';fe=     e# Count occurrences of ';' in each
           :c   e# Convert each to character (code point)
             `  e# Escape

APL, 31 bytes

{⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽

Salida:

      ({⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽) ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#'
⎕UCS 59 35
      ⍝ evaluate the output
      ⍎({⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽) ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#'
;#

Explicación:

• ⌽: invertir la entrada
• {... }: pásalo a esta función:
  • ⍵⊂⍨'#'=⍵: partición en cada uno #de la cadena (desde el principio, por lo que tuvo que invertirse primero)
  • +/¨';'=: cuenta los ;s en cada partición
  • 127|: módulo 127
  • ⌽: invertirlo de nuevo
  • '⎕UCS',: anteponer la cadena ⎕UCS, que es la función Unicode.
  • ⍕: representación de cadena

Ruby , 47 + 1 = 48 bytes

$_=gsub(/.*?#/){"$><<#{$&.count(?;)%127}.chr;"}

+1 byte para -p.

Pruébalo en línea!

-30 bytes gracias a @manatwork !

Pyth, 25 23 24 bytes

j\\+"jk["mC%/d\;127Pcw\#

+1 bytes gracias a @FryAmTheEggman

¡Intentalo!

maneja los caracteres a los que se debe escapar utilizando solo 1-char-strings.

Resultados de muestra:

jk[\"

jk[\H\e\l\l\o\,\ \W\o\r\l\d\!

Utiliza mi; # intérprete .

C, 150 bytes

#include<stdio.h>
c;n=0;main(){puts("#include<stdio.h>\nmain(){");while(~(c=getchar()))c-35?c-59?:n++:(printf("putchar(%d);",n%127)&(n=0));puts("}");}

Expandido:

#include<stdio.h>
c;
n=0;
main(){
        puts("#include<stdio.h>\nmain(){");
        while( ~(
            c=getchar()
        ))
                c-35?
                        c-59?
                                :
                                n++
                        :
                        ( printf("putchar(%d);",n%127)
                        &(n=0))
                ;
        puts("}");
}

Es un programa completo que (debería) terminar, ignorar los comentarios y producir un código de salida siempre correcto. Supongo EOF = -1

Probado en SystemResque-Cd 4.9.6, compilado con gcc 4.9.4

braingasm , 40 bytes

,[35-z["[127-s[127+.>]]<0*".]24-z[43.],]

Debo decir que eso es sorprendentemente corto.

,[                                    ,]     Read a byte until end of input
  35-                                          Subtract 35.
     z[                     ]                  If the result is zero,
       "[127-s[127+.>]]<0*".                     print the code for `#`.
                             24-               Subtract 24.
                                z[   ]         If the result is zero,
                                  43.            print the code for `;`

El código generado para ;es un+ , que incrementa la celda actual.

El código generado para #contiene una operación de módulo manual incómoda

[127-s[127+.>]]<0*
[             ]       While current cell is not zero
 127-                   Subtract 127
     s[      ]          If result is negative
       127+.              Add 127 again and print current cell
            >             Step to next cell to break the loop
               <0*      Step back to first cell and clear it

Braingolf , 55 bytes

V#0VR&,l1-MvMR[R.#;e"+1"MM|.##e"@%+1~#"MMMMMM|$_vv]Rv&@

Pruébalo en línea!

Básicamente reemplaza ;con 1+, #con #~1+%@y antepone todo el asunto con un 0porque el +operador monádico está roto en este momento.

1+ agrega 1 al último elemento en la pila.

#~1+%@empuja el valor de char de ~(126), agrega 1 para hacer 127, módulo con otro elemento en la pila, luego aparece e imprime como char.

Explicación

V#0VR&,l1-MvMR                         Implicit input of each char to stack
[R.#;e"+1"MM|.##e"@%+1~#"MMMMMM|$_vv]
Rv&@

V#0                                    Create stack2, push char value of 0
   VR                                  Create stack3, return to stack1
     &,                                Reverse stack
       l1-                             Push length of stack - 1
          MvMR                         Move length to stack2, switch to stack 2
                                       Move length to stack3, switch back to stack1
[R................................vv]  Do-While loop, will run l times
                                       where l is length of input
  .#;                                  Duplicate last item and push char value of semicolon
     e                                 Pop last 2 items, if they are equal..
      "+1"                             ..Push char values of +1 in that order
          MM                           ..Move last 2 items to stack2
            |                          endif
             .##                       Duplicate last item and push char value of hash
                e                      Pop last 2 items, if they are equal..
                 "@%+1~#"              ..Push char values of @%+1~# in that order
                         MMMMMM        ..Move last 6 chars to stack2
                               |       endif
                                $_     Silently pop last item
Rv                                     Switch to stack2
  &@                                   Greedy char print, print every item in stack as char

q / kdb +, 42 bytes

Solución:

{-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}

Ejemplos:

Tenga en cuenta que ,se usa para significar una lista (frente a un átomo), ya que "\""es una lista de un elemento, en lugar de ser un átomo.

q){-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"
";#"
q){-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"
,"\""

Explicación:

Tome la cadena de entrada, elimine todo lo que no sea a #o a ;, divida en listas #, cuente el número de elementos en cada lista, realice el mod 127 en el resultado y eche a una cadena:

{-1_"c"$mod[;127]count each"#"vs x inter"#;"} / ungolfed
{                                           } / lambda function
                                 x inter"#;"  / intersection of input and ';#' to clear out any 'comments'
                           "#"vs              / split string on hash
                 count each                   / length of each sub-list
        mod[;127]                             / 127 modulo result (vectorised)
    "c"$                                      / cast back to string
 -1_                                          / drop last character (assuming terminated string)

Notas:

• Asume que la entrada es terminada por un # , de lo contrario, el último fragmento se caerá por error -1_.
• Podría ser 10 bytes más corto si se garantiza que la entrada solo contenga ;#.

Perl 5 , 78 bytes

say"say''",map{$_=chr y/;//%127;$_.=$_ if/\\|'/;",'$_'"}(join$",<>)=~/[^#]*#/g

Pruébalo en línea!