*** นักกอล์ฟ


32

หนึ่งในโค้ดที่ง่ายที่สุดที่เขียนด้วยภาษาการเขียนโปรแกรมคือลำดับการพิมพ์ของอักขระ (เช่น "Hello, world!") อย่างไรก็ตามs o อี อีs o ทีอีอาร์ฉันCการเขียนโปรแกรมภาษาเช่นbrainfuckแม้รหัสที่ง่ายนี้ค่อนข้างน่ารำคาญที่จะเขียน

งานของคุณคือการเขียนโปรแกรม (ไม่ต้องเขียนใน brainfuck) ซึ่งพิมพ์โปรแกรม Brainfuck (ความยาวต่ำสุด) ที่พิมพ์ข้อความที่กำหนด

อินพุต

ลำดับของอักขระ (ระหว่าง1และ255) ถูกกำหนดโดยรูปแบบใด ๆ (ตัวแปร, อาร์กิวเมนต์, stdin, ไฟล์, ... )

เอาท์พุต

เอาต์พุตนั้นถูกต้อง (ไม่มีการจับคู่[และ] ) รหัส brainfuck (สมมติ 8 บิตเซลล์ห่อไม่ได้ลงนามและไม่ จำกัด จำนวนของเซลล์ไปทางซ้ายและขวา) พิมพ์สตริงที่แน่นอนที่ได้รับเป็น input

ยกตัวอย่างเช่นการส่งออกไปได้อย่างใดอย่างหนึ่งสำหรับการป้อนข้อมูลเป็น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ย่อหน้าจะคั่นด้วยสอง0x0As และไม่มีอักขระขึ้นบรรทัดใหม่ในตอนท้าย
  • สตริงอื่น ๆ ที่คุณอาจมีให้

โปรแกรมของคุณอาจรวมถึงการคำนวณคะแนนของตัวเอง

แน่นอนรหัสคะแนนต่ำสุดจะเป็นผู้ชนะ


ทำซ้ำ (แม้ว่าจะเป็นประโยคที่ดีกว่า) ของcodegolf.stackexchange.com/questions/3450/…
คัดลอก

4
มันค่อนข้างยากที่จะคำนวณคะแนน มันเป็นไฟล์ที่แตกต่างกันมากมายที่เราต้องติดตามและเรียกใช้ 'สตริงอื่น ๆ ที่คุณอาจระบุ' คืออะไร ทำไมฉันจะเพิ่มมากขึ้นถ้ามันจะเพิ่มคะแนนของฉัน
captncraig

1
Lenna.pngจะไปครองคะแนนเพราะมันเป็นอินพุตที่ใหญ่ที่สุด อาจทำให้ขนาดปกติเป็นปกติหรือไม่
Keith Randall

1
รหัสความยาวต่ำสุดสำหรับ 'A' คือ ---- [----> + <]> ++
Scony

1
เห็นได้ชัดว่า OP ไม่สนใจความท้าทายนี้ ลองแก้ไขกฎการให้คะแนนเป็นสิ่งที่สมเหตุสมผลหรือไม่ ขณะนี้มีเพียงหนึ่งคำตอบ (ไม่สำเร็จ) พยายามใช้กฎเหล่านี้ดังนั้นการเปลี่ยนกฎจะไม่ทำให้คำตอบไม่ถูกต้อง
Anatolyg

คำตอบ:


15

ใน Java คำนวณส่วนสั้น BF ซึ่งสามารถแปลงตัวเลขใด ๆ เป็นหมายเลขอื่น แต่ละไบต์เอาต์พุตถูกสร้างขึ้นโดยการแปลงไบต์สุดท้ายที่ส่งออกหรือเป็น 0 สดบนเทป

ตัวอย่างถูกสร้างขึ้นในสามวิธี ครั้งแรกด้วยการทำซ้ำอย่างง่าย ๆ ของ+และ-(เช่น++++แปลง 7 ถึง 11) โดยการรวมตัวอย่างที่รู้จัก (เช่นถ้า A แปลง 5 ถึง 50 และ B แปลง 50 ถึง 37 จากนั้น AB แปลง 5 ถึง 37) และการคูณแบบง่าย (เช่น[--->+++++<]คูณจำนวนปัจจุบันด้วย 5/3) การคูณแบบง่ายใช้ประโยชน์จากการขึ้นบรรทัดใหม่เพื่อสร้างผลลัพธ์ที่ผิดปกติ (เช่น--[------->++<]>สร้าง 36 จาก 0 โดยที่การวนรอบดำเนินการ 146 ครั้งโดยมีการลดหลั่นลงมา 4 ครั้งและการขึ้นลง 1 รอบ 1 ครั้ง)

