Verwandt mit: Erstellen Sie einen; # -Interpreter und generieren Sie; # -Code

;# - Ein Wirbelwindführer

Dies ist eine einfache Sprache mit zwei Befehlen. Die einzige Datenstruktur ist ein Akkumulator, der mit 0 initialisiert wird.

1. ; Erhöhen Sie den Akku

2. #Berechnen Sie den Wert des Akkumulators modulo 127 und geben Sie das entsprechende ASCII-Zeichen aus. Setzen Sie dann den Akku auf 0 zurück.

Der Quellcode kann zusätzliche Zeichen enthalten (druckbares ASCII + Leerzeichen), diese werden jedoch als Kommentare behandelt und haben keine Auswirkungen auf die Programmausführung.

Herausforderung

Da die meisten Computer nicht ;#vorinstalliert sind, wäre es sehr nützlich, ein Tool zu haben, das ;#Code in eine andere Sprache konvertieren kann. In dieser Herausforderung schreiben Sie ein Programm, um dies zu erreichen.

Eingang

Einige ;#Quellcodes, die über Argument oder STDIN aufgenommen wurden. Dieser Quellcode kann andere (Kommentar-) Zeichen als ;oder enthalten #.

Ausgabe

Code in derselben Sprache wie Ihre Einreichung, der bei Ausführung dieselbe Zeichenfolge wie der ursprüngliche ;#Code ausgibt / zurückgibt . Dieser resultierende Code gibt möglicherweise nach der Zielzeichenfolge eine abschließende neue Zeile aus, wenn dies für Ihre Sprache praktischer ist.

Anmerkungen

Achten Sie auf Escape-Sequenzen, z. B. auf Code, der Backslashes oder Anführungszeichen druckt. Achten Sie auch auf ;#Code, der Dinge enthalten kann, die wie Schlüsselwörter oder Befehle in Ihrer Sprache aussehen.

Zusätzliche Einschränkungen

Alle Programme müssen beendet werden (ich betrachte dies normalerweise als Standard, aber jemand hat danach gefragt, also gebe ich es hier an).

Beispiele

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

Python 2 , 76 69 Bytes

Code

Die Eingabe ist von Anführungszeichen umgeben.

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

Probieren Sie es online!

Erläuterung

Der erste Teil der Ausgabe erfolgt im Wesentlichen über die Eingabe mit input('print'). Wir teilen die Eingabe in Hashtags und verwerfen das letzte Element. Wir drucken die Darstellung von ord (y% 127) , wobei y die Anzahl der Vorkommen des Semikolons ist. Wir hängen das ,am Ende des Ausdrucks an, um sicherzustellen, dass dabei keine neue Zeile gedruckt wird.

Dies würde den folgenden Python-Code für das Hello, World!-Programm ergeben:

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

Welches kann online ausprobiert werden .

Brainfuck , 126 Bytes

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

Probieren Sie es online!

Das Ausgabeprogramm schlägt in der TIO-Implementierung fehl, wenn die ;#Ausgabe 65536 Zeichen überschreitet. Ich habe auch eine 130-Byte-Version erstellt, die [+]anstelle von ausgibt <, um dieses Problem zu vermeiden:

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

Erläuterung

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

Leerzeichen, 291 Bytes

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Ersetzen Sie S durch Leerzeichen, T durch Tabulator und N durch eine neue Zeile.

Das Generieren von Leerzeichen in Leerzeichen ist nicht die effizienteste Sache der Welt. Das Generieren jeglicher Art von dynamischem Code erfordert signifikantes Bit-Twiddling, was in einer Sprache ohne bitweise Operationen dazu führen würde, dass die Codegröße explodiert. Daher versucht dieses Programm nicht, etwas Kluges zu tun, sondern setzt stattdessen darauf, nur das Quellprogramm eins zu eins zu übersetzen. Es lässt sich wie folgt zerlegen:

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

Der vom Programm generierte Code sieht folgendermaßen aus:

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, kaputt wenn es #am Ende keine gab

Bugfix, implementiert mod 127

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

