Générer; # code

36

En rapport avec: Faire un; # interprète

Dans le défi ci-dessus, la tâche consistait à créer un interprète pour le langage ésotérique ;#.

La ;#langue

Le langage a exactement deux commandes: ;et #(tous les autres caractères sont ignorés par l'interpréteur):

;: Incrémenter l'accumulateur

#Modulez l'accumulateur par 127, imprimez le caractère ASCII correspondant et réinitialisez l'accumulateur à 0.

Défi

Parce que je suis paresseux mais que je veux encore tester quelques cas de test, j'ai besoin d'un programme ou d'une fonction qui convertit le texte brut en ;#code.

Contribution

L'entrée est une chaîne, prise en argument ou via stdin. Il ne contiendra que des caractères ASCII imprimables et des nouvelles lignes.

Sortie

La sortie est le ;#programme généré en retournant ou en imprimant sur stdout. Tant que le programme est valide, il peut contenir des caractères en excès autres que #et ;tous les autres caractères sont ignorés.

Exemples

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

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

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

Classement

Afficher l'extrait de code

code-golf  code-generation 
— Kalsowerus
source
9
Brillant! Content de voir; # attire l'attention!
— Caird coinheringaahing
1
Vous pouvez tester votre sortie ici , car; # + est un sur-ensemble de; #.
— Adám
3
La sortie peut-elle contenir un caractère supplémentaire? ;#ignore tous les autres caractères, donc le programme généré continuerait à fonctionner.
— Dennis
2
@ Benoît: Le module n'est pas pertinent lors de la génération de code, car il est toujours plus facile de générer du code utilisant le nombre minimal de ;. Deuxièmement, 127 est correct, comme indiqué dans la question liée qui contient la spécification du langage; #.
— Joey
2
Ce n'est pas vraiment transpiler. "Générer #; code" est un meilleur titre. Je vais changer cela pour cela.
— Mego

Réponses:

34

; # + , 40 octets

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

Essayez-le en ligne! L'entrée se termine par un octet nul.

Explication

Le code est divisé en deux parties: la génération et l'itération.

Génération

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

Cela met les constantes ;et #en mémoire en tant que telles:

;;;;;~+++++++>~;~++++:>
;;;;;                     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

Itération

*(-(;~<#~):<#-*:)
*                    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
source
1
Tout cela à partir d'une blague que j'ai faite quand je m'ennuyais. Je suis flatté.
— Caird coinheringaahing
@RandomUser: D c'est un concept amusant à jouer
— Conor O'Brien
hein Que se passe-t-il si je veux que le programme imprime un octet nul dans; #?
— Tuskiomi
— Conor O'Brien
@ ConorO'Brien, comment pourrais-je l'intégrer à votre programme?
— Tuskiomi
12

Gelée , 10 8 7 octets

O”;ẋp”#

Essayez-le en ligne!

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 octets grâce à @Emigna
-1 octet grâce à @Dennis

— HyperNeutrino
source
Pourriez-vous faire à la O”;ẋ;€”#place?
— Emigna
@ Emigna Ah, oui, merci. Je ne comprends pas très bien comment cela fonctionne mais je le comprends un peu. Merci!
— HyperNeutrino
4
;€peut devenir p.
— Dennis
@ Dennis Oh, je comprends maintenant comment cela fonctionne. Merci! :)
— HyperNeutrino
11

GS2 , 6 octets

■•;2•#

Essayez-le en ligne!

Hexdump réversible (xxd)

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

Comment ça marche

■       Map the rest of the program over  all code points C of the input.
 •;         Push ';'.
   2        Multiply; repeat ';' C times.
    •#      Push '#'.
— Dennis
source
2
■= qu'est-ce que c'est?
— Erik the Outgolfer
1
2est la commande de multiplication? GS2 is weird: P
— ETHproductions
1
@EriktheOutgolfer exécute le code pour chacun des points de code du caractère de l'entrée o_O
— Mr. Xcoder
@EriktheOutgolfer Cela semble plus sophistiqué qu'il ne l'est. ■est simplement la carte , et GS2 implémente des chaînes en tant que listes d'entiers.
— Dennis
@ETHproductions GS2 n'est pas basé sur des caractères; il interprète le code source comme un flux d'octets brut et il n'y a généralement pas de connexion entre l'instruction et le caractère CP-437 encodé par l'octet. En x86_64 octets, 2est-ce que XOR ...
— Dennis
10

Taxi, 779 octets

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]

Essayez-le en ligne!

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]

