Связано с: Создать интерпретатор; # и Создать; # код

;# - Гид Вихря

Это простой язык с двумя командами. Его единственной структурой данных является аккумулятор, который инициализируется в 0.

1. ; Увеличить аккумулятор

2. #Вычислить значение аккумулятора по модулю 127 и вывести соответствующий символ ASCII. Затем сбросьте аккумулятор на 0.

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

Вызов

Поскольку большинство компьютеров не поставляются с ;#предустановленными, было бы очень полезно иметь инструмент, который может конвертировать ;#код на другой язык. В этом задании вы должны написать программу для достижения этой цели.

вход

Некоторый ;#исходный код, взятый через аргумент или STDIN. Этот исходный код может содержать (комментарий) символы, отличные от ;или #.

Выход

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

Заметки

Стоит обратить внимание на escape-последовательности, такие как код, который печатает обратную косую черту или печатает кавычки. Также обратите внимание на ;#код, который может содержать вещи, которые выглядят как ключевые слова или команды на вашем языке.

Дополнительные ограничения

Все программы должны завершаться (я обычно считаю это значением по умолчанию, но кто-то спрашивал об этом, поэтому я заявляю это здесь).

Примеры

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!-program:

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, где ноль - псевдоаккумулятор на #. Каждый #сбрасывает аккумулятор на 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Ç;“Ọø”
ṣ”#Ç€ṙ-

Попробуйте онлайн!

И попробуйте этот код Jelly здесь!

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

Вывод Jelly становится похожим на код Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, который печатает 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 байт

Golfed:

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

Попробуйте онлайн!

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)

Брахилог , 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>, это выведет последовательность таких блоков кода.

МАТЛ , 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|+/¨';'=⍵⊂⍨'#'=⍵}⌽) ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#'
;#

Объяснение:

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

Рубин , 47 + 1 = 48 байтов

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

+1 байт за -p.

Попробуйте онлайн!

-30 байт благодаря @manatwork !

Pyth, 25 23 24 байта

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

+1 байт благодаря @FryAmTheEggman

Попытайся!

обрабатывает символы, которые должны быть экранированы только с использованием 1-символьных строк.

Пример выходов:

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

Expanded:

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

Сгенерированный код для ; является +, который увеличивает текущую ячейку.

Сгенерированный код для #содержит несложную, ручную операцию по модулю

[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+%@и предварительно ожидает все это, 0потому что монадический+ оператор сейчас не работает.

1+ добавляет 1 к последнему элементу в стеке.

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

объяснение

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 ;, разбейте на списки #, посчитайте количество элементов в каждом списке, выполните мод 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)

Заметки:

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

Perl 5 , 78 байт

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

Попробуйте онлайн!