Związane z: Make a; # interpreter and Generate; # code

;# - Przewodnik Whirlwind

Jest to prosty język z dwoma poleceniami. Jego jedyną strukturą danych jest akumulator, który jest inicjowany na 0.

1. ; Zwiększyć akumulator

2. #Oblicz wartość modułu 127 akumulatora i wydrukuj odpowiedni znak ASCII. Następnie zresetuj akumulator do 0.

Kod źródłowy może zawierać dodatkowe znaki (drukowalne ASCII + białe znaki), ale są one traktowane jako komentarze i nie mają wpływu na wykonanie programu.

Wyzwanie

Ponieważ większość komputerów nie jest ;#fabrycznie zainstalowana, bardzo przydatne byłoby posiadanie narzędzia do konwersji ;#kodu na inny język. W tym wyzwaniu napiszesz program, aby to osiągnąć.

Wkład

Trochę ;#kodu źródłowego pobranego przez argument lub STDIN. Ten kod źródłowy może zawierać (komentarz) znaki inne niż ;lub #.

Wydajność

Kod w tym samym języku, co przesłanie, który po uruchomieniu drukuje / zwraca ten sam ciąg znaków, co oryginalny ;#kod. Ten wynikowy kod może wyświetlać końcowy znak nowej linii po ciągu docelowym, jeśli jest to wygodniejsze dla twojego języka.

Notatki

Należy zwrócić uwagę na sekwencje specjalne, takie jak kod drukujący odwrotne ukośniki lub znaki cudzysłowu. Uważaj również na ;#kod, który może zawierać rzeczy, które wyglądają jak słowa kluczowe lub polecenia w twoim języku.

Dodatkowe ograniczenia

Wszystkie programy muszą zostać zakończone (zwykle uważam to za domyślne, ale ktoś o to zapytał, więc tutaj to stwierdzam).

Przykłady

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

Python 2 , 76 69 bajtów

Kod

Dane wejściowe są otoczone cudzysłowami.

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

Wypróbuj online!

Wyjaśnienie

Pierwsza część danych wyjściowych jest zasadniczo wykonywana przez dane wejściowe przy użyciu input('print'). Podzieliliśmy dane wejściowe na hashtagi i odrzucamy ostatni element. Drukujemy reprezentację ord (y% 127) , gdzie y jest liczbą wystąpień średnika. Dołączamy ,na końcu wydruku, aby upewnić się, że nie zostanie wydrukowany nowy wiersz.

Dałoby to następujący kod Python dla Hello, World!-programu:

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

Które można wypróbować online .

pieprzenie mózgu , 126 bajtów

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

Wypróbuj online!

Program wyjściowy zawiedzie w implementacji TIO, jeśli wynik ;#wyjściowy przekroczy 65536 znaków. Zrobiłem również 130-bajtową wersję, która wyświetla [+]zamiast <, unikając tego problemu:

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

Wyjaśnienie

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

Biała spacja, 291 bajtów

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Zamień S na spację, T na tab, a N na nową linię.

Generowanie białych znaków w białych znakach nie jest najbardziej wydajną rzeczą na świecie. Generowanie dowolnego rodzaju kodu dynamicznego wymaga znacznego kręcenia bitów, co w języku bez operacji bitowych spowodowałoby eksplozję rozmiaru kodu. Dlatego ten program nie próbuje zrobić czegoś mądrego, zamiast tego po prostu tłumaczy program źródłowy jeden na jednego. Rozkłada się na następujące:

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

Kod generowany przez program wygląda następująco:

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 bajtów

Bugfix, zepsuł się, jeśli #na końcu nie było

Zaimplementowano poprawkę mod 127

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

Wypróbuj online!

Spróbuj wygenerować kod

Wyjaśnienie:

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

W V, w trybie wstawiania, dowolny znak ASCII można wstawić kodem za pomocą <C-v><Code>. Kod V zastępuje wszystkie #z <C-v>0, przy czym zero pseudo-akumulator przypadający #. Każdy #resetuje akumulatora do 0 więc mając jeden na odrabia grzywny. Następnie kod wykonuje inkrementację dla każdego znalezionego średnika, co tylko inkrementuje kolejną znalezioną liczbę, która byłaby kolejnym akumulatorem. 0Dołączany jest do końca tak, że dyspozycja nie zawieść do ;s bez dalszej #.

Hexdump:

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

05AB1E , 20 19 18 16 bajtów

-1 dzięki Adnan
-2 dzięki carusocomputing
-2 dzięki Kevin Cruijssen

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

Wypróbuj online! (obejmuje dane wyjściowe wykonanego kodu 05AB1E)

'#¡              # 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 bajtów

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

Wypróbuj online! (obejmuje dane wyjściowe z wykonania transpilowanego kodu Python)

Dzięki ovs dla wielu wielu bajtów!

Wyjaśnienie

Ten program transponuje #; kod dzieląc na #s ( s.split('#')[:-1]), licząc liczbę średników w każdej porcji mod 127 ( x.count(';')%127for x in ...) i konwertując ją na odpowiedni znak ASCII ( chr(...)). Ta lista jest następnie konkatenowana ( ''.join(...)), konwertowana na reprezentację łańcucha znaków w Pythonie (backticks) i wstawiana do szkieletowego programu Python do drukowania łańcuchów ( "print"+...).

Galaretka ,  25 24  16 bajtów

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

Pełny program drukujący ekwiwalent kodu Jelly (jako monadyczny link zwraca listę list typów mieszanych).

Pierwszy przykład to wypróbuj online! co daje ten program .

W jaki sposób?

Zlicza ;s w każdym przebiegu między #s bierze każdy moduł 127 i dołącza rzut do instrukcji porządkowej, Ọatomu monadycznego , po każdym.

