Relacionado a: Criar um; # interpretador e Gerar; # código

;# - Um guia de turbilhão

Esta é uma linguagem simples com dois comandos. Sua única estrutura de dados é um acumulador, que é inicializado como 0.

1. ; Incrementar o acumulador

2. #Calcule o valor do módulo acumulador 127 e imprima o caractere ASCII correspondente. Em seguida, redefina o acumulador para 0.

O código fonte pode conter caracteres adicionais (espaço em branco ASCII + imprimível), mas estes são tratados como comentários e não têm efeito na execução do programa.

Desafio

Como a maioria dos computadores não vem com o ;#pré - instalado, seria muito útil ter uma ferramenta que possa converter ;#código em um idioma diferente. Neste desafio, você deve escrever um programa para fazer isso.

Entrada

Algum ;#código fonte, obtido via argumento ou STDIN. Este código fonte pode conter caracteres (comentários) diferentes de ;ou #.

Saída

Código, no mesmo idioma do envio, que, quando executado, imprime / retorna a mesma sequência que o ;#código original . Esse código resultante pode gerar uma nova linha após a sequência de destino, se isso for mais conveniente para o seu idioma.

Notas

Uma coisa a se observar são as seqüências de escape, como código que imprime barras invertidas ou aspas. Procure também por ;#códigos que possam conter itens semelhantes a palavras-chave ou comandos no seu idioma.

Restrições adicionais

Todos os programas devem ser encerrados (eu normalmente considero isso padrão, mas alguém perguntou sobre isso, por isso estou afirmando aqui).

Exemplos

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

Python 2 , 76 69 bytes

Código

A entrada é cercada por aspas.

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

Experimente online!

Explicação

A primeira parte da saída é essencialmente feita pela entrada, usando input('print'). Dividimos a entrada em hashtags e descartamos o último elemento. Imprimimos a representação de ord (y% 127) , onde y é o número de ocorrências do ponto e vírgula. Anexamos ,no final da impressão para garantir que isso não imprima uma nova linha.

Isso daria o seguinte código Python para o Hello, World!programa:

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

O que pode ser experimentado online .

brainfuck , 126 bytes

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

Experimente online!

O programa de saída falhará na implementação do TIO se a ;#saída exceder 65536 caracteres. Eu também fiz uma versão de 130 bytes que gera em [+]vez de <, evitando este problema:

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

Explicação

+++[->+++++<]>[->++++>+++<<]        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.
  ]
,]

Espaço em branco, 291 bytes

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Substitua S pelo espaço, T pela guia e N por uma nova linha.

Gerar espaço em branco no espaço em branco não é a coisa mais eficiente do mundo. A geração de qualquer tipo de código dinâmico requer uma modificação significativa de bits que, em um idioma sem operações bit a bit, faria com que o tamanho do código explodisse. Portanto, este programa não tenta fazer algo inteligente, optando apenas por traduzir o programa de origem de um para um. Desmonta-se ao seguinte:

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

O código gerado pelo programa se parece com:

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

Correção de bug, quebrou se não houvesse #no final

Bugfix, implementado mod 127

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

Experimente online!

Experimente o código gerado

Explicação:

Í;û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

Em V, no modo de inserção, qualquer caractere ASCII pode ser inserido por código usando <C-v><Code>. O código V substitui todos #por <C-v>0, onde o zero é um pseudo-acumulador por #. Cada um #redefine o acumulador para 0, portanto, ter um por funciona bem. Em seguida, o código faz um incremento para cada ponto e vírgula encontrado, que apenas incrementa o próximo número encontrado, que seria o próximo acumulador. O 0é anexado ao final para que a instrução não falhe por ;s sem seguir #.

Hexdump:

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

05AB1E , 20 19 18 16 bytes

-1 graças a Adnan
-2 graças a carusocomputing
-2 graças a Kevin Cruijssen

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

Experimente online! (inclui saída do código 05AB1E executado)

'#¡              # 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])`

Experimente online! (inclui saída da execução do código Python transpilado)

Obrigado a ovs por muitos bytes!

Explicação

Este programa transpila o #; dividindo em #s ( s.split('#')[:-1]), contando o número de ponto-e-vírgula em cada pedaço de mod 127 ( x.count(';')%127for x in ...) e convertendo-o no respectivo caractere ASCII ( chr(...)). Essa lista é concatenada ( ''.join(...)), convertida em uma representação Python da string (backticks) e inserida em um programa esqueleto Python para imprimir strings ( "print"+...).

Gelatina ,  25 24  16 bytes

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

Um programa completo que imprime o código Jelly equivalente (como um link monádico, ele retorna uma lista de listas de tipos mistos).

O primeiro exemplo está em Experimente online! que produz este programa .

Quão?

