ব্রেইনফ *** গল্ফার


32

প্রোগ্রামিং ল্যাঙ্গুয়েজে রচিত সহজতম কোডগুলির মধ্যে একটি হ'ল অক্ষরের প্রোগ্রাম প্রিন্টিংয়ের ক্রম (উদাহরণস্বরূপ "হ্যালো, ওয়ার্ল্ড!")। যাইহোক, গুলি মি গুলি টি আমি মত প্রোগ্রামিং ভাষা Brainfuck , এমনকি এই সহজ কোড বেশ লিখতে বিরক্তিকর।

আপনার কাজ হ'ল একটি প্রোগ্রাম লিখুন (মস্তিষ্কে লেখার দরকার নেই), যা প্রদত্ত পাঠ্যটি মুদ্রণের জন্য একটি (ন্যূনতম দৈর্ঘ্য) ব্রেনফাক প্রোগ্রাম প্রিন্ট করে।

ইনপুট

অক্ষরের একটি ক্রম ( 1এবং এর মধ্যে 255) যে কোনও বিন্যাস (ভেরিয়েবল, আর্গুমেন্ট, স্টিডিন, ফাইল, ...) দ্বারা দেওয়া হয়।

আউটপুট

আউটপুট হ'ল একটি বৈধ (কোনও মিল নেই [এবং ]) ব্রেইনফাক কোড (স্বাক্ষরিত স্বাক্ষরযুক্ত 8-বিট মোড়ানোর সেল এবং সীমাহীন সংখ্যক কোষ বাম এবং ডানদিকে) প্রিন্টিং সঠিক স্ট্রিং যা ইনপুট হিসাবে দেওয়া হয়েছিল।

উদাহরণস্বরূপ, ইনপুট জন্য একটি সম্ভাব্য আউটপুট Aহয় ++++++++[<++++++++>-]<+.

আপনার প্রোগ্রামটি >2mচালাতে দীর্ঘ সময় ( ) লাগবে না।

BF প্রোগ্রামটি >10sচালাতে বেশি সময় লাগবে না ।

স্কোরিং

(বিজ্ঞপ্তি: বর্তমান স্কোরিং পদ্ধতিটি পরিবর্তন হতে পারে, যেহেতু এটি গণনা করা সহজ নয় ...)

প্রোগ্রামের দৈর্ঘ্য (বিএফ কোড উত্পন্ন করা) নিজেই কিছু যায় আসে না । তবে, প্রোগ্রাম কোডে হার্ড-কোডিং বিএফ কোডগুলি ঠিক নেই। বিএফ কোডগুলির কেবল গ্রহণযোগ্য ব্যাপ্তি (উদাহরণস্বরূপ একটি বিএফ কোড একটি একক অক্ষর মুদ্রণ করে ) 0x01: +.হার্ড-কোডড হতে পারে।

স্কোর এই স্ট্রিংগুলি মুদ্রণের জন্য বিএফ কোডগুলির দৈর্ঘ্যের সমষ্টি।

  • Hello, world!একটি একক 0x0A( \n) অর্থাত্ "হ্যালো, ওয়ার্ল্ড!" প্রোগ্রাম) এর সাথে যুক্ত একটি স্ট্রিং
  • From থেকে একক চরিত্র 0x01~0xFF
    • এই 255 বিএফ কোডগুলির দৈর্ঘ্যের যোগফলটি গুণিত হয় 1/16, বৃত্তাকার হয় এবং স্কোরগুলিতে যোগ হয়।
  • প্রথম 16 স্ট্রিং, বিভাজন দ্বারা উত্পন্ন তালিকা বাইটের একটি র্যান্ডম ক্রম 11-11-11 এ উৎপন্ন দ্বারা 0x00, সমস্ত শূন্য দৈর্ঘ্যের স্ট্রিং অপসারণ।
  • Lenna.png , সমস্ত অপসারণ 0x00
  • গানের বিয়ার 99 বোতল , দিয়ে শুরু 99 bottles~, নতুন লাইন হয় 0x0A, অনুচ্ছেদ দুই দ্বারা বিভক্ত করা হয় 0x0As, এবং শেষে কোন newline অক্ষর।
  • আপনি সরবরাহ করতে পারেন অন্যান্য স্ট্রিং।

আপনার প্রোগ্রামের মধ্যে নিজের স্কোর গণনা অন্তর্ভুক্ত থাকতে পারে।

অবশ্যই, সর্বনিম্ন স্কোর কোডটি বিজয়ী হবে।



4
এটি স্কোরগুলি গণনা করা বরং কঠিন বলে মনে হচ্ছে। এটি আমাদের ট্র্যাক ডাউন এবং এর মাধ্যমে চালানোর জন্য প্রচুর আলাদা ফাইল। 'আপনি সরবরাহ করতে পারেন অন্যান্য স্ট্রিং' এর মূল বিষয়টি কী। এটি যদি আমার স্কোর যুক্ত করে তবে আমি কেন আরও যুক্ত করব?
ক্যাপচার্যাগ