Probieren Sie es online!

Versuchen Sie es mit generiertem Code

Erläuterung:

Í;û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 kann im Einfügemodus ein beliebiges ASCII-Zeichen mithilfe von Code eingefügt werden <C-v><Code>. Der V-Code ersetzt alle #mit <C-v>0, wobei die Null ein Pseudo-Akkumulator per ist #. Jedes #setzt den Akku auf 0 zurück, so dass ein Akku pro Akku in Ordnung ist. Dann führt der Code für jedes gefundene Semikolon ein Inkrement durch, das nur die nächste gefundene Zahl inkrementiert, die der nächste Akkumulator wäre. Das 0wird an das Ende angehängt, damit die Anweisung für ;s ohne Folgendes nicht fehlschlägt #.

Hexdump:

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

05AB1E , 20 19 18 16 Bytes

-1 dank Adnan
-2 dank carusocomputing
-2 dank Kevin Cruijssen

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

Probieren Sie es online! (Enthält die Ausgabe des ausgeführten 05AB1E-Codes)

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

Probieren Sie es online! (Enthält die Ausgabe von der Ausführung des transpilierten Python-Codes)

Danke an ovs für viele, viele Bytes!

Erläuterung

Dieses Programm übersetzt die #; Code durch Teilen von #s ( s.split('#')[:-1]), Zählen der Anzahl der Semikolons in jedem Chunk-Mod 127 ( x.count(';')%127for x in ...) und Konvertieren dieser in das entsprechende ASCII-Zeichen ( chr(...)). Diese Liste wird dann verkettet ( ''.join(...)), in eine Python-Darstellung des Strings (der Backticks) konvertiert und in ein Python-Programm zum Drucken von Strings ( "print"+...) eingefügt .

Jelly ,  25 24  16 Bytes

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

Ein vollständiges Programm, das den entsprechenden Jelly-Code druckt (als monadischer Link gibt es eine Liste mit Listen gemischter Typen zurück).

Das erste Beispiel finden Sie unter Online testen! was ergibt dieses Programm .

Wie?

Zählt das ;s in jedem Lauf zwischen #s und nimmt jedes Modulo 127 und fügt Ọnach jedem einen Cast zur Ordinalanweisung, dem monadischen Atom, hinzu.

Jelly leitet implizit jeden Wert an STDOUT weiter, während es ein solches Programm durchläuft, dh 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọdruckt 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Ọ...)

Ein Hinweis zur Eingabe: Jelly nimmt Zeichenketteneingaben im Python-Format entgegen. Das leere Programm könnte eingegeben werden , wie "", und die Hash-only - Programme wie "#", "##"usw. Andere Manipulationen können für die Eingabe enthält , Schrägstriche und Anführungszeichen erforderlich.

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

Probieren Sie es online!

Hinweis: Sie können ersetzen müssen &6mit ?6&für sie auf TIO zu arbeiten. &6ist jedoch in der Sprachspezifikation.

Wie es funktioniert

+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

Ausgabeprogramm:

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

Löscht bei einer gegebenen Eingabezeichenfolge alle unnötigen Zeichen und gibt dann die Quelle der folgenden Funktion zurück:

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

Wo ...steht die gereinigte ;#Quelle ?

C 98 96 99 98 97 Bytes