ฉันขี้เกียจเกินไปที่จะคำนวณคะแนนของฉัน แต่จะใช้เกี่ยวกับการดำเนินงาน 12.3 BF Lenna.pngต่อไบต์

import java.io.*;

class shortbf {
    static String repeat(String s, int n) {
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < n; i++) b.append(s);
        return b.toString();
    }

    // G[x][y]: BF code that transforms x to y.                                                     
    static String[][] G = new String[256][256];
    static {
        // initial state for G[x][y]: go from x to y using +s or -s.                                
        for (int x = 0; x < 256; x++) {
            for (int y = 0; y < 256; y++) {
                int delta = y - x;
                if (delta > 128) delta -= 256;
                if (delta < -128) delta += 256;

                if (delta >= 0) {
                    G[x][y] = repeat("+", delta);
                } else {
                    G[x][y] = repeat("-", -delta);
                }
            }
        }

        // keep applying rules until we can't find any more shortenings                             
        boolean iter = true;
        while (iter) {
            iter = false;

            // multiplication by n/d                                                                
            for (int x = 0; x < 256; x++) {
                for (int n = 1; n < 40; n++) {
                    for (int d = 1; d < 40; d++) {
                        int j = x;
                        int y = 0;
                        for (int i = 0; i < 256; i++) {
                            if (j == 0) break;
                            j = (j - d + 256) & 255;
                            y = (y + n) & 255;
                        }
                        if (j == 0) {
                            String s = "[" + repeat("-", d) + ">" + repeat("+", n) + "<]>";
                            if (s.length() < G[x][y].length()) {
                                G[x][y] = s;
                                iter = true;
                            }
                        }

                        j = x;
                        y = 0;
                        for (int i = 0; i < 256; i++) {
                            if (j == 0) break;
                            j = (j + d) & 255;
                            y = (y - n + 256) & 255;
                        }
                        if (j == 0) {
                            String s = "[" + repeat("+", d) + ">" + repeat("-", n) + "<]>";
                            if (s.length() < G[x][y].length()) {
                                G[x][y] = s;
                                iter = true;
                            }
                        }
                    }
                }
            }

            // combine number schemes                                                               
            for (int x = 0; x < 256; x++) {
                for (int y = 0; y < 256; y++) {
                    for (int z = 0; z < 256; z++) {
                        if (G[x][z].length() + G[z][y].length() < G[x][y].length()) {
                            G[x][y] = G[x][z] + G[z][y];
                            iter = true;
                        }
                    }
                }
            }
        }
    }
    static void generate(String s) {
        char lastc = 0;
        for (char c : s.toCharArray()) {
            String a = G[lastc][c];
            String b = G[0][c];
            if (a.length() <= b.length()) {
                System.out.print(a);
            } else {
                System.out.print(">" + b);
            }
            System.out.print(".");
            lastc = c;
        }
        System.out.println();
    }

    static void genFile(String file) throws IOException {
        File f = new File(file);
        int len = (int)f.length();
        byte[] b = new byte[len];
        InputStream i = new FileInputStream(f);
        StringBuilder s = new StringBuilder();
        while (true) {
            int v = i.read();
            if (v < 0) break;
            if (v == 0) continue; // no zeros                                                       
            s.append((char)v);
        }
        generate(s.toString());
    }
    public static void main(String[] args) throws IOException {
        genFile(args[0]);
    }
}

ฉันรู้ว่าฉันประมาณสองปีครึ่งที่ผ่านมาและนี่ไม่ใช่กอล์ฟ แต่วิธีการทำซ้ำอาจจะส่งคืนสตริงใหม่ (อักขระใหม่ [ความยาว]) แทนที่ทั้งหมด ("\ 0", STR);
Loovjo

13

นี่คือวิธีแก้ปัญหาที่เลวร้ายที่สุดที่เป็นไปได้ถึงแม้ว่าจะดูดีใน Brainfuck:

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