1
Lenna.pngএটি এখন পর্যন্ত সবচেয়ে বড় ইনপুট হিসাবে স্কোরকে প্রাধান্য দিতে চলেছে। আকার দিয়ে কিছুটা স্বাভাবিক হতে পারে?
কীথ র্যান্ডাল

1
'এ' এর জন্য সর্বনিম্ন দৈর্ঘ্যের কোডটি হল ---- [----> + <]> ++।
স্কনি

1
ওপি স্পষ্টতই এই চ্যালেঞ্জের বিষয়ে চিন্তা করে না। বোধগম্য কিছুতে স্কোরিংয়ের নিয়মগুলি সম্পাদনা করা যাক? বর্তমানে কেবলমাত্র একটি উত্তর (ব্যর্থ) এই নিয়মগুলি ব্যবহার করার চেষ্টা করেছে, সুতরাং নিয়ম পরিবর্তন করলে উত্তরগুলি অকার্যকর হবে না।
অ্যানাটলিগ

উত্তর:


15

জাভাতে, একটি সংক্ষিপ্ত বিএফ স্নিপেট গণনা করুন যা যে কোনও সংখ্যাকে অন্য কোনও সংখ্যায় রূপান্তর করতে পারে। প্রতিটি আউটপুট বাইট হয় হয় শেষ আউটপুট বাইট বা টেপটিতে একটি তাজা 0 রূপান্তর করে is

স্নিপেটগুলি তিনটি উপায়ে তৈরি করা হয়। প্রথমে সরল পুনরাবৃত্তি দ্বারা +এবং -(যেমন ++++7 থেকে ১১ রূপান্তর করে) পরিচিত স্নিপেটগুলি মিশ্রন করে (উদাহরণস্বরূপ যদি A 5 থেকে 50 এবং B 50 থেকে 37 রূপান্তর করে, তবে AB 5 থেকে 37 রূপান্তর করে) এবং সরল গুণ (উদাহরণস্বরূপ [--->+++++<]বর্তমান সংখ্যাকে গুণিত করে) 5/3)। সাধারণ গুণগুলি অস্বাভাবিক ফলাফলগুলি উত্পন্ন করতে র‌্যাপ্রাউন্ডের সুবিধা গ্রহণ করে (যেমন --[------->++<]>0 থেকে 36 উত্পন্ন করে, যেখানে লুপটি 146 বার কার্যকর করে, মোট 4 টি অবতরণ এবং 1 আরোহী র‌্যাপ্রাউন্ডস)।

আমি আমার স্কোর গণনা করতে খুব অলস, তবে এটি বাইটে প্রায় 12.3 বিএফ অপারেশন ব্যবহার করে 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]);
    }
}

আমি জানি যে আমি প্রায় আড়াই বছর দেরি করেছি এবং এটি গল্ফ নয়, তবে পুনরাবৃত্তি পদ্ধতিটি কেবল নতুন স্ট্রিং (নতুন চর [দৈর্ঘ্য]) ফেরত আসতে পারে replace প্রতিস্থাপনআল ("\ 0", স্ট্রিং);
লুভজো

13

ভাল এখানে সবচেয়ে খারাপ সমাধান সম্পর্কে, যদিও Brainfuck নিজেই একটি বরং সুন্দর চেহারা এক:

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

স্কোরটি সম্ভবত আমরা সবচেয়ে খারাপ এটি ইচ্ছাকৃতভাবে খারাপ তৈরি না করে দেখতে পাচ্ছি।

আসল স্কোর গণনা করে কাজ করা।


আপনি কি ব্যাখ্যা করতে পারেন এটি কি করে? বিএফ কোড পড়া বরং কঠিন।
বিএমাক


আমি বিশ্বাস করি [-]প্রতিটি চরিত্রের মধ্যে ঘর পরিষ্কার করতে একটি a
ক্যাপচার্যাগ

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 (এলোমেলোভাবে উত্পন্ন ডেটা ছাড়াই)

(এর মধ্যে 4085639 লেনা.পিএনজি থেকে That's এটি 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"

জাভা কোডটি কিছুটা কুৎসিত হলেও এটি কার্যকর হয়। প্রতি ইনপুট বাইট অনুপাতের উত্পন্ন নির্দেশ সম্ভবত গড় বাইট মানের চেয়ে বেশি is

আপনি যদি এটি চালাতে চান তবে আপনাকে .class ফাইলের মতো একই ডিরেক্টরিতে Lenna.png রাখতে হবে। এটি কনসোল করার জন্য স্কোরটি মুদ্রণ করে এবং উত্পাদিত বিএফ কোডটিকে "আউটপুট.টেক্সট" নামক একটি ফাইলে লিখে দেয়।

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");
}

আমি কিছু ছোট উন্নতি করতে যাচ্ছি তবে সম্ভবত খুব বেশি নয়। সম্পন্ন.


এটি ভেঙে গেছে, উত্পন্ন বিএফ NU বাইট আউটপুট দেয় বা '?' 1.127-তে কোনও অক্ষরের জন্য লোকেলের উপর নির্ভর করে অক্ষর। সমতল ASCII (1-127) যদিও ঠিক আছে বলে মনে হচ্ছে। (বাইট) গুলি স্বাক্ষরিত হয়েছে এবং সাবধানে কোনও লোকেল নির্বাচন করা তাদের অনেকগুলি (5800000 এর চেয়ে বেশি স্কোর নেওয়া) পেয়েছে বলে মনে করে তবে এখনও লেনা.পিএনজিএফ রূপান্তর থেকে কয়েক হাজার এনএইউএল রয়েছে। সুতরাং অন্য কিছু আছে।
user3710044

4

BrainF ** K

আমি খুব খারাপ বিএফ প্রোগ্রামার, সুতরাং এই উত্তরটি সম্ভবত বেশ অদক্ষ। আমি স্কোর সম্পর্কে অনিশ্চিত, তবে এটি আপনার গড় পাঠ্যের বিদ্যমান উত্তরের চেয়ে কিছুটা ভাল সম্পাদন করা উচিত। প্রতিটি চরিত্রের পরে ঘরটি শূন্যের পরিবর্তে, প্রদত্ত পূর্ববর্তী অক্ষরটি বৃহত্তর হলে এটি বিয়োগের সাথে একটি নতুন অক্ষরে "সামঞ্জস্য" করবে।

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

(দ্রষ্টব্য, এই কোডটি আমি অনেক আগে লিখেছিলাম এবং এই প্রতিযোগিতার জন্য পুনরায় প্রকাশ করেছি I আমি আন্তরিকভাবে আশা করি যে আমি রূপান্তরটি সঠিকভাবে করেছি, তবে এটি যদি কোনও ইনপুট ব্যর্থ হয় তবে আমাকে জানান))

কোড জুড়ে টেপের রাজ্য দেখানো একটি সংস্করণ:

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

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

এটি সিজিএসইতে আমার প্রথম উত্তর! আমি যদি কিছু ভুল করেছি, আমাকে জানাবেন!


4

> <>

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

আমি সদৃশ হিসাবে চিহ্নিত একটি প্রশ্নের জবাবে এটি লিখেছিলাম, এবং যদিও এটি সর্বশ্রেষ্ঠ গল্ফ নয় (এই নির্দিষ্ট প্রশ্নের জন্য, কমপক্ষে) আমি বুঝতে পেরেছিলাম যে আমি এটি ভাগ না করলে এটি এক ধরণের অপচয় হবে d এটির সমস্ত ঘৃণ্য জিব্বারেশ-গৌরব। সত্যই, আমি এমনকি এটি কাজ করে অর্ধ-বিস্মিত। আমি এটি গল্ফ করার জন্য কোনও পরামর্শ নেব কারণ এটির সৃষ্টির এটিই আমার প্রধান লক্ষ্য।

পার্শ্ব নোট হিসাবে, দ্বিতীয় লাইনে শুরুতে তিনটি অক্ষর দুটি স্পেস দ্বারা .21প্রতিস্থাপন করা যেতে পারে vযদি এটি পড়া সহজ করে তোলে। আমি আমার> <> প্রোগ্রামগুলিতে স্পেস দেখতে পছন্দ করি না কারণ এর অর্থ স্থানটি নষ্ট হয়ে গেছে (আক্ষরিকভাবে)। এটি অনেকগুলি প্রোটোটাইপের একটিরও অবশেষ।

এটি যেভাবে কাজ করে তা সত্যিই সহজ এবং খুব স্পষ্টভাবেই আমি অন্য একটি অ্যালগরিদম বাস্তবায়নের উপায় নিয়ে ভাবতে অসুবিধায় পড়েছি। এটি প্রিন্ট করে তবে প্রথম অক্ষরটির জন্য অনেকগুলি প্রিন্ট করা প্রয়োজন এবং প্রতিটি অতিরিক্ত অক্ষরকে পিরিয়ড সহ পৃথক করে আরও "+" বা "-" গুলি প্রিন্ট করে। প্রোগ্রামটি সম্পর্কে আমি যা দেখতে পেয়েছি তা হ'ল এটি তার নিজস্ব উত্স কোডটি পরিবর্তন করে যাতে এটি "+" বা "-" মুদ্রণ করে (এটি বর্তমান অক্ষরটির চেয়ে বড় কিনা তা নির্ধারণের পরে যথাযথ অক্ষরের সাথে "+" প্রতিস্থাপন করে আগেরটির চেয়ে কম)।

এর জন্য আউটপুট Hello, World!:

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

আমি স্কোর করার ইচ্ছা মতো এইভাবে স্কোর করতে পারি তবে আমি হারাতে পেরেছি ইতিবাচক আমি এবং> <> ইন লেনা.পিএনগির মতো কিছু কীভাবে পড়তে হবে তা আমি পুরোপুরি জানি না।

যদি এই উত্তরটি আপনার আগ্রহী এবং আপনি একটি ব্যাখ্যা চান, সর্বদাই জিজ্ঞাসা করুন, তবে আপাতত আমি এটি কতটা বাঁকানো এবং ঘুরানো কারণেই এটিকে ছাড়াই ছাড়ব।

সম্পাদনা 1: এটি একটি সময় হয়ে গেছে তবে আমি প্রোগ্রামটি যেভাবে কোনও প্লাস বা বিয়োগ মুদ্রণ করবে কিনা তার প্রায় সম্পূর্ণ ওভারহল দিয়ে 2 বাইট বন্ধ করে দিতে সক্ষম হয়েছি। এটি একটি বৃহত ওভারহোলের জন্য কিছুটা হতাশাব্যঞ্জক প্রত্যাবর্তন তবে কমপক্ষে এটি কার্যকর হয়।


এই গিবারি প্রোগ্রামটি আরও একটি গীবির প্রোগ্রাম করে! এটি আমার দেখা সর্বশ্রেষ্ঠ প্রোগ্রাম!
Aequitas

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
সাইটে স্বাগতম! আপনার উত্তরের শিরোনামে স্কোরটি অন্তর্ভুক্ত করা উচিত।
গম উইজার্ড

আমি সবেমাত্র বিএফ জেনারেটর তৈরি করেছি, মূল স্কোর সিস্টেমে ইমেজ প্রসেসিং যা প্রাসঙ্গিক নয় :( হ্যালো ওয়ার্ল্ড রেশিও তখন কম 9 (বিএফ দৈর্ঘ্য / মূল পাঠ্য দৈর্ঘ্য)
পিটার

1

আমি জাভা কিছু তৈরি। স্কোর গণনা করা হয়নি। 3 বা তার চেয়ে কম অক্ষরের পাঠ্য প্রতি অক্ষর যেমন "A" = এর সাথে একটি গুণ দিয়ে এনকোড করা থাকে ++++++++[>++++++++<-]>+.। 3 টিরও বেশি অক্ষরের পাঠ্য একটি গণনা তালিকার সাথে এনকোড করা হয়েছে যা 3 টি অঞ্চলে বিভক্ত। প্রথম ক্ষেত্রটি হল x গুণ 49, তারপরে 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);
        }
    }
}

প্রদত্ত স্ট্রিং "### সংযুক্তি এখানে পাঠ্য ###" হয়ে যায় --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"ওহে বিশ্ব!" হয়ে --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]


1

পাইথন ঘ

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

এটি মূলত আইসডে ভেরিয়েবলগুলির উত্তরের একটি সামান্য উন্নত সংস্করণ। (-1 গম উইজার্ড থেকে বাইট, ফ্যাটালআরারের থেকে -5, জেজ থেকে -2)


আমি বিশ্বাস করি এটি অজগর 3.। যদি তাই হয় তবে এটি আপনার শিরোনামে অন্তর্ভুক্ত করা উচিত। যদি তাই হয় তবে আপনার পরে লাইন ব্রেকটিও মুছে ফেলতে পারেন :। এটি সম্ভবত বাইটস সংরক্ষণের জন্য তালিকা বোধ হিসাবেও করা যেতে পারে।
গম উইজার্ড

-5 বাইট সহprint("".join(["+"*ord(i)+".[-]"for i in input()]))
ফ্যাটালআরারের

-2 বাইট: বর্গাকার বন্ধনীগুলি হারাবেন যাতে আপনি join()একটি তালিকা বোঝার চেয়ে জেনারেটরের এক্সপ্রেশনটি কল করছেন : print("".join("+"*ord(i)+".[-]"for i in input()))
জিজ

-2 বাইট: আপনি কেবল (পরবর্তী কক্ষে স্থানান্তর করতে পারেন প্রশ্ন যুক্তরাষ্ট্রের আপনি উভয় নির্দেশাবলী মধ্যে অসীম ব্যান্ড অনুমান করা উচিত print("".join("+"*ord(i)+".>"for i in input()))(এই এছাড়াও যেহেতু আপনি আউটপুটে 2 বাইট হারান স্কোর হ্রাস)
MegaIng
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.