Brainf *** Golfer


32

Một trong những mã dễ nhất được viết bởi ngôn ngữ lập trình là chuỗi ký tự in của chương trình (ví dụ: "Xin chào, thế giới!"). Tuy nhiên, s o m e e s o t e r i c ngôn ngữ lập trình như Brainfuck , thậm chí mã đơn giản này là khá khó chịu để ghi.

Nhiệm vụ của bạn là viết một chương trình (không phải viết bằng brainfuck), trong đó in một chương trình Brainfuck (độ dài tối thiểu) in văn bản đã cho.

Đầu vào

Một chuỗi các ký tự (giữa 1255) được đưa ra bởi bất kỳ định dạng nào (biến, đối số, stdin, tệp, ...).

Đầu ra

Đầu ra là một mã Brainfuck hợp lệ (không khớp []) (giả sử ô bao bọc 8 bit không dấu và số lượng ô không giới hạn ở bên trái và bên phải) in chuỗi chính xác được đưa ra làm đầu vào.

Ví dụ, một đầu ra có thể cho đầu vào A++++++++[<++++++++>-]<+..

Chương trình của bạn không nên mất nhiều thời gian ( >2m) để chạy.

Chương trình BF không nên mất nhiều thời gian ( >10s) để chạy.

Chấm điểm

(Lưu ý: phương pháp tính điểm hiện tại có thể thay đổi, vì không dễ tính toán ...)

Độ dài của chương trình (tạo mã BF) không thành vấn đề. Tuy nhiên, mã BF mã hóa cứng trong mã chương trình không ổn. Chỉ phạm vi chấp nhận (ví dụ một mã BF in một nhân vật duy nhất. 0x01: +.) Mã BF có thể được mã hóa cứng.

Điểm số là tổng chiều dài của mã BF in các chuỗi này.

  • Một chuỗi được Hello, world!nối với một chương trình 0x0A( \n) (tức là chương trình "Xin chào, thế giới!")
  • Nhân vật duy nhất từ 0x01~0xFF
    • Tổng chiều dài của 255 mã BF này được nhân với 1/16, làm tròn và thêm vào điểm số.
  • Danh sách 16 chuỗi đầu tiên, được tạo bằng cách chia một chuỗi byte ngẫu nhiên được tạo vào ngày 11-11-11 bằng cách 0x00xóa tất cả các chuỗi có độ dài bằng không.
  • Lenna.png , loại bỏ tất cả 0x00s.
  • Lời bài hát 99 chai bia , bắt đầu bằng 99 bottles~, dòng mới 0x0A, các đoạn được phân tách bằng hai 0x0As và không có ký tự dòng mới ở cuối.
  • Các chuỗi khác bạn có thể cung cấp.

Chương trình của bạn có thể bao gồm việc tính điểm của chính nó.

Tất nhiên, mã số điểm thấp nhất sẽ là người chiến thắng.


Bản sao (mặc dù được thực hiện tốt hơn) của codegolf.stackexchange.com/questions 43250 / Đổi
sao chép

4
Điều này có vẻ khá khó để tính điểm. Đó là rất nhiều tập tin khác nhau mà chúng tôi cần theo dõi và chạy qua. Điểm của 'Các chuỗi khác bạn có thể cung cấp' là gì. Tại sao tôi sẽ thêm nhiều hơn nếu nó sẽ thêm vào điểm số của tôi?
captncraig

1
Lenna.pngsẽ thống trị điểm số, vì nó là đầu vào lớn nhất. Có thể bình thường hóa một chút theo kích thước?
Keith Randall

1
Mã có độ dài tối thiểu cho 'A' là ---- [----> + <]> ++.
Scony

1
OP rõ ràng không quan tâm đến thách thức này. Hãy chỉnh sửa các quy tắc tính điểm thành một cái gì đó hợp lý? Hiện tại, chỉ có một câu trả lời (không thành công) đã cố gắng sử dụng các quy tắc này, vì vậy việc thay đổi quy tắc sẽ không làm mất hiệu lực câu trả lời.
anatolyg

Câu trả lời:


15

Trong Java, tính toán một đoạn BF ngắn có thể chuyển đổi bất kỳ số nào thành bất kỳ số nào khác. Mỗi byte đầu ra được tạo bằng cách chuyển đổi byte đầu ra cuối cùng hoặc 0 mới trên băng.

Các đoạn được tạo theo ba cách. Đầu tiên bằng cách lặp lại đơn giản +-(ví dụ ++++chuyển đổi 7 thành 11), bằng cách kết hợp các đoạn đã biết (ví dụ: nếu A chuyển đổi 5 thành 50 và B chuyển đổi 50 thành 37, thì AB chuyển đổi 5 thành 37) và nhân đơn giản (ví dụ: [--->+++++<]nhân số hiện tại 5/3). Các phép nhân đơn giản tận dụng phép quay vòng để tạo ra kết quả bất thường (ví dụ: --[------->++<]>tạo 36 từ 0, trong đó vòng lặp thực hiện 146 lần, với tổng số 4 vòng giảm dần và 1 vòng tăng dần).

