Relativo a: Crea un; # interprete e Genera; # codice

;# - Una guida a vortice

Questo è un linguaggio semplice con due comandi. La sua unica struttura di dati è un accumulatore, inizializzato su 0.

1. ; Incrementa l'accumulatore

2. #Calcola il valore dell'accumulatore modulo 127 e stampa il corrispondente carattere ASCII. Quindi, ripristinare l'accumulatore su 0.

Il codice sorgente può contenere caratteri aggiuntivi (ASCII + spazi bianchi stampabili), ma questi vengono trattati come commenti e non hanno alcun effetto sull'esecuzione del programma.

Sfida

Poiché la maggior parte dei computer non sono ;#preinstallati, sarebbe molto utile disporre di uno strumento in grado di convertire il ;#codice in un'altra lingua. In questa sfida, dovrai scrivere un programma per raggiungere questo obiettivo.

Ingresso

Qualche ;#codice sorgente, preso tramite argomento o STDIN. Questo codice sorgente può contenere (commentare) caratteri diversi da ;o #.

Produzione

Codice, nella stessa lingua dell'invio, che, una volta eseguito, stampa / restituisce la stessa stringa del ;#codice originale . Questo codice risultante può generare una nuova riga finale dopo la stringa di destinazione, se è più conveniente per la tua lingua.

Gli appunti

Una cosa da cercare sono le sequenze di escape, come il codice che stampa barre rovesciate o stampa virgolette. Cerca anche il ;#codice che potrebbe contenere elementi che sembrano parole chiave o comandi nella tua lingua.

Ulteriori restrizioni

