Lié à: créer un interpréteur; # et générer; # code

;# - Un guide tourbillon

Il s'agit d'un langage simple avec deux commandes. Sa seule structure de données est un accumulateur, qui est initialisé à 0.

1. ; Incrémenter l'accumulateur

2. #Calculez la valeur de l'accumulateur modulo 127 et imprimez le caractère ASCII correspondant. Ensuite, réinitialisez l'accumulateur à 0.

Le code source peut contenir des caractères supplémentaires (ASCII imprimable + espaces blancs), mais ceux-ci sont traités comme des commentaires et n'ont aucun effet sur l'exécution du programme.

Défi

Étant donné que la plupart des ordinateurs ne sont pas livrés avec ;#préinstallés, il serait très utile d'avoir un outil qui peut convertir le ;#code dans une langue différente. Dans ce défi, vous écrirez un programme pour y parvenir.

Contribution

Certains ;#code source, pris par argument ou STDIN. Ce code source peut contenir (commenter) des caractères autres que ;ou #.

Sortie

Code, dans la même langue que votre soumission, qui, une fois exécuté, imprime / renvoie la même chaîne que le ;#code d' origine . Ce code résultant peut générer un retour à la ligne après la chaîne cible, si cela convient mieux à votre langue.

Remarques

Une chose à surveiller est les séquences d'échappement, telles que le code qui imprime les barres obliques inverses ou les guillemets. Recherchez également le ;#code qui pourrait contenir des éléments qui ressemblent à des mots clés ou des commandes dans votre langue.

Restrictions supplémentaires

