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

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 octets

Joué par Conor O'Brien

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

Essayez-le en ligne!

Notez que l'entrée a un octet de fin nul.

; # + , 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

brainfuck , 59 54 octets

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

Essayez-le en ligne!

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

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 '#'.

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.

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

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

Python 3 , 39 octets

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

Essayez-le en ligne!

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

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"

Python 2 - 36 octets

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

Essayez-le en ligne!

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

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

Mathematica, 49 octets

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

Explication

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.

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.

Perl, 24 octets

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

Courez avec perl -pe.

Solution alternative:

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

Courez avec perl -nE.

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.

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

Befunge-98 (FBBI) , le 23 17 10 octets

-5 octets grâce à Jo King .

"#@~k:*k,;

Essayez-le en ligne!

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])+"#")

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

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

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.

PHP, 54 octets

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

Essayez-le en ligne!

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.

PHP, 48 octets

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

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

Pyth, 10 octets

sm_+\#*\;C

Essayez le!

Röda , 24 octets

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

Essayez-le en ligne!