Défi

Écrivez un programme ou une fonction qui a donné une chaîne, renvoie un programme Brainfuck valide qui, une fois compilé et exécuté en tant que Brainfuck, renvoie cette chaîne.

Supposons que toutes les entrées sont codées en ASCII.
Supposons que le programme BF en sortie s'exécute dans un environnement avec une bande infinie.
Supposons que le pointeur commence à la cellule 0 avec chaque cellule initialisée à une valeur de zéro.
Chaque exemple ci-dessous représente une sortie correcte possible pour l'entrée donnée. En particulier, les exemples incluent des sauts de ligne et des espaces supplémentaires pour aider la lisibilité humaine. Les solutions sont libres de formater le code BF en sortie de n'importe quelle manière.
La bande est doublement infinie.
Toutes les cellules fournies par l'interpréteur sont exactement des cellules 8 bits. Le débordement et le débordement s'enroulent dans une matière prévisible et saine.

Exemples

Chaîne d'espace

Compte tenu de l'entrée , votre programme / fonction pourrait retourner:

+++++ +++++
+++++ +++++
+++++ +++++
++ .

Point d'exclamation

Compte tenu de l'entrée !, votre programme / fonction pourrait retourner:

+++++ +++++
+++++ +++++
+++++ +++++
+++
.

Deux lettres

Compte tenu de l'entrée hi, votre programme / fonction pourrait retourner:

+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++

+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++

++++
.
+
.

Il s'agit de code-golf , donc le code avec le plus petit nombre d'octets l'emporte. Bonne chance.

code-golf brainfuck Yeow_Meng
la source

10

Plus de tests, s'il vous plaît.

Leaky Nun

1

Quelles sont exactement les directives mentionnées dans la révision 9 ?

user8397947

4

Je rouvre ça. Je pense que les préoccupations de Peter ont été prises en compte et nous avons un consensus assez clair sur ce qui compte comme un double, et ce défi ne répond pas à ces critères.

Martin Ender

"Débordement et sous-débordement d'une manière prévisible et saine" - donc 127 + 1 retourne à 0 et -128-1 retourne également à 0, n'est-ce pas? C'est une manière prévisible et sensée possible.

user253751

1

@immibis Exactement.

user8397947

18

Gelée , 8 octets

O”+ẋp“.>

Essayez-le en ligne!

Exemple d'exécution

Pour la saisie hi, ce programme imprime

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++>

(sans les sauts de ligne) qui, à son tour, imprimehi .

Comment ça fonctionne

O”+ẋp“.>  Main link. Argument: s (string)

O         Ordinal; convert each character in s into its code point.
 ”+       Yield the character '+'.
   ẋ      Repeat '+' k times, for each k in the code points.
     “.>  Yield the string ".>".
    p     Take the Cartesian product of both results.

Dennis
la source

La vôtre ne fonctionne pas sur une mémoire limitée, la mienne le fait.

Leaky Nun

5

Pas vraiment. Nous stockons tous les deux la sortie entière en mémoire avant l'impression. Pour les interprètes BF avec une bande suffisamment grande, cela deviendra un problème bien avant la bande.

Dennis

Pourquoi n'apparaît pas .>dans la sortie?

cat

2

@cat Parce que le produit cartésien ( p) est plus court que l' ajout à chaque ( ;€). Ces programmes de sortie doublent la cellule après l'impression et avant la commutation. Puisque nous ne revisitons jamais la cellule, cela n'affecte pas la sortie.

Dennis

@Dennis ahh, intéressant.

cat

55

Brainfuck, 55 51 octets

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

Essayez-le en ligne!

Exemple de sortie pour hi(sans les sauts de ligne):

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

Explication

Cela se déplace sur la bande lors de l'écriture du programme. L'environnement ,[...,]est une boucle d'entrée standard. Pour chaque personnage, nous utilisons quatre cellules:

[... x a b c ...]

où xest la cellule dans laquelle nous écrivons l'entrée.

>+++[>+++++++<-]

Cette partie utilise la cellule apour écrire une 21dans la cellule bvia une multiplication standard de 3et 7.

>[<++>>+++<-]

Maintenant, nous utilisons cela 21pour écrire42 dans aet 63en cen multipliant par 2et 3respectivement. Puis <+<Revient à la cellule xtout en tournant la 42dans un 43(point de code +). Résumer:

[... x 43 21 63 ...]

Maintenant, la boucle de sortie principale:

[>.<-]

Autrement dit, tout en décrémentant, xnous en imprimons un à +chaque fois.

>+++.

Après avoir terminé, nous réutilisons la +cellule, en ajoutant 3pour donner ..

>>-.

Enfin, nous passons au 63 , la décrémentons en 62( >) et la sortie également. La prochaine itération utilisera cette cellule comme x.

Martin Ender
la source

5

Je donnerais une prime à cela si j'avais plus de représentants.

user8397947

34

Brainfuck, 39 33 32 31 octets

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

L'algorithme qui place 45 sur la bande est tiré des constantes Brainfuck d' Esolang .

Cette réponse suppose que l'interpréteur du programme de sortie a des cellules enveloppantes et délimitées; et cela, zéro la cellule actuelle (ce qui implique que le programme de sortie est exécuté sans entrée). Essayez-le en ligne!

Pour une solution (plus longue) qui fonctionne sans condition, voir mon autre réponse .

Essai

Pour l'entrée Code Golf, la sortie suivante est générée.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-------------------------------------------------------------------------------------------------------------------------------------------------.,------------------------------------------------------------------------------------------------------------------------------------------------------------.,-----------------------------------------------------------------------------------------------------------------------------------------------------------.,--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-------------------------------------------------------------------------------------------------------------------------------------------------.,----------------------------------------------------------------------------------------------------------------------------------------------------.,----------------------------------------------------------------------------------------------------------------------------------------------------------.,

Essayez-le en ligne!

Comment ça fonctionne

Nous commençons par mettre l'entier 45 (code de caractère de -) dans une cellule de la bande. Le code suivant y parvient.

-      Decrement cell 0, setting it to 255.
[      While the cell under the head in non-zero:
  [>]    Advance to the next zero cell.
  <--    Decrement the cell to its left.
  <--    Decrement the next cell to the left.
]

Avant d'entrer dans la boucle, la bande ressemble à ceci.

         v
000 000 255

Ces trois cellules - -2 , -1 et 0 - sont les seules que nous utiliserons dans ce programme.

Dans la première chaque itération de la boucle, la cellule la plus à droite est, puis cette cellule et la cellule du milieu sont décrémentées deux fois, laissant l'état suivant.

     v
000 254 252

Dans les 126 itérations suivantes, l'initiale -décrémente la cellule du milieu, [>]<saute à la cellule la plus à droite et --<--décrémente la cellule du milieu et la cellule de droite. Par conséquent, 3 est soustrait de la cellule centrale (modulo 256 ) et 2 est soustrait de la cellule la plus à droite.

Puisque 254 ÷ 3 (mod 256) = (254 + 256) ÷ 3 = 510 ÷ 3 = 170 et 252 ÷ 3 = 84 , la cellule la plus à droite est mise à zéro avant celle du milieu, laissant l'état suivant.

     v
000 132 000

Comme pour la première itération de la boucle, l'itération suivante soustrait maintenant 3 de la cellule du milieu et 2 de la cellule la plus à gauche, en plaçant la tête sur la cellule la plus à gauche.

 v
254 129 000

Les itérations suivantes, comme dans l'itération 126 avant elles, soustraient 3 de la cellule la plus à gauche et 2 de la cellule la plus à droite.

Puisque 254 ÷ 3 (mod 256) = 170 et 129 ÷ 2 (mod 256) n'est pas défini, cela se fait 170 fois, laissant l'état suivant.

 v
000 045 000

La cellule sous la tête est nulle; la boucle se termine.

Nous sommes maintenant prêts à générer une sortie.

,      Read a character from STDIN and put it the leftmost cell.
[        While the leftmost cell is non-zero:
  [        While the leftmost cell is non-zero:
    >.     Print the content of the middle cell ('-').
    <-     Increment the leftmost cell.
  ]      If the leftmost cell held n, the above will print 256 - n minus signs
         which, when executed, will put n in cell 0 of the output program.
  >      Increment the middle cell, setting it to 46 ('.').
  .      Print its content ('.').
  --     Decrement the middle cell twice, setting it to 44 (',').
  .      Print its content (',').
         When executed, since the output program receives no input, the above
         will zero cell 0 of the output program.
  +      Increment the second cell, setting it back to 45 ('-').
  <,     Go back to the leftmost cell and read another character from STDIN.
]      Once EOF is reached, this will put 0 in the leftmost cell, ending the loop.

Dennis
la source

Pourquoi le BF résultant ne se traduit-il pas dans la chaîne d'entrée pour moi? C'est l' interprète que j'utilise, qui a fonctionné pour les autres réponses.

Insane

2

Cet interprète a beaucoup de paramètres. Pour la version 32 octets, vous aurez besoin de mémoire dynamique et fin de l' entrée:\0 .

Dennis

10

Brainfuck, 35 ₁₃ 43 octets

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

Cette réponse ne fait aucune hypothèse sur l'interpréteur du programme de sortie. Essayez-le en ligne!

Pour une solution plus courte (qui ne fonctionne qu'avec certains interprètes), voir mon autre réponse .

Essai

Pour l'entrée Code Golf, la sortie suivante est générée.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.----------------------------------------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-----------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++.--------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-----------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------------------------------------------------------------+++++++++++++++++++++++++++++++++.---------------------------------

Essayez-le en ligne!

Comment ça fonctionne

Nous commençons par mettre l'entier 43 (code de caractère de +) dans la deuxième cellule de la bande. Le code suivant y parvient.

++         Increment the first cell twice, setting it to 2.
[          While the first cell in non-zero:
  >+         Increment the second cell.
  <------    Decrement the first cell six times.
]

Cela effectue essentiellement la division modulaire 2 ÷ 6 (mod 256) . Puisque (2 + 256) ÷ 6 = 258 ÷ 6 = 43 , le résultat est 43 , comme prévu.

Nous sommes maintenant prêts à générer une sortie.

,      Read a character from STDIN and put it the first cell.
[        While the first cell is non-zero:
  [        While the first cell is non-zero:
    >.     Print the content of the second cell ('+').
    >+     Increment the third cell.
    <<-    Decrement the first cell.
  ]      If the first cell held n, the above prints n plus signs
         and puts n in the third cell.
  >+++   Add three to the second cell, setting it to 46 ('.').
  .      Print its content ('.').
  -      Decrement, setting it to 45 ('-').
  >      Advance to the third cell.
  [      While the third cell is non-zero:
    <.     Print the content of the second cell ('-').
    >-     Decrement the third cell.
  ]      If the first cell held n, the above prints n minus signs,
         thus negating the plus signs and zeroing the cell of the output program.
  <--    Subtract 2 from the second cell, setting it back to 43.
  <,     Go back to the first cell and read another character from STDIN.
]      Once EOF is reached, ',' will put 0 in the first cell, ending the loop.

Dennis
la source

Oh mec! Vous ne pouvez pas briser le mème barré-44-is-44, allez! Quoi qu'il en soit, votre tentative de le vaincre a lamentablement échoué car il n'a pas l'air rayé, il semble qu'il y ait de la saleté sur mon écran (PHP, peut-être?): P

cat

2

Tout pour éviter ce commentaire ...

Dennis

5

Pyth - 11 octets

sm+*\+Cd".>

Essayez-le en ligne ici .

Maltysen
la source

4

05AB1E, 12 11 octets

vyÇ`'+×„.>J

Expliqué

v             # for each char in input string
 yÇ`          # convert to its ascii value
    '+×       # push the char '+' that many times
       „.>J   # push string ".>" and join with the plus signs
              # implicitly print combined string

Essayez-le en ligne

1 octet enregistré grâce à @Adnan

Emigna
la source

'+×au lieu d' F'+}enregistrer un octet.

Adnan

1

@Adnan: Merci! Je cherchais une commande "répéter".

Emigna

4

Java, 98 octets

class a{String A(char[]b){String z="";for(char B:b){for(int c=B;c-->0;)z+="+";z+=".>";}return z;}}

Stringles s ne sont rien de plus que des char[]s immuables avec un tas de méthodes utilitaires, alors utilisons le tableau!

Non golfé:

class a {
    void A(char[] b) {
        for (char B : b) {
            for (int c = B; c-- > 0;)
                 System.out.print('+');
            System.out.print(".>");
        }
    }
}

Programme autonome équivalent de 138 octets de long:

interface a{static void main(String[]A){for(char b:A[0].toCharArray()){for(int B=b;B-->0;)System.out.print('+');System.out.print(".>");}}}

Prime:

interface a{static void main(String[]A){for(char b:new java.util.Scanner(new java.io.File(A[0])).useDelimiter("\\Z").next().toCharArray()){for(int B=b;B>0;B--)System.out.print('+');System.out.print(".>");}}}

Cette application de 207 octets code en fait un fichier en tant que programme BF, comme indiqué dans le titre.

user8397947
la source

2

Est-ce juste moi ou la façon dont le programme non golfé est indenté est-elle géniale?

user8397947

Je me suis rendu compte juste avant de poster que ma réponse est essentiellement une version golfée de la vôtre.

Insane

2

Vitsy, 19 17 octets

I\[&'>.+'i1-\Du]Z

I                     Get the length of the input stack.
 \[            ]      Pop n, repeat this block of code n times.
   &                  Push a new stack and move to it.
    '>.+'             Push the string '+.>' to the stack.
         i            Pop an item from the input stack and push it to the current
                      program stack.
          1-          Subtract one from the top program stack item.
            \D        Duplicate the '+' in the stack that many times.
              u       Merge the current program stack with the previous.
                Z     Output the entire current stack as a string.

Notez que cette réponse est l'une des rares fois que j'ai jamais utilisée Iet u. :RÉ

Essayez-le en ligne!

Addison Crump
la source

2

O , 13 octets

i{'+n#*".>"}d

Explication:

i              Read standard input into a string and push it onto the stack.
 {         }d  For each character in the string...
  '+           Push "+".
    n#         Convert the character (n) to its ASCII code.
      *        Multiply the "+" by the character code to get the number of +'s needed.
       ".>"    Push the string ".>".
               In O, the stack is printed after execution, so this prints out the result.

kirbyfan64sos
la source

2

K6, 16 octets

,/{|">.",x#"+"}'

Usage

,/{|">.",x#"+"}'"some string"

Explication

  {           }'  For each character in the string...
         x#"+"    Repeat "+" as many times as the character's ASCII code.
        ,         Combine that with...
    ">."          The code to print it and move on.
   |              But we put the string together backwards...so now it gets reversed.
,/                Combine all the substrings into one BIG string.

kirbyfan64sos
la source

Explication plz: D

Addison Crump

@VTCAKAVSMoACE Terminé! :)

kirbyfan64sos

2

Python 3, 43 octets

lambda s:''.join('+'*ord(c)+'.>'for c in s)

Le Python met un certain nombre d'avantages équivalents au code ASCII de chaque caractère, suivi de .> pour imprimer et passer à la cellule suivante. Le brainfuck augmente jusqu'à la valeur correcte, imprime et passe à la cellule suivante.

Sortie pour hi(avec des nouvelles lignes pour plus de clarté):

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

Sortie de ce programme:

hi

bkul
la source

2

Perl, 25 octets

s/./"+"x ord($&).".>"/eg

Usage

echo -n hi | perl -pe 's/./"+"x ord($&).".>"/eg'

Explication

Utilise une opération de remplacement d'expression régulière pour remplacer chaque caractère de chaque ligne donnée sur l'entrée standard par un nombre +calculé à partir de la valeur ordinale de ce caractère, puis sort .>pour imprimer et passer au caractère suivant.

Utilise l' -pindicateur perl pour lire automatiquement l'entrée et imprimer le résultat, en ajoutant 1 supplémentaire au bytecount.

tuyau
la source

2

Java, 91 octets

String b(char[] f){String k="";for(char b:f){for(int u=b;u>0;u--)k+="+";k+=".>";}return k;}

Accessoires à dorukayhan pour m'avoir battu :)

Insensé
la source

Vous ne pouvez pas simplement supprimer le passe-partout et modifier tous les noms des variables, puis réclamer cela comme une nouvelle réponse.

Leaky Nun

@LeakyNun Je ne l'ai pas fait, mais je pourrais si je le voulais.

Insane

En quoi cette réponse est-elle différente de la réponse à laquelle vous avez lié?

Leaky Nun

@LeakyNun Downvote and move on

Insane

2

C, 72 64 60 octets

main(c){for(;c=~getchar();)for(;printf(~c++?"+":".>")^2;);}

Version non golfée:

main( c )
{
    for ( ; c = ~getchar( ); )
        for ( ; printf( ~c++ ? "+" : ".>" ) ^ 2; );
}

Compilez et testez avec:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Résultats

hi- http://paste.ubuntu.com/17995958/
quick brown fox jumps over the lazy dog- http://paste.ubuntu.com/17996059/
code source - http://paste.ubuntu.com/18000808/

Jacajack
la source

Pourquoi cl'inverse au niveau du bit getchar, surtout si vous inversez simplement l'inversion?

cat

@cat est c = ~getchar( )évalué à 0 activé EOF. c = ~getchar( )et ~c++sont tout simplement plus courts que ~( c = getchar( ) )etc--

Jacajack

2

CJam, 12 octets

Convertit chaque caractère en sa valeur ASCII et incrémente la cellule actuelle de ce nombre de fois avant de l'imprimer. Comme nous avons une bande infinie, nous pouvons simplement nous déplacer vers la droite après avoir traité chaque caractère.

q{i'+*'.'>}%

Essayez-le en ligne!

Cas
la source

2

Lua, 67 66 61 octets

Parcourez simplement chaque caractère de l'argument et imprimez une ligne pour chacun avec n +s suivi de .>où nest la valeur de ce caractère dans la table ASCII.

Utilise gmatch comme @LeakyNun conseillé dans le commentaire pour économiser 1 octet sur la solution gsub

for c in(...):gmatch"."do print(("+"):rep(c:byte())..".>")end

Ancienne solution utilisant gsub

(...):gsub(".",function(c)print(c.rep("+",c:byte())..".>")end)

Vieux 67

(...):gsub(".",function(c)print(string.rep("+",c:byte())..".>")end)

Pour l'exécuter, il suffit de l'enregistrer en tant que fichier ( golf.luapar exemple) et de l'exécuter avec lua golf.lua "hi". Pour hi, il devrait sortir

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

Katenkyo
la source

Comment est-ce que j'utilise ceci? Le coller simplement dans le REPL donne attempt to index a nil valueet f = ...donne la même chose et function f ... enddonneunexpected symbol near ':'

cat

@cat Il suffit de l'enregistrer dans un fichier et de l'exécuter en tant que lua file.lua "argument", je mettrai à jour le message pour donner des instructions.

Katenkyo

Comment ça marche même? est ...un identifiant avec argv?

cat

1

@cat ...contient les valeurs de la table argdécompressée. Ce qui signifie qu'il correspondra toujours à arg[1]moins que vous ne l'utilisiez dans un appel de fonction comme dernier paramètre, il sera dépensé.

Katenkyo

n=...for n:gmatch"."do print(("+"):rep(c:byte())..".>")endpour 48 octets

Leaky Nun

1

J, 28 octets

[:;[:('.>',~'+'#~])"0[:]3&u:

Assez simple. 3&u:convertit les caractères en codes de caractères. Le reste est simplement répéter '+'ce nombre de fois, puis concaténer avec .>à la fin de chaque ligne, et; aplatit le résultat.

Quelques résultats

   bf =: [:;[:('>.',~'+'#~])"0[:]3&u:
   bf 'hi'
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>. +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.
   bf ' !'
++++++++++++++++++++++++++++++++>. +++++++++++++++++++++++++++++++++>.
   bf ' ~'
++++++++++++++++++++++++++++++++>.
                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.

Conor O'Brien
la source

1

Pyke, 11 octets

F.o\+*".>"+

Essayez-le ici!

Bleu
la source

1

En fait, 13 octets

O`'+*".>"@`MΣ

Essayez-le en ligne!

La stratégie utilisée ici est la même que dans la plupart des autres solutions - pour chaque caractère, sortez suffisamment de +s pour incrémenter une cellule initialisée à zéro au bon ordinal ASCII, sortez-la avec .et passez à la cellule suivante avec> .

Explication:

O`'+*".>"@`MΣ
O              list of ordinals (technically this is Unicode code points, but code points 0-127 are the same for Unicode and ASCII)
 `'+*".>"@`M   for each ordinal:
  '+*            push a string containing that many +s
     ".>"@       push ".>" and swap (putting it before the +s)
            Σ  concatenate all the strings (if "[", "]", and "," weren't meaningful characters in BF, this technically wouldn't be necessary)

Mego
la source

1

Souris-2002, 27 octets

(?'l:l.^(l.^"+"l.1-l:)".>")

Cela fonctionne en théorie et selon la documentation du langage, mais l'implémentation de référence de l'interpréteur de Mouse semble avoir un bug où l'entrée de chaîne ajoute un ', donc pour aces sorties

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++.>

Qui à son tour sort a'. Cela peut ou peut ne pas être correct, alors voici un long de 39 octets qui ne sort 'jamais et est donc probablement plus invalide.

(?'l:l.39=l.0=+0=^(l.0>^"+"l.1-l:)".>")

Ce qui donne une bonne sortie dans l'impl de référence. tant qu'il n'y a pas de 's :)

Expliqué:

(              ~ while (true) {
  ?' l:        ~   l = getchar() 
  l. ^         ~   if (! (l) ) { break }
  (            ~   while (true) {
    l. ^       ~     if (! (l) ) { break }
    "+"        ~     puts("+")
    l. 1 - l:  ~     l-- // l = l - 1
  )            ~   }
  ".>"         ~   puts(".>")
)              ~ }

chat
la source

1

Facteur, 58 octets

[ [ [ 43 ] ""replicate-as ".>"append ] { } map-as ""join ]

Fonctionne comme:

[ 
  [ 
    [ 43 ] "" replicate-as  ! ``+'' * code point, clone-like a string ""
    ".>" append             ! append ".>"
  ] 
  { } map-as                ! for each char in string and clone-like an array { }
  "" join                   ! join array of str into str by ""
]

Étant donné que Factor est livré avec un interprète Brainfuck, il est simple à tester.

bfcat.factor

USING: sequences ;
IN: bfcat

: string>brainfuck ( s -- bf )
  [ [ 43 ] "" replicate-as ".>" append ]
  { } map-as "" join ;

bfcat-tests.factor

USING: tools.test bfcat brainfuck ;
IN: bfcat.tests

{ "a"  } [ "a"  string>brainfuck get-brainfuck ] unit-test
{ "ab" } [ "ab" string>brainfuck get-brainfuck ] unit-test
{ "+++++++++++++" } [ "+++++++++++++" string>brainfuck get-brainfuck ] unit-test
{ "Code Golf" } [ "Code Golf" string>brainfuck get-brainfuck ] unit-test

production

Unit Test: { { "a" } [ "a" string>brainfuck get-brainfuck ] }
Unit Test: { { "ab" } [ "ab" string>brainfuck get-brainfuck ] }
Unit Test: {
    { "+++++++++++++" }
    [ "+++++++++++++" string>brainfuck get-brainfuck ]
}
Unit Test: {
    { "Code Golf" }
    [ "Code Golf" string>brainfuck get-brainfuck ]
}

Yay! ils passent tous.

chat
la source

1

Rubis, 40 38 octets

gets.chop.each_byte{|o|puts"+"*o+".>"}

Fève de cacao
la source

Je ne connais pas ruby mais je sais que vous pouvez utiliser à la putsplace de print, car le format de la sortie n'est pas significatif tant qu'il est valide brainfuck et brainfuck ne se soucie pas des autres personnages

cat

@cat oh je ne savais pas que bf ignore les autres personnages, merci!

CocoaBean

1

Sidef , 38 octets

Hé, la même longueur que Ruby! juste que Sidef n'est pas Ruby: D

read().bytes.each{|c|say"+"*c;say".>"}

Lisez quelques caractères, puis pour chaque octet, faites cette chose.

chat
la source

1

GNU Bash, 100 85 octets

while IFS= read -rn1 c;do printf '+%.0s' $(seq 1 $(printf %d \'$c));echo '.>';done<$1

Merci @cat de m'avoir sauvé 15 octets!

Postramble

Suppose que la chaîne d'entrée est représentée telle quelle dans un fichier transmis comme premier argument.
Usage: bash bfcat.sh <path to file containing string>
Utilisation (avec canal nommé): bash bfcat.sh <(echo -n '<string>')

Non golfé

while IFS= read -r -n1 c # Read file byte by byte [1]
do
    n=$(printf "%d" \'"$c") # `ord` of a char in bash [2]
    printf '+%.0s' $(seq 1 $n) # emit character $n times [3]
    echo '.>' # Emit output and shift command for bf. I love infinite memory.
done <"$1"

Références en version non golfée

Yeow_Meng
la source

1

J'ai amélioré une partie de la mise en forme et des éléments de votre réponse, et supprimé les informations redondantes des liens. N'hésitez pas à le défaire si vous ne l'aimez pas. De plus, c'est GNU Bash, pas GNU / Bash comme GNU / Linux. :)

cat

1

Conseils de golf (je ne suis pas un golfeur bash) read -rn1:, débarrassez-vous des espaces après ;, débarrassez-vous de l'espace done <"$1"pour économiser un total de 9 octets

cat

1

@cat Ça a l'air génial! J'ai vraiment besoin de prendre l'habitude de modifier-> prévisualiser-> modifier -> ...

Yeow_Meng

1

ES6, 119 115 octets

f=s=>{a='';for(i in[...s]){b=s[c='charCodeAt'](i)-(s[c](i-1)|0);a+=(b>0?'+'.repeat(b):'-'.repeat(-b))+'.'}return a}

4 octets enregistrés grâce à @Leibrug

bodqhrohro
la source

1

Vous pouvez attribuer charCodeAtà certains var (disons c) et utiliser comme ça: s[c](i)pour raccourcir de 1 octet, et aussi supprimer certains caractères (j'ai trouvé 3: espace avant [...s], remplacez OR logique par un bit et un point-virgule avant return).

Leibrug

1

Sesos (non compétitif)

Hexdump:

0000000: 28cbf6 02e83d 655bae 243901                       (....=e[.$9.

Size   : 12 byte(s)

Essayez-le en ligne!

Assembleur

add 43,fwd 1,get
jmp
  jmp,sub 1,rwd 1,put,fwd 1,jnz
  add 46,put,add 16,put
  get

Leaky Nun
la source

0

Rubis, 26 octets

gsub(/./){?+*$&.ord+'.>'}

+ 1 octet pour l' poption de ligne de commande. Par exemple, pour obtenir le code brainfuck pour ABC xyzvous pouvez exécuter

$ ruby -p -e 'gsub(/./){?+*$&.ord+".>"}' <<< "ABC xyz"

et obtenir

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

daniero
la source

0

Haskell 50 octets

f[]=[]
f(x:y)=replicate(fromEnum x)'+'++".>"++f y

ForemanBob
la source

bfcat - encoder un fichier en tant que programme brainf ***

Défi

Exemples

Chaîne d'espace

Point d'exclamation

Deux lettres

Réponses:

Gelée , 8 octets

Exemple d'exécution

Comment ça fonctionne

Brainfuck, 55 51 octets

Explication

Brainfuck, 39 33 32 31 octets

Essai

Comment ça fonctionne

Brainfuck, 35 13 43 octets

Essai

Comment ça fonctionne

Pyth - 11 octets

05AB1E, 12 11 octets

Java, 98 octets

Vitsy, 19 17 octets

O , 13 octets

K6, 16 octets

Usage

Explication

Python 3, 43 octets

Perl, 25 octets

Usage

Explication

Java, 91 octets

C, 72 64 60 octets

Résultats

CJam, 12 octets

Lua, 67 66 61 octets

J, 28 octets

Quelques résultats

Pyke, 11 octets

En fait, 13 octets

Souris-2002, 27 octets

Facteur, 58 octets

Rubis, 40 38 octets

Sidef , 38 octets

GNU Bash, 100 85 octets

Postramble

Non golfé

Références en version non golfée

ES6, 119 115 octets

Sesos (non compétitif)

Assembleur

Rubis, 26 octets

Haskell 50 octets

Brainfuck, 35 ₁₃ 43 octets