Tous les programmes doivent se terminer (je considère normalement cela comme un défaut, mais quelqu'un a posé une question à ce sujet, donc je le dis ici).

Exemples

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

Python 2 , 76 69 octets

Code

L'entrée est entourée de guillemets.

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

Essayez-le en ligne!

Explication

La première partie de la sortie se fait essentiellement par l'entrée, en utilisant input('print'). Nous divisons l'entrée sur les hashtags et éliminons le dernier élément. Nous imprimons la représentation de ord (y% 127) , où y est le nombre d'occurrences du point-virgule. Nous ajoutons le ,à la fin de l'impression pour nous assurer que cela n'imprime pas une nouvelle ligne.

Cela donnerait le code Python suivant pour le Hello, World!programme:

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

Qui peut être essayé en ligne .

brainfuck , 126 octets

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

Essayez-le en ligne!

Le programme de sortie échouera dans l'implémentation TIO si la ;#sortie dépasse 65 536 caractères. J'ai également fait une version de 130 octets qui sort [+]au lieu de <, en évitant ce problème:

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

Explication

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

Espace, 291 octets

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Remplacez S par un espace, T par une tabulation et N par une nouvelle ligne.

Générer des espaces blancs dans des espaces blancs n'est pas la chose la plus efficace au monde. La génération de tout type de code dynamique nécessite un twittage de bits important qui, dans un langage sans opérations au niveau du bit, ferait exploser la taille du code. Par conséquent, ce programme n'essaie pas de faire quelque chose d'intelligent, optant plutôt pour simplement traduire le programme source un à un. Il se démonte comme suit:

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

Le code généré par le programme ressemble à:

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 octets

Bugfix, cassé s'il n'y avait pas #à la fin

Bugfix, implémenté mod 127

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

Essayez-le en ligne!

Essayez le code généré

Explication:

Í;û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 mode insertion, tout caractère ASCII peut être inséré par code à l'aide de <C-v><Code>. Le code V remplace tout #par <C-v>0, où le zéro est un pseudo-accumulateur par #. Chacun #remet l'accumulateur à 0, donc en avoir un par fonctionne bien. Ensuite, le code effectue un incrément pour chaque point-virgule trouvé, qui incrémente simplement le nombre suivant qu'il trouve, qui serait le prochain accumulateur. Le 0est ajouté à la fin afin que l'instruction n'échoue pas pour ;s sans un suivi #.

Hexdump:

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

05AB1E , 20 19 18 16 octets

-1 grâce à Adnan
-2 grâce à carusocomputing
-2 grâce à Kevin Cruijssen

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

Essayez-le en ligne! (inclut la sortie du code 05AB1E exécuté)

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

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

Essayez-le en ligne! (inclut la sortie de l'exécution du code Python transpilé)

Merci aux ovs pour de nombreux octets!

Explication

Ce programme transpile le #; code en divisant sur #s ( s.split('#')[:-1]), en comptant le nombre de points-virgules dans chaque module 127 ( x.count(';')%127for x in ...) et en le convertissant en caractère ASCII respectif ( chr(...)). Cette liste est ensuite concaténée ( ''.join(...)), convertie en une représentation Python de la chaîne (les backticks) et insérée dans un programme Python squelette pour imprimer des chaînes ( "print"+...).

Gelée ,  25 24  16 octets

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

Un programme complet d'impression de code Jelly équivalent (en tant que lien monadique, il renvoie une liste de listes de types mixtes).

Le premier exemple est à essayer en ligne! qui donne ce programme .

Comment?

Compte le ;s dans chaque passage entre #s prend chaque module 127 et ajoute un cast à l'instruction ordinale, l' Ọatome monadique , après chaque.

Jelly dirige implicitement chaque valeur vers STDOUT lors de son exécution dans un programme comme celui- 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọci, c'est-à-dire qui s'imprimerait 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Ọ...)

Une note concernant l'entrée: Jelly prend l'entrée de chaîne au format Python. Le programme vide pourrait être entrée comme "", et les programmes de hachage uniquement comme "#", "##", etc. D' autres manipulations peuvent être requis pour une entrée contenant antislashs et des citations.

Cubiquement , 138 137 octets

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

Essayez-le en ligne!

Remarque: vous devrez peut-être le remplacer &6par ?6&pour qu'il fonctionne sur TIO. &6est dans la spécification de langue, cependant.

Comment ça marche

+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

Programme de sortie:

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 octets

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

Étant donné une chaîne d'entrée, supprime tous les caractères inutiles, puis retourne la source de la fonction suivante:

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

Où ...représente la ;#source nettoyée .

C, 98 96 99 98 97 octets

^{+3 octets car j'ai oublié que C n'est pas interprété :(}

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

Courir avec:

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

Imprime:

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

Gelée , 26 octets

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

Essayez-le en ligne!

Et essayez ce code Jelly ici!

ṣ”#Ç€ṙ-      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 sortie Jelly devient du code Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, qui imprime chr (13) + chr (10)

PHP, 72 octets

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

> <>, 106 81 77 octets

Ceci est mon premier golf à> <> (poisson)! Une langue assez intéressante que je dois dire. Beaucoup de plaisir!

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

C # 169 octets

Golfé:

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

Version lisible par l'homme:

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 octets

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

Essayez-le en ligne!

Non 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 octets

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

Essayez-le en ligne!

Je me sens un peu trop fatigué pour expliquer cela pour le moment, si quelqu'un le voit et se demande comment cela fonctionne, laissez un commentaire pour me le rappeler.

MathGolf , 17 octets

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

Essayez-le en ligne!

Explication

⌡                      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

Étant donné que n'importe quel caractère peut être placé sur la pile (et donc la sortie) en utilisant '<char>, cela produira une séquence de ces blocs de code.

MATL , 32 28 octets

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

Essayez-le en ligne!

Approche complètement différente basée sur un programme strsplitplutôt que sur un programme de type automate.

      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 fait , 25 octets

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

Essayez-le en ligne! (inclut la sortie de l'exécution du code transpilé Actually)

Explication:

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

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

Fourier, 32 octets

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

Essayez-le sur FourIDE!

Ce fut un défi assez facile car Fourier est essentiellement un surensemble de; #:

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

CJam, 14 octets

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

Explication:

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 octets

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

Sortie:

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

Explication:

• ⌽: inverser l'entrée
• {... }: passez-le à cette fonction:
  • ⍵⊂⍨'#'=⍵: partition à chacun #dans la chaîne (depuis le début, c'est pourquoi il fallait d'abord l'inverser)
  • +/¨';'=: compter les ;s dans chaque partition
  • 127|: modulo 127
  • ⌽: inverser à nouveau
  • '⎕UCS',: ajoute la chaîne ⎕UCS, qui est la fonction Unicode.
  • ⍕: représentation de chaîne

Ruby , 47 + 1 = 48 octets

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

+1 octet pour -p.

Essayez-le en ligne!

-30 octets grâce à @manatwork !

Pyth, 25 23 24 octets

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

+1 octets grâce à @FryAmTheEggman

Essayez!

gère les caractères qui doivent être échappés en utilisant uniquement des chaînes de 1 caractère.

Exemples de sorties:

jk[\"

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

Utilise mon; # interprète .

C, 150 octets

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

Étendu:

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

C'est un programme complet qui (devrait) se terminer, ignorer les commentaires et produire un code de sortie toujours correct. Je suppose que EOF = -1

Testé sur SystemResque-Cd 4.9.6, compilé avec gcc 4.9.4

braingasme , 40 octets

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

Je dois dire que c'est étonnamment court.

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

Le code généré pour ;est un+ , qui incrémente la cellule actuelle.

Le code généré pour #contient une opération modulo manuelle 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 octets

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

Essayez-le en ligne!

Remplace fondamentalement ;par 1+, #avec #~1+%@et précède le tout avec un 0parce que monadique+ opérateur est rompu en ce moment.

1+ ajoute 1 au dernier élément de la pile.

#~1+%@ pousse la valeur char de ~ (126), ajoute 1 pour faire 127, module avec un autre élément sur la pile, puis pop et imprimez en tant que char.

Explication

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 octets

Solution:

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

Exemples:

Notez que le ,est utilisé pour signifier une liste (par rapport à l'atome) comme l' "\""est une liste d'un élément, plutôt que d'être un atome.

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

Explication:

Prenez la chaîne d'entrée, supprimez tout ce qui n'est pas un #ou un ;, divisé en listes #, comptez le nombre d'éléments dans chaque liste, effectuez le mod 127 sur le résultat et convertissez-le en une chaîne:

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

Remarques:

• Suppose que l'entrée est terminée par un #, sinon le dernier morceau sera supprimé par erreur par le -1_.
• Peut être 10 octets plus court si l'entrée ne contient que la garantie ;#.

Perl 5 , 78 octets

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

Essayez-le en ligne!