Brainf ***ゴルファー


32

プログラミング言語で記述された最も簡単なコードの1つは、文字のプログラム出力シーケンスです(例:「Hello、world!」)。ただし、sはoをM E E S O T E R I Cのようなプログラミング言語Brainfuckもこの最も単純なコードを書くために非常に迷惑です。

あなたの仕事はプログラムを書くことです(brainfuckで書く必要はありません)。これは与えられたテキストを印刷する(最小長の)Brainfuckプログラムを印刷します。

入力

(間の文字列1とは255)任意の形式(変数、引数、標準入力、ファイル、...)で与えられます。

出力

出力は、入力として指定された正確な文字列を出力する有効な(一致しない[andでない])Brainfuckコード(符号なしの8ビットラッピングセルと左右の無制限のセル数を想定)です。

たとえば、入力の1つの可能な出力A++++++++[<++++++++>-]<+.です。

プログラムの>2m実行に長い時間()はかかりません。

BFプログラムの>10s実行に長い時間()がかかることはありません。

得点

(注意:計算が容易ではないため、現在のスコアリング方法は変わる可能性があります...)

プログラムの長さ(BFコードの生成)自体関係ありません。ただし、プログラムコードにBFコードをハードコーディングすることはできません。のみ許容範囲(例:単一の文字を印刷BFコード。0x01+.)BFコードは、ハードコードされたかもしれません。

スコアは、これらの文字列を印刷するBFコードの長さの合計です。

  • Hello, world!単一の0x0A\n)が追加された文字列(つまり、「Hello、world!」プログラム)
  • 0x01〜からの単一文字0xFF
    • これらの255個のBFコードの長さの合計にを乗算し1/16、丸め、スコアに追加します。
  • 分割により生成された最初の16個の文字列のリスト、11-11-11に発生バイトのランダムシーケンスによって0x00全長さゼロの文字列を削除し、。
  • Lenna.png、すべて0x00のsを削除します。
  • 歌の歌詞99本のビール、で始まる99 bottles~、改行は0x0A、段落は2で区切られ0x0A、最後に改行文字はありません。
  • あなたが提供する他の文字列。

プログラムには、それ自体のスコアの計算が含まれる場合があります。

もちろん、最低スコアのコードが勝者になります。



4
これはスコアを計算するのがかなり難しいようです。追跡して実行する必要がある多くの異なるファイルです。「提供できるその他の文字列」のポイントは何ですか。スコアに追加する場合、なぜ追加するのですか?
captncraig

1
Lenna.png圧倒的に最大の入力であるため、スコアを支配します。サイズで少し正規化するのでしょうか?
キースランドール

1
'A'の最小長コードは---- [----> + <]> ++です。
スコーニー14

1
OPは明らかにこの課題を気にしません。スコアリングルールを適切なものに編集しましょう。現在、これらのルールを使用しようとした回答は1つのみで(失敗)、ルールを変更しても回答が無効になることはありません。
アナトリグ

回答:


15

Javaでは、任意の数値を他の数値に変換できる短いBFスニペットを計算します。各出力バイトは、最後の出力バイトを変換するか、テープ上の新しい0を生成することにより生成されます。

スニペットは3つの方法で生成されます。最初の簡単の繰り返しによって+、および-(例えば、++++変換7〜11)は、公知の断片を組み合わせて(Aは、変換した場合、例えば5〜50及びBの変換50 37に、次いでABは5〜37変換)と単純な乗算(例えば[--->+++++<]乗算現在の数によって5/3)。単純な乗算は、ラップアラウンドを利用して異常な結果を生成します(たとえば--[------->++<]>、ループが146回実行される0から36を生成し、合計4つの降順と1つの昇順のラップアラウンド)。

私は自分のスコアを計算するのが面倒ですが、1バイトあたり約12.3のBF操作を使用し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]);
    }
}

私は約2年半遅れており、これはゴルフではないことを知っていますが、リピートメソッドは単にnew String(new char [length])。replaceAll( "\ 0"、str);を返すことができます。
-Loovjo

13

ここに、最悪の解決策がありますが、Brainfuck自体ではかなり見栄えの良いものです。

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

スコアは、意図的に悪化させない限り、おそらく最悪の結果になります。

実際のスコアの計算に取り組んでいます。


これが何をするのか説明してもらえますか?BFコードの読み取りはかなり困難です。
BMac

3
入力の各バイトに対して、単にN +とa.
captncraig

私は[-]各キャラクター間のセルをクリアすると信じています。
captncraig

8

Python 3.x

さて、私は最短の出力コードで賞を獲得するつもりはありませんが、コードを生成するプログラムで賞を獲得するかもしれません...

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

'こんにちは、世界!\ n':

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

1
マディソンズの回答に誤って回答しました。短いジェネレータ:print("".join(["+"*ord(i)+".[-]"for i in input()]))
あるFatalError

あなたは置き換えることにより、ゴルフ2つの文字によってあなたのプログラムをすることができ.[-].>
MilkyWay90


8

どれだけ良いかわかりませんが、これを書くのは楽しかったです。(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
   )
  )

おそらく、より効率的なソリューションと、よりエレガントなソリューションがありますが、これは私の思考パターンにある程度線形に従うため、最も簡単でした。


8

スコア: 4787486 41439404086426(ランダムに生成されたデータなし)

(そのうち4085639はLenna.pngからのものです。99.98%です)

ランダムなデータの一部を取得しません。データを取得するために支払う必要があるアカウントは必要ありませんか?

かなり素朴。これは、「1Aa」(49、65、97)用に生成されたコードと小さなドキュメントです。

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

Javaコードは少しいですが、動作します。入力バイトあたりの生成された命令の比率は、おそらく平均バイト値が高いほど優れています。

実行する場合は、Lenna.pngを.classファイルと同じディレクトリに配置する必要があります。スコアをコンソールに出力し、生成されたBFコードを「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");
}

私はいくつかの小さな改善を行いますが、おそらくあまり改善しません。 できた


これは壊れており、生成されたBFはNULバイトまたは「?」を出力します 1..127にない文字のロケールに応じた文字。ただし、プレーンASCII(1-127)は問題ないようです。(バイト)が署名されており、ロケールを慎重に選択するとそれらの多くが取得されます(5800000を超えるスコアを取得します)が、Lenna.pngのbf変換からはまだ数千のNULがあります。他にも何かがあります。
user3710044

4

BrainF ** k

私はかなり悪いBFプログラマなので、この答えはおそらくかなり非効率的です。スコアは定かではありませんが、平均的なテキストの既存の回答よりもわずかに優れたパフォーマンスを発揮するはずです。すべての文字の後にセルをゼロで埋めるのではなく、指定された前の文字が大きい場合、この文字は減算で新しい文字に「調整」されます。

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

(これは私がずっと前に書いたコードであり、このコンペティションのために再利用されています。変換が正しく行われたことを心から願っていますが、入力に失敗した場合はお知らせください。)

コード全体でテープの状態を示すバージョン:

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

生成コードHello, World!

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

これがCG.SEに関する私の最初の回答です!何かおかしくなったら、教えてください!


4

> <>

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

重複するようにマークされた質問に答えてこれを書きました。これは最高のゴルフではありませんが(少なくともこの特定の質問では)、共有しないと無駄になると思いました。そのすべてのうんざりするような冗談のよ​​うな栄光。本当に、私もそれがうまくいくと驚いています。それを作成する際の私の主な目標だったので、私はそれをゴルフに落とすためにどんな提案もします。

補足として、2行目の最初の3文字.21v読みやすくするために2つのスペースに置き換えられます。> <>プログラムでスペースを見るのは好きではありません。スペースが無駄になっているからです(文字通り)。また、多くのプロトタイプの1つからの名残です。

それが機能する方法は本当に簡単で、率直に言って、私は別のアルゴリズムを実装する方法を考えるのに苦労するでしょう。ただし、最初の文字に多くの「+」を印刷する必要があり、その後、追加の文字ごとに必要に応じて「+」または「-」が印刷され、各セクションがピリオドで区切られます。私がプログラムで素晴らしいと思うのは、「+」または「-」を印刷するように独自のソースコードを変更することです(現在の文字がより大きいかどうかを判断した後、3行目の「+」を適切な文字に置き換えます前のものよりも少ない)。

の出力Hello, World!

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

私はこれを採点するつもりだった方法で採点するかもしれませんが、私は負けそうだとほぼ肯定的で、> <>でlenna.pngのようなものを読む方法を完全に知りません。

この回答に興味があり、説明が必要な場合は、ぜひ質問してください。しかし、今のところ、それがどれほどツイストで曲がりくねっているという理由だけで、私はそれを残します。

編集1:それはしばらくされていますが、プラスまたはマイナスを印刷するかどうかをプログラムが決定する方法のほぼ完全なオーバーホールで2バイトオフすることができました。大規模なオーバーホールの場合、それはやや残念なリターンですが、少なくとも機能します。


このわいせつなプログラムは、別のわいせつなプログラムになります!これは私が今まで見た中で最高のプログラムです!
-Aequitas

1

私のJavaScriptソリューションは速くて汚いです:)

の出力 Hello World\n

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

ソース:

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

2
サイトへようこそ!回答のタイトルにスコアを含める必要があります。
小麦ウィザード

私はちょうどBF発電機を作った、オリジナルのスコアシステムは関係ありませんどのような画像処理:(こんにちは世界の比率が少ないし、9(BF長/元のテキスト長)であり
ピーター・

1

Javaで何かを構築しました。スコアを計算しませんでした。3文字以下のテキストは、文字ごとの乗算でエンコードされます(例: "A" =)++++++++[>++++++++<-]>+.。3文字を超えるテキストは、3つの領域に分割された計算リストでエンコードされます。最初の領域はx x 49、次にx x 7、最後にxの合計です。たとえば、「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);
        }
    }
}

指定された文字列「### INSERT TEXT HERE ###」は、 --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"こんにちは世界!" になる --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]


1

Python 3

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

これは、基本的にはicedvariablesの答えのわずかに改善されたバージョンです。(Wheat Wizardから-1バイト、FatalErrorから-5、jezから-2)


これはpython 3だと思います。もしそうなら、あなたもあなたの後に改行を削除することができます:。これはおそらく、バイトを節約するためのリストの内包としても実行できます。
小麦ウィザード

-5バイトprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

-2バイト:角かっこが失われるためjoin()、リストの内包表記ではなくジェネレーター式を呼び出します: print("".join("+"*ord(i)+".[-]"for i in input()))
jez

-2バイト:次のセルに単純に移動できます(質問では、両方向に無限の帯域を想定する必要がありますprint("".join("+"*ord(i)+".>"for i in input()))(これにより、出力で2バイトが失われるため、スコアも低下します)
MegaIng
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.