Brainf *** Pegolf

32

Salah satu kode termudah yang ditulis oleh bahasa pemrograman adalah urutan pencetakan karakter program (mis. "Halo, dunia!"). Namun, s o m e e s o t e r i c bahasa pemrograman seperti Brainfuck , bahkan kode sederhana ini cukup menjengkelkan untuk menulis.

Tugas Anda adalah menulis sebuah program (tidak harus ditulis dalam brainfuck), yang mencetak program Brainfuck (panjang minimum) yang mencetak teks yang diberikan.

Memasukkan

Urutan karakter (antara 1dan 255) diberikan oleh format apa pun (variabel, argumen, stdin, file, ...).

Keluaran

Output adalah valid (tidak ada yang tidak cocok [dan] kode brainfuck yang ) (asumsikan sel pembungkus 8-bit yang tidak ditandatangani dan jumlah sel yang tidak terbatas ke kiri dan kanan) mencetak string yang diberikan sebagai input.

Sebagai contoh, satu kemungkinan output untuk input Aadalah ++++++++[<++++++++>-]<+..

Program Anda seharusnya tidak membutuhkan waktu lama ( >2m) untuk dijalankan.

Program BF seharusnya tidak memakan waktu lama ( >10s) untuk dijalankan.

Mencetak gol

(Perhatikan: metode penilaian saat ini dapat berubah, karena tidak mudah untuk menghitung ...)

Panjang program (menghasilkan kode BF) itu sendiri tidak masalah. Namun, kode BF hard-coding dalam kode program tidak OK. Hanya rentang yang dapat diterima (mis. Kode BF yang mencetak satu karakter 0x01:+. ) Kode BF mungkin sulit-kode.

Skornya adalah jumlah panjang kode BF yang mencetak string ini.

  • Sebuah string Hello, world!ditambahkan dengan satu 0x0A( \n) (yaitu program "Halo, dunia!")
  • Karakter tunggal dari 0x01~0xFF
    • Jumlah panjang dari 255 kode BF ini dikalikan dengan 1/16, dibulatkan, dan ditambahkan ke skor.
  • Daftar 16 string pertama, yang dihasilkan dengan memisahkan urutan acak byte yang dihasilkan pada 11-11-110x00 , dengan menghapus semua string panjang nol.
  • Lenna.png , hapus semua 0x00s.
  • Lirik lagu 99 botol bir , dimulai dengan 99 bottles~, baris baru 0x0A, paragraf dipisahkan oleh dua 0x0As, dan tidak ada karakter baris baru di akhir.
  • String lain yang mungkin Anda berikan.

Program Anda mungkin termasuk menghitung skornya sendiri.

Tentu saja, kode skor terendah akan menjadi pemenang.

JiminP
sumber
Gandakan (walaupun diucapkan dengan lebih baik) dari codegolf.stackexchange.com/questions/3450/…
salin
4
Tampaknya ini agak sulit untuk menghitung skor. Ada banyak file berbeda yang perlu kita lacak dan jalankan. Apa gunanya 'string lain yang mungkin Anda berikan'. Mengapa saya menambahkan lebih banyak jika itu akan menambah skor saya?
captncraig
1
Lenna.pngakan mendominasi skor, karena sejauh ini merupakan input terbesar. Mungkin menormalkan sedikit berdasarkan ukuran?
Keith Randall
1
Kode panjang minimum untuk 'A' adalah ---- [----> + <]> ++.
Scony
1
OP jelas tidak peduli dengan tantangan ini. Mari kita edit aturan penilaian menjadi sesuatu yang masuk akal? Saat ini, hanya satu jawaban (tidak berhasil) yang mencoba menggunakan aturan ini, jadi mengubah aturan tidak akan membatalkan jawaban.
anatolyg

Jawaban:

15

Di Jawa, menghitung cuplikan BF pendek yang dapat mengonversi angka apa pun menjadi angka lain. Setiap byte keluaran dihasilkan dengan mengubah byte keluaran terakhir atau 0 baru pada pita.

Cuplikan dihasilkan dalam tiga cara. Pertama dengan pengulangan sederhana dari +dan -(mis. ++++Mengkonversi 7 ke 11), dengan menggabungkan cuplikan yang diketahui (mis. Jika A mengkonversi 5 ke 50 dan B mengkonversi 50 ke 37, lalu AB mengkonversi 5 ke 37) dan perkalian sederhana (mis. [--->+++++<]Mengalikan angka saat ini dengan 5/3). Perkalian sederhana mengambil keuntungan dari sampul untuk menghasilkan hasil yang tidak biasa (mis--[------->++<]> menghasilkan 36 dari 0, di mana loop dieksekusi 146 kali, dengan total 4 turun dan 1 sampul naik).