Explication:

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.
— Rôti d'ingénieur
source
+1 J'adore les langues comme celle-ci et Mornington Crescent, le code est tellement beau!
— Karl-Johan Sjögren
9

05AB1E , 8 octets

Ç';×'#«J

Essayez-le en ligne!

Explication

Ç          # 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
source
9

Brainfuck, 43 octets

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

Un octet nul termine le programme.

Explication

+[+[<]>->++]          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
source
C'est incroyablement petit pour Brainf * ck.
— MD XF
presque en concurrence avec la réponse python. Impressionnant.
— dimanche
7

Python 3 , 39 octets

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

Essayez-le en ligne!

— Fuite Nun
source
2
for s in input():print(";"*ord(s)+"#")est un octet plus court.
— Ovs
1
@ovs ce moment où vous supposez que la compréhension d'une liste est plus courte.
— M. Xcoder
1
Cela n'accepte pas une chaîne avec une nouvelle ligne, n'est-ce pas?
— Tim
5

> <> , 22 octets

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

Essayez-le en ligne ou au terrain de jeu du poisson

L'entrée est STDIN, la sortie est STDOUT. Dans> <>, les caractères et les codes ASCII sont identiques. Il suffit donc de lire un caractère, de l’imprimer ";"et de le décrémenter jusqu’à 0, puis d’imprimer "#"et de boucler jusqu’à épuisement des entrées.

— Pas un arbre
source
5

F #, 79 octets

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

Essayez-le en ligne!

Étendu

// 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 prend la chaîne d'entrée et génère un programme; #

Usage

convert "Hello, World!" |> printfn "%s"
convert "ABC" |> printfn "%s"
convert ";#" |> printfn "%s"
— Brunner
source
4
Nous avons besoin de plus de réponses F #
— aloisdg dit: Réintégrer Monica
@aloisdg je ferai de mon mieux :)
— Brunner
5

PowerShell, 29 27 25 octets

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

Assez simple. Prend l'entrée comme argument de ligne de commande. La sortie est un # programme valide qui imprime le texte demandé.

— Joey
source
Il doit rejoindre les chaînes de résultats.
— mazzy
@mazzy: D'après la description de la tâche: »Tant que le programme est valide, il peut contenir un excès de caractères autres que #et ;comme tous les autres caractères sont ignorés.«
— Joey
comme vous le souhaitez :-)
— mazzy
les guillemets peuvent être supprimés. $argsest assez.
— mazzy
À moins que l'argument ne soit numérique.
— Joey
4

brainfuck , 47 octets

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

Essayez-le en ligne!

Voir aussi: la réponse de ovs , qui adopte une approche similaire, mais avec une méthode différente pour générer des constantes et une disposition de cellules différente.

Explication:

Ce défi cadre assez bien avec la spécification "brainfuck", ce qui signifie que la solution est essentiellement triviale. Brainfuck prend les entrées en tant que valeurs ASCII, ce qui est exactement ce que # doit produire en tant que.

Le schéma de transposition est simple: générez la valeur ASCII pour ;et #, impression ;égale à la valeur ASCII du caractère saisi, imprimez #, répétez pour chaque entrée.