^{+3 Bytes, weil ich vergessen habe, dass C nicht interpretiert wird :(}

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

Laufen mit:

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

Druckt:

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

Gelee , 26 Bytes

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

Probieren Sie es online!

Und versuchen Sie diesen Jelly-Code hier!

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

Die Jelly-Ausgabe wird zu einem Code Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, der chr (13) + chr (10) ausgibt.

PHP, 72 Bytes

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

> <> 106 81 77 Bytes

Dies ist mein erstes Golfspiel in> <> (Fisch)! Eine ziemlich interessante Sprache muss ich sagen. Viel Spaß!

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

C # 169 Bytes

Golf gespielt:

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

Vom Menschen lesbare Version:

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

Probieren Sie es 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 Bytes

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

Probieren Sie es online!

Fühlen Sie sich ein bisschen zu müde, um dies im Moment zu erklären, wenn jemand dies sieht und sich fragt, wie es funktioniert, schreiben Sie einen Kommentar, um mich daran zu erinnern.

MathGolf , 17 Bytes

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

Probieren Sie es online!

Erläuterung

⌡                      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

Da jedes Zeichen mit auf den Stapel (und damit auf die Ausgabe) gelegt werden kann '<char>, wird eine Folge solcher Codeblöcke ausgegeben.

MATL , 32 28 Bytes

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

Probieren Sie es online!

Ein völlig anderer Ansatz strsplitals ein automatisches Programm.

      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.

Eigentlich 25 Bytes

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

Probieren Sie es online! (Beinhaltet die Ausgabe des transpilierten Actually-Codes)

Erläuterung:

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

Probieren Sie es auf FourIDE!

Dies war eine recht einfache Herausforderung, da Fourier im Grunde eine Obermenge von; # ist:

;# 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`

Erläuterung:

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

Ausgabe:

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

Erläuterung:

• ⌽: kehrt die Eingabe um
• {... }: übergebe es an diese Funktion:
  • ⍵⊂⍨'#'=⍵: Partition bei jedem # in der Zeichenkette (von Anfang an, weshalb es zuerst umgekehrt werden musste)
  • +/¨';'=: Zähle die ;s in jeder Partition
  • 127|: modulo 127
  • ⌽: wieder umkehren
  • '⎕UCS',: Stellen Sie den String voran ⎕UCS, bei dem es sich um die Unicode-Funktion handelt.
  • ⍕: String-Darstellung

Ruby , 47 + 1 = 48 Bytes

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

+1 Byte für -p.

Probieren Sie es online!

-30 Bytes dank @manatwork !

Pyth, 25 23 24 Bytes

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

+1 Bytes dank @FryAmTheEggman

Versuch es!

behandelt Zeichen, die nur mit 1-Zeichen-Zeichenfolgen maskiert werden müssen.

Beispielausgaben:

jk[\"

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

Benutzt meinen; # Interpreter .

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

Erweitert:

#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 ist ein komplettes Programm, das Kommentare (beenden), ignorieren und immer korrekten Ausgabecode erzeugen soll. Ich gehe von EOF = -1 aus

Getestet auf SystemResque-Cd 4.9.6, kompiliert mit gcc 4.9.4

Braingasmus , 40 Bytes

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

Ich muss sagen, das ist überraschend kurz.

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

Der generierte Code für ;ist a +, der die aktuelle Zelle inkrementiert.

Der generierte Code für #enthält eine akward, manuelle Modulo-Operation

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

Probieren Sie es online!

Ersetzt im Grunde genommen ;mit 1+, #with #~1+%@und stellt das Ganze mit a voran, 0weil der monadische +Operator gerade gebrochen ist.

1+ Fügt dem letzten Element im Stapel 1 hinzu.

#~1+%@Drückt den Zeichenwert von ~(126), addiert 1, um 127, Modul mit einem anderen Element auf dem Stapel zu bilden, und druckt dann als Zeichen.

Erläuterung

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

Lösung:

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

Beispiele:

Beachten Sie, dass das ,Symbol verwendet wird, um eine Liste (gegenüber einem Atom) als "\""eine Liste eines Elements zu kennzeichnen , anstatt ein Atom zu sein.

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

Erläuterung:

Nimm die Eingabezeichenfolge, entferne alles, was nicht a #oder a ;ist , teile sie in Listen auf #, zähle die Anzahl der Elemente in jeder Liste, führe Mod 127 für das Ergebnis aus und gib sie in eine Zeichenfolge um:

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

Anmerkungen:

• Es wird davon ausgegangen, dass die Eingabe mit einem abgeschlossen wird #, da sonst der letzte Block irrtümlicherweise von der gelöscht wird -1_.
• Könnte 10 Byte kürzer sein, wenn die Eingabe garantiert nur enthalten würde ;#.

Perl 5 , 78 Bytes

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

Probieren Sie es online!