Einer der einfachsten Codes, der von einer Programmiersprache geschrieben wird, ist eine Programmdrucksequenz aus Zeichen (z. B. "Hallo Welt!"). Allerdings s o m e e s o t e r i c Programmiersprachen wie Brainfuck , auch dieser einfachste Code ist ziemlich ärgerlich zu schreiben.

Ihre Aufgabe ist es, ein Programm zu schreiben (muss nicht in Brainfuck geschrieben sein), das ein (minimales) Brainfuck-Programm druckt, das den angegebenen Text druckt.

Eingang

Eine Folge von Zeichen (zwischen 1und 255) wird durch ein beliebiges Format (Variable, Argument, stdin, Datei, ...) angegeben.

Ausgabe

Die Ausgabe ist ein gültiger (nicht übereinstimmender [und nicht übereinstimmender ]) Brainfuck-Code (vorausgesetzt, 8-Bit-Umbruchzelle ohne Vorzeichen und unbegrenzte Anzahl von Zellen nach links und rechts), der die genaue Zeichenfolge ausgibt, die als Eingabe angegeben wurde.

Eine mögliche Ausgabe für die Eingabe Aist beispielsweise ++++++++[<++++++++>-]<+..

Das >2mAusführen Ihres Programms sollte nicht lange dauern ( ).

Die >10sAusführung des BF-Programms sollte nicht lange dauern ( ).

Wertung

(Hinweis: Die aktuelle Bewertungsmethode kann sich ändern, da die Berechnung nicht einfach ist ...)

Die Länge des Programms (Generierung von BF-Code) selbst spielt keine Rolle. Das Festcodieren von BF-Codes im Programmcode ist jedoch nicht in Ordnung. Nur akzeptablen Bereich (ex ein Code BF ein einzelnes Zeichen zu drucken. 0x01: +.) BF - Codes könnte hartcodiert sein.

Die Punktzahl ist die Summe der Länge der BF-Codes, die diese Zeichenfolgen drucken.

• Ein String, Hello, world!an den ein single 0x0A( \n) angehängt ist (dh das Programm "Hello, world!")
• Einzelzeichen von 0x01~0xFF
  • Die Summe der Länge dieser 255 BF-Codes wird mit multipliziert 1/16, gerundet und zur Punktzahl hinzugefügt.
• Liste der ersten 16 Zeichenfolgen, die durch Aufteilen einer zufälligen Folge von Bytes generiert wurden, die am 11.11.11 durch 0x00Entfernen aller Zeichenfolgen mit der Länge Null generiert wurden .
• Lenna.png , alle 0x00s entfernen .
• Songtexte 99 Flaschen Bier , beginnend mit 99 bottles~, Zeilenumbrüche sind 0x0A, Absätze werden durch zwei 0x0As getrennt, und kein Zeilenumbruchszeichen am Ende.
• Andere Zeichenfolgen, die Sie möglicherweise bereitstellen.

Ihr Programm kann das Berechnen der Bewertung von sich selbst enthalten.

Natürlich gewinnt der Code mit der niedrigsten Punktzahl.

Berechnet in Java ein kurzes BF-Snippet, das eine beliebige Zahl in eine beliebige andere Zahl umwandeln kann. Jedes Ausgangsbyte wird generiert, indem entweder das letzte Ausgangsbyte oder eine neue 0 auf dem Band transformiert wird.

Die Snippets werden auf drei Arten generiert. Zuerst durch einfache Wiederholungen von +und -(zB ++++konvertiert 7 nach 11), durch Kombinieren bekannter Ausschnitte (zB wenn A 5 nach 50 konvertiert und B 50 nach 37 konvertiert, dann konvertiert AB 5 nach 37) und einfache Multiplikationen (zB [--->+++++<]multipliziert die aktuelle Zahl mit 5/3). Die einfachen Multiplikationen nutzen den Wraparound, um ungewöhnliche Ergebnisse zu generieren (z. B. --[------->++<]>generiert 36 aus 0, wobei die Schleife 146-mal ausgeführt wird, mit insgesamt 4 absteigenden und 1 aufsteigenden Wraparounds).

Ich bin zu faul, um meine Punktzahl zu berechnen, aber es werden ungefähr 12,3 BF-Operationen pro Byte verwendet 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]);
    }
}

Nun, hier ist die schlechteste mögliche Lösung, obwohl sie in Brainfuck selbst ziemlich gut aussieht:

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

Die Punktzahl ist wahrscheinlich die schlechteste, die wir sehen werden, ohne sie absichtlich schlecht zu machen.

Arbeit an der Berechnung der tatsächlichen Punktzahl.

Python 3.x

Nun, ich werde keine Preise für den kürzesten Ausgabe-Code gewinnen, aber vielleicht für das Programm, das den Code generiert ...

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

'Hallo Welt! \ N':

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++++++
++++.[-]++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++.[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++.[-]++++++++++.[-]

Ich bin mir nicht sicher, wie gut es ist, aber ich hatte Spaß beim Schreiben. (In 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
   )
  )

Es gibt wahrscheinlich effizientere und elegantere Lösungen, aber dies folgt meinem Gedankenmuster etwas linear, so dass es am einfachsten war.

Ergebnis: 4787486 41439404086426 (ohne zufällig generierte Daten)

(4085639 davon sind von Lenna.png. Das sind 99,98%)

Ich verstehe das Teil mit den Zufallsdaten nicht. Benötige ich kein Konto, für das ich bezahlen muss, um die Daten zu erhalten?

Ziemlich naiv. Hier ist der generierte Code für "1Aa" (49, 65, 97) mit einer kleinen Dokumentation:

                   // 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"

Der Java-Code ist ein bisschen hässlich, aber es funktioniert. Je höher der durchschnittliche Bytewert ist, desto besser ist wahrscheinlich das erzeugte Befehlsverhältnis pro Eingangsbyte.

Wenn Sie es ausführen möchten, müssen Sie Lenna.png im selben Verzeichnis wie die .class-Datei ablegen. Es druckt die Partitur auf die Konsole und schreibt den generierten BF-Code in eine Datei mit dem Namen "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");
}

Ich werde ein paar kleine Verbesserungen vornehmen, aber wahrscheinlich nicht viel. Getan.

Gehirn ** k

Ich bin ein ziemlich schlechter BF-Programmierer, daher ist diese Antwort wahrscheinlich ziemlich ineffizient. Ich bin mir nicht sicher, was die Punktzahl betrifft, aber sie sollte im Durchschnittstext etwas besser abschneiden als die vorhandene Antwort. Anstatt die Zelle nach jedem Zeichen auf Null zu setzen, "stellt" sich dieser auf ein neues Zeichen mit Subtraktion ein, wenn das vorher angegebene Zeichen größer ist.

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

(Beachten Sie, dass dies der Code ist, den ich vor langer Zeit geschrieben habe und der für diesen Wettbewerb neu verwendet wurde. Ich hoffe aufrichtig, dass ich die Konvertierung korrekt durchgeführt habe, aber wenn die Eingabe fehlschlägt, lassen Sie es mich wissen.)

Eine Version, die den Status des Bandes im gesamten Code anzeigt:

>>++++++[-<+++++++>]<+>             [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]

Generierter Code für Hello, World!:

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

Dies ist meine erste Antwort auf CG.SE! Wenn ich etwas vermasselt habe, lass es mich wissen!

> <>

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

Ich schrieb dies als Antwort auf eine Frage, die für ein Duplikat markiert wurde, und obwohl dies nicht das beste Golfspiel ist (zumindest für diese spezielle Frage), dachte ich, dass es eine Verschwendung wäre, wenn ich es nicht teile all sein widerlicher Kauderwelsch. Wirklich, ich bin halb überrascht, dass es sogar funktioniert. Ich nehme alle Vorschläge an, um Golf zu spielen, da dies mein Hauptziel bei der Entwicklung war.

Als Randnotiz, in der zweiten Zeile .21könnten die ersten drei Zeichen durch vgefolgt von zwei Leerzeichen ersetzt werden, wenn dies das Lesen erleichtert. Ich mag es nicht, Leerzeichen in meinen> <> Programmen zu sehen, weil das bedeutet, dass (buchstäblich) Platz verschwendet wird. Es ist auch ein Überbleibsel eines von vielen Prototypen.

Die Funktionsweise ist sehr einfach, und ehrlich gesagt fällt es mir schwer, einen Weg zu finden, um einen anderen Algorithmus zu implementieren. Es werden jedoch viele "+" - Zeichen gedruckt, die für das erste Zeichen gedruckt werden müssen, und dann werden mehr "+" - oder "-" - Zeichen für jedes zusätzliche Zeichen gedruckt, wobei jeder Abschnitt durch Punkte getrennt wird. Was ich an dem Programm cool finde, ist, dass es seinen eigenen Quellcode so ändert, dass er "+" oder "-" ausgibt (das "+" in Zeile 3 wird durch das entsprechende Zeichen ersetzt, nachdem festgestellt wurde, ob das aktuelle Zeichen größer als oder ist weniger als die vorherige).

Ausgabe für Hello, World!:

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

Ich könnte das so bewerten, wie es beabsichtigt war, aber ich bin mir fast sicher, dass ich verlieren würde, und ich weiß nicht ganz, wie man so etwas wie lenna.png in> <> liest.

Wenn diese Antwort Sie interessiert und Sie eine Erklärung wünschen, fragen Sie auf jeden Fall, aber jetzt werde ich sie ohne eine lassen, nur weil sie kurvig und kurvig ist.

EDIT 1: Es ist eine Weile her, aber ich war in der Lage, 2 Bytes mit einer fast vollständigen Überarbeitung der Art und Weise, wie das Programm entscheidet, ob ein Plus oder ein Minus gedruckt wird, abzuspielen. Es ist eine etwas enttäuschende Rückkehr für eine große Überholung, aber zumindest funktioniert es.

meine JavaScript-Lösung ist schnell und dreckig :)

Ausgabe für Hello World\n

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

Quelle:

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);
}

Ich habe etwas in Java gebaut. Die Punktzahl wurde nicht berechnet. Texte mit 3 oder weniger Zeichen werden mit einer Multiplikation pro Buchstabe codiert, z. B. "A" = ++++++++[>++++++++<-]>+.. Texte mit mehr als 3 Zeichen werden mit einer berechneten Liste codiert, die in 3 Bereiche aufgeteilt ist. Der erste Bereich ist x mal 49, dann plus x mal 7 und schließlich plus x. Zum Beispiel ist "A" 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);
        }
    }
}

Der bereitgestellte String "### INSERT TEXT HERE ###" wird --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"Hallo Welt!" wird --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]

Python 3

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

Dies ist im Wesentlichen nur eine leicht verbesserte Version der Antwort von icedvariables. (-1 Byte von Wheat Wizard, -5 von FatalError, -2 von jez)