Tôi quá lười để tính điểm của mình, nhưng nó sử dụng khoảng 12,3 thao tác BF trên mỗi 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]);
    }
}

Tôi biết rằng tôi trễ khoảng hai năm rưỡi và đây không phải là golf, nhưng phương thức lặp lại chỉ có thể trả về Chuỗi mới (char mới [length]). Thay thế All ("\ 0", str);
Loovjo

13

Vâng đây là về giải pháp tồi tệ nhất có thể, mặc dù một giải pháp khá đẹp mắt trong chính Brainfuck:

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

Điểm có lẽ là tồi tệ nhất chúng ta có thể nhìn thấy mà không cố ý làm cho nó xấu.

Làm việc trên tính toán điểm thực tế.


Bạn có thể giải thích điều này không? Đọc mã BF khá khó khăn.
BMac

3
Đối với mỗi byte đầu vào, nó chỉ cần in N +'và a.
captncraig

Với tôi tin rằng [-]để xóa các tế bào giữa mỗi nhân vật.
captncraig 04/03/2015

8

Python 3.x

Chà, tôi sẽ không giành được bất kỳ giải thưởng nào cho mã đầu ra ngắn nhất nhưng có lẽ là để chương trình tạo mã ...

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

'Xin chào, Thế giới! \ N':

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

1
Vô tình trả lời câu trả lời của Madisons. Trình tạo ngắn hơn:print("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

Bạn có thể đánh golf chương trình của mình bằng 2 ký tự bằng cách thay thế .[-]bằng.>
MilkyWay90


8

Tôi không chắc nó tốt như thế nào, nhưng tôi rất vui khi viết nó. (Trong 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
   )
  )

Có thể có các giải pháp hiệu quả hơn, và các giải pháp thanh lịch hơn, nhưng điều này theo mô hình suy nghĩ của tôi hơi tuyến tính, vì vậy nó là dễ nhất.


8

Ghi bàn: 4787486 41439404086426 (không có dữ liệu được tạo ngẫu nhiên)

(4085639 trong số đó là của Lenna.png. Đó là 99,98%)

Tôi không nhận được một phần với dữ liệu ngẫu nhiên. Tôi không cần một tài khoản mà tôi phải trả tiền để có được dữ liệu?

Khá ngây thơ. Đây là mã được tạo cho "1Aa" (49, 65, 97) với một ít tài liệu:

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

Mã Java hơi xấu nhưng nó hoạt động. Lệnh được tạo trên mỗi tỷ lệ byte đầu vào có lẽ tốt hơn giá trị byte trung bình càng cao.

Nếu bạn muốn chạy nó, bạn phải đặt Lenna.png vào cùng thư mục với tệp. Class. Nó in điểm số ra bàn điều khiển và ghi mã BF được tạo vào một tệp có tên là "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");
}

Tôi sẽ thực hiện một số cải tiến nhỏ nhưng có lẽ không nhiều. Làm xong.


Điều này bị hỏng, BF tạo ra NUL byte hoặc '?' các ký tự tùy thuộc vào miền địa phương cho bất kỳ ký tự nào không nằm trong 1..127. Mặc dù ASCII (1-127) có vẻ vẫn ổn. Nhận thấy rằng (byte) đã được ký và cẩn thận chọn một miền địa phương sẽ nhận được rất nhiều trong số chúng (lấy số điểm trên 5800000) nhưng vẫn còn vài nghìn NUL từ chuyển đổi bf của Lenna.png. Vì vậy, có một cái gì đó quá.
dùng3710044

4

Não ** k

Tôi là một lập trình viên BF khá tệ, vì vậy câu trả lời này có lẽ không hiệu quả. Tôi không chắc về điểm số, nhưng nó sẽ hoạt động tốt hơn một chút so với câu trả lời hiện có trên văn bản trung bình của bạn. Thay vì loại bỏ ô ra sau mỗi ký tự, cái này sẽ "điều chỉnh" thành một ký tự mới có phép trừ nếu ký tự trước đó lớn hơn.

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

(Lưu ý, đây là mã tôi đã viết cách đây rất lâu và đã được gửi lại cho cuộc thi này. Tôi thực sự hy vọng tôi đã thực hiện chuyển đổi một cách chính xác, nhưng nếu nó không thành công cho bất kỳ đầu vào nào hãy cho tôi biết.)

Một phiên bản hiển thị trạng thái của băng trong suốt mã:

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

Mã được tạo cho Hello, World!:

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

Đây là câu trả lời đầu tiên của tôi trên CG.SE! Nếu tôi làm hỏng cái gì đó, hãy cho tôi biết!


4

> <>

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