Galaretka niejawnie przesyła każdą wartość do STDOUT, ponieważ jest uruchamiana przez taki program, tj . 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33ỌDrukuje się 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Ọ...)

Uwaga dotycząca wprowadzania: Jelly pobiera ciąg znaków w formacie Python. Pusty program może być wprowadzona jako ""i programy hash tylko jak "#", "##"itp Inne manipulacja może być wymagane dla wejściowych zawierających ukośniki i cytatów.

Kubiczną , 138 137 bajtów

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

Wypróbuj online!

Uwaga: Być może trzeba wymienić &6z ?6&go do pracy na TIO. &6jest jednak w specyfikacji językowej.

Jak to działa

+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

Program wyjściowy:

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 bajtów

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

Podany ciąg wejściowy usuwa wszystkie niepotrzebne znaki, a następnie zwraca źródło następującej funkcji:

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

Gdzie ...reprezentuje oczyszczone ;#źródło.

C, 98 96 99 98 97 bajtów

^{+3 bajty, ponieważ zapomniałem, że C nie jest interpretowane :(}

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

Działa z:

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

Wydrukuje:

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

Galaretka , 26 bajtów

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

Wypróbuj online!

I wypróbuj ten kod Jelly tutaj!

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

Wyjście Jelly staje się kodem Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, który wypisuje chr (13) + chr (10)

PHP, 72 bajty

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

> <>, 106 81 77 bajtów

To jest mój pierwszy golf w> <> (ryba)! Całkiem interesujący język muszę powiedzieć. Dużo zabawy!

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

C # 169 bajtów

Gra w golfa:

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

Wersja czytelna dla człowieka:

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 bajtów

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

Wypróbuj online!

Nie golfił

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 bajty

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

Wypróbuj online!

Czuję się trochę zbyt zmęczony, aby to wyjaśnić, jeśli ktoś to zobaczy i zastanowi się, jak to działa, zostaw komentarz, aby mi przypomnieć.

MathGolf , 17 bajtów

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

Wypróbuj online!

Wyjaśnienie

⌡                      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

Ponieważ dowolny znak można umieścić na stosie (a tym samym na wyjściu) za pomocą '<char>, spowoduje to wygenerowanie sekwencji takich bloków kodu.

MATL , 32 28 bajtów

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

Wypróbuj online!

Zupełnie inne podejście oparte na strsplitprogramie automatycznym niż na programie.

      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.

Właściwie 25 bajtów

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

Wypróbuj online!(obejmuje dane wyjściowe z wykonania transponowanego kodu faktycznie)

Wyjaśnienie:

'#@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 bajtów

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

Fourier, 32 bajty

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

Wypróbuj na FourIDE!

Było to dość łatwe wyzwanie, ponieważ Fourier jest w zasadzie nadzbiorem; #:

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

CJam, 14 bajtów

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

Wyjaśnienie:

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 bajtów

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

Wydajność:

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

Wyjaśnienie:

• ⌽: odwróć wejście
• {... }: przekaż to do tej funkcji:
  • ⍵⊂⍨'#'=⍵: podział na każdy #w ciągu (od początku, dlatego najpierw trzeba było go odwrócić)
  • +/¨';'=: policz ;s w każdej partycji
  • 127|: modulo 127
  • ⌽: odwróć to jeszcze raz
  • '⎕UCS',: dodaj ciąg ⎕UCS, który jest funkcją Unicode.
  • ⍕: reprezentacja ciągu

Rubinowy , 47 + 1 = 48 bajtów

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

+1 bajt dla -p.

Wypróbuj online!

-30 bajtów dzięki @manatwork !

Pyth, 25 23 24 bajtów

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

+1 bajtów dzięki @FryAmTheEggman

Spróbuj!

radzi sobie ze znakami, które muszą być poprzedzane znakami 1-znakowymi.

Przykładowe wyniki:

jk[\"

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

Korzysta z mojego; # tłumacza .

C, 150 bajtów

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

Rozszerzony:

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

Jest to kompletny program, który (powinien) zakończyć, zignorować komentarze i zawsze generować poprawny kod wyjściowy. Zakładam EOF = -1

Testowany na SystemResque-Cd 4.9.6, skompilowany z gcc 4.9.4

braingasm , 40 bajtów

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

Muszę powiedzieć, że to zaskakująco krótko.

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

Wygenerowany kod dla ; to+ , który zwiększa bieżącą komórkę.

Wygenerowany kod #zawiera działającą, ręczną operację modulo

[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 bajtów

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

Wypróbuj online!

Zasadniczo zastępuje ;się 1+, #ze #~1+%@i pre-pends całość z 0ponieważ monadycznego+ operatora jest zepsuty teraz.

1+ dodaje 1 do ostatniego elementu na stosie.

#~1+%@ przesuwa wartość char ~ (126), dodaje 1, aby uzyskać 127, moduł z innym przedmiotem na stosie, a następnie pop i drukuj jako char.

Wyjaśnienie

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 bajty

Rozwiązanie:

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

Przykłady:

Zauważ, że ,używa się go do oznaczenia listy (w przeciwieństwie do atomu), podobnie jak "\""listy jednego elementu, a nie atomu.

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

Wyjaśnienie:

Weź ciąg wejściowy, usuń wszystko, co nie jest a #lub a ;, podziel na listy #, policz liczbę elementów na każdej liście, wykonaj mod 127 na wyniku i rzutuj na ciąg:

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

Uwagi:

• Zakłada, że ​​wejście jest zakończone przez a #, w przeciwnym razie ostatnia porcja zostanie błędnie usunięta przez -1_.
• Może być o 10 bajtów krótszy, jeśli gwarantowane jest, że dane wejściowe zawierają tylko ;#.

Perl 5 , 78 bajtów

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

Wypróbuj online!