Сделайте; # переводчик

62

Недавно я создал новый язык ;#(произносится как «Точка с запятой»), который имеет только две команды:

; добавить один в аккумулятор

#по модулю аккумулятора на 127, преобразовать в символ ASCII и вывести без перевода строки. После этого сбросьте аккумулятор на 0. Да, 127 правильно.

Любой другой персонаж игнорируется. Это не влияет на аккумулятор и ничего не должно делать.

Ваша задача - создать переводчика для этого мощного языка!

Это должна быть либо полная программа, либо функция, которая примет ;#программу в качестве входных данных и выдаст правильные выходные данные.

Примеры

Output: Hello, World!
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Output: ;#
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Output: 2d{ (unprintable characters here; should have 4 `\000` bytes between the `d` and the `{` and 3 after the `{`)
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o

Output: Fizz Buzz output
Program: link below

Output: !
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Fizz Buzz до 100

Caird Coneheringaahing
источник
1
Приемлемо ли, если интерпретатор не прекращает свое выполнение в конце ввода, а вместо этого продолжает бесконечно повторять цикл, не создавая дополнительного вывода?
Лев
5
Второй пример заставляет меня задуматься о программе, кодирующей программу для вывода ... рекурсивной компиляции!
frarugi87
@ Лео, да, все в порядке
Кейрд Монгерингхахинг
1
@iamnotmaynard Точка с запятой Hash
caird coinheringaahing
2
Может быть, Wink Hash будет проще сказать
Джеймс Уолдби - jwpat7

Ответы:

17

JavaScript (ES6), 76 82 80 байт

s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)

демонстрация

Рекурсивная версия, 82 77 байт

Сохранено 5 байтов благодаря Нейлу

Это может привести к сбою при больших входах, таких как пример Fizz Buzz.

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""
Arnauld
источник
Я думаю, что f(s,a+(c==';'))может выбить три байта из вашей рекурсивной версии.
Нил
@Neil Это на самом деле экономит 5 байтов. :-)
Арно
Я чувствую себя действительно глупо сейчас. У меня изначально была глючная версия, и я вычел 2 байта, чтобы исправить ошибку. Но я просчитался и версия глючит фактически спасла 7 байт ...
Neil
12

Retina , 336 63 67 65 66 62 59 байт

T`;#-ÿ`¯_
;{127}|;+$

(^|¯)
¯
+T`-~`_-`[^¯]
T\`¯`

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

Читаемая версия с использованием гипотетического escape-синтаксиса:

T`;#\x01-ÿ`\x01¯_
;{127}|;+$

(^|¯)\x01\x01
¯\x02
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
T\`¯`

Не печатает байты NUL, потому что TIO не допускает их в исходном коде. Также печатает дополнительный символ новой строки в конце, но я думаю, что это не может сделать иначе. Трейлинг новой строки подавлен благодаря @Leo .

-273 (!) Байта благодаря @ETHproductions .

-2 байта благодаря @ovs .

-3 байта благодаря @Neil . Проверьте их замечательное 34-байтовое решение .