Tutti i programmi devono terminare (normalmente lo considero un valore predefinito, ma qualcuno me l'ha chiesto, quindi lo sto dichiarando qui).

Esempi

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

Python 2 , 76 69 byte

Codice

L'input è racchiuso tra virgolette.

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

Provalo online!

Spiegazione

La prima parte dell'output viene essenzialmente eseguita dall'input, usando input('print'). Dividiamo l'input sugli hashtag e scartiamo l'ultimo elemento. Stampiamo la rappresentazione di ord (y% 127) , dove y è il numero di occorrenze del punto e virgola. Aggiungiamo ,la fine della stampa per assicurarci che ciò non stampi una nuova riga.

Questo darebbe il seguente codice Python per il Hello, World!programma:

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

Che può essere provato online .

Brainfuck , 126 byte

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

Provalo online!

Il programma di output avrà esito negativo nell'implementazione di TIO se l' ;#output supera 65536 caratteri. Ho anche creato una versione a 130 byte che emette [+]invece di <, evitando questo problema:

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

Spiegazione

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

Spazio bianco, 291 byte

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Sostituisci S con spazio, T con scheda e N con una nuova riga.

Generare spazi bianchi in spazi bianchi non è la cosa più efficiente al mondo. La generazione di qualsiasi tipo di codice dinamico richiede una significativa modifica dei bit che, in una lingua senza operazioni bit a bit, causerebbe l'esplosione delle dimensioni del codice. Pertanto, questo programma non tenta di fare qualcosa di intelligente, optando invece solo per tradurre il programma sorgente uno a uno. Si smonta a quanto segue:

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

Il codice generato dal programma è simile a:

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 byte

Bugfix, rotto se non ci fosse #alla fine

Bugfix, implementato mod 127

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

Provalo online!

Prova il codice generato

Spiegazione:

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

In V, nella modalità di inserimento, qualsiasi carattere ASCII può essere inserito per codice usando <C-v><Code>. Il codice V sostituisce tutto #con <C-v>0, dove lo zero è uno pseudo-accumulatore per #. Ognuno #reimposta l'accumulatore su 0, quindi averne uno per ogni lavoro va bene. Quindi il codice fa un incremento per ogni punto e virgola trovato, che incrementa semplicemente il numero successivo che trova, che sarebbe l'accumulatore successivo. La 0è allegato alla fine in modo che l'istruzione non sicuro per ;s senza seguito #.

hexdump:

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

05AB1E , 20 19 18 16 byte

-1 grazie ad Adnan
-2 grazie al carusocomputing
-2 grazie a Kevin Cruijssen

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

Provalo online! (include l'output del codice 05AB1E eseguito)

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

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

Provalo online! (include l'output dell'esecuzione del codice Python traspilato)

Grazie a ovs per molti molti byte!

Spiegazione

Questo programma traspila il #; codice dividendo su #s ( s.split('#')[:-1]), contando il numero di punti e virgola in ogni blocco mod 127 ( x.count(';')%127for x in ...) e convertendolo nel rispettivo carattere ASCII ( chr(...)). Tale elenco viene quindi concatenato ( ''.join(...)), convertito in una rappresentazione Python della stringa (i backtick) e inserito in un programma scheletro Python per la stampa di stringhe ( "print"+...).

Gelatina ,  25 24  16 byte

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

Un programma completo che stampa codice Jelly equivalente (come collegamento monadico restituisce un elenco di elenchi di tipi misti).

Il primo esempio è Provalo online! che produce questo programma .

Come?

Conta la ;s in ogni sequenza tra #s prende ogni modulo 127 e aggiunge un cast all'istruzione ordinale, l' Ọatomo monadico , dopo ciascuno.

Jelly indirizza implicitamente ogni valore su STDOUT mentre scorre un programma del genere, cioè 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọverrebbe stampato 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 riguardante l'input: Jelly prende l'input di stringa in formato Python. Il programma vuota potrà ingresso come "", ei programmi hash sola come "#", "##"ecc Altri manipolazione può essere richiesto per ingresso contenenti backslash e citazioni.

Cubicamente , 138 137 byte

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

Provalo online!

Nota: potrebbe essere necessario sostituirlo &6con ?6&per farlo funzionare su TIO. &6è nelle specifiche della lingua, però.

Come funziona

+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

Programma di uscita:

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 byte

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

Data una stringa di input, elimina tutti i caratteri non necessari, quindi restituisce l'origine della seguente funzione:

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

Dove ...rappresenta la ;#fonte pulita .

C, 98 96 99 98 97 byte

^{+3 byte perché ho dimenticato che C non è interpretato :(}

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

In esecuzione con:

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

Stampa:

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

Gelatina , 26 byte

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

Provalo online!

E prova quel codice Jelly qui!

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

L'output di Jelly diventa simile al codice Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, che stampa chr (13) + chr (10)

PHP, 72 byte

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

> <>, 106 81 77 byte

Questo è il mio primo golf in> <> (pesce)! Una lingua piuttosto interessante che devo dire. Un sacco di divertimento!

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

C # 169 byte

golfed:

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

Versione leggibile dall'uomo:

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 byte

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

Provalo 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)

Brachylog , 33 byte

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

Provalo online!

Mi sento un po 'troppo stanco per spiegarlo in questo momento, se qualcuno lo vede e si chiede come funziona, lascia un commento per ricordarmelo.

MathGolf , 17 byte

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

Provalo online!

Spiegazione

⌡                      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

Poiché qualsiasi carattere può essere messo in pila (e quindi l'output) usando '<char>, questo genererà una sequenza di tali blocchi di codice.

MATL , 32 28 byte

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

Provalo online!

Approccio completamente diverso basato su strsplitun programma piuttosto che su un tipo di automa.

      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.

In realtà , 25 byte

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

Provalo online! (include l'output dall'esecuzione del codice Transpiled Realually)

Spiegazione:

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

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

Fourier, 32 byte

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

Provalo su FourIDE!

Questa è stata una sfida piuttosto semplice poiché Fourier è sostanzialmente un superset di; #:

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

CJam, 14 byte

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

Spiegazione:

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 byte

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

Produzione:

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

Spiegazione:

• ⌽: inverte l'ingresso
• {... }: passalo a questa funzione:
  • ⍵⊂⍨'#'=⍵: partizione a ciascuno #nella stringa (dall'inizio, ecco perché doveva essere prima invertito)
  • +/¨';'=: conta le ;s in ogni partizione
  • 127|: modulo 127
  • ⌽: invertire di nuovo
  • '⎕UCS',: antepone la stringa ⎕UCS, che è la funzione Unicode.
  • ⍕: rappresentazione di stringa

Rubino , 47 + 1 = 48 byte

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

+1 byte per -p.

Provalo online!

-30 byte grazie a @manatwork !

Pyth, 25 23 24 byte

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

+1 byte grazie a @FryAmTheEggman

Provalo!

gestisce i caratteri che devono essere salvati usando solo stringhe di 1 carattere.

Output di esempio:

jk[\"

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

Usa il mio; # interprete .

C, 150 byte

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

Allargato:

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

È un programma completo che (dovrebbe) terminare, ignorare i commenti e produrre sempre un codice di output corretto. Presumo EOF = -1

Testato su SystemResque-Cd 4.9.6, compilato con gcc 4.9.4

Braingasm , 40 byte

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

Devo dire che è sorprendentemente breve.

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

Il codice generato per ;è a +, che incrementa la cella corrente.

Il codice generato per #contiene un'operazione di modulo manuale akward

[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 byte

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

Provalo online!

Sostanzialmente sostituisce ;con 1+, #con #~1+%@e anticipa il tutto con un operatore 0monadico +ora rotto.

1+ aggiunge 1 all'ultimo oggetto nello stack.

#~1+%@spinge il valore char ~(126), aggiunge 1 per creare 127, modulo con un altro oggetto in pila, quindi pop e stampa come char.

Spiegazione

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 byte

Soluzione:

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

Esempi:

Si noti che ,viene utilizzato per indicare un elenco (rispetto all'atomo) come "\""è un elenco di un elemento, anziché essere un atomo.

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

Spiegazione:

Prendi la stringa di input, rimuovi tutto ciò che non è #ao ;, diviso in liste su #, conta il numero di elementi in ogni lista, esegui la mod 127 sul risultato e lancia su una stringa:

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

Gli appunti:

• Presuppone che l'input sia terminato da a #, altrimenti l'ultimo pezzo verrà erroneamente lasciato cadere da-1_ .
• Potrebbe essere più breve di 10 byte se l'input fosse garantito solo per contenere ;#.

Perl 5 , 78 byte

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

Provalo online!