A contagem de ;s em cada corrida entre #s pega cada módulo 127 e anexa uma conversão à instrução ordinal, o Ọátomo monádico , após cada uma.

A geléia canaliza implicitamente cada valor para STDOUT enquanto ele executa um programa como esse, ou seja, 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọseria impresso 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Ọ...)

Uma observação sobre a entrada: Jelly recebe entrada de string no formato Python. O programa vazio poderia ser introduzido como "", e os programas só-hash como "#", "##"etc. Outro manipulação pode ser necessário para que contêm barras invertidas de entrada e citações.

Cubicamente , 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})

Experimente online!

Nota: Pode ser necessário substituir &6por ?6&para que ele funcione no TIO. &6está na especificação de idioma, no entanto.

Como 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 saída:

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 uma sequência de entrada, exclui todos os caracteres desnecessários e retorna a fonte da seguinte função:

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

Onde ...representa a ;#fonte limpa .

C, 98 96 99 98 97 bytes

^{+3 bytes porque esqueci que C não é interpretado :(}

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

Executando com:

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

Irá imprimir:

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

Geléia , 26 bytes

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

Experimente online!

E tente esse código Jelly aqui!

ṣ”#Ç€ṙ-      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

A saída Jelly se transforma em 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 é o meu primeiro golfe em> <> (peixe)! Uma linguagem bastante interessante, tenho que dizer. Muita diversão!

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

C # 169 bytes

Golfe:

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+");");}}

Versão legível por 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)))

Experimente online!

Ungolfed

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)

Braquilog , 33 bytes

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

Experimente online!

Sentindo-me um pouco cansado demais para explicar isso no momento, se alguém vê isso e se pergunta como isso funciona, envie um comentário para me lembrar.

MathGolf , 17 bytes

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

Experimente online!

Explicação

⌡                      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

Como qualquer caractere pode ser colocado na pilha (e, portanto, na saída) usando '<char>, isso produzirá uma sequência desses blocos de código.

MATL , 32 28 bytes

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

Experimente online!

Abordagem completamente diferente com base em strsplitum programa do tipo autômato.

      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.

Na verdade , 25 bytes

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

Experimente online!(inclui saída da execução do código atualmente transpilado)

Explicação:

'#@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)

Experimente no FourIDE!

Esse foi um desafio bastante fácil, pois Fourier é basicamente um 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`

Explicação:

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|+/¨';'=⍵⊂⍨'#'=⍵}⌽

Saída:

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

Explicação:

• ⌽: inverte a entrada
• {... }: passe para esta função:
  • ⍵⊂⍨'#'=⍵: partição em cada uma #na sequência (desde o início, e é por isso que ela teve que ser revertida primeiro)
  • +/¨';'=: conte os ;em cada partição
  • 127|: módulo 127
  • ⌽: inverta novamente
  • '⎕UCS',: precede a sequência ⎕UCS, que é a função Unicode.
  • ⍕: representação de string

Ruby , 47 + 1 = 48 bytes

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

+1 byte para -p.

Experimente online!

-30 bytes graças a @manatwork !

Pitão, 25 23 24 bytes

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

+1 bytes graças a @FryAmTheEggman

Tente!

lida com caracteres que precisam ser escapados usando apenas 1-char-strings.

Saídas de amostra:

jk[\"

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

Usa meu; # 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("}");
}

É um programa completo que (deve) terminar, ignorar comentários e produzir sempre o código de saída correto. Eu assumo EOF = -1

Testado no SystemResque-Cd 4.9.6, compilado com o gcc 4.9.4

braingasm , 40 bytes

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

Tenho que dizer, isso é surpreendentemente curto.

,[                                    ,]     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 `;`

O código gerado para ;é a +, que incrementa a célula atual.

O código gerado para #contém uma operação desagradável e manual do módulo

[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&@

Experimente online!

Substitui basicamente ;por 1+, #por #~1+%@e antecipa a coisa toda por um operador 0monádico porque +está quebrado no momento.

1+ adiciona 1 ao último item da pilha.

#~1+%@empurra o valor de char de ~(126), adiciona 1 para fazer 127, módulo com outro item na pilha e, em seguida, pop e imprime como char.

Explicação

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

Solução:

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

Exemplos:

Observe que the ,é usado para significar uma lista (versus átomo) como "\""é uma lista de um elemento, em vez de ser um átomo.

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

Explicação:

Pegue a string de entrada, remova qualquer coisa que não seja a #ou a ;, divida em listas #, conte o número de elementos em cada lista, execute o mod 127 no resultado e faça a conversão para uma string:

{-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:

• Assume que a entrada é finalizada por a #, caso contrário, o último pedaço será erroneamente descartado pelo -1_.
• Pode ser 10 bytes mais curto se for garantido que a entrada contenha apenas ;#.

Perl 5 , 78 bytes

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

Experimente online!