Saya terlalu malas untuk menghitung skor saya, tetapi menggunakan sekitar 12,3 operasi BF per byte 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
sumber
Saya tahu bahwa saya terlambat sekitar dua setengah tahun dan ini bukan golf, tetapi metode pengulangan bisa saja mengembalikan String baru (karakter baru [panjang]). ReplaceAll ("\ 0", str);
Loovjo
13

Nah ini tentang solusi terburuk yang mungkin, meskipun yang terlihat bagus di Brainfuck sendiri:

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

Skor mungkin adalah yang terburuk yang akan kita lihat tanpa sengaja membuatnya buruk.

Bekerja menghitung skor aktual.

captncraig
sumber
Bisakah Anda menjelaskan apa fungsinya? Membaca kode BF agak sulit.
BMac
3
Untuk setiap byte input, ia hanya mencetak N +dan a.
captncraig
Dengan saya percaya [-]untuk membersihkan sel antara masing-masing karakter.
captncraig
8

Python 3.x

Yah, saya tidak akan memenangkan hadiah untuk kode output terpendek tapi mungkin bagi program untuk menghasilkan kode ...

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

'Halo, Dunia! \ N':

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++++++
++++.[-]++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++.[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++.[-]++++++++++.[-]
icedvariables
sumber
1
Tanpa sengaja menjawab jawaban Madisons. Generator lebih pendek:print("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError
Anda dapat golf program Anda dengan 2 karakter dengan mengganti .[-]dengan.>
MilkyWay90
47 byte
MilkyWay90
8

Saya tidak yakin seberapa bagus itu, tapi saya senang menulis ini. (Dalam 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
   )
  )

Mungkin ada solusi yang lebih efisien, dan lebih elegan, tetapi ini mengikuti pola pikir saya agak linier, jadi itu yang paling mudah.

Marty
sumber
8

Skor: 4787486 41439404086426 (tanpa data yang dihasilkan secara acak)

(4085.639 di antaranya dari Lenna.png. Itu 99,98%)

Saya tidak mendapatkan bagian dengan data acak. Apakah saya tidak memerlukan akun yang harus saya bayar untuk mendapatkan data?

Sangat naif. Berikut kode yang dihasilkan untuk "1Aa" (49, 65, 97) dengan sedikit dokumentasi:

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

Kode Java agak jelek tapi berfungsi. Instruksi yang dihasilkan per rasio byte input mungkin lebih baik semakin tinggi nilai byte rata-rata.

Jika Anda ingin menjalankannya, Anda harus meletakkan Lenna.png di direktori yang sama dengan file .class. Ini mencetak skor untuk menghibur dan menulis kode BF yang dihasilkan ke dalam file yang disebut "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");
}

Saya akan membuat beberapa perbaikan kecil tapi mungkin tidak banyak. Selesai

IchBinKeinBaum
sumber
Ini rusak, hasil BF yang dihasilkan NUL byte atau '?' karakter tergantung pada lokal untuk karakter apa pun yang tidak ada di 1..127. Plain ASCII (1-127) tampaknya baik-baik saja. Memperhatikan bahwa (byte) telah ditandatangani dan dengan hati-hati memilih lokasi, mereka akan mendapatkan banyak (mengambil skor di atas 5800000) tetapi masih ada beberapa ribu NUL dari konversi Lenna.png. Jadi ada hal lain juga.
user3710044
4

BrainF ** k

Saya seorang programmer BF yang sangat buruk, jadi jawaban ini mungkin sangat tidak efisien. Saya tidak yakin dengan skornya, tetapi seharusnya berkinerja lebih baik daripada jawaban yang ada pada teks rata-rata Anda. Daripada memusatkan sel setelah setiap karakter, yang satu ini akan "menyesuaikan" ke karakter baru dengan pengurangan jika karakter sebelumnya yang diberikan lebih besar.

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

(Catatan, ini adalah kode yang saya tulis sejak lama, dan telah digunakan kembali untuk kompetisi ini. Saya sungguh berharap saya telah melakukan konversi dengan benar, tetapi jika gagal untuk masukan apa pun, beri tahu saya.)

Versi yang menunjukkan status rekaman di seluruh kode:

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

Kode yang dihasilkan untuk Hello, World!:

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

Ini adalah jawaban pertama saya di CG.SE! Jika saya mengacaukan sesuatu, beri tahu saya!

BrainSteel
sumber
4

> <>

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

