Relacionado a: Faça um; # intérprete

No desafio vinculado acima, a tarefa era criar um intérprete para a linguagem esotérica ;#.

O ;#idioma

O idioma possui exatamente dois comandos: ;e #(todos os outros caracteres são ignorados pelo intérprete):

;: Incrementar o acumulador

#: Module o acumulador por 127, imprima o caractere ASCII correspondente e redefina o acumulador para 0.

Desafio

Como sou preguiçoso, mas ainda quero testar mais casos de teste, preciso de um programa ou função que converta texto sem formatação em ;#código.

Entrada

A entrada é uma sequência, tomada como argumento ou através de stdin. Ele conterá apenas caracteres ASCII imprimíveis e novas linhas.

Saída

A saída é o ;#programa gerado retornando ou imprimindo em stdout. Desde que o programa seja válido, ele pode conter caracteres em excesso que não sejam #e ;como todos os outros caracteres são ignorados.

Exemplos

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

Input: ABC
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Input: ;#
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Entre os melhores

var QUESTION_ID=122139,OVERRIDE_USER=73772;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

; # + , 61 bytes

Superado por Conor O'Brien

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

Experimente online!

Observe que a entrada possui um byte nulo à direita.

; # + , 40 bytes

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

Experimente online! A entrada é finalizada com um byte nulo.

Explicação

O código é dividido em duas partes: geração e iteração.

Geração

;;;;;~+++++++>~;~++++:>

Isso coloca as constantes ;e #na memória como tal:

;;;;;~+++++++>~;~++++:>
;;;;;                     set A to 5
     ~                    swap A and B
      +++++++             add B to A 7 times
                          (A, B) = (5*7, 5) = (35, 5)
             >            write to cell 0
              ~           swap A and B
               ;          increment A
                ~         swap A and B
                          (A, B) = (35, 6)
                 ++++     add B to A 4 times
                          (A, B) = (59, 6)
                     :    increment cell pointer
                      >   write to cell 1

Iteração

*(-(;~<#~):<#-*:)
*                    read a character into A
 (            * )    while input is not a null byte:
  -                  flip Δ
   (     )           while A != 0
    ;                decrement
     ~               swap A and B
      <              read ";" into A
       #             output it
        ~            swap A and B
           :         decrement cell pointer
            <        read "#" into A
             #       output it
              -      flip Δ
               *     take another character from input
                :    increment cell pointer

brainfuck , 59 54 bytes

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

Experimente online!

Geléia , 10 8 7 bytes

O”;ẋp”#

Experimente online!

O”;ẋp”#  Main Link
O        Map over `ord` which gets the codepoint of every character
 ”;ẋ     Repeat ';' the required number of times
     ”#  '#'
    p    Cartesian Product; this puts a '#' at the end of each element in the array

Implicit Output shows as a single string

-2 bytes graças a @Emigna
-1 byte graças a @Dennis

GS2 , 6 bytes

■•;2•#

Experimente online!

Hexdump reversível (xxd)

0000000: ff 07 3b 32 07 23                                ■•;2•#

Como funciona

■       Map the rest of the program over  all code points C of the input.
 •;         Push ';'.
   2        Multiply; repeat ';' C times.
    •#      Push '#'.

Táxi, 779 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 1 r 1 l 4 r 1 l.[c]Switch to plan "e" if no one is waiting.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:n 1 l 3 l 3 l.Pickup a passenger going to The Underground.Go to Writer's Depot:w 1 r.[p]; is waiting at Writer's Depot.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to The Underground:n 1 r 1 l.Switch to plan "n" if no one is waiting.Pickup a passenger going to The Underground.Go to Zoom Zoom:n 3 l 2 r.Go to Writer's Depot:w.Switch to plan "p".[n]# is waiting at Writer's Depot.Go to Writer's Depot:n 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to Chop Suey:n 1 r 1 l 4 r 1 l.Switch to plan "c".[e]

Experimente online!

Ungolfed:

Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
[c]
Switch to plan "e" if no one is waiting.
Pickup a passenger going to Charboil Grill.
Go to Charboil Grill: north 1st left 3rd left 3rd left.
Pickup a passenger going to The Underground.
Go to Writer's Depot: west 1st right.
[p]
; is waiting at Writer's Depot.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to The Underground: north 1st right 1st left.
Switch to plan "n" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north 3rd left 2nd right.
Go to Writer's Depot: west.
Switch to plan "p".
[n]
# is waiting at Writer's Depot.
Go to Writer's Depot: north 3rd left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
Switch to plan "c".
[e]

Explicação:

Pick up stdin and split it into characters.
Covert each character to ASCII.
Print ";" as you count down from that ASCII to zero.
Print "#".
Pickup the next character and repeat until done.

05AB1E , 8 bytes

Ç';×'#«J

Experimente online!

Explicação

Ç          # convert each input char to its ascii value
 ';×       # repeat ";" those many times
    '#«    # append a "#" to each run of semi-colons
       J   # join to string

Brainfuck, 43 bytes

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

Byte nulo finaliza o programa.

Explicação

+[+[<]>->++]          59 (semicolon) location 5
--[>--<+++++++]>-       35 (hash) location 7
<,[                     input location 6
    [   while input byte not 0
        <.>     print semicolon
        -       decrement input byte
    ]
    >.< print hash
,]  loop while input not null

Python 3 , 39 bytes

[print(";"*ord(s)+"#")for s in input()]

Experimente online!

> <> , 22 bytes

i:0(?;\"#"o
o1-:?!\";"

Experimente on-line ou no playground de peixes

A entrada é STDIN, a saída é STDOUT. Em> <>, caracteres e códigos ASCII são a mesma coisa, então tudo o que precisamos fazer é ler um caractere, imprimir ";"e diminuir o caractere até chegar a 0, depois imprimir "#"e fazer um loop até que não haja mais entrada.

F #, 79 bytes

let c i=System.String.Join("#",Seq.map(fun c->String.replicate(int c)";")i)+"#"

Experimente online!

Expandido

// string -> string
let convert input =
    System.String.Join(
        "#",      // join the following char seq with "#"
        input     // replicate ";" n times where n = ASCII value of char c
        |> Seq.map (fun c-> String.replicate (int c) ";") 
    ) + "#" // and add the last "#" to the output

convert pega a string de entrada e gera um programa;;

Uso

convert "Hello, World!" |> printfn "%s"
convert "ABC" |> printfn "%s"
convert ";#" |> printfn "%s"

Python 2 - 36 bytes

for i in input():print';'*ord(i)+'#'

Experimente online!

PowerShell, 29 27 25 bytes

$args|% t*y|%{';'*$_+'#'}

Bem direto. Recebe entrada como argumento da linha de comando. A saída é um programa; # válido que imprime o texto solicitado.

brainfuck , 47 bytes

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

Experimente online!

Veja também: resposta de ovs , que adota uma abordagem semelhante, mas com um método diferente de gerar constantes e um layout de célula diferente.

Explicação:

Esse desafio se alinha muito bem às especificações do cérebro, o que significa que a solução é essencialmente trivial. Brainfuck recebe a entrada como valores ASCII, que é exatamente o que; # precisa produzir como.

O esquema para transpilar é simples: gere o valor ASCII para ;e #, imprima ;igual ao valor ASCII do caractere de entrada, imprima #, repita para cada entrada.

+++++++[-             7
         >++++++++       * 8 = 56
         >+++++<<        * 5 = 35 (#)
       ]>+++<                  56 + 3 = 59 (;)
,[                    Input into first cell
  [>.<-]              Print ;'s equal to ASCII input
  >>.<<,              Print one #
 ]                    End on EOF

Mathematica, 49 bytes

StringRepeat[";",#]<>"#"&/@ToCharacterCode@#<>""&

Explicação

Converte a sequência de entrada em uma lista de códigos de caracteres, depois Mapa função StringRepeat[";",#]<>"#"&sobre a lista e StringJoino resultado com a sequência vazia.

Aceto , 19 bytes

Como há um intérprete em Aceto , pensei que também haveria uma resposta para esse desafio. Ele se encaixa perfeitamente em uma curva de Hilbert de segunda ordem:

\n;*
'o'p
`!#'
,dpO

Antes de tudo, lemos um único caractere ( ,) e o duplicamos e negamos para testar se é uma nova linha (d! ao ler uma nova linha, um caractere vazio normalmente é pressionado na pilha). Depois, uso o que considero um truque bastante inteligente para lidar com o caso da nova linha de maneira compacta:

`'\n

Se o valor na pilha for True(lemos uma nova linha), esse código significa: do ( `) coloca um caractere literal na pilha (' ), que é uma nova linha:\n .

Se o valor na pilha for False(não lemos uma nova linha), esse código significa: não ( `) leia um caractere literal ( '). Isso significa que o próximo caractere é executado como um comando. Felizmente, uma barra invertida escapa ao próximo comando (o faz para que não seja executado), entãon não imprime uma nova linha (que é o que ngeralmente faz).

O restante do código é direto; convertemos o caractere na pilha no número inteiro de seu ponto de código unicode ( o), pressionamos um ponto e vírgula literal ( ';), multiplicamos o número pela string ( *como em Python), pcriamos o resultado, pressionamos um literal ( ') #, pexecutamos também e volte ao Origin.

Corra com -Fse você quiser ver resultados imediatos (porque o buffer), mas ele funciona sem também.

Perl, 24 bytes

s/./";"x(ord$&)."#"/ges

Corra com perl -pe.

Solução alternativa:

say";"x ord,"#"for/./gs

Corra com perl -nE.

Consolo , 11 bytes

Yay, novos idiomas.

';@jx{'#}Ep

Explicação

';           Push the code point of ';' (59).
  @j         Push the entire input as a list of code points.
    x        For each code point in the input, repeat 59 that many times.
     {  }E   For each resulting list of 59s:
      '#      Push the code point of '#' (35).
          p  Flatten and print as unicode characters.

Fourier , 19 bytes

$(I(`;`&j)`#`0~j&i)

Experimente no FourIDE!

Para executar, você deve colocar a sequência de entrada entre aspas.

Pseudocódigo de explicação

While i != Input length
    temp = pop first char of Input
    While j != Char code of temp
        Print ";"
        Increment j
    End While
    Print "#"
    j = 0
    Increment i
End While

Befunge-98 (FBBI) , 23 17 10 bytes

-5 bytes graças a Jo King .

"#@~k:*k,;

Experimente online!

JavaScript, 55 54 51 50 48 bytes

s=>1+[...s].map(c=>";".repeat(Buffer(c)[0])+"#")

Experimente online

• 1 byte economizado graças a Neil .

Alternativas

Se pudermos considerar a entrada como uma matriz de caracteres individuais, podemos salvar 5 bytes.

a=>1+a.map(c=>";".repeat(Buffer(c)[0])+"#")

Se também podemos produzir como uma matriz, mais 2 bytes podem ser salvos.

a=>a.map(c=>";".repeat(Buffer(c)[0])+"#")

Na verdade , 11 bytes

O⌠';*'#o⌡MΣ

Experimente online!

Explicação:

O⌠';*'#o⌡MΣ
O            convert string to list of ASCII ordinals
 ⌠';*'#o⌡M   for each ordinal:
  ';*          repeat ";" that many times
     '#o       append "#"
          Σ  concatenate

APL (Dyalog) , 18 bytes

'#',¨⍨';'⍴¨⍨⎕UCS

Experimente online!

⎕UCS Converter em pontos de código Unicode

';'⍴¨⍨ use cada ponto de código para remodelar ( ⍴ = Rho ≈ R ; R eshape) um ponto e vírgula

#',¨⍨ acrescentar um hash a cada string

Ruby, 28 25 bytes

24 bytes, mais a -nopção de linha de comando para operar repetidamente stdin.

$_.bytes{|b|$><<?;*b+?#}

3 bytes salvos (e saída corrigida em novas linhas!) Graças ao trabalho manual.

PHP, 54 bytes

for(;$o=ord($argn[$i++]);)echo str_repeat(";",$o)."#";

Experimente online!

Alice , 12 bytes

'#I.h%&';d&O

Experimente online!

Explicação

'#    Push 35, the code point of '#'.
I     Read a code point C from STDIN. Pushes -1 at EOF.
.h%   Compute C%(C+1). For C == -1, this terminates the program due to division
      by zero. For C > -1, this just gives back C, so it does nothing.
&';   Pop C and push that many 59s (the code point of ';').
d     Push the stack depth, which is C+1.
&O    Print that many code points from the top of the stack.
      The IP wraps around to the beginning and another iteration of this
      loop processes the next character.

PHP, 48 bytes

for(;$c?:~$c=~ord($argn[$i++]);)echo";#"[!++$c];

jq, 30 caracteres

(Código de 26 caracteres + opções de linha de comando de 4 caracteres)

explode|map(";"*.+"#")|add

Exemplo de execução:

bash-4.4$ jq -Rr 'explode|map(";"*.+"#")|add' <<< 'Hello, World!' | jq -Rrj '[scan(".*?#")|gsub("[^;]";"")|length%127]|implode'
Hello, World!

Teste on-line

Pitão, 10 bytes

sm_+\#*\;C

Tente!

Röda , 24 bytes

{chars|[";"*ord(_),"#"]}

Experimente online!