Brainf *** 골퍼


32

프로그래밍 언어로 작성된 가장 쉬운 코드 중 하나는 문자를 인쇄하는 프로그램입니다 (예 : "Hello, world!"). 그러나 이야 O를 m 전자 전자 t 전자 R C 와 같은 프로그래밍 언어 브레인 퍽 도이 간단한 코드를 쓰기에 매우 성가신입니다.

당신의 임무는 주어진 텍스트를 인쇄하는 (최소 길이의) Brainfuck 프로그램을 인쇄하는 프로그램을 작성하는 것입니다 (brainfuck로 작성하지 않아도 됨).

입력

일련의 문자 ( 1와 사이 255)는 모든 형식 (변수, 인수, stdin, 파일 등)으로 제공됩니다.

산출

출력은 입력으로 제공된 정확한 문자열을 인쇄 하는 유효한 (일치하지 않는 []) brainfuck 코드 (서명되지 않은 8 비트 랩핑 셀과 무제한의 셀 수 (왼쪽 및 오른쪽으로 가정))입니다.

예를 들어, 입력 가능한 출력 중 하나 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 를 제거하고 모든 0x00s를 제거하십시오 .
  • 노래 99의 맥주 의 가사는 ,로 시작하며 99 bottles~, 줄 바꿈은 0x0A이며, 단락은 두 개로 구분되며 0x0A끝에 줄 바꿈 문자가 없습니다.
  • 당신이 제공 할 수있는 다른 줄들.

귀하의 프로그램에는 자체 점수 계산이 포함될 수 있습니다.

물론 가장 낮은 점수의 코드가 승자가 될 것입니다.


의 (더 나은 표현한 있지만) 중복 codegolf.stackexchange.com/questions/3450/...는
복사

4
점수를 계산하기가 다소 어려워 보입니다. 추적하고 실행하는 데 필요한 많은 다른 파일입니다. '당신이 제공 할 수있는 다른 줄'의 요점은 무엇입니까? 내 점수에 추가 될 경우 왜 더 추가합니까?
captncraig

1
Lenna.png그것은 가장 큰 입력이므로 점수를 지배 할 것입니다. 어쩌면 크기별로 조금 정상화 하시겠습니까?
Keith Randall

1
'A'의 최소 길이 코드는 ---- [----> + <]> ++입니다.
Scony

1
OP는 분명히이 도전에 관심이 없습니다. 점수 규칙을 적절한 것으로 편집 해 보자. 현재 하나의 답변 (성공하지 못함) 만이 규칙을 사용하려고했기 때문에 규칙을 변경해도 답변이 무효화되지 않습니다.
anatolyg 2016 년

답변:


15

Java에서는 임의의 숫자를 다른 숫자로 변환 할 수있는 짧은 BF 스 니펫을 계산합니다. 각 출력 바이트는 마지막 출력 바이트를 변환하거나 테이프에서 새로운 0을 생성하여 생성됩니다.

스 니펫은 세 가지 방식으로 생성됩니다. 먼저 알려진 스 니펫 (예 : A가 5를 50으로 변환하고 B가 50을 37으로 변환 한 다음 AB가 5를 37으로 변환하는 경우)과 간단한 곱셈 (예 : 현재 수에 곱하는 것 )을 결합 하여 간단한 반복 +-(예 : ++++7에서 11로 변환) [--->+++++<]5/3). 간단한 곱셈은 특이한 결과를 생성하기 위해 랩 어라운드를 이용합니다 (예 : --[------->++<]>루프에서 146 회 실행되는 0에서 36을 생성, 총 4 개의 내림차순 및 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 +'s 및 .
captncraig

나는 [-]각 문자 사이의 셀을 지우는 것으로 생각합니다 .
captncraig

8

파이썬 3.x

글쎄, 나는 가장 짧은 출력 코드로 상을 수상하지는 않지만 프로그램이 코드를 생성하도록 어쩌면 ...

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

'안녕하세요, 세계! \ n':

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

1
실수로 Madisons 답변에 답변했습니다. 더 짧은 발전기 :print("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

당신은 대체하여 골프 2 개 문자로 프로그램을 할 수 .[-].>
MilkyWay90


8

나는 그것이 얼마나 좋은지 확신하지 못하지만, 이것을 쓰는 것이 재미있었습니다. (클로저 어에서 ...)

(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
+-

나는 중복으로 표시된 질문에 대한 답변으로 이것을 썼고, 이것이 가장 큰 골프는 아니지만 (적어도이 특정 질문에 대해) 공유하지 않으면 일종의 낭비라고 생각했습니다. 그 역겨운 횡설수설 같은 영광. 실제로, 나는 그것이 작동조차도 반쯤 놀랐습니다. 그것이 골프 제작의 주요 목표 였기 때문에 골프를 치는 제안을 할 것입니다.

부수적으로, 두 번째 줄에서 시작 하기 쉬운 3 개의 문자 .21v더 읽기 쉬운 경우 2 개의 공백 으로 대체 될 수 있습니다 . > <> 프로그램에서 공백을보고 싶지 않습니다. 왜냐하면 (문자 그대로) 공간이 낭비되었음을 의미하기 때문입니다. 또한 많은 프로토 타입 중 하나의 잔재이기도합니다.

그것이 작동하는 방식은 정말 간단하며 솔직히 다른 알고리즘을 구현하는 방법을 생각하기가 어렵습니다. 그러나 첫 번째 문자에 대해 많은 "+"를 인쇄 한 다음 각 추가 문자에 필요한 "+"또는 "-"를 더 인쇄하여 각 섹션을 마침표로 구분합니다. 내가 프로그램에서 멋진 점은 "+"또는 "-"를 인쇄하도록 자체 소스 코드를 수정한다는 것입니다 (현재 문자가 또는보다 큰지 여부를 판별 한 후 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 곱하기 49, 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

파이썬 3

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

이것은 본질적으로 icedvariables의 대답의 약간 개선 된 버전입니다. (밀 마법사에서 1 바이트, FatalError에서 -5, jez에서 -2)


나는 이것이 파이썬 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.