Пов’язано з: Зробіть # перекладач і Створіть;

;# - Посібник з вихору

Це проста мова з двома командами. Єдиною структурою даних є акумулятор, який ініціалізується на 0.

1. ; Збільшення акумулятора

2. #Обчисліть значення модуля 127 акумулятора та надрукуйте відповідний символ ASCII. Потім відновіть акумулятор до 0.

Вихідний код може містити додаткові символи (друкований ASCII + пробіли), але вони розглядаються як коментарі і не впливають на виконання програми.

Виклик

Оскільки більшість комп’ютерів не мають ;#попередньо встановленої програми, було б дуже корисно мати інструмент, який може перетворити ;#код на іншу мову. У цьому виклику ви повинні написати програму для цього.

Вхідні дані

Деякий ;#вихідний код, взятий через аргумент або STDIN. Цей вихідний код може містити (коментувати) символи, відмінні від ;або #.

Вихідні дані

Код на тій самій мові, що і ваше подання, який при виконанні друкує / повертає той самий рядок, що і вихідний ;#код. Цей результуючий код може вивести новий рядк після цільового рядка, якщо це зручніше для вашої мови.

Примітки

Одне, на що слід звернути увагу, - це послідовності втечі, такі як код, який друкує зворотні косої риски або друкує лапки. Також слідкуйте за ;#кодом, який може містити речі, схожі на ключові слова чи команди на вашій мові.

Додаткові обмеження

Усі програми повинні бути припинені (я зазвичай вважаю це за замовчуванням, але хтось запитав про це, тому я тут це констатую).

Приклади

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

Python 2 , 76 69 байт

Код

Введення оточене лапками.

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

Спробуйте в Інтернеті!

Пояснення

Перша частина виводу по суті робиться введенням, використовуючи input('print'). Ми розділяємо вхід на хештеги та відкидаємо останній елемент. Друкуємо подання ord (y% 127) , де y - кількість випадків крапки з комою. Ми додаємо ,в кінці друку, щоб переконатися, що це не надрукує новий рядок.

Це дасть наступний код Python для Hello, World!-програми:

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

Що можна спробувати в Інтернеті .

мозковий ебать , 126 байт

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

Спробуйте в Інтернеті!

Вихідна програма не зможе реалізувати TIO, якщо ;#вихід перевищує 65536 символів. Я також створив 130-байтну версію, яка виводить [+]замість цього <, уникаючи цієї проблеми:

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

Пояснення

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

Пробіл, 291 байт

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Замініть S на пробіл, T на вкладку і N на новий рядок.

Створення пробілів у пробілах - не найефективніша річ у світі. Генерування будь-якого типу динамічного коду вимагає значного скручування бітів, що мовою без побітових операцій може призвести до вибуху розміру коду. Тому ця програма не намагається зробити щось розумне, натомість вибирає просто переклад вихідної програми один на один. Він розбирається на наступне:

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

Код, згенерований програмою, виглядає так:

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 байт

Помилка, зламана, якщо її не було # в кінці

Помилка, реалізована mod 127

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

Спробуйте в Інтернеті!

Спробуйте створений код

Пояснення:

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

У режимі V у режимі вставки будь-який символ ASCII можна вставити за допомогою коду, використовуючи <C-v><Code>. Код V замінює все #на <C-v>0, де нуль - псевдоакумулятор per #. Кожен #скидає акумулятор до 0, так що один на кожен виходить чудово. Тоді код робить приріст для кожного знайденого крапки з комою, який просто збільшує наступне число, яке воно знайде, яке було б наступним накопичувачем. 0Додаються до кінця , так що команда не підведе в протягом ;секунд без наступного #.

Hexdump:

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

05AB1E , 20 19 18 16 байт

-1 завдяки Аднану
-2 завдяки carusocomputing
-2 завдяки Kevin Cruijssen

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

Спробуйте в Інтернеті! (включає вихід коду 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 байт

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

Спробуйте в Інтернеті!(включає вихід із виконання перекладеного коду Python)

Дякую ovs за багато багато байтів!

Пояснення

Ця програма копіює #; код, розділивши на #s ( s.split('#')[:-1]), підрахувавши кількість крапків з комою в кожному моді 127 ( x.count(';')%127for x in ...) та перетворивши його у відповідний символ ASCII ( chr(...)). Потім цей список конкатенований ( ''.join(...)), перетворюється в представлення рядка Python (задніх посилань) і вставляється в скелетну програму Python для друку рядків ( "print"+...).

Желе ,  25 24  16 байт

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

Повна програма, що друкує еквівалентний код Jelly (як монадійне посилання повертає список списків змішаних типів).

Перший приклад - це Спробуйте в Інтернеті! що дає цю програму .

Як?

Підрахунок ;s у кожному пробігу між #s приймає кожен модуль 127 і додає команду до порядкової інструкції, монадичного Ọатома, після кожного.

Jelly неявно передає кожне значення в STDOUT, коли воно проходить через таку програму, як тобто 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọнадрукується 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Ọ...)

Примітка щодо введення даних: Jelly приймає рядок у форматі Python. Порожня програма може бути введена в якості "", і хеш-тільки програми , як "#", "##"і т.д. Інші маніпуляції можуть знадобитися для введення , що містять зворотні косі риси і лапки.

Кубічно , 138 137 байт

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

Спробуйте в Інтернеті!

Примітка: Ви , можливо , буде потрібно замінити &6з ?6&для того , щоб працювати на TIO. &6Хоча в мовній специфікації.

Як це працює

+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

Вихідна програма:

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 байт

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

Давши рядок введення, видаляє всі непотрібні символи, а потім повертає джерело наступної функції:

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

Де ...представлено очищене ;#джерело.

C, 98 96 99 98 97 байт

^{+3 байт, тому що я забув, C не інтерпретується :(}

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

Запуск:

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

Буде надруковано:

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

Желе , 26 байт

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

Спробуйте в Інтернеті!

І спробуйте той желейний код тут!

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

Вихід желе стає кодовим Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, який друкує chr (13) + chr (10)

PHP, 72 байти

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

> <>, 106 81 77 байт

Це мій перший гольф в> <> (рибі)! Досить цікаву мову, яку я повинен сказати. Весело!

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

C # 169 байт

Гольф:

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

Прочитана людиною версія:

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 байт

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

Спробуйте в Інтернеті!

Безумовно

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)

Брахілог , 33 байти

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

Спробуйте в Інтернеті!

Я відчуваю себе занадто втомленим, щоб пояснити це на даний момент, якщо хтось бачить це і дивується, як це працює, залиште коментар, щоб нагадати мені.

MathGolf , 17 байт

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

Спробуйте в Інтернеті!

Пояснення

⌡                      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

Оскільки будь-який символ може бути поставлений на стек (і, таким чином, на вихід), використовуючи '<char>, це виведе послідовність таких блоків коду.

MATL , 32 28 байт

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

Спробуйте в Інтернеті!

Зовсім інший підхід, що базується на strsplitпрограмі автоматичного типу, а не на автоматичному.

      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.

Власне , 25 байт

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

Спробуйте в Інтернеті! (включає вихід із виконання перекладеного фактично коду)

Пояснення:

'#@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 байт

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

Фур’є, 32 байти

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

Спробуйте це на FourIDE!

Це було досить легким викликом, оскільки Фур'є в основному є сукупністю;

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

CJam, 14 байт

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

Пояснення:

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 байт

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

Вихід:

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

Пояснення:

• ⌽: зворотний вхід
• {... }: передайте цю функцію:
  • ⍵⊂⍨'#'=⍵: розділ у кожному #рядку (спочатку, тому його потрібно було змінити спочатку)
  • +/¨';'=: підраховують ;s у кожному розділі
  • 127|: модуль 127
  • ⌽: повернути його знову
  • '⎕UCS',: додайте рядок ⎕UCS, який є функцією Unicode.
  • ⍕: рядкове подання

Ruby , 47 + 1 = 48 байт

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

+1 байт для -p.

Спробуйте в Інтернеті!

-30 байт завдяки @manatwork !

Pyth, 25 23 24 байт

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

+1 байт завдяки @FryAmTheEggman

Спробуй це!

обробляє символи, яких потрібно уникнути, використовуючи лише 1-char-рядки.

Приклади виходів:

jk[\"

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

Використовує мій; # перекладач .

C, 150 байт

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

Розширено:

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

Це повна програма, яка (повинна) припиняти, ігнорувати коментарі та створювати завжди правильний вихідний код. Я припускаю, що EOF = -1

Тестовано на SystemResque-Cd 4.9.6, складеному з gcc 4.9.4

braingasm , 40 байт

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

Треба сказати, це напрочуд коротко.

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

Згенерований код для ;- це +, який збільшує поточну комірку.

Згенерований код для #містить ручну модульну операцію 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 байт

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

Спробуйте в Інтернеті!

В основному замінює ;з 1+, #з #~1+%@і попередньо pends всієї справи з 0бо Монадичним +оператором зламаним прямо зараз.

1+ додає 1 до останнього елемента в стеку.

#~1+%@висуває значення char ~(126), додає 1 для складання 127, модуль з іншим елементом на стеці, потім виводить і друкує як char.

Пояснення

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 байти

Рішення:

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

Приклади:

Зауважте, що ,символ використовується для позначення списку (проти атома) як "\""списку одного елемента, а не атома.

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

Пояснення:

Візьміть рядок введення, видаліть все, що не є a #чи a ;, розділіть на списки #, порахуйте кількість елементів у кожному списку, виконайте mod 127 за результатом та перекладіть на рядок:

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

Примітки:

• Припускає, що введення закінчується символом a #, інакше останній фрагмент буде помилково відкинутий-1_ .
• Може бути на 10 байт коротше, якщо вхід гарантовано лише містити ;#.

Perl 5 , 78 байт

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

Спробуйте в Інтернеті!