Tôi đã viết điều này để trả lời cho một câu hỏi được đánh dấu cho một bản sao và mặc dù đây không phải là môn golf tuyệt vời nhất (ít nhất là cho câu hỏi cụ thể này), tôi nghĩ rằng nó sẽ là một sự lãng phí nếu tôi không chia sẻ nó tất cả vinh quang vô nghĩa ghê tởm của nó. Thực sự, tôi nửa ngạc nhiên khi nó thậm chí hoạt động. Tôi sẽ đưa ra bất kỳ đề xuất nào để đánh gôn vì đó là mục tiêu chính của tôi trong việc tạo ra nó.

Như một lưu ý phụ, trong dòng thứ hai, ba ký tự đầu .21có thể được thay thế vbằng hai dấu cách nếu điều đó làm cho nó dễ đọc hơn. Tôi không muốn thấy không gian trong các chương trình> <> của mình vì điều đó có nghĩa là không gian bị lãng phí (theo nghĩa đen). Nó cũng là tàn dư từ một trong nhiều nguyên mẫu.

Cách thức hoạt động của nó thực sự đơn giản và thật lòng mà nói, tôi có một thời gian khó khăn để nghĩ cách để thực hiện một thuật toán khác. Tuy nhiên, nó sẽ in nhiều ký tự "+" cho ký tự đầu tiên và sau đó in thêm các dấu "+" hoặc "-" nếu cần cho mỗi ký tự bổ sung, tách từng phần bằng dấu chấm. Điều tôi thấy thú vị về chương trình là nó sửa đổi mã nguồn của chính nó để nó in "+" hoặc "-" (nó thay thế "+" trên dòng 3 bằng ký tự phù hợp sau khi xác định xem ký tự hiện tại có lớn hơn hay không ít hơn cái trước).

Đầu ra cho Hello, World!:

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

Tôi có thể ghi bàn theo cách nó được ghi, nhưng tôi gần như tích cực Tôi thua và tôi hoàn toàn không biết cách đọc thứ gì đó như lenna.png trong> <>.

Nếu câu trả lời này làm bạn quan tâm và bạn muốn giải thích, thì bằng mọi cách hãy hỏi, nhưng bây giờ tôi sẽ rời khỏi nó mà không cần ai chỉ vì nó ngoằn ngoèo và ngoằn ngoèo như thế nào.

EDIT 1: Đã được một thời gian nhưng tôi đã có thể đánh bại 2 byte với sự cải tiến gần như hoàn toàn về cách chương trình quyết định in một phép cộng hay trừ. Đó là một sự trở lại có phần đáng thất vọng cho một cuộc đại tu lớn nhưng ít nhất nó cũng hoạt động.


Chương trình vô nghĩa này làm cho một chương trình vô nghĩa khác! Đây là chương trình tuyệt vời nhất tôi từng thấy!
Aequitas

1

giải pháp JavaScript của tôi nhanh và bẩn :)

đầu ra cho Hello World\n

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

Nguồ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
Chào mừng đến với trang web! Bạn nên bao gồm điểm số trong tiêu đề của câu trả lời của bạn.
Phù thủy lúa mì

Tôi vừa mới tạo trình tạo bf, hệ thống điểm gốc có xử lý hình ảnh không liên quan :( Tỷ lệ thế giới xin chào ít hơn 9 (chiều dài bf / chiều dài văn bản gốc)
Peter

1

Tôi đã xây dựng một cái gì đó bằng Java. Không tính điểm. Các văn bản có 3 ký tự trở xuống được mã hóa với số nhân trên mỗi chữ cái, ví dụ: "A" =++++++++[>++++++++<-]>+. . Các văn bản có nhiều hơn 3 ký tự được mã hóa với một danh sách được tính toán được chia thành 3 khu vực. Vùng đầu tiên là x lần 49, sau đó cộng x lần 7 và cuối cùng cộng x. Ví dụ: "A" là 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);
        }
    }
}

Chuỗi được cung cấp "### INSERT TEXT TẠI ĐÂY ###" trở thành --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"Chào thế giới!" trở thành --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]


1

Con trăn 3

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

Đây thực chất chỉ là một phiên bản cải tiến của câu trả lời của icedvariabled. (-1 Byte từ Wheat Wizard, -5 từ FatalError, -2 từ jez)


Tôi tin rằng đây là python 3. Nếu vậy Bạn nên đưa nó vào tiêu đề của bạn. Nếu vậy bạn cũng có thể loại bỏ ngắt dòng sau của bạn :. Điều này cũng có thể được thực hiện như một sự hiểu biết danh sách để lưu byte.
Thuật sĩ lúa mì

-5 byte vớiprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

-2 byte: mất dấu ngoặc vuông để bạn gọi join()biểu thức trình tạo thay vì hiểu danh sách: print("".join("+"*ord(i)+".[-]"for i in input()))
jez

-2 byte: bạn có thể chỉ cần di chuyển đến ô tiếp theo (câu hỏi cho biết bạn nên giả sử một dải vô hạn theo cả hai hướng print("".join("+"*ord(i)+".>"for i in input()))(điều này cũng làm giảm điểm vì bạn mất 2 byte ở đầu ra)
MegaIng
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.