+++++++[-             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.
source
-2 octets seulement -1 si vous évitez les cellules négatives
— Jo King
4

Mathematica, 49 octets

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

Explication

entrez la description de l'image ici

Convertit la chaîne en entrée en une liste de codes de caractères, puis Mapla fonction StringRepeat[";",#]<>"#"&sur la liste, puis StringJoinle résultat avec la chaîne vide.

— ngenisis
source
Pourquoi avez-vous besoin du <>""?
— CalculatriceFeline
@CalculatorFeline Sans cela, il me resterait une liste de chaînes pour chaque caractère. StringJoining ( <>) la chaîne vide concatène chaque chaîne.
— ngenisis
J'ai oublié ça: P
— CalculatriceFeline
3

Aceto , 19 octets

Puisqu'il y a un interprète à Aceto , j'ai pensé qu'il serait également possible que Aceto réponde à ce défi. Il s'inscrit parfaitement dans une courbe de Hilbert du 2ème ordre:

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

Tout d'abord, nous lisons un caractère unique ( ,), nous le dupliquons et le nions pour vérifier s'il s'agit d'une nouvelle ligne ( d!lors de la lecture d'une nouvelle ligne, un caractère vide est normalement placé sur la pile). J'utilise ensuite ce que je pense être une astuce assez astucieuse pour gérer le cas newline de manière compacte:

`'\n

Si la valeur sur la pile est True (nous lisons une nouvelle ligne), ce code signifie: do ( `) place un caractère littéral sur la pile ( '), qui est une nouvelle ligne:\n .

Si la valeur sur la pile est False (nous n'avons pas lu de nouvelle ligne), ce code signifie: ne ( `) lit pas un caractère littéral ( '). Cela signifie que le caractère suivant est exécuté en tant que commande. Heureusement, une barre oblique inversée échappe à la commande suivante (elle évite ainsi qu’elle ne soit exécutée), nelle n’imprime donc pas de nouvelle ligne (ce quin généralement le cas).

Le reste du code est simple. nous convertissons le caractère de la pile en entier de son codepoint unicode ( o), nous poussons un point-virgule littéral ( ';), multiplions le nombre par la chaîne (* comme dans Python), printons le résultat, poussons un littéral ( ') #, pleons aussi, et retournez à laO rigin.

Courir avec -F si vous voulez voir des résultats immédiats (à cause de la mise en mémoire tampon), mais cela fonctionne aussi sans.

— L3viathan
source
3

Perl, 24 octets

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

Courez avec perl -pe.

Solution alternative:

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

Courez avec perl -nE.

— Grimmy
source
3

Soulagement , 11 octets

Oui, nouvelles langues.

';@jx{'#}Ep

Explication

';           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.
— Chat d'affaires
source
3

Fourier , 19 octets

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

Essayez-le sur FourIDE!

Pour exécuter, vous devez placer la chaîne de saisie entre guillemets.

Pseudocode d'explication

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
source
3

JavaScript, 55 54 51 50 48 octets

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

Essayez-le en ligne

  • 1 octet enregistré grâce à Neil .

Des alternatives

Si nous pouvons prendre l’entrée comme un tableau de caractères individuels, alors 5 octets peuvent être sauvegardés.

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

Si nous pouvons aussi sortir sous forme de tableau, 2 autres octets peuvent être sauvegardés.

a=>a.map(c=>";".repeat(Buffer(c)[0])+"#")
— Hirsute
source
\ndevrait devenir ;;;;;;;;;;#.
— Neil
Hmm ... c'est étrange. Je suppose que je vais devoir revenir à la solution plus longue, alors. Merci, Neil.
— Shaggy
2
Je pense que vous pourriez changer .en [^], ce qui laisserait encore un octet plus court que map/join?
— Neil
Yup, ça a fait le boulot, @Neil :)
— Shaggy
Juste un avertissement, join()votre réponse précédente était inutile étant donné la spécification de ;#, et vous pouvez également déclarer que l'entrée de votre fonction est un tableau de caractères, bien que la seconde suggestion soit un peu exagérée. Quoi qu'il en soit, cela vous ramène au maximum à 48 octets.
— Patrick Roberts
2

En fait , 11 octets

O⌠';*'#o⌡MΣ

Essayez-le en ligne!

Explication:

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

APL (Dyalog) , 18 octets

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

Essayez-le en ligne!

⎕UCS Convertir en points de code Unicode

';'⍴¨⍨ utiliser chaque point de code pour remodeler ( ⍴ = Rho ≈ R , R Eshape) un point - virgule

#',¨⍨ ajoute un hachage à chaque chaîne

— Adam
source
2

Ruby, 28 ans 25 octets

24 octets, plus le -ncommutateur de ligne de commande à utiliser de manière répétée stdin.

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

3 octets sauvés (et sortie corrigée sur les nouvelles lignes!) Grâce à manatwork.

— Chowlett
source
Vous pouvez éviter l'utilisation d' .orden travaillant directement avec les codes de caractères: $_.bytes{|b|$><<?;*b+?#}. Il y a une différence: celle-ci code également la nouvelle ligne dans l'entrée. Je ne suis pas sûr de ce que le propriétaire de la question a l'intention de dire par «Cela ne contiendra que des caractères ASCII imprimables et des nouvelles lignes.», Mais pour moi, les sons comme les nouvelles lignes devraient également être encodés.
— Manatwork
Votre Ruby-fu dépasse le mien, @manatwork - je l'avais oublié bytes. J'ai posé la question à OP au sujet des sauts de ligne et je l'éditerai plus tard.
— Chowlett
2

Alice , 12 octets

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

Essayez-le en ligne!

Explication

'#    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
source
2

jq, 30 caractères

(26 caractères de code + 4 caractères d'options de ligne de commande)

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

Échantillon échantillon:

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

Test en ligne

— homme au travail
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.