Terkait dengan: Buat kode ; # interpreter dan Generate; #

;# - Panduan Whirlwind

Ini adalah bahasa yang sederhana dengan dua perintah. Satu-satunya struktur data adalah akumulator, yang diinisialisasi ke 0.

1. ; Tambahkan akumulator

2. #Hitung nilai akumulator modulo 127, dan cetak karakter ASCII yang sesuai. Kemudian, setel ulang akumulator ke 0.

Kode sumber dapat berisi karakter tambahan (printable ASCII + whitespace), tetapi ini diperlakukan sebagai komentar dan tidak berpengaruh pada eksekusi program.

Tantangan

Karena sebagian besar komputer tidak dilengkapi dengan ;#pra - instal, akan sangat berguna untuk memiliki alat yang dapat mengubah ;#kode menjadi bahasa yang berbeda. Dalam tantangan ini, Anda harus menulis sebuah program untuk mencapai ini.

Memasukkan

Beberapa ;#kode sumber, diambil melalui argumen atau STDIN. Kode sumber ini dapat berisi (komentar) karakter selain ;atau #.

Keluaran

Kode, dalam bahasa yang sama dengan kiriman Anda, yang, ketika dieksekusi, mencetak / mengembalikan string yang sama dengan ;#kode aslinya . Kode yang dihasilkan ini dapat menampilkan baris tambahan setelah string target, jika itu lebih nyaman untuk bahasa Anda.

Catatan

Satu hal yang perlu diwaspadai adalah urutan melarikan diri, seperti kode yang mencetak garis miring terbalik atau mencetak tanda kutip. Cari juga ;#kode yang bisa berisi hal-hal yang terlihat seperti kata kunci atau perintah dalam bahasa Anda.

Batasan tambahan

Semua program harus diakhiri (Saya biasanya menganggap ini sebagai default, tetapi seseorang bertanya tentang hal itu jadi saya menyatakannya di sini).

Contohnya

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

Python 2 , 76 69 byte

Kode

Input dikelilingi oleh tanda kutip.

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

Cobalah online!

Penjelasan

Bagian pertama dari output pada dasarnya dilakukan oleh input, menggunakan input('print'). Kami membagi input pada tagar dan membuang elemen terakhir. Kami mencetak representasi ord (y% 127) , di mana y adalah jumlah kemunculan titik koma. Kami menambahkan ,di akhir cetakan untuk memastikan ini tidak mencetak baris baru.

Ini akan memberikan kode Python berikut untuk Hello, World!-program:

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

Yang bisa dicoba online .

brainfuck , 126 byte

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

Cobalah online!

Program output akan gagal dalam implementasi TIO jika ;#output melebihi 65536 karakter. Saya juga membuat versi 130-byte yang menghasilkan [+]bukan <, menghindari masalah ini:

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

Penjelasan

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

Spasi, 291 byte

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Ganti S dengan spasi, T oleh tab dan N dengan baris baru.

Menghasilkan spasi putih di ruang putih bukanlah hal yang paling efisien di dunia. Menghasilkan segala jenis kode dinamis memerlukan sedikit-twiddling signifikan yang, dalam bahasa tanpa operasi bitwise, akan menyebabkan ukuran kode meledak. Oleh karena itu, program ini tidak berusaha melakukan sesuatu yang cerdas, melainkan memilih hanya menerjemahkan program sumber satu ke satu. Itu membongkar sebagai berikut:

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

Kode yang dihasilkan oleh program terlihat seperti:

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

Perbaikan bug, rusak jika tidak ada #di akhir

Perbaikan bug, diterapkan mod 127

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

Cobalah online!

Coba Kode Generated

Penjelasan:

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

Dalam V, dalam mode penyisipan, karakter ASCII apa pun dapat dimasukkan dengan kode menggunakan <C-v><Code>. Kode V menggantikan semua #dengan <C-v>0, di mana nol adalah pseudo-akumulator per #. Setiap #reset akumulator ke 0 sehingga memiliki satu per bekerja dengan baik. Kemudian kode melakukan penambahan untuk setiap titik koma yang ditemukan, yang hanya menambah angka berikutnya yang ditemukannya, yang akan menjadi akumulator berikutnya. The 0ditambahkan ke akhir sehingga instruksi tidak gagal untuk ;s tanpa pengikut #.

Hexdump:

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

05AB1E , 20 19 18 16 byte

-1 berkat Adnan
-2 berkat carusocomputing
-2 berkat Kevin Cruijssen

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

Cobalah online! (termasuk output dari kode 05AB1E yang dieksekusi)

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

Cobalah online! (termasuk output dari mengeksekusi kode Python yang di-transpile)

Berkat ovs untuk banyak byte!

Penjelasan

Program ini mentranspilasikan #; kode dengan memisahkan pada #s ( s.split('#')[:-1]), menghitung jumlah titik koma di setiap chunk mod 127 ( x.count(';')%127for x in ...), dan mengonversinya menjadi masing-masing karakter ASCII ( chr(...)). Daftar itu kemudian digabungkan ( ''.join(...)), dikonversi menjadi representasi Python dari string (backticks) dan dimasukkan ke dalam program kerangka Python untuk mencetak string ( "print"+...).

Jelly ,  25 24  16 byte

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

Program lengkap yang mencetak kode Jelly yang setara (sebagai tautan monadik, kode ini mengembalikan daftar jenis campuran).

Contoh pertama ada di Coba online! yang menghasilkan program ini .

Bagaimana?

Menghitung ;s di setiap run antara #s mengambil setiap modulo 127 dan menambahkan gips ke instruksi ordinal, Ọatom monadik , setelah masing-masing.

Jelly secara tersirat menyalurkan setiap nilai ke STDOUT saat dijalankan melalui program seperti yang 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọakan dicetak 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Ọ...)

Catatan tentang input: Jelly mengambil input string dalam format Python. Program yang kosong bisa menjadi masukan sebagai "", dan program hash-hanya sebagai "#", "##", dll manipulasi lain mungkin diperlukan untuk masukan mengandung backslash dan kutipan.

Secara kubik , 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})

Cobalah online!

Catatan: Anda mungkin perlu menggantinya &6dengan ?6&agar bisa bekerja di TIO. &6dalam spesifikasi bahasa, meskipun.

Bagaimana itu bekerja

+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 keluaran:

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

Diberikan string input, menghapus semua karakter yang tidak perlu, lalu mengembalikan sumber fungsi berikut:

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

Di mana ...merupakan ;#sumber yang dibersihkan .

C, 98 96 99 98 97 byte

^{+3 byte karena saya lupa C tidak diartikan :(}

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

Berjalan dengan:

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

Akan dicetak:

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

Jelly , 26 byte

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

Cobalah online!

Dan coba kode Jelly itu di sini!

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

Output Jelly menjadi kode seperti Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, yang mencetak 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

Ini golf pertama saya di> <> (ikan)! Saya harus mengatakan bahasa yang cukup menarik. Menyenangkan!

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

C # 169 Bytes

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

Versi yang dapat dibaca manusia:

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

Cobalah online!

Tidak disatukan

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

Cobalah online!

Merasa terlalu lelah untuk menjelaskan ini saat ini, jika ada yang melihat ini dan bertanya-tanya bagaimana cara kerjanya, berikan komentar untuk mengingatkan saya.

MathGolf , 17 byte

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

Cobalah online!

Penjelasan

⌡                      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

Karena setiap karakter dapat diletakkan di stack (dan dengan demikian output) menggunakan '<char>, ini akan menampilkan urutan blok kode tersebut.

MATL , 32 28 byte

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

Cobalah online!

Pendekatan yang benar-benar berbeda berdasarkan pada strsplitprogram tipe otomat.

      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.

Sebenarnya , 25 byte

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

Cobalah online! (termasuk keluaran dari mengeksekusi kode Sebenarnya yang ditranskrip)

Penjelasan:

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

Cobalah di FourIDE!

Ini adalah tantangan yang mudah karena Fourier pada dasarnya adalah superset dari; #:

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

Penjelasan:

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

Keluaran:

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

Penjelasan:

• ⌽: membalikkan input
• {... }: berikan ke fungsi ini:
  • ⍵⊂⍨'#'=⍵: partisi pada masing-masing #dalam string (dari awal, itulah sebabnya harus dibalik dulu)
  • +/¨';'=: hitung ;s di setiap partisi
  • 127|: modulo 127
  • ⌽: balikkan lagi
  • '⎕UCS',: prepend the string ⎕UCS, yang merupakan fungsi Unicode.
  • ⍕: representasi string

Ruby , 47 + 1 = 48 byte

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

+1 byte untuk -p.

Cobalah online!

-30 byte terima kasih kepada @manatwork !

Pyth, 25 23 24 byte

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

+1 byte berkat @FryAmTheEggman

Cobalah!

menangani karakter yang harus melarikan diri dengan hanya menggunakan string 1-char.

Output sampel:

jk[\"

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

Menggunakan penerjemah; # saya .

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

Diperluas:

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

Ini adalah program lengkap yang (harus) mengakhiri, mengabaikan komentar dan menghasilkan kode keluaran yang selalu benar. Saya menganggap EOF = -1

Diuji pada SystemResque-Cd 4.9.6, dikompilasi dengan gcc 4.9.4

braingasm , 40 byte

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

Harus dikatakan, itu sangat singkat.

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

Kode yang dihasilkan untuk ; adalah a +, yang menambah sel saat ini.

Kode yang dihasilkan untuk #berisi operasi modulo manual, 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&@

Cobalah online!

Pada dasarnya menggantikan ;dengan 1+, #dengan #~1+%@dan pra-pends semuanya dengan 0monadik+ operator rusak sekarang.

1+ menambahkan 1 ke item terakhir di stack.

#~1+%@ mendorong nilai char ~ (126), menambahkan 1 untuk membuat 127, modulus dengan item lain di stack, lalu pop dan cetak sebagai char.

Penjelasan

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

Larutan:

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

Contoh:

Perhatikan bahwa ,digunakan untuk menandakan daftar (versus atom) sebagaimana "\""daftar satu elemen, bukan menjadi atom.

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

Penjelasan:

Ambil string input, hapus apa pun yang bukan a #atau a ;, pisahkan ke dalam daftar #, hitung jumlah elemen dalam setiap daftar, lakukan mod 127 pada hasilnya dan masukkan ke string:

{-1_"c"$mod[;127]count each"#"vs x inter"#;"} / ungolfed
{                                           } / lambda function
                                 x inter"#;"  / intersection of input and ';#' to clear out any 'comments'
                           "#"vs              / split string on hash
                 count each                   / length of each sub-list
        mod[;127]                             / 127 modulo result (vectorised)
    "c"$                                      / cast back to string
 -1_                                          / drop last character (assuming terminated string)

Catatan:

• Mengasumsikan bahwa input diakhiri oleh #, jika tidak, potongan terakhir akan salah dijatuhkan oleh -1_.
• Bisa lebih pendek 10 byte jika input dijamin hanya berisi ;#.

Perl 5 , 78 byte

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

Cobalah online!