ब्रेनफ *** गोल्फर


32

प्रोग्रामिंग भाषा द्वारा लिखे गए सबसे आसान कोड में से एक प्रोग्राम प्रिंटिंग सीक्वेंस ऑफ कैरेक्टर्स है (उदा। हैलो, वर्ल्ड! ")। हालांकि, एस एम एस टी आर मैं की तरह प्रोग्रामिंग भाषाओं Brainfuck , यहां तक कि इस सरल कोड काफी लिखने के लिए कष्टप्रद है।

आपका कार्य एक प्रोग्राम लिखना है (ब्रेनफ़क में लिखना नहीं है), जो दिए गए टेक्स्ट को प्रिंट करने के लिए एक न्यूनतम (न्यूनतम-लंबाई) ब्रेनफ़क प्रोग्राम प्रिंट करता है।

इनपुट

(बीच वर्णों के अनुक्रम 1और 255) किसी भी प्रारूप (चर, तर्क, stdin, फ़ाइल, ...) द्वारा दिया जाता है।

उत्पादन

आउटपुट एक मान्य (कोई गैर-मिलान नहीं ) [और ]ब्रेनफ़ॉक कोड है (मान लें कि 8-बिट रैपिंग सेल और बाईं और दाईं ओर सेल की असीमित संख्या) सटीक स्ट्रिंग को प्रिंट करें जो इनपुट के रूप में दिया गया था।

उदाहरण के लिए, इनपुट के लिए एक संभावित आउटपुट Aहै ++++++++[<++++++++>-]<+.

आपके प्रोग्राम >2mको चलने में लंबा समय ( ) नहीं लगना चाहिए ।

BF प्रोग्राम >10sको चलने में लंबा समय ( ) नहीं होना चाहिए ।

स्कोरिंग

(सूचना: वर्तमान स्कोरिंग विधि बदल सकती है, क्योंकि इसकी गणना करना आसान नहीं है ...)

कार्यक्रम की लंबाई (बीएफ कोड उत्पन्न करना) अपने आप में कोई मायने नहीं रखता है। हालांकि, प्रोग्राम कोड में हार्ड कोडिंग BF कोड ठीक नहीं है। बीएफ कोड की केवल स्वीकार्य सीमा (पूर्व बीएफ कोड एक एकल वर्ण छपाई ) 0x01: +.हार्ड-कोडित हो सकती है।

स्कोर बीएफ कोड की लंबाई को इन तारों को मुद्रित करने का योग है।

  • Hello, world!एकल 0x0A( \n) के साथ एक तार जोड़ा गया (यानी "हैलो, दुनिया!" कार्यक्रम)
  • 0x01~ से एकल चरित्र0xFF
    • इन 255 बीएफ कोड की लंबाई के योग को गुणा 1/16, गोल और स्कोर में जोड़ा जाता है।
  • पहले 16 तारों की सूची, 11-11-11 को उत्पन्न बाइट्स के एक यादृच्छिक अनुक्रम को विभाजित करके 0x00, सभी शून्य-लंबाई वाले तारों को हटाकर।
  • लेनना.पिंग , सभी को हटाकर 0x00
  • गाने के बोल 99 बोतल बीयर के साथ शुरू 99 bottles~, नई सुर्खियां हैं 0x0A, पैराग्राफ को दो 0x0Aएस से अलग किया गया है , और अंत में कोई नया चरित्र नहीं है।
  • अन्य तार आप प्रदान कर सकते हैं।

आपके कार्यक्रम में स्वयं के स्कोर की गणना करना शामिल हो सकता है।

बेशक, सबसे कम-स्कोर कोड विजेता होगा।



4
ऐसा लगता है कि अंकों की गणना करना कठिन है। यह बहुत सी अलग-अलग फाइलें हैं जिन्हें हमें नीचे ट्रैक करने और चलाने की आवश्यकता है। 'आपके द्वारा प्रदान किए जा सकने वाले अन्य तार' क्या है। अगर यह मेरे स्कोर में जोड़ देगा तो मैं और अधिक क्यों जोड़ूंगा?
captncraig

1
Lenna.pngस्कोर पर हावी होने जा रहा है, क्योंकि यह अब तक का सबसे बड़ा इनपुट है। शायद आकार से थोड़ा सामान्य हो सकता है?
कीथ रान्डेल

1
'ए' के ​​लिए न्यूनतम लंबाई कोड ---- [----> + <]> ++ है।
Scony

1
ओपी स्पष्ट रूप से इस चुनौती के बारे में परवाह नहीं करता है। चलो कुछ समझदार को स्कोरिंग नियम संपादित करें? वर्तमान में, केवल एक उत्तर (असफल) ने इन नियमों का उपयोग करने की कोशिश की, इसलिए नियम बदलने से उत्तर अमान्य नहीं होंगे।
अनातोली

जवाबों:


15

जावा में, एक संक्षिप्त BF स्निपेट की गणना करता है जो किसी भी संख्या को किसी अन्य संख्या में परिवर्तित कर सकता है। प्रत्येक आउटपुट बाइट अंतिम आउटपुट बाइट या टेप पर एक ताज़ा 0 को परिवर्तित करके उत्पन्न होता है।

स्निपेट्स तीन तरीकों से उत्पन्न होते हैं। के पहले पुनरावृत्तियों द्वारा +और -(जैसे ++++7 से 11 धर्मान्तरित), ज्ञात स्निपेट के संयोजन द्वारा (जैसे यदि A 5 से 50 में परिवर्तित होता है और B 50 से 37 में परिवर्तित होता है, तो AB 5 से 37 में परिवर्तित होता है) और सरल गुणन (जैसे [--->+++++<]वर्तमान संख्या को गुणा करता है) 5/3)। साधारण गुणा असामान्य परिणाम उत्पन्न करने के लिए रैपराउंड का लाभ उठाता है (उदाहरण --[------->++<]>0 से 36 उत्पन्न करता है, जहां लूप 146 बार निष्पादित होता है, जिसमें कुल 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]);
    }
}

मुझे पता है कि मैं लगभग ढाई साल लेट हूं और यह गोल्फ नहीं है, लेकिन रिपीट तरीका सिर्फ नया स्ट्रिंग (नया चार [लंबाई]) वापस किया जा सकता है। प्रतिस्थापन ("\ 0", str);
लवजो

13

अच्छी तरह से संभव सबसे खराब समाधान के बारे में यहाँ है, हालांकि ब्रेनफक में एक अच्छा दिखने वाला है:

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

स्कोर शायद सबसे खराब है जिसे हम जानबूझकर खराब किए बिना देख सकते हैं।

वास्तविक स्कोर की गणना पर काम करना।


क्या आप बता सकते हैं कि यह क्या करता है? BF कोड पढ़ना मुश्किल है।
बीएमएसी

3
इनपुट के प्रत्येक बाइट के लिए यह +.
captncraig

मुझे विश्वास है कि [-]प्रत्येक चरित्र के बीच सेल को साफ करने के लिए।
captncraig

8

अजगर 3.x

ठीक है, मैं कम से कम आउटपुट कोड के लिए कोई पुरस्कार जीतने नहीं जा रहा हूं, लेकिन शायद प्रोग्राम के लिए कोड उत्पन्न करने के लिए ...

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

'हैलो, वर्ल्ड! \ N':

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

1
गलती से मैडिसन जवाब दे दिया। छोटा जनरेटर:print("".join(["+"*ord(i)+".[-]"for i in input()]))
घातक ५

आप अपने कार्यक्रम को 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 (बेतरतीब ढंग से उत्पन्न डेटा के बिना)

(४० (५६३ ९ उस लेनना.पिंग से हैं। यह ९९.९ of% है)

मुझे यादृच्छिक डेटा के साथ हिस्सा नहीं मिलता है। क्या मुझे उस खाते की आवश्यकता नहीं है जो मुझे डेटा प्राप्त करने के लिए भुगतान करना है?

बहुत भोला। यहाँ थोड़ा प्रलेखन के साथ "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"

जावा कोड थोड़ा बदसूरत है लेकिन यह काम करता है। इनपुट बाइट अनुपात प्रति उत्पन्न निर्देश शायद बेहतर है बाइट मान औसत है।

अगर आप इसे चलाना चाहते हैं, तो आपको .class फाइल के समान ही डायरेक्टरी में Lenna.png डालना होगा। यह स्कोर को कंसोल करने के लिए प्रिंट करता है और उत्पन्न बीएफ कोड को "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 से अधिक का स्कोर) लेकिन अभी भी कई हजार NULs हैं, जो कि Lenna.png के bf रूपांतरण से हैं। तो कुछ और भी है।
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
+-

मैंने इसे एक डुप्लिकेट के लिए चिह्नित प्रश्न के जवाब में लिखा था, और भले ही यह सबसे बड़ा गोल्फ नहीं है (इस विशिष्ट प्रश्न के लिए, कम से कम) मुझे लगा कि अगर मैं इसे साझा नहीं करता तो यह एक तरह का बेकार होगा। इसके सभी घृणित जीवंतता-वाई महिमा। वास्तव में, मैं आधा आश्चर्यचकित हूं कि यह भी काम करता है। मैं इसे नीचे लाने के लिए कोई सुझाव दूंगा क्योंकि इसके निर्माण में मेरा मुख्य लक्ष्य था।

एक साइड नोट के रूप में, दूसरी पंक्ति में शुरुआत के तीन अक्षरों .21को vदो रिक्त स्थान के साथ प्रतिस्थापित किया जा सकता है यदि यह पढ़ने में आसान बनाता है। मुझे अपने> <> कार्यक्रमों में स्थान देखना पसंद नहीं है क्योंकि इसका मतलब है कि वहाँ व्यर्थ स्थान (शाब्दिक) है। यह कई प्रोटोटाइपों में से एक अवशेष भी है।

जिस तरह से यह कार्य वास्तव में सरल है, और काफी स्पष्ट रूप से मुझे एक और एल्गोरिथ्म को लागू करने के तरीके के बारे में सोचने में मुश्किल समय होगा। हालांकि यह पहले वर्ण के लिए कई "+" मुद्रित होने की आवश्यकता है, और फिर प्रत्येक अतिरिक्त वर्ण के लिए आवश्यकतानुसार "+" s या "-" प्रिंट करता है, प्रत्येक खंड को अवधियों के साथ अलग करता है। कार्यक्रम के बारे में मुझे जो अच्छा लगता है वह यह है कि यह अपने स्वयं के सोर्स कोड को संशोधित करता है ताकि यह "+" या "-" प्रिंट करता है (यह लाइन 3 पर "+" को प्रतिस्थापित करता है, यह निर्धारित करने के बाद कि वर्तमान चरित्र अधिक है या नहीं। पहले वाले से कम)।

इसके लिए आउटपुट Hello, World!:

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

मैं इसे स्कोर करने के इरादे से कर सकता हूं, लेकिन मैं लगभग सकारात्मक हूं और मैं हार गया और मुझे पूरी तरह से पता नहीं है कि lenna.png>> <> में कुछ कैसे पढ़ना है।

यदि यह उत्तर आपको रुचिकर लगता है, तो आप सभी से पूछना चाहते हैं, लेकिन अब मैं इसे सिर्फ एक के बिना छोड़ दूंगा, क्योंकि यह कितना ट्विस्टी और टर्न है।

संपादित 1: यह एक समय हो गया है, लेकिन मैं 2 बाइट को बंद करने में सक्षम था जिस तरह से कार्यक्रम तय करता है कि एक प्लस या माइनस प्रिंट करना है या नहीं। बड़े ओवरहाल के लिए यह कुछ निराशाजनक वापसी है लेकिन कम से कम यह काम करता है।


यह gibberish प्रोग्राम एक और gibberish प्रोग्राम बनाता है! यह मैंने कभी देखा सबसे बड़ा कार्यक्रम है!
असितत्व

1

मेरे जावास्क्रिप्ट समाधान यह जल्दी और गंदा है :)

के लिए उत्पादन 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

मैंने जावा में कुछ बनाया। स्कोर की गणना नहीं की। 3 या उससे कम वर्ण वाले ग्रंथों को प्रति अक्षर गुणा के साथ कूटबद्ध किया जाता है जैसे "A" = ++++++++[>++++++++<-]>+.। 3 से अधिक वर्ण वाले ग्रंथों की गणना की गई सूची से की गई है, जो 3 क्षेत्रों में विभाजित है। पहला क्षेत्र x गुना 49 है, फिर x x 7 और अंत में x है। उदाहरण के लिए "ए" 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

अजगर ३

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

यह अनिवार्य रूप से icedvariables के उत्तर का केवल थोड़ा उन्नत संस्करण है। (गेहूं के जादूगर से -1 बाइट, फैटलएयर से -5, जेज से -2)


मेरा मानना ​​है कि यह अजगर 3 है। यदि ऐसा है तो आपको इसे अपने हेडर में शामिल करना चाहिए। यदि ऐसा है तो आप अपने बाद लाइन ब्रेक को भी हटा सकते हैं :। यह शायद बाइट्स को बचाने के लिए एक सूची समझ के रूप में भी किया जा सकता है।
गेहूं जादूगर

-5 बाइट्सprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

-2 बाइट्स: वर्गाकार कोष्ठक खो दें ताकि आप join()सूची print("".join("+"*ord(i)+".[-]"for i in input()))
बोध के

-2 बाइट्स: आप बस अगली सेल में जा सकते हैं (प्रश्न बताता है कि आपको दोनों दिशाओं में एक अनंत बैंड मान लेना चाहिए print("".join("+"*ord(i)+".>"for i in input()))(यह स्कोर कम कर देता है क्योंकि आप आउटपुट में 2 बाइट्स खो देते हैं)
मेगाइंज
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.