Brainf *** Golfer

32

L'un des codes les plus simples écrits par un langage de programmation est une séquence d'impression de caractères de programme (ex. "Bonjour, monde!"). Cependant, s o m e e s o t e r i c langages de programmation comme Brainfuck , même ce code le plus simple est assez ennuyeux d'écrire.

Votre tâche consiste à écrire un programme (pas besoin d'écrire en brainfuck), qui imprime un programme Brainfuck (de longueur minimale) imprimant le texte donné.

Contribution

Une séquence de caractères (entre 1et 255) est donnée par n'importe quel format (variable, argument, stdin, fichier, ...).

Sortie

La sortie est un code brainfuck valide (pas de correspondance [et non ]) (supposez une cellule d'encapsulation 8 bits non signée et un nombre illimité de cellules à gauche et à droite) imprimant la chaîne exacte qui a été donnée en entrée.

Par exemple, une sortie possible pour l'entrée Aest ++++++++[<++++++++>-]<+..

Votre programme ne devrait pas prendre beaucoup de temps ( >2m) pour s'exécuter.

Le programme BF ne devrait pas prendre beaucoup de temps ( >10s) pour s'exécuter.

Notation

(Remarque: la méthode de notation actuelle peut changer, car elle n'est pas facile à calculer ...)

La longueur du programme (génération du code BF) lui - même n'a pas d' importance. Cependant, les codes BF codés en dur dans le code de programme ne sont pas OK. Seule plage acceptable (ex un code BF impression d' un caractère unique. 0x01: +.) De code BF peut être codé en dur.

Le score est la somme de la longueur des codes BF imprimant ces chaînes.

  • Une chaîne Hello, world!ajoutée avec un simple 0x0A( \n) (c'est-à-dire le programme "Hello, world!")
  • Caractère unique de 0x01~0xFF
    • La somme de la longueur de ces 255 codes BF est multipliée par 1/16, arrondie et ajoutée au score.
  • Liste des 16 premières chaînes, générées en fractionnant une séquence aléatoire d'octets générés le 11-11-11 par 0x00, supprimant toutes les chaînes de longueur nulle.
  • Lenna.png , supprimant tous les 0x00s.
  • Paroles de la chanson 99 bouteilles de bière , en commençant par 99 bottles~, les sauts de ligne sont 0x0A, les paragraphes sont séparés par deux 0x0As, et aucun caractère de saut de ligne à la fin.
  • Autres chaînes que vous pouvez fournir.

Votre programme peut inclure le calcul du score de lui-même.

Bien sûr, le code ayant obtenu le score le plus bas sera le gagnant.

JiminP
la source
Dupliquer (bien que mieux formulé) de codegolf.stackexchange.com/questions/3450/…
copie le
4
Cela semble assez difficile à calculer les scores. Il s'agit de nombreux fichiers différents que nous devons rechercher et parcourir. Quel est l'intérêt des «autres chaînes que vous pouvez fournir». Pourquoi ajouterais-je plus si cela ajoutera à mon score?
captncraig
1
Lenna.pngva dominer le score, car il est de loin la plus grande entrée. Peut-être normaliser un peu par taille?
Keith Randall
1
Le code de longueur minimale pour «A» est ---- [----> + <]> ++.
Scony
1
OP ne se soucie évidemment pas de ce défi. Modifions les règles de notation en quelque chose de sensé? Actuellement, une seule réponse (sans succès) a essayé d'utiliser ces règles, donc la modification des règles n'invalidera pas les réponses.
anatolyg

Réponses:

15

En Java, calcule un court extrait BF qui peut convertir n'importe quel nombre en n'importe quel autre nombre. Chaque octet de sortie est généré en transformant le dernier octet de sortie ou un nouveau 0 sur la bande.

Les extraits sont générés de trois manières. D'abord par de simples répétitions de +et -(par exemple, ++++convertit 7 en 11), en combinant des extraits connus (par exemple si A convertit 5 en 50 et B convertit 50 en 37, puis AB convertit 5 en 37) et des multiplications simples (par exemple, [--->+++++<]multiplie le nombre actuel par 5/3). Les multiplications simples profitent du wraparound pour générer des résultats inhabituels (par exemple, --[------->++<]>génère 36 à partir de 0, où la boucle s'exécute 146 fois, avec un total de 4 wraparounds décroissants et 1 ascendant).

Je suis trop paresseux pour calculer mon score, mais il utilise environ 12,3 opérations BF par octet Lenna.png.

import java.io.*;

class shortbf {
    static String repeat(String s, int n) {
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < n; i++) b.append(s);
        return b.toString();
    }

    // G[x][y]: BF code that transforms x to y.                                                     
    static String[][] G = new String[256][256];
    static {
        // initial state for G[x][y]: go from x to y using +s or -s.                                
        for (int x = 0; x < 256; x++) {
            for (int y = 0; y < 256; y++) {
                int delta = y - x;
                if (delta > 128) delta -= 256;
                if (delta < -128) delta += 256;

                if (delta >= 0) {
                    G[x][y] = repeat("+", delta);
                } else {
                    G[x][y] = repeat("-", -delta);
                }
            }
        }

        // keep applying rules until we can't find any more shortenings                             
        boolean iter = true;
        while (iter) {
            iter = false;

            // multiplication by n/d                                                                
            for (int x = 0; x < 256; x++) {
                for (int n = 1; n < 40; n++) {
                    for (int d = 1; d < 40; d++) {
                        int j = x;
                        int y = 0;
                        for (int i = 0; i < 256; i++) {
                            if (j == 0) break;
                            j = (j - d + 256) & 255;
                            y = (y + n) & 255;
                        }
                        if (j == 0) {
                            String s = "[" + repeat("-", d) + ">" + repeat("+", n) + "<]>";
                            if (s.length() < G[x][y].length()) {
                                G[x][y] = s;
                                iter = true;
                            }
                        }

                        j = x;
                        y = 0;
                        for (int i = 0; i < 256; i++) {
                            if (j == 0) break;
                            j = (j + d) & 255;
                            y = (y - n + 256) & 255;
                        }
                        if (j == 0) {
                            String s = "[" + repeat("+", d) + ">" + repeat("-", n) + "<]>";
                            if (s.length() < G[x][y].length()) {
                                G[x][y] = s;
                                iter = true;
                            }
                        }
                    }
                }
            }

            // combine number schemes                                                               
            for (int x = 0; x < 256; x++) {
                for (int y = 0; y < 256; y++) {
                    for (int z = 0; z < 256; z++) {
                        if (G[x][z].length() + G[z][y].length() < G[x][y].length()) {
                            G[x][y] = G[x][z] + G[z][y];
                            iter = true;
                        }
                    }
                }
            }
        }
    }
    static void generate(String s) {
        char lastc = 0;
        for (char c : s.toCharArray()) {
            String a = G[lastc][c];
            String b = G[0][c];
            if (a.length() <= b.length()) {
                System.out.print(a);
            } else {
                System.out.print(">" + b);
            }
            System.out.print(".");
            lastc = c;
        }
        System.out.println();
    }

    static void genFile(String file) throws IOException {
        File f = new File(file);
        int len = (int)f.length();
        byte[] b = new byte[len];
        InputStream i = new FileInputStream(f);
        StringBuilder s = new StringBuilder();
        while (true) {
            int v = i.read();
            if (v < 0) break;
            if (v == 0) continue; // no zeros                                                       
            s.append((char)v);
        }
        generate(s.toString());
    }
    public static void main(String[] args) throws IOException {
        genFile(args[0]);
    }
}
Keith Randall
la source
Je sais que j'ai environ deux ans et demi de retard et ce n'est pas du golf, mais la méthode de répétition pourrait simplement être de renvoyer une nouvelle chaîne (nouveau char [longueur]). ReplaceAll ("\ 0", str);
Loovjo
13

Eh bien, voici la pire solution possible, bien que plutôt jolie à Brainfuck:

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

Le score est probablement le pire que nous puissions voir sans le rendre intentionnellement mauvais.

Travailler sur le calcul du score réel.

captncraig
la source
Pourriez-vous expliquer ce que cela fait? La lecture du code BF est assez difficile.
BMac
3
Pour chaque octet d'entrée, il +.
affiche
Avec je crois un [-]pour effacer la cellule entre chaque personnage.
captncraig
8

Python 3.x

Eh bien, je ne vais pas gagner de prix pour le code de sortie le plus court mais peut-être pour le programme pour générer le code ...

x=input();o=''
for i in x:
 a=ord(i)
 o+="+"*a+".[-]"
print(o)

"Bonjour le monde! \ N":

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++++++
++++.[-]++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++.[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++.[-]++++++++++.[-]
icedvariables
la source
1
Accidentellement répondu à la réponse de Madisons. Générateur plus court:print("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError
Vous pouvez jouer votre programme par 2 caractères en remplaçant .[-]par.>
MilkyWay90
47 octets
MilkyWay90
8

Je ne sais pas à quel point c'est bon, mais je me suis amusé à écrire ceci. (À Clojure ...)

(ns bf.core)
(def input "Hello world!")
(defn abs [x] (if (and (< x 0) (= (type x) (type 1))) (* x -1) x)) 
(defn sqrt? [x y] (if (= (* y y) x) true false) )
(defn sqrt [x] (for [y (range x) :when (sqrt? x y)] y) )
(defn broot [x]
;  Run this using trampoline, e.g., (trampoline broot 143)
  (if (< x 2) nil)
  (let [y (sqrt x)]
    (if (not= (seq y) nil)
      (first y)
      (broot (dec x) )
      )
    )
  )
(defn factor [x]
  (if (<= x 2) x)
  (for [y (range (- x 1) 1 -1)
        :when (= ( type (/ x y) ) (type 1) )
        ]
    y)
  )

(defn smallest_factors [x]
  (let [ facts (factor x) ]
  (if (= (count facts) 2) facts)
  (if (< (count facts) 2) (flatten [facts facts])
    (let [ y (/ (dec (count facts) ) 2)
          yy (nth facts y)
          z (inc y)
          zz (nth facts z)
          ]
      (if (= (* yy zz) x ) [yy zz] [yy yy])
      )
    )
    )
  )

(defn smallestloop [x]
  (let [ facts (smallest_factors x)
        fact (apply + facts)
        sq (trampoline broot x)
        C (- x (* sq sq) )]
    (if (and (< fact (+ (* 2 sq) C) ) (not= fact 0))
      facts
      [sq sq C])
    )
  )
(def lastx nil)
;Finally!
(defn buildloop [x]
  (if (nil? lastx)
     (let [pluses (smallestloop x)]
       (apply str
              (apply str (repeat (first pluses) \+))
              "[>"
              (apply str (repeat (second pluses) \+))
              "<-]>"
              (if (and (= (count pluses) 3) (> (last pluses) 0))
                (apply str(repeat (last pluses) \+))
              )
              "."
              )
    )
    (let [diff (abs (- x lastx) )]
      (if (< diff 10)
        (if (> x lastx)
          (apply str
               (apply str (repeat diff \+))
               "."
                 )
          (apply str
                 (apply str (repeat diff \-))
                 "."
                 )
          )
        (let [signs (smallestloop diff)]
          (apply str
             "<"
             (apply str (repeat (first signs) \+))
             "[>"
             (if (> x lastx)
               (apply str (repeat (second signs) \+))
               (apply str (repeat (second signs) \-))
             )
             "<-]>"
             (if (and (= (count signs) 3) (> (last signs) 0))
               (if (> x lastx)
                 (apply str(repeat (last signs) \+))
                 (apply str(repeat (last signs) \-))
               )
             )
             "."
           )
         )
        )
      )
    )
  )
(for [x (seq input)
  :let [y (buildloop (int x))]
      ]
  (do 
   (def lastx (int x))
   y
   )
  )

Il existe probablement des solutions plus efficaces et plus élégantes, mais cela suit mon schéma de pensée de manière quelque peu linéaire, donc c'était plus facile.

Marty
la source
8

But: 4787486 41439404086426 (sans données générées aléatoirement)

(4085639 de Lenna.png. C'est 99,98%)

Je ne reçois pas la partie avec les données aléatoires. N'ai-je pas besoin d'un compte pour lequel je dois payer pour obtenir les données?

Assez naïf. Voici le code généré pour "1Aa" (49, 65, 97) avec une petite documentation:

                   // field 0 and 1 are loop counters.
                   // The fields 2, 3 and 4 are for "1", "A" and "a"
++++++++++[        // do 10 times
    >
    ++++++++++[    // do 10 times
        >          // "1" (49) is below 50 so we don't need to do anything here
        >+         // When the loops are done, this part will have increased the value of field 3 by 100 (10 * 10 * 1)
        >+         // same as above
        <<<-       // decrease inner loop counter
    ]
    >+++++         // this will add 50 (10 * 5) to field 2, for a total of 50
    >----          // subtract 40 from field 3, total of 60
    >              // Nothing done, value stays at 100
    <<<<-          // decrease outer loop counter
]
>>-.               // subtract 1 from field 2, total now: 49, the value for "1"
>+++++.            // add 5 to field 3, makes a total of 65, the value for "A"
>---.              // subtract 3 from field 4, total of 97, the value for "a"

Le code Java est un peu moche mais ça marche. Le rapport d'instructions générées par octet d'entrée est probablement meilleur si la valeur d'octet moyenne est élevée.

Si vous voulez l'exécuter, vous devez mettre Lenna.png dans le même répertoire que le fichier .class. Il imprime la partition sur la console et écrit le code BF généré dans un fichier appelé "output.txt".

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;


public class BrainFuckGenerator {
    public static CharSequence generate(byte[] bytes) {
        final StringBuilder brainfuckBuilder = new StringBuilder();
        for(int j = 0; j<10; j++)
                brainfuckBuilder.append("+");

        brainfuckBuilder.append("[>");

        for(int j = 0; j<10; j++)
            brainfuckBuilder.append("+");

        brainfuckBuilder.append("[");

        final StringBuilder singles = new StringBuilder();
        final StringBuilder tens = new StringBuilder();
        final StringBuilder goBack = new StringBuilder();

        for(byte b: bytes) {
            brainfuckBuilder.append(">");
            for(int j=0; j<(b/100); j++) {
                brainfuckBuilder.append("+");
            }

            tens.append(">");
            if((b - (b/100)*100)/10 <= 5) {
                for(int j=0; j<(b - (b/100)*100)/10; j++) {
                    tens.append("+");
                }
            } else {
                brainfuckBuilder.append("+");
                for(int j=0; j<10 - (b - (b/100)*100)/10; j++) {
                    tens.append("-");
                }
            }

            singles.append(">");
            if(b%10 <= 5) {
                for(int j=0; j<b%10; j++) {
                    singles.append("+");
                }
            } else {
                tens.append("+");
                for(int j=0; j<10 - (b%10); j++) {
                    singles.append("-");
                }
            }
            singles.append(".");

            goBack.append("<");
        }
        goBack.append("-");

        brainfuckBuilder
            .append(goBack)
            .append("]")
            .append(tens)
            .append("<")
            .append(goBack)
            .append("]>")
            .append(singles);

        return brainfuckBuilder;
    }

    public static void main(String[] args) {
        /* Hello, World! */
        int score = score("Hello, world!"+((char)0xA));

        /* 255 single chars */
        int charscore = 0;
        for(char c=1; c<=0xff; c++)
            charscore += score(String.valueOf(c));

        score += Math.round(((double)charscore)/16);

        /* Lenna */
        final File lenna = new File("Res/Lenna.png");
        final byte[] data = new byte[(int)lenna.length()];
        int size = 0;
        try(FileInputStream input = new FileInputStream(lenna)) {
            int i, skipped=0;
            while((i = input.read()) != -1)
                if(i == 0)
                    skipped++;
                else
                    data[size++ - skipped] = (byte)(i&0xff);
        } catch (IOException e) {
            e.printStackTrace();
        }

        score += score(Arrays.copyOf(data, size), "Lenna");

        /* 99 Bottles */
        final StringBuilder bottleBuilder = new StringBuilder();
        for(int i=99; i>2; i--) {
            bottleBuilder
                .append(i)
                .append(" bottles of beer on the wall, ")
                .append(i)
                .append(" bottles of beer.")
                .append((char) 0xa)
                .append("Take one down and pass it around, ")
                .append(i-1)
                .append(" bottles of beer on the wall.")
                .append((char) 0xa)
                .append((char) 0xa);

        }

        bottleBuilder
            .append("2 bottles of beer on the wall, 2 bottles of beer.")
            .append((char) 0xa)
            .append("Take one down and pass it around, 1 bottle of beer on the wall.")
            .append((char) 0xa)
            .append((char) 0xa)
            .append("No more bottles of beer on the wall, no more bottles of beer. ")
            .append((char) 0xa)
            .append("Go to the store and buy some more, 99 bottles of beer on the wall.");

        score(bottleBuilder.toString(), "99 Bottles");
        System.out.println("Total score: "+score);
    }

    private static int score(String s) {
        return score(s, null);
    }

    private static int score(String s, String description) {
        final CharSequence bf = generate(s.getBytes());
        try(FileWriter writer = new FileWriter("Res/output.txt", true)) {
            writer.write((description == null ? s : description));
            writer.write(NL);
            writer.write("Code:");
            writer.write(NL);
            writer.write(bf.toString());
            writer.write(NL+NL);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bf.length();
    }

    private static int score(byte[] bytes, String description) {
        final CharSequence bf = generate(bytes);
        try(FileWriter writer = new FileWriter("Res/output.txt", true)) {
            if(description != null) {
                writer.write(description);
                writer.write(NL);
            }
            writer.write("Code:");
            writer.write(NL);
            writer.write(bf.toString());
            writer.write(NL+NL);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bf.length();
    }

    private static final String NL = System.getProperty("line.separator");
}

Je vais apporter quelques petites améliorations mais probablement pas beaucoup. Terminé.

IchBinKeinBaum
la source
Ceci est cassé, le BF généré génère des octets NUL ou '?' en fonction des paramètres régionaux pour tout caractère ne figurant pas dans 1..127. L'ASCII ordinaire (1-127) semble cependant convenir. Remarquant que les (octets) sont signés et en choisissant soigneusement une locale en obtient beaucoup (en prenant le score supérieur à 5800000) mais il y a encore plusieurs milliers de NUL de la conversion bf de Lenna.png. Il y a donc autre chose aussi.
user3710044
4

BrainF ** k

Je suis un mauvais programmeur BF, donc cette réponse est probablement assez inefficace. Je ne suis pas sûr du score, mais il devrait fonctionner légèrement mieux que la réponse existante sur votre texte moyen. Plutôt que de mettre à zéro la cellule après chaque caractère, celui-ci "s'ajustera" à un nouveau caractère avec soustraction si le caractère précédent donné est plus grand.

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

(Remarque, il s'agit d'un code que j'ai écrit il y a longtemps et que j'ai réutilisé pour ce concours. J'espère sincèrement que j'ai fait la conversion correctement, mais s'il échoue pour une entrée, faites-le moi savoir.)

Une version montrant l'état de la bande dans tout le code:

>>++++++[-<+++++++>]<+>             [0 '+' 0]
                                           ^
>+++++[-<+++++++++>]                [0 '+' '-' 0]
                                               ^
>+++++[-<+++++++++>]<+>             [0 '+' '-' '.' 0]
                                                   ^
>,[-<+>>>>>>+<<<<<]                 [0 '+' '-' '.' a 0 0 0 0 0 a]
                                                     ^
<[-<<<.>>>]<.>>+>                   [0 '+' '-' '.' 0 1 0 0 0 0 a]
                                                       ^
,[[-<<+>>>+>>+<<<]                  [0 '+' '-' '.' b 1 0 b 0 b a]
                                    [b is not 0]       ^
>>>>[-<<+>>]<[->+<]                 [0 '+' '-' '.' b 1 0 b a 0 b]
                                                             ^    
<<[->-[>]<<]

<[->->[-<<<<<<.>>>>>>]<<]           

>+[-<<->>>[-<<<<<<.>>>>>>]<]        [0 '+' '-' '.' b 0 0 0 0 0 b]
                                                       ^|^
                                    [OUTPUT ONE CHARACTER BY THIS POINT]
<<<[>]<<.>[-]>                      [0 '+' '-' '.' 0 0 0 0 0 0 b]
                                                     ^
+>,]                                [End when b == 0]
                                    [GOAL: '+' '-' '.' b 1 0 b a 0 a]

Code généré pour Hello, World!:

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

Ceci est ma première réponse sur CG.SE! Si j'ai foiré quelque chose, faites le moi savoir!

BrainSteel
la source
4

> <>

i:&v
.21<>i:0(?;:&:@(4g62p$:&-01-$:@0(?*l2=?~02.
>:?!v"+"o1-
"."~<.15o
+-

J'ai écrit cela en réponse à une question marquée pour un doublon, et même si ce n'est pas le plus grand golf (pour cette question spécifique, au moins), je me suis dit que ce serait une sorte de gaspillage si je ne le partageais pas dans toute sa gloire de charabia dégoûtant. Vraiment, je suis à moitié surpris que ça marche même. Je prendrai toutes les suggestions pour le jouer car c'était mon objectif principal dans sa création.

En remarque, dans la deuxième ligne, les trois premiers caractères .21pourraient être remplacés par vsuivis de deux espaces si cela est plus facile à lire. Je n'aime pas voir les espaces dans mes> <> programmes car cela signifie qu'il y a de l'espace gaspillé (littéralement). Il s'agit également d'un vestige d'un des nombreux prototypes.

La façon dont il fonctionne est vraiment simple, et franchement, j'aurais du mal à penser à un moyen de mettre en œuvre un autre algorithme. Il imprime cependant de nombreux "+" doivent être imprimés pour le premier caractère, puis imprime plus de "+" ou "-" selon les besoins pour chaque caractère supplémentaire, en séparant chaque section par des points. Ce que je trouve cool à propos du programme, c'est qu'il modifie son propre code source pour qu'il affiche "+" ou "-" (il remplace le "+" sur la ligne 3 par le caractère approprié après avoir déterminé si le caractère actuel est supérieur ou moins que le précédent).

Sortie pour Hello, World!:

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

Je pourrais marquer cela comme il était censé être marqué, mais je suis presque certain que je perdrais et je ne sais pas entièrement comment lire quelque chose comme lenna.png dans> <>.

Si cette réponse vous intéresse et que vous souhaitez une explication, demandez certainement, mais pour l'instant je vais la laisser sans raison juste à cause de la tournure et de la tournure.

EDIT 1: Cela fait un moment mais j'ai pu jouer sur 2 octets avec une refonte presque complète de la façon dont le programme décide d'imprimer un plus ou un moins. C'est un retour quelque peu décevant pour une grande refonte mais au moins ça marche.

Cole
la source
Ce programme charabia fait un autre programme charabia! C'est le meilleur programme que j'aie jamais vu!
Aequitas
1

ma solution JavaScript c'est rapide et sale :)

sortie pour Hello World\n

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

La source:

BfGen("Hello World!\n");
// ++++++++++[>+++++++>++++++++++>+++++++++++>+++>+++++++++>+<<<<<<-]>++.>+.>--..+++.>++.>---.<<.+++.------.<-.>>+.>>.
// Length of BF code: 115
// Score: 8.846153846153847


function BfGen(input) {
    function StringBuilder() {
        var sb = {};

        sb.value = '';
        sb.append = (txt) => sb.value += txt;

        return sb;
    }

    function closest (num, arr) {
        var arr2 = arr.map((n) => Math.abs(num-n))
        var min = Math.min.apply(null, arr2);
        return arr[arr2.indexOf(min)];
    }

    function buildBaseTable(arr) {
        var out = StringBuilder();
        out.append('+'.repeat(10));
        out.append('[')
        arr.forEach(function(cc) {
            out.append('>');
            out.append('+'.repeat(cc/10));    
        });
        out.append('<'.repeat(arr.length));
        out.append('-');

        out.append(']');
        return out.value;
    }

    var output = StringBuilder();

    var charArray = input.split('').map((c) =>c.charCodeAt(0));
    var baseTable = charArray.map((c) => Math.round(c/10) * 10).filter((i, p, s) => s.indexOf(i) === p);

    output.append(buildBaseTable(baseTable));

    var pos = -1;
    charArray.forEach(function (charCode) {
        var bestNum = closest(charCode, baseTable);
        var bestPos = baseTable.indexOf(bestNum);

        var moveChar = pos < bestPos? '>' : '<';
        output.append(moveChar.repeat(Math.abs(pos - bestPos)))
        pos = bestPos;

        var opChar = baseTable[pos] < charCode? '+': '-';
        output.append(opChar.repeat(Math.abs(baseTable[pos] - charCode)));
        output.append('.');
        baseTable[pos] = charCode;
    });

    console.log(output.value)
    console.log('Length of BF code: ' + output.value.length);
    console.log('Score: ' + output.value.length / input.length);
}
Peter
la source
2
Bienvenue sur le site! Vous devez inclure le score dans le titre de votre réponse.
Wheat Wizard
je viens de faire le générateur bf, le système de score original a un traitement d'image ce qui n'est pas pertinent :( le ratio Hello world est inférieur à 9 (longueur bf / longueur du texte original)
Peter
1

J'ai construit quelque chose en Java. N'a pas calculé le score. Les textes de 3 caractères ou moins sont codés avec une multiplication par lettre, par exemple "A" = ++++++++[>++++++++<-]>+.. Les textes de plus de 3 caractères sont codés avec une liste calculée divisée en 3 zones. La première zone est x fois 49, puis plus x fois 7 et enfin plus x. Par exemple, "A" est 1 * 49 + 2 * 7 + 2

public class BFbuilder {
    public static void main(String[] args) {
        String text = "### INSERT TEXT HERE ###";

        if (text.length()<=3){
            String result = "";
            for (char c:text.toCharArray()) {
                result += ">";
                if (c<12) {
                    for (int i=0;i<c;i++) {
                        result += "+";
                    }
                    result += ".>";
                } else {
                    int root = (int) Math.sqrt(c);
                    for (int i = 0; i<root;i++) {
                        result += "+";
                    }
                    result += "[>";
                    int quotient = c/root;
                    for (int i = 0; i<quotient;i++) {
                        result += "+";
                    }
                    result += "<-]>";
                    int remainder = c - (root*quotient);
                    for (int i = 0; i<remainder;i++) {
                        result += "+";
                    }
                    result += ".";
                }
            }
            System.out.println(result.substring(1));
        } else {
            int[][] offsets = new int[3][text.length()];
            int counter = 0;
            String result = "---";

            for(char c:text.toCharArray()) {
                offsets[0][counter] = c/49;
                int temp = c%49;
                offsets[1][counter] = temp/7;
                offsets[2][counter] = temp%7;
                counter++;
            }

            for (int o:offsets[0]) {
                switch (o) {
                case 0: result+=">--";
                break;
                case 1: result+=">-";
                break;
                case 2: result+=">";
                break;
                case 3: result+=">+";
                break;
                case 4: result+=">++";
                break;
                case 5: result+=">+++";
                break;
                }
            }
            result += ">+[-[>+++++++<-]<+++]>----";
            for (int o:offsets[1]) {
                switch (o) {
                case 0: result+=">---";
                break;
                case 1: result+=">--";
                break;
                case 2: result+=">-";
                break;
                case 3: result+=">";
                break;
                case 4: result+=">+";
                break;
                case 5: result+=">++";
                break;
                case 6: result+=">+++";
                break;
                }
            }
            result += ">+[-[>+++++++<-]<++++]>----";
            for (int o:offsets[2]) {
                switch (o) {
                case 0: result+=">---";
                break;
                case 1: result+=">--";
                break;
                case 2: result+=">-";
                break;
                case 3: result+=">";
                break;
                case 4: result+=">+";
                break;
                case 5: result+=">++";
                break;
                case 6: result+=">+++";
                break;
                }
            }
            result += ">+[-<++++]>[.>]";
            System.out.println(result);
        }
    }
}

La chaîne fournie "### INSERER LE TEXTE ICI ###" devient --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"Bonjour le monde!" devient --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]

Dorian
la source
1

Python 3

print("".join("+"*ord(i)+".[-]"for i in input()))

Il s'agit essentiellement d'une version légèrement améliorée de la réponse d'icedvariables. (-1 octet de Wheat Wizard, -5 de FatalError, -2 de jez)

Madison Silver
la source
Je crois que c'est python 3. Si c'est le cas, vous devriez l'inclure dans votre en-tête. Si c'est le cas, vous pouvez également supprimer le saut de ligne après votre :. Cela pourrait également être fait comme une compréhension de liste pour économiser des octets.
Wheat Wizard
-5 octets avecprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError
-2 octets: perdez les crochets afin que vous join()print("".join("+"*ord(i)+".[-]"for i in input()))
appeliez
-2 octets: vous pouvez simplement passer à la cellule suivante (la question indique que vous devez supposer une bande infinie dans les deux sens print("".join("+"*ord(i)+".>"for i in input()))(cela réduit également le score puisque vous perdez 2 octets en sortie))
MegaIng