คะแนนน่าจะแย่ที่สุดที่เราจะเห็นโดยไม่ตั้งใจทำให้มันแย่

ทำงานเกี่ยวกับการคำนวณคะแนนจริง


คุณช่วยอธิบายสิ่งนี้ได้ไหม? การอ่านรหัส BF ค่อนข้างยาก
BMac

3
สำหรับอินพุตแต่ละไบต์เพียงพิมพ์ N +และ a.
captncraig

ด้วยฉันเชื่อว่าการ[-]ล้างเซลล์ระหว่างตัวละครแต่ละตัว
captncraig

8

Python 3.x

ฉันจะไม่ชนะรางวัลใด ๆ สำหรับรหัสผลลัพธ์ที่สั้นที่สุด แต่อาจเป็นโปรแกรมที่สร้างรหัส ...

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

'สวัสดีโลก! \ n':

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

1
ตอบโดยบังเอิญกับคำตอบที่ Madisons ตัวสร้างที่สั้นกว่า:print("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

คุณสามารถตีโปรแกรมของคุณได้ 2 ตัวโดยแทนที่.[-]ด้วย.>
MilkyWay90


8

ฉันไม่แน่ใจว่ามันดีแค่ไหน แต่ฉันสนุกที่ได้เขียนสิ่งนี้ (ใน Clojure ... )

(ns bf.core)
(def input "Hello world!")
(defn abs [x] (if (and (< x 0) (= (type x) (type 1))) (* x -1) x)) 
(defn sqrt? [x y] (if (= (* y y) x) true false) )
(defn sqrt [x] (for [y (range x) :when (sqrt? x y)] y) )
(defn broot [x]
;  Run this using trampoline, e.g., (trampoline broot 143)
  (if (< x 2) nil)
  (let [y (sqrt x)]
    (if (not= (seq y) nil)
      (first y)
      (broot (dec x) )
      )
    )
  )
(defn factor [x]
  (if (<= x 2) x)
  (for [y (range (- x 1) 1 -1)
        :when (= ( type (/ x y) ) (type 1) )
        ]
    y)
  )

(defn smallest_factors [x]
  (let [ facts (factor x) ]
  (if (= (count facts) 2) facts)
  (if (< (count facts) 2) (flatten [facts facts])
    (let [ y (/ (dec (count facts) ) 2)
          yy (nth facts y)
          z (inc y)
          zz (nth facts z)
          ]
      (if (= (* yy zz) x ) [yy zz] [yy yy])
      )
    )
    )
  )

(defn smallestloop [x]
  (let [ facts (smallest_factors x)
        fact (apply + facts)
        sq (trampoline broot x)
        C (- x (* sq sq) )]
    (if (and (< fact (+ (* 2 sq) C) ) (not= fact 0))
      facts
      [sq sq C])
    )
  )
(def lastx nil)
;Finally!
(defn buildloop [x]
  (if (nil? lastx)
     (let [pluses (smallestloop x)]
       (apply str
              (apply str (repeat (first pluses) \+))
              "[>"
              (apply str (repeat (second pluses) \+))
              "<-]>"
              (if (and (= (count pluses) 3) (> (last pluses) 0))
                (apply str(repeat (last pluses) \+))
              )
              "."
              )
    )
    (let [diff (abs (- x lastx) )]
      (if (< diff 10)
        (if (> x lastx)
          (apply str
               (apply str (repeat diff \+))
               "."
                 )
          (apply str
                 (apply str (repeat diff \-))
                 "."
                 )
          )
        (let [signs (smallestloop diff)]
          (apply str
             "<"
             (apply str (repeat (first signs) \+))
             "[>"
             (if (> x lastx)
               (apply str (repeat (second signs) \+))
               (apply str (repeat (second signs) \-))
             )
             "<-]>"
             (if (and (= (count signs) 3) (> (last signs) 0))
               (if (> x lastx)
                 (apply str(repeat (last signs) \+))
                 (apply str(repeat (last signs) \-))
               )
             )
             "."
           )
         )
        )
      )
    )
  )
(for [x (seq input)
  :let [y (buildloop (int x))]
      ]
  (do 
   (def lastx (int x))
   y
   )
  )

อาจมีวิธีแก้ปัญหาที่มีประสิทธิภาพมากกว่าและหรูหรากว่า แต่นี่เป็นไปตามรูปแบบความคิดของฉันค่อนข้างเป็นเชิงเส้นดังนั้นจึงเป็นวิธีที่ง่ายที่สุด


8

คะแนน: 4787486 41439404086426 (ไม่มีข้อมูลที่สร้างแบบสุ่ม)

(4085639 จากนั้นมาจาก Lenna.png นั่นคือ 99.98%)

ฉันไม่ได้รับข้อมูลสุ่ม ฉันไม่ต้องการบัญชีที่ต้องจ่ายเพื่อรับข้อมูลหรือไม่

ไร้เดียงสาสวย นี่คือรหัสที่สร้างขึ้นสำหรับ "1Aa" (49, 65, 97) พร้อมเอกสารประกอบเล็กน้อย:

                   // field 0 and 1 are loop counters.
                   // The fields 2, 3 and 4 are for "1", "A" and "a"
++++++++++[        // do 10 times
    >
    ++++++++++[    // do 10 times
        >          // "1" (49) is below 50 so we don't need to do anything here
        >+         // When the loops are done, this part will have increased the value of field 3 by 100 (10 * 10 * 1)
        >+         // same as above
        <<<-       // decrease inner loop counter
    ]
    >+++++         // this will add 50 (10 * 5) to field 2, for a total of 50
    >----          // subtract 40 from field 3, total of 60
    >              // Nothing done, value stays at 100
    <<<<-          // decrease outer loop counter
]
>>-.               // subtract 1 from field 2, total now: 49, the value for "1"
>+++++.            // add 5 to field 3, makes a total of 65, the value for "A"
>---.              // subtract 3 from field 4, total of 97, the value for "a"

รหัส Java เป็นบิตที่น่าเกลียด แต่มันใช้งานได้ คำสั่งที่สร้างขึ้นต่ออัตราส่วนไบต์อินพุทน่าจะดีกว่าค่าไบต์เฉลี่ยที่สูงขึ้น

หากคุณต้องการเรียกใช้คุณต้องใส่ Lenna.png ในไดเรกทอรีเดียวกันกับไฟล์. class มันพิมพ์คะแนนเพื่อคอนโซลและเขียนรหัส BF ที่สร้างขึ้นลงในไฟล์ที่เรียกว่า "output.txt"

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;


public class BrainFuckGenerator {
    public static CharSequence generate(byte[] bytes) {
        final StringBuilder brainfuckBuilder = new StringBuilder();
        for(int j = 0; j<10; j++)
                brainfuckBuilder.append("+");

        brainfuckBuilder.append("[>");

        for(int j = 0; j<10; j++)
            brainfuckBuilder.append("+");

        brainfuckBuilder.append("[");

        final StringBuilder singles = new StringBuilder();
        final StringBuilder tens = new StringBuilder();
        final StringBuilder goBack = new StringBuilder();

        for(byte b: bytes) {
            brainfuckBuilder.append(">");
            for(int j=0; j<(b/100); j++) {
                brainfuckBuilder.append("+");
            }

            tens.append(">");
            if((b - (b/100)*100)/10 <= 5) {
                for(int j=0; j<(b - (b/100)*100)/10; j++) {
                    tens.append("+");
                }
            } else {
                brainfuckBuilder.append("+");
                for(int j=0; j<10 - (b - (b/100)*100)/10; j++) {
                    tens.append("-");
                }
            }

            singles.append(">");
            if(b%10 <= 5) {
                for(int j=0; j<b%10; j++) {
                    singles.append("+");
                }
            } else {
                tens.append("+");
                for(int j=0; j<10 - (b%10); j++) {
                    singles.append("-");
                }
            }
            singles.append(".");

            goBack.append("<");
        }
        goBack.append("-");

        brainfuckBuilder
            .append(goBack)
            .append("]")
            .append(tens)
            .append("<")
            .append(goBack)
            .append("]>")
            .append(singles);

        return brainfuckBuilder;
    }

    public static void main(String[] args) {
        /* Hello, World! */
        int score = score("Hello, world!"+((char)0xA));

        /* 255 single chars */
        int charscore = 0;
        for(char c=1; c<=0xff; c++)
            charscore += score(String.valueOf(c));

        score += Math.round(((double)charscore)/16);

        /* Lenna */
        final File lenna = new File("Res/Lenna.png");
        final byte[] data = new byte[(int)lenna.length()];
        int size = 0;
        try(FileInputStream input = new FileInputStream(lenna)) {
            int i, skipped=0;
            while((i = input.read()) != -1)
                if(i == 0)
                    skipped++;
                else
                    data[size++ - skipped] = (byte)(i&0xff);
        } catch (IOException e) {
            e.printStackTrace();
        }

        score += score(Arrays.copyOf(data, size), "Lenna");

        /* 99 Bottles */
        final StringBuilder bottleBuilder = new StringBuilder();
        for(int i=99; i>2; i--) {
            bottleBuilder
                .append(i)
                .append(" bottles of beer on the wall, ")
                .append(i)
                .append(" bottles of beer.")
                .append((char) 0xa)
                .append("Take one down and pass it around, ")
                .append(i-1)
                .append(" bottles of beer on the wall.")
                .append((char) 0xa)
                .append((char) 0xa);

        }

        bottleBuilder
            .append("2 bottles of beer on the wall, 2 bottles of beer.")
            .append((char) 0xa)
            .append("Take one down and pass it around, 1 bottle of beer on the wall.")
            .append((char) 0xa)
            .append((char) 0xa)
            .append("No more bottles of beer on the wall, no more bottles of beer. ")
            .append((char) 0xa)
            .append("Go to the store and buy some more, 99 bottles of beer on the wall.");

        score(bottleBuilder.toString(), "99 Bottles");
        System.out.println("Total score: "+score);
    }

    private static int score(String s) {
        return score(s, null);
    }

    private static int score(String s, String description) {
        final CharSequence bf = generate(s.getBytes());
        try(FileWriter writer = new FileWriter("Res/output.txt", true)) {
            writer.write((description == null ? s : description));
            writer.write(NL);
            writer.write("Code:");
            writer.write(NL);
            writer.write(bf.toString());
            writer.write(NL+NL);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bf.length();
    }

    private static int score(byte[] bytes, String description) {
        final CharSequence bf = generate(bytes);
        try(FileWriter writer = new FileWriter("Res/output.txt", true)) {
            if(description != null) {
                writer.write(description);
                writer.write(NL);
            }
            writer.write("Code:");
            writer.write(NL);
            writer.write(bf.toString());
            writer.write(NL+NL);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bf.length();
    }

    private static final String NL = System.getProperty("line.separator");
}

ฉันจะทำการปรับปรุงเล็กน้อย แต่อาจจะไม่มาก เสร็จสิ้น


สิ่งนี้เสียแล้วผลลัพธ์ของ BF ที่สร้างขึ้นเป็น NUL ไบต์หรือ '?' อักขระขึ้นอยู่กับโลแคลสำหรับอักขระใด ๆ ที่ไม่ได้อยู่ใน 1..127 ASCII ธรรมดา (1-127) ดูเหมือนจะไม่เป็นไร สังเกตว่า (ไบต์) มีการเซ็นชื่อและเลือกสถานที่อย่างระมัดระวังได้รับจำนวนมาก (รับคะแนนมากกว่า 5,800,000) แต่ยังมี NUL หลายพันรายการจากการแปลง bf ของ Lenna.png ดังนั้นก็มีอย่างอื่นเช่นกัน
user3710044

4

BrainF ** k

ฉันเป็นโปรแกรมเมอร์ BF ที่ไม่ดีนักดังนั้นคำตอบนี้อาจไม่มีประสิทธิภาพเลย ฉันไม่แน่ใจในคะแนน แต่ควรมีประสิทธิภาพดีกว่าคำตอบที่มีอยู่เดิมในข้อความโดยเฉลี่ยของคุณ แทนที่จะ zeroing เซลล์ออกหลังจากตัวละครทุกตัวอันนี้จะ "ปรับ" เป็นตัวละครใหม่ที่มีการลบถ้าตัวละครก่อนหน้าให้มีขนาดใหญ่กว่า

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

(หมายเหตุนี่คือรหัสที่ฉันเขียนเมื่อนานมาแล้วและได้นำมาใช้ในการแข่งขันครั้งนี้ฉันหวังเป็นอย่างยิ่งว่าฉันได้ทำการแปลงที่ถูกต้องแล้ว แต่ถ้ามันล้มเหลวสำหรับการป้อนข้อมูลใด ๆ

เวอร์ชันที่แสดงสถานะของเทปตลอดโค้ด:

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

ฉันเขียนสิ่งนี้เพื่อตอบคำถามที่มีการทำเครื่องหมายซ้ำกันและแม้ว่านี่ไม่ใช่กอล์ฟที่ยิ่งใหญ่ที่สุด (สำหรับคำถามเฉพาะนี้อย่างน้อยที่สุด) ฉันคิดว่ามันน่าขยะแขยงถ้าฉันไม่ได้แชร์ ทั้งหมดเป็นสง่าราศีซึ่งพูดไม่ชัดน่ารังเกียจ จริง ๆ ฉันรู้สึกประหลาดใจครึ่งหนึ่งที่ใช้งานได้ดี ฉันจะนำข้อเสนอแนะใด ๆ ในการเล่นกอล์ฟลงเพราะนั่นคือเป้าหมายหลักของฉันในการสร้าง

ในฐานะที่เป็นบันทึกด้านข้างในบรรทัดที่สอง.21สามารถแทนที่อักขระสามตัวเริ่มต้นได้vด้วยเว้นวรรคสองช่องหากทำให้อ่านง่ายขึ้น ฉันไม่ชอบที่จะเห็นช่องว่างในโปรแกรมของฉัน> <> เพราะนั่นหมายความว่ามีพื้นที่ว่างเปล่า (แท้จริง) นอกจากนี้ยังเป็นเศษเล็กเศษน้อยจากหนึ่งในหลายต้นแบบ

วิธีการใช้งานนั้นง่ายมากและค่อนข้างตรงไปตรงมาฉันมีช่วงเวลาที่ยากลำบากในการคิดหาวิธีที่จะใช้อัลกอริทึมอื่น มันจะพิมพ์อย่างไรก็ตามต้องพิมพ์ "+" หลายตัวสำหรับอักขระตัวแรกแล้วพิมพ์ "+" s หรือ "-" s ตามต้องการสำหรับอักขระเพิ่มเติมแต่ละตัวโดยแยกแต่ละส่วนด้วยจุด สิ่งที่ฉันพบเกี่ยวกับโปรแกรมนี้คือมันปรับเปลี่ยนซอร์สโค้ดของตัวเองเพื่อให้พิมพ์ "+" หรือ "-" (มันจะแทนที่ "+" ในบรรทัดที่ 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 / ความยาวข้อความดั้งเดิม)
Peter

1

ฉันสร้างบางสิ่งใน Java ไม่ได้คำนวณคะแนน ตำราที่มี 3 หรือน้อยกว่าตัวอักษรมีการเข้ารหัสด้วยคูณต่อตัวอักษรเช่น "A" ++++++++[>++++++++<-]>+.= 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

Python 3

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

นี่เป็นเพียงคำตอบที่ปรับปรุงแล้วเล็กน้อยของ icedvariables (-1 ไบต์จาก Wheat Wizard, -5 จาก FatalError, -2 จาก Jez)


ฉันเชื่อว่านี่คือ python 3 ถ้าเป็นเช่นนั้นคุณควรรวมไว้ในส่วนหัวของคุณ :ถ้าเป็นเช่นนั้นคุณยังสามารถลบเส้นแบ่งของคุณหลังจาก นี่อาจเป็นรายการความเข้าใจเพื่อบันทึกไบต์
ข้าวสาลีตัวช่วยสร้าง

-5 ไบต์ด้วยprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

-2 bytes: ทำเครื่องหมายวงเล็บเหลี่ยมเสียดังนั้นคุณจึงโทรหาjoin()นิพจน์เครื่องกำเนิดไฟฟ้าแทนการทำความเข้าใจรายการ: print("".join("+"*ord(i)+".[-]"for i in input()))
jz

-2 ไบต์: คุณสามารถย้ายไปยังเซลล์ถัดไปได้ (คำถามระบุว่าคุณควรใช้แบนด์ที่ไม่มีที่สิ้นสุดในทั้งสองทิศทางprint("".join("+"*ord(i)+".>"for i in input()))(ซึ่งจะช่วยลดคะแนนเนื่องจากคุณสูญเสีย 2 ไบต์ในเอาต์พุต)
MegaIng
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.