Gerar; # código

36

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

kalsowerus
fonte
9
Brilhante! Fico feliz em ver; # está recebendo atenção!
caird coinheringaahing
1
Você pode testar sua saída aqui , pois; # + é um superconjunto de; #.
Adám
3
A saída pode conter caracteres adicionais? ;#ignora todos os outros caracteres, para que o programa gerado ainda funcione.
Dennis
2
@ Benoît: O módulo é irrelevante ao gerar código, pois é sempre mais fácil gerar código que usa o número mínimo de ;. Em segundo lugar, 127 está correto, conforme declarado na pergunta vinculada que contém a especificação da linguagem; #.
Joey
2
Isso não é realmente transpilar. "Gerar #; código" é um título melhor. Eu vou mudar para isso.
Mego

Respostas:

49

; # + , 61 bytes

Superado por Conor O'Brien

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

Experimente online!

Observe que a entrada possui um byte nulo à direita.

ovs
fonte
12
Pontos por estilo.
Chowlett 23/05
1
Estou de acordo com esta resposta: D definitivamente a linguagem certa para o trabalho
Conor O'Brien
34

; # + , 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
Conor O'Brien
fonte
1
Tudo isso a partir de uma linguagem de piada que fiz quando estava entediada. Fico lisonjeado.
caird coinheringaahing
@RandomUser: D é um conceito divertido para brincar com
Conor O'Brien
Hã. E se eu quiser que o programa imprima um byte nulo em; #?
precisa saber é o seguinte
#@tuskiomi. Experimente online!
Conor O'Brien
@ ConorO'Brien, como eu inseri isso no seu programa?
Tuskiomi
12

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

HyperNeutrino
fonte
Você poderia fazer O”;ẋ;€”#?
Emigna
@ Emigna Ah, sim, obrigado. Eu não entendo direito como isso funciona, mas eu meio que entendo. Obrigado!
HyperNeutrino
4
;€pode se tornar p.
Dennis
@ Dennis Oh agora eu entendo como isso funciona. Obrigado! :)
HyperNeutrino
11

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 '#'.
Dennis
fonte
2
= o que diabos?
Erik the Outgolfer
1
2é o comando de multiplicação? GS2 é estranho: P
ETHproductions
1
@EriktheOutgolfer executa o código para cada um dos o_O ponto de código do caráter da entrada
Mr. Xcoder
@EriktheOutgolfer Isso parece mais chique do que é. é apenas map e GS2 implementa strings como listas de números inteiros.
Dennis
@ETHproductions GS2 não é baseado em caracteres; ele interpreta o código-fonte como um fluxo de bytes brutos, e geralmente não há conexão entre a instrução e o caractere CP-437 que o byte codifica. No código byte x86_64, 2é XOR ...
Dennis
10

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.
Engenheiro Toast
fonte
+1 Adoro idiomas como este e o Mornington Crescent, o código é tão bonito!
Karl-Johan Sjögren
9

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
Emigna
fonte
9

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
Mika Lammi
fonte
Isso é impressionantemente pequeno para o Brainf * ck.
MD XF
quase concorre com a resposta python. Impressionante.
precisa saber é o seguinte
7

Python 3 , 39 bytes

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

Experimente online!

Freira Furada
fonte
2
for s in input():print(";"*ord(s)+"#")é um byte mais curto.
ovs 23/05
1
@ nesse momento em que você assume que a compreensão da lista é mais curta.
Sr. Xcoder 23/05
1
Isso não aceita uma string com uma nova linha, não é?
Tim
5

> <> , 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.

Não é uma árvore
fonte
5

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"
Brunner
fonte
4
Precisamos de mais respostas F #
aloisdg diz Reinstate Monica
@aloisdg eu vou fazer o meu melhor :)
Brunner
5

Python 2 - 36 bytes

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

Experimente online!

Mr. Xcoder
fonte
5

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.

Joey
fonte
Ele precisa juntar as seqüências de resultados.
Mazzy
@mazzy: Na descrição da tarefa: »Desde que o programa seja válido, ele pode conter caracteres em excesso que não sejam #e ;todos os outros caracteres são ignorados.«
Joey
como você deseja :-)
mazzy
aspas podem ser removidas. $argsbasta.
Mazzy
A menos que o argumento seja numérico.
Joey
4

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
Zack C.
fonte
-2 Bytes Só -1 se você está evitando células negativas
Jo rei
4

Mathematica, 49 bytes

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

Explicação

insira a descrição da imagem aqui

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.

ngenisis
fonte
Por que você precisa do <>""?
CalculatorFeline
@CalculatorFeline Sem ele, ficaria com uma lista de strings para cada caractere. StringJoining ( <>) a string vazia concatena cada string.
Ngenisis
Esqueceu-se de que: P
CalculatorFeline
3

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.

L3viathan
fonte
3

Perl, 24 bytes

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

Corra com perl -pe.

Solução alternativa:

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

Corra com perl -nE.

Grimmy
fonte
3

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.
Gato de negócios
fonte
3

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
Beta Decay
fonte
3

Befunge-98 (FBBI) , 23 17 10 bytes

-5 bytes graças a Jo King .

"#@~k:*k,;

Experimente online!

ovs
fonte
1
@JoKing Muito obrigado. Consegui jogar mais dois bytes de golfe. Agora, a par de Pyth, Husk e CJam!
ovs 7/09/18
3

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])+"#")
Shaggy
fonte
\ndeve se torna ;;;;;;;;;;#.
Neil
Hmm ... isso é estranho. Acho que vou ter que reverter para a solução mais longa, então. Obrigado, @Neil.
Shaggy
2
Eu acho que você poderia mudar .para [^], o que ainda deixaria um byte menor que map/join?
Neil
Yup, que fez o trabalho, @Neil :)
Shaggy
Apenas um aviso, a join()resposta anterior era desnecessária, dada a especificação de ;#, e você também pode declarar que a entrada para sua função é uma matriz de caracteres, embora a segunda sugestão seja um pouco exagerada. De qualquer maneira, isso reduz a no máximo 48 bytes.
Patrick Roberts
2

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
Mego
fonte
2

APL (Dyalog) , 18 bytes

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

Experimente online!

⎕UCS Converter em pontos de código Unicode

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

#',¨⍨ acrescentar um hash a cada string

Adão
fonte
2

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.

Chowlett
fonte
Você pode evitar o uso de .ordtrabalhando diretamente com códigos de caracteres: $_.bytes{|b|$><<?;*b+?#}. Há diferença: este também codifica a nova linha na entrada. Não sei o que o proprietário da pergunta pretende dizer com "Ele conterá apenas caracteres ASCII e novas linhas imprimíveis". Mas para mim parece que as novas linhas também devem ser codificadas.
Manatwork
Seu Ruby-fu excede o meu, @manatwork - eu tinha esquecido bytes. Perguntei à OP sobre as novas linhas no topo e editarei isso depois.
Chowlett
2

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.
Martin Ender
fonte
2

PHP, 48 bytes

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

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

homem a trabalhar
fonte
2

Pitão, 10 bytes

sm_+\#*\;C

Tente!

KarlKastor
fonte