Saya menulis ini sebagai jawaban atas pertanyaan yang ditandai untuk duplikat, dan meskipun ini bukan golf terbesar (untuk pertanyaan spesifik ini, setidaknya) saya pikir itu akan menjadi sia-sia jika saya tidak membagikannya semua kemuliaan omong kosong-y menjijikkan. Sungguh, aku setengah terkejut bahkan berhasil. Saya akan mengambil saran untuk menurunkannya karena itu adalah tujuan utama saya dalam penciptaannya.

Sebagai catatan, pada baris kedua, tiga karakter awal .21dapat diganti dengan vdiikuti oleh dua spasi jika itu membuatnya lebih mudah dibaca. Saya tidak suka melihat spasi di>> program saya karena itu berarti ada ruang yang terbuang (secara harfiah). Ini juga merupakan sisa dari salah satu dari banyak prototipe.

Cara kerjanya sangat sederhana, dan terus terang saya akan kesulitan memikirkan cara untuk mengimplementasikan algoritma lain. Namun mencetak banyak "+" yang perlu dicetak untuk karakter pertama, dan kemudian mencetak lebih banyak "+" atau "-" seperti yang diperlukan untuk setiap karakter tambahan, memisahkan setiap bagian dengan periode. Apa yang saya temukan keren tentang program ini adalah ia memodifikasi kode sumbernya sendiri sehingga ia mencetak "+" atau "-" (itu menggantikan "+" pada baris 3 dengan karakter yang sesuai setelah menentukan apakah karakter saat ini lebih besar dari atau kurang dari yang sebelumnya).

Output untuk Hello, World!:

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

Saya mungkin skor ini seperti yang dimaksudkan untuk dinilai, tapi saya hampir yakin saya akan kalah dan saya tidak sepenuhnya tahu cara membaca sesuatu seperti lenna.png di> <>.

Jika jawaban ini menarik bagi Anda dan Anda ingin penjelasan, tentu saja tanyakan, tetapi untuk sekarang saya akan membiarkannya tanpa satu hanya karena betapa berbelit-belit dan berbelit-belitnya.

EDIT 1: Sudah lama tapi saya bisa bermain golf 2 byte dengan perombakan yang hampir lengkap dari cara program memutuskan apakah akan mencetak plus atau minus. Ini adalah pengembalian yang agak mengecewakan untuk perbaikan besar tapi setidaknya berhasil.

cole
sumber
Program omong kosong ini membuat program omong kosong lain! Ini adalah program terhebat yang pernah saya lihat!
Aequitas
1

solusi JavaScript saya cepat dan kotor :)

output untuk Hello World\n

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

Sumber:

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
sumber
2
Selamat datang di situs ini! Anda harus memasukkan skor dalam judul jawaban Anda.
Wheat Wizard
saya baru saja membuat bf generator, sistem skor asli memiliki pemrosesan gambar yang tidak relevan :( Halo rasio dunia kurang dari 9 (panjang bf / panjang teks asli)
Peter
1

Saya membangun sesuatu di Jawa. Tidak menghitung skor. Teks dengan 3 karakter atau kurang dikodekan dengan perkalian per huruf mis. "A" = ++++++++[>++++++++<-]>+.. Teks dengan lebih dari 3 karakter dikodekan dengan daftar terhitung yang dibagi menjadi 3 area. Area pertama adalah x kali 49, lalu tambah x kali 7 dan akhirnya ditambah x. Misalnya "A" adalah 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);
        }
    }
}

String yang disediakan "### INSERT TEXT HERE ###" menjadi --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"Halo Dunia!" menjadi --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]

Dorian
sumber
1

Python 3

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

Ini pada dasarnya hanya versi yang sedikit lebih baik dari jawaban icedvariables. (-1 Byte dari Wheat Wizard, -5 dari FatalError, -2 dari jez)

Madison Silver
sumber
Saya percaya ini adalah python 3. Jika demikian, Anda harus memasukkannya di header Anda. Jika demikian, Anda juga dapat menghapus baris setelah Anda :. Ini mungkin juga bisa dilakukan sebagai daftar pemahaman untuk menyimpan byte.
Wheat Wizard
-5 byte denganprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError
-2 byte: kehilangan tanda kurung siku sehingga Anda memanggil join()ekspresi generator daripada pemahaman daftar: print("".join("+"*ord(i)+".[-]"for i in input()))
jez
-2 byte: Anda cukup pindah ke sel berikutnya (pertanyaan menyatakan Anda harus mengasumsikan band tak terbatas di kedua arah print("".join("+"*ord(i)+".>"for i in input()))(ini juga mengurangi skor karena Anda kehilangan 2 byte dalam output)
MegaIng