eush77
источник
1
О мое слово Но разве нельзя сэкономить тысячу байт +T`\x01-~`_\x03-\x7f`[^\x01¯]\x01? (конечно, включая непечатные символы в виде одинарных символов)
ETHproductions
@ETHproductions Конечно, вы можете. Спасибо! :)
eush77
1
В настоящее время последняя буква всегда на выходе, даже если #на входе нет трейлинга . Вы можете это исправить, изменив свой второй этап на(;{127}|;+$)
овс
1
Вам нужно + `на третьей строке? Когда вы удалите все совпадение, во второй итерации не останется ничего, что можно заменить.
овс
1
Я думаю, что я могу сделать это в 34 байта: T`;#\x01-ÿ`\x80\x7F_ \x80+$(пустая строка) \+T`\x7Fo`\x01-\x80_`\x80[^\x80](используя шестнадцатеричные экранированные символы для представления непечатных). Выводит \ x7F вместо нулей.
Нил
12

Java 8, 100 байт

s->{int i=0;for(byte b:s.getBytes()){if(b==59)i++;if(b==35){System.out.print((char)(i%127));i=0;}}};

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

Mas
источник
3
Добро пожаловать на сайт! :)
DJMcMayhem
Я добавил ссылку на онлайн-переводчика с примером FizzBuzz для вас (текст ссылки был слишком длинным, чтобы поместиться в комментарии)
Джонатан Аллан
Java использует UTF-16 для своих программ . Итак, это не 100 байтов, а 100 символов .
Г.Брозер говорит восстановить Монику
5
@GeroldBroser Unicode - это набор символов: UTF-8 и UTF-16 - две кодировки этого набора символов. Исходный код ASCII отлично подходит как Java-программа, и у меня есть множество исходных файлов Java, закодированных в ASCII (что также является допустимым UTF-8, следовательно, также кодировкой Unicode).
1
Полностью игра в гольф, для 81 байта как Consumer<char[]>:s->{char i=0;for(int b:s){if(b==59)i++;if(b==35){System.out.print(i%=127);i=0;}}}
Оливье Грегуар
11

Japt , 18 байт

®è'; %# d}'# ë ¯J

После этого есть непечатаемый символ \ x7f %#. Проверьте это онлайн!

Как это устроено

®   è'; %#   d}'# ë ¯  J
mZ{Zè'; %127 d}'# ë s0,J
                         // Implicit: operate on input string
mZ{           }'#        // Split the input at '#'s, and map each item Z to
   Zè';                  //   the number of semicolons in Z,
        %127             //   mod 127,
             d           //   turned into a character.
m              '#        // Rejoin the list on '#'. At this point the Hello, World! example
                         // would be "H#e#l#l#o#,# #W#o#r#l#d#!#" plus an null byte.
                  ë      // Take every other character. Eliminates the unnecessary '#'s. 
                    ¯J   // Slice off the trailing byte (could be anything if there are
                         // semicolons after the last '#').
                         // Implicit: output result of last expression
ETHproductions
источник
1
Ты должен был проверить ответы! Просто потратил некоторое время на это, только чтобы найти, что ты избил меня до удара. q'# ®è'; u# dì¯Jтакже работает на тот же счет.
Лохматый
11

Python , 65 байт

Это гольф этого раннего ответа.

lambda t:''.join(chr(x.count(';')%127)for x in t.split('#')[:-1])

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

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

объяснение

Это довольно простой ответ, мы определяем, сколько ;s между каждым #и печатаем chrмод 127. Единственное, что может быть немного странным, это [:-1]. Нам нужно отбросить последнюю группу, потому что #после нее не будет.

Например

;;#;;;;#;;;;;#;;;

Будет разделен на

[';;',';;;;',';;;;;',';;;']

Но мы не хотим последнего, ;;;потому что #после него нет значения для печати.

Мастер пшеницы
источник
1
Я был занят, пытаясь получить все тесты в одной ссылке TIO. Был chr для chr кроме tи x.
Джонатан Аллан
9

> <> 35 байт

>i:0(?;:'#'=?v';'=?0
^   [0o%'␡'l~<

Попробуйте онлайн! Заменить на 0x7F ^?или «удалить».

Основной цикл

>i:0(?;:'#'=?v      
^            <

Он принимает символ input ( i), проверяет, является ли он меньше нуля, т.е. EOF ( :0(), и завершает программу, если он равен ( ?;). В противном случае, проверьте, равен ли вход #( :'#'=). Если это так, разветвите и перезапустите цикл ( ?v... ^ ... <).

Счетная логика

              ';'=?0
              

Проверьте, равен ли вход ;( ';'=). Если это так, нажмите 0. В противном случае ничего не делать. Это перезапускает основной цикл.

Печатная логика

>       '#'=?v      
^   [0o%'␡'l~<

Когда входной символ равен #, вытолкните ввод из стека ( ~), получите количество членов в стеке ( l), нажмите 127 ( '␡') и возьмите модуль ( %). Затем выведите его как символ ( o) и запустите новый стек ( [0). Это «обнуляет» счетчик. Затем цикл возобновляется.

Конор О'Брайен
источник
3
Плохо> <>. Это печально :0(:(
Caird Coinheringaahing
9

Python 3, 69 байт

Улучшено, благодаря @Wheat Wizard, @Uriel

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))
MrGeek
источник
3
Добро пожаловать в программирование головоломок и Code Golf! Цель здесь - сделать код как можно короче (в байтах), поэтому вам нужно включить количество байтов в заголовок :).
Аднан
Спасибо за объяснение, не знал этого. Я буду работать над этим тогда.
MrGeek
2
Вы можете удалить пробел после :s.
Павел
1
Я считаю 74 байта. tio.run/nexus/…
Деннис
2
Кроме того, ';'==cэкономит место, но без использования ifоператоров вообще будет еще короче.
Денис
9

Рёда , 44 39 38 байт

5 байтов сохранено благодаря @fergusq

{(_/`#`)|{|d|d~="[^;]",""chr #d%127}_}

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

Анонимная функция, которая принимает данные из потока.


Если другие символы не должны быть проигнорированы, я получаю это:

Рёда , 20 байт

{(_/`#`)|chr #_%127}
Kritixi Lithos
источник
8

Рубин, 41 35 34 персонажа

( 40 34 33 символов кода + 1 символ опции командной строки)

gsub(/.*?#/){putc$&.count ?;%127}

Благодаря:

  • Джордан за предложение использовать putcне нужно явное преобразование с .chr(6 символов)
  • Кириллу Л. за нахождение ненужных скобок (1 символ)

Образец прогона:

bash-4.4$ ruby -ne 'gsub(/.*?#/){putc$&.count ?;%127}' < '2d{.;#' | od -tad1
0000000    2  etb    d  nul  nul  nul  nul    {  nul  nul  nul
          50   23  100    0    0    0    0  123    0    0    0
0000013

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

manatwork
источник
Doh. Хотя я делал C в ранние годы, я полностью забыл putc(). Спасибо, @Jordan
manatwork
1
К моему собственному удивлению, вы можете опустить скобки после подсчета, чтобы сохранить байт
Кирилл Л.
Хороший улов, @KirillL., Спасибо.
manatwork
7

05AB1E , 16 15 14 байтов

Код:

'#¡¨ʒ';¢127%ç?

Объяснение:

'#¡              # Split on hashtags
   ¨             # Remove the last element
    ʒ            # For each element (actually a hacky way, since this is a filter)
     ';¢         #   Count the number of occurences of ';'
        127%     #   Modulo by 127
            ç    #   Convert to char
             ?   #   Pop and print without a newline

Использует кодирование 05AB1E. Попробуйте онлайн!

Аднан
источник
7

Желе , 13 байт

ṣ”#Ṗċ€”;%127Ọ

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

Как это устроено

ṣ”#Ṗċ€”;%127Ọ  Main link. Argument: s (string)

ṣ”#            Split s at hashes.
   Ṗ           Pop; remove the last chunk.
    ċ€”;       Count the semicola in each chunk.
        %127   Take the counts modulo 127.
            Ọ  Unordinal; cast integers to characters.
Деннис
источник
1
Слово semicolaне существует, это semicolons.
Эрик Outgolfer
@EriktheOutgolfer en.m.wiktionary.org/wiki/semicola
Деннис
Хм, странное слово.
Эрик Outgolfer
@EriktheOutgolfer Кто-то из Викисловаря, вероятно, пытался сделать латинское множественное число действительным на английском языке, но написание колы и семиколы должно быть запрещено.
Cœur
7

машинный код x86 в MS-DOS - 29 байт

00000000  31 d2 b4 01 cd 21 73 01  c3 3c 3b 75 06 42 80 fa  |1....!s..<;u.B..|
00000010  7f 74 ed 3c 23 75 eb b4  02 cd 21 eb e3           |.t.<#u....!..|
0000001d

Комментируемая сборка:

bits 16
org 100h

start:
    xor dx,dx       ; reset dx (used as accumulator)
readch:
    mov ah,1
    int 21h         ; read character
    jnc semicolon
    ret             ; quit if EOF
semicolon:
    cmp al,';'      ; is it a semicolon?
    jne hash        ; if not, skip to next check
    inc dx          ; increment accumulator
    cmp dl,127      ; if we get to 127, reset it; this saves us the
    je start        ; hassle to perform the modulo when handling #
hash:
    cmp al,'#'      ; is it a hash?
    jne readch      ; if not, skip back to character read
    mov ah,2        ; print dl (it was choosen as accumulator exactly
    int 21h         ; because it's the easiest register to print)
    jmp start       ; reset the accumulator and go on reading
Matteo Italia
источник
6

05AB1E , 25 21 19 байт

-2 байта благодаря Аднану

Îvy';Q+y'#Qi127%ç?0

Объяснение:

Î                       Initialise stack with 0 and then push input
 v                      For each character
  y';Q+                 If equal to ';', then increment top of stack
       y'#Qi            If equal to '#', then
            127%        Modulo top of stack with 127
                ç       Convert to character
                 ?      Print without newline
                  0     Push a 0 to initialise the stack for the next print

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

Okx
источник
1
Я думаю, что вы можете заменить i>}на +.
Аднан
6

Сетчатка , 34 байта

T`;#-ÿ`_
\+T`o`-_`[^]|$

Попробуйте онлайн! Включает контрольный пример. Редактировать: Сохранено 2 байта с некоторой помощью @MartinEnder. Примечание. Код содержит непечатаемые шрифты, а использование &#x;кодов приводит к неверным результатам, поскольку браузер использует Windows-1252 вместо ISO-8859-1. Объяснение: Первая строка очищает входные данные: ;изменяется на \x80, #на \x7F(из-за ограничений TIO), а все остальное удаляется. Затем всякий раз, когда мы видим, \x80что нет перед другим \x80, мы удаляем его и циклически увеличиваем код любого следующего символа. Это повторяется до тех пор, пока не останется больше \x80символов. Исходный код, который поддерживает нулевые байты, в основном вычитает 1 из непечатаемых байтов, за исключением первой строки, где \xFFнеизменен и \x7Fстановится\x00, С побегами для удобства чтения:

T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$
Нил
источник
Вы можете сохранить байт, объединив два последних этапа с \x80([^\x80]|$)последним этапом.
Мартин Эндер
@MartinEnder Спасибо! Досадно, что \s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?также сохраняет только один байт.
Нил
Ах, но [^\x80]|\x80$я думаю, что сохраняет два байта.
Нил
Ах, хорошо, да, последний работает. Я также попробовал отрицательный взгляд, но sэто раздражает.
Мартин Эндер
6

R, 97 90 86 84 байта

Функция:

function(s)for(i in utf8ToInt(s)){F=F+(i==59);if(i==35){cat(intToUtf8(F%%127));F=0}}

Когда R начинается, Fопределяется как FALSE(числовой 0).

Ungolfed:

function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }
Свен Хоэнштейн
источник
Разве это не должно быть R + Pryr?
L3viathan
@ L3viathan Так pryrкак пакет R, он все еще R код.
Свен Хоэнштайн
Это код R, но он требует установки дополнительной библиотеки.
L3viathan
@ L3viathan Как вы думаете, мой ответ неверен? Следует ли мне избегать использования дополнительных пакетов?
Свен Хоэнштайн
2
@ BLT Нет разницы. На мой взгляд, это не проблема использовать дополнительные пакеты, которые были созданы перед вызовом. Это верно для всех языков. В Python вы должны использовать в importто время как в R вы можете использовать ::для прямого доступа к функции в пакетах. Здесь часто можно увидеть использование дополнительных пакетов (например, для Python и Java). Однако я изменил свой прежний пост, потому что я не хочу участвовать в обсуждении.
Свен
5

Python, 82 байта

lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])
Уриэль
источник
1
@WheatWizard, так как вы уже опубликовали это как ответ, я считаю, что для меня было бы правильным поднять голос, а не обновлять
Уриэль
4

Простой TeX, 156 байт

\newcount\a\def\;{\advance\a by 1\ifnum\a=127\a=0\fi}\def\#{\message{\the\a}\a=0}\catcode`;=13\catcode35=13\let;=\;\let#=\#\loop\read16 to\>\>\iftrue\repeat

Удобочитаемый

\newcount\a

\def\;{
  \advance\a by 1
  \ifnum \a=127 \a=0 \fi
}
\def\#{
  \message{\the\a}
  \a=0
}

\catcode`;=13
\catcode35=13

\let;=\;
\let#=\#

\loop
  \read16 to \> \>
  \iftrue \repeat
Уриэль
источник
Может ли он печатать символы символически?
eush77
4

Perl, 25 байт

$_=chr(y%;%%%127)x/#/

Выполнить с perl -043pe(считается как 4 байта, так как perl -eявляется стандартным).

Объяснение: -043устанавливает терминатор строки в #(ASCII 043). -pперебирает входные «строки» (теперь на самом деле # -ограниченные строки). y%;%%подсчитывает количество ;в каждой «строке». x/#/гарантирует, что мы не печатаем дополнительный символ для программ, которые не заканчиваются на # (например, третий тестовый пример). %127должно быть довольно очевидно. $_=это обычный шаблон

Grimmy
источник
Впечатляет одно, хотя есть и глюк: для ;;#;;;него выводится № 5 вместо № 2.
manatwork
Как вы получили этот результат? echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxdправильно выводит 00000000: 02на мою машину. Если вы остановились 043или используете кодовую страницу, где #нет ASCII 043, это объяснит ваш результат.
Grimmy
1
К сожалению. Извините, в моем тесте была опечатка. Ваш код работает отлично.
manatwork
4

CJam, 27 байт

0q{";#"#") 127%co0 "S/=~}%;

Объяснение:

0                            e# Push 0
 q                           e# Push the input
  {                          e# For each character in the input:
   ";#"#                     e#   Index of character in ";#", -1 if not found
        ") 127%co0 "S/       e#   Push this string, split on spaces
                      =      e#   Array access (-1 is the last element)
                       ~     e#   Execute as CJam code. ")" increments the accumulator,
                             e#     and "127%co0" preforms modulo by 127, converts to character, pops and outputs, and then pushes 0.
                        }%   e# End for
                          ;  e# Delete the accumulator

Альтернативное решение, 18 байт

q'#/);{';e=127%c}%

Объяснение:

q                   e# Read the whole input
 '#/                e# Split on '#'
    );              e# Delete the last element
      {             e# For each element:
       ';e=         e#   Count number of ';' in string
           127%     e#   Modulo by 127
               c    e#   Convert to character code
                }%  e# End for
Esolanging Fruit
источник
Бизнес-кошка, которая не игнорирует недопустимые символы.
Esolanging Fruit
зачем вам ;удалять аккумулятор?
caird coinheringaahing
@RandomUser Так что это не заканчивается выводом в конце строки.
ETHproductions
4

F #, 79 91 93 байта

let rec r a=function|[]->()|';'::t->r(a+1)t|'#'::t->printf"%c"(char(a%127));r 0 t|_::y->r a y

Ungolfed

let rec run acc = function
    | [] -> ()
    | ';'::xs ->
        run (acc + 1) xs
    | '#'::xs ->
        printf "%c" (char(acc % 127))
        run 0 xs
    | x::xs -> run acc xs

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

Изменить: Обрабатывал любой другой символ, кроме ';' как '#'. Изменено так, что он игнорирует недопустимые символы.

альтернатива

F #, 107 104 байта

let r i=
 let a=ref 0
 [for c in i do c|>function|';'->a:=!a+1|'#'->printf"%c"(!a%127|>char);a:=0|_->()]

Использование эталонной ячейки экономит 3 байта

Ungolfed

let run i =
    let a = ref 0;
    [for c in i do
        match c with
        | ';' -> a := !a + 1
        | '#' ->
            printf "%c" (char(!a % 127))
            a := 0
        |_->()
    ]

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

Brunner
источник
4

Processing.js (версия для ханакадемии), 118 байт

var n="",a=0;for(var i=0;i<n.length;i++){if(n[i]===";"){a++;}if(n[i]==="#"){println(String.fromCharCode(a%127));a=0;}}

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

Поскольку используемая версия обработки не имеет методов ввода, ввод помещается в n.

Кристофер
источник
Технически вы можете создать свой собственный метод ввода с помощью keyTyped=function(){ ... }: P
ETHproductions
@ETHproductions Это вид отвращения.
Кристофер
@ RandomUser уууу! Я сделал это! Мне нравится отвечать в Обработка (проверьте мои ответы)
Кристофер
2
@RandomUser Не просто 1000 повторений .., но 2 ^ 10 повторений (͡ ° ͜ʖ ͡ °)
@Midnightas Оооо, да
Кристофер
4

Лабиринт , 61 47 байт

_36},)@
;    {
; 42_-
"#-  1
_ ; 72
_ ) %
"""".

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

объяснение

цветное изображение кода решения

Выполнение кода начинается в верхнем левом углу, а первая точка с запятой отбрасывает неявный ноль со стека и продолжается вправо.

оранжевый

  • _36толкает 36 на стек. Это для сравнения ввода с#
  • } перемещает вершину стека во вторичный стек
  • , помещает целое значение символа в стек
  • )увеличивает стек (если это конец ввода, это сделает стек 0 и поток программы перейдет к @и завершится )
  • { перемещает вершину вторичного стека к вершине первичного стека
  • -pop y, pop x, нажмите x - y. Это для сравнения ввода с #(35 в ascii). Если ввод был #кодом, то он перейдет к фиолетовой части (так как вершина стека равна 0, IP будет продолжать в том же направлении, в котором он двигался ранее), в противном случае он перейдет к зеленой части.

Фиолетовый

  • 127 нажмите 127 в стек
  • % pop x, pop y, нажмите x% y
  • . вытолкнуть вершину стека (аккумулятор) и вывести в виде символа

Отсюда серый код переносит нас в верхний левый угол программы без стека.

зеленый

  • _24 толкнуть 24 в стек
  • -pop x, pop y, нажмите xy. 24 - это разница между, #и ;поэтому он проверяет, был ли ввод ;. Если это было так, ;код продолжается прямо к ). В противном случае он превратится в значение, #которое увеличивает высоту стека (всегда положительное число, заставляя программу повернуть направо на следующем перекрестке и пропустить код, который увеличивает значение аккумулятора)
  • ; сбросить вершину стека
  • ) инкремент вершины стека, который либо является неявным нулем, либо является ранее увеличенным нулем, действующим в качестве аккумулятора для вывода

Отсюда серый код переносит нас в верхний левый угол программы со стеком, в котором находится только аккумулятор.

Серый

Кавычки не имеют значения, помещают _0 в стек и ;сбрасывают верхнюю часть стека. Все это всего лишь код для правильного направления потока управления и удаления всего лишнего с вершины стека.

Роберт Хикман
источник
Из любопытства, как вы создали изображение-объяснение? Вы создали это сами?
Стефнотч
2
@ Stefnotch, я использовал текстовый редактор, чтобы поместить вкладку между каждым символом, а затем вставил код в Microsoft Excel, который поместил каждый символ в его собственную ячейку. Я выбрал все ячейки, чтобы дать им равные ширину и высоту. Затем я настроил цвета и границы и сделал скриншот.
Роберт Хикман
3

MATL , 29 байт

';#'&mXz!"@o?T}vn127\c&YD]]vx

Ввод - это строка, заключенная в одинарные кавычки.

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

Программа FizzBuzz слишком длинная для онлайн-переводчиков; увидеть это работает в автономном режиме в этом GIF:

введите описание изображения здесь

объяснение

Значение аккумулятора реализовано в виде количества элементов в стеке. Это делает программу медленнее, чем если бы значением аккумулятора было одно число в стеке, но сохраняет несколько байтов.

';#'       % Push this string
&m         % Input string (implicit). Pushes row vector array of the same size with 
           % entries 1, 2 or 0 for chars equal to ';', '#' or others, respectively
Xz         % Remove zeros. Gives a column vector
!          % Transpose into a row vector
"          % For each entry
  @        %   Push current entry
  o?       %   If odd
    T      %     Push true. This increases the accumulator (number of stack elements)
  }        %   Else
    v      %     Concatenate stack into a column vector
    n      %     Number of elements
    127\   %     Modulo 127
    c      %     Convert to char
    &YD    %     Display immediately without newline
  ]        %   End
]          % End
vx         % Concatenate stack and delete. This avoids implicit display
Луис Мендо
источник
3

Алиса , 22 байта

I!?';-n+?h$'@u%?'#-n$O

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

объяснение

Мы держим в стеке только один счетчик того, сколько ;мы встретили. Когда стек пуст (например, в начале программы), это неявно 0.

I!?';-n+?h$'@u%?'#-n$O
I                      Push codepoint of next char from input
 !?                    store it on the tape and reload it right away
   ';-n+               add 1 to the counter if this char is a semicolon,
                       0 otherwise
        ?h$'           If the input char was -1 (EOF) execute the next command,
                       otherwise push its codepoint
            @          Terminate the program (or push 64)
             u         Set all bits up to the most significant as equal to 1
                       this turns 64 (1000000b) into 127 (1111111b)
              %        Compute modulo
               ?       reload the input char from the tape
                '#-n$O if it is a hash, pop the counter and print
                       the corresponding character
                       wrap back to the start of the line

Более короткая, но не прекращающаяся версия этой программы может быть найдена здесь .

Лео
источник
Подтвердили это здесь
caird coinheringaahing
Извините за плохое форматирование, я выложил это со своего телефона, я исправлю это, как только получу руки на ПК
Лев
Программы должны быть прекращены, если в конкурсе не указано иное.
Мартин Эндер
Вы можете сохранить байт, используя вместо него литерал 0x7F ~h.
Мартин Эндер
@MartinEnder сделал это прекращением. Мне не удалось вставить 0x7F в код, но я думаю, что эта альтернативная модификация в любом случае более интересна :)
Лев
3

JS (ES6), 97 92 байта

c=>(a=0,y="",c.split``.map(x=>x=="#"?(a%=127,y+=String.fromCharCode(a),a=0):x==";"?a++:0),y)

Пытался принять иной подход, чем ответ Шэгги . Ну что ж.


источник
3

; # + , 59 байт, неконкурентный

Язык был сделан после этого вызова.

;;;;;~+++++++>~;~++++:>*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)

Попробуйте онлайн! Ввод завершается нулевым байтом.

объяснение

Поколение такое же, как и из моего ответа Generate; # code . Единственная разница здесь - итерация.

итерация

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   take input while != 0
  ~                                    swap
   <                                   read value from memory (;)
    :                                  move forward to the accumulator memory spot (AMS)
     -                                 flip Δ
      +                                subtract two accumulators into A
       !                               flip A (0 -> 1, else -> 0)
        (     (;))                     if A is nonzero, or, if A == ';'
         <                             read from AMS
          -;-                          increment
             >                         write to AMS
                  ::                   move to cell 0 (#)
                    <                  read value from memory (#)
                     +                 subtract two accumulators into A
                      -                flip Δ
                       ::              move to AMS
                         !(   )        if A == '#'
                           <           read from AMS
                            #          output mod 127, and clear
                             >         write to AMS
                               -:-     move back to initial cell
Конор О'Брайен
источник
3

Bash + coreutils, 46 39 байт

tr -dc \;#|sed 'y/;/1/;s/#/.ZC7%P/g'|dc

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

объяснение

(Спасибо Корове Кряк за -7 байт!)

trЧасть удаляет все посторонние символы (я мог бы поставить это в sedтечение точно так же ByteCount, но тогда он не обрабатывает символ перевода строки правильно, так как sedоставляет их и dcполучает только до первого перевода строки с ?)

sedберет остальное и строит dcпрограмму:

Струны ;становятся нитями 1(длинный буквальный)

#становится .ZC7%P(если это следует за строкой 1, то .это десятичная точка для неоперации. Но если это в начале программы или после другой #, это литерал 0. Затем он принимает длину числа, модифицирует его, и печатает соответствующий ASCII.)

София Лехнер
источник
Вам не нужно убегать ;изнутри, '...'и вы можете просто измениться dc -ez?на dc. Кроме того, вместо ;добавления 1 в стек, вы можете сгруппировать их и получить их длину, используя Zдля этого tio.run/##S0oszvj/… .
Kritixi Lithos
@ Cowsquack Это хорошо, спасибо! (и это dc -ez?было следствием необходимости дополнительного нуля для запуска программы) Но ваша программа добавляет дополнительный вывод stderrлибо в случае последовательного #ввода, либо в случае ввода, который не заканчивается #(в обоих случаях я имею в виду после удаления посторонних символов) , Я не знаю, есть ли консенсус, но я чувствую, что дополнительный вывод делает решение недействительным. Однако я адаптировал вашу идею и оказался на один байт больше, чем ваше предложение, без dcошибок!
София Лехнер
В соответствии с этим stderr можно игнорировать, если в запросе не указано явным образом, что очень удобно для dc. Также обратите внимание, что это текущее решение дает сбой с последовательными #s из- Zза 0is 1, поэтому оно выводит 0x01 вместо 0x00 (я тоже попал в ту же ловушку, но мой браузер отображает непечатаемые в виде их шестнадцатеричных кодов, поэтому я понял это).
Kritixi Lithos
3

C, 65 64 60 байт

(-2 благодаря потолочной кошке)

c;f(char*s){for(c=0;*s;s++)c+=*s-35?*s==59:-putchar(c%127);}
HVD
источник
Вам нужно инициализировать cв ноль, чтобы сделать функцию многократно используемой .
Конор О'Брайен
@ ConorO'Brien Исправлено. К сожалению, мне не удалось придумать что-то более короткое, чем просто добавление в c=0, и я не хотел бы обманывать, копируя ответ Денниса.
HVD
@ceilingcat Еще раз спасибо, после этого я смог удалить еще три байта. В ответе Денниса используется хитрость (проверено после редактирования), но на этот раз прошло так много времени, что я все об этом забыл и сам придумал.
HVD