Brainf *** Golfçü


32

Bir programlama dili tarafından yazılan en kolay kodlardan biri, karakterlerin program yazdırma dizisidir (ör. "Merhaba dünya!"). Bununla birlikte, s o m e e s O t e r i c gibi programlama dilleri brainfuck , hatta bu basit kod yazımı için oldukça rahatsız edicidir.

Göreviniz verilen metni basan (minimum uzunlukta) bir Brainfuck programı basan bir program yazmaktır (beyin fırtınası ile yazmak zorunda değilsiniz).

Giriş

Bir karakter dizisi ( 1ve arasında 255) herhangi bir formatta (değişken, argüman, stdin, dosya, ...) verilir.

Çıktı

Çıktı, geçerli bir (eşleşmeyen [ve olmayan ]) beyin şifresi kodudur (imzasız 8 bitlik sarma hücresi ve sol ve sağa sınırsız sayıda hücre varsayar), girdi olarak verilen tam dizgiyi basar.

Örneğin, giriş için olası bir çıkış Aolduğunu ++++++++[<++++++++>-]<+..

Programınızın >2mçalışması uzun zaman almamalı ( ).

BF programının >10sçalışması uzun sürmemelidir ( ).

puanlama

(Dikkat: Geçerli puanlama yöntemi değişebilir, çünkü hesaplanması kolay değildir ...)

Programın uzunluğu (BF kodu üreten) kendisi önemli değil . Bununla birlikte, program kodundaki kodlama BF kodları iyi değil. Sadece olarak kabul edilebilir bir aralık (örneğin tek bir karakter baskı BF kodu. 0x01: +.) BF kodlarının kodlanmış olabilir.

Skor, bu dizeleri basan BF kodlarının uzunluğunun toplamıdır.

  • Hello, world!Single 0x0A( \n) eklenmiş bir dize (yani, "Merhaba dünya!" Programı)
  • 0x01~ Dan tek karakter0xFF
    • Bu 255 BF kodlarının uzunluğu toplamı ile çarpılır 1/16, yuvarlanır ve skora eklenir.
  • Bölme tarafından oluşturulan birinci 16 dizeleri listesi 11-11-11 oluşturulan bir bayt rastgele bir dizi ile 0x00tüm sıfır uzunluklu dizeleri çıkarılması.
  • Lenna.png , hepsini 0x00s.
  • Şarkının sözleri 99 şişe bira ile başlar 99 bottles~, yeni satırlar 0x0A, paragraflar iki 0x0Asaniye ile ayrılır ve sonunda yeni satır karakteri yoktur.
  • Sağlayabileceğiniz diğer dizeler.

Programınız kendi skorunu hesaplamayı içerebilir.

Tabii ki, en düşük puan kodu kazanacak.


Arasında (daha iyi ifade edilmiş olsa da) Yinelenen codegolf.stackexchange.com/questions/3450/...
copy

4
Bu puanları hesaplamak için oldukça zor görünüyor. İzlememiz ve izlememiz gereken çok sayıda farklı dosya var. 'Verebileceğiniz diğer karakter dizileri' nin amacı nedir. Eğer puanımı ekleyecekse neden daha fazlasını ekleyeyim?
captncraig

1
Lenna.pngşimdiye kadarki en büyük girdi olduğu gibi skora hakim olacak. Belki boyutuna göre biraz normalleştirmek?
Keith Randall

1
'A' için minimum uzunluk kodu ---- [----> + <]> ++.
Scony

1
OP açıkça bu zorlukla ilgilenmiyor. Puanlama kurallarını mantıklı bir şeye göre düzenleyelim mi? Şu anda yalnızca bir cevap (başarısız olarak) bu kuralları kullanmaya çalıştı, bu nedenle kuralları değiştirmek cevapları geçersiz kılmayacak.
anatolyg,

Yanıtlar:


15

Java'da, herhangi bir sayıyı başka bir sayıya dönüştürebilen kısa bir BF parçacığını hesaplar. Her çıktı baytı, ya son çıktı baytı dönüştürülür ya da teyp üzerinde yeni bir 0 değeri oluşturulur.

Parçacıklar üç şekilde üretilir. İlk olarak bilinen tekrarlanan parçaları birleştirerek (örneğin 7 ila 11'i dönüştürür) +ve -(örneğin ++++A, 5 ila 50'yi ve B, 50 ila 37'yi dönüştürürse, daha sonra AB, 5 ila 37'yi dönüştürür) ve basit çarpımları (ör [--->+++++<]. Mevcut sayıyı çarparak) 5/3). Basit çarpımlar, olağandışı sonuçlar üretmek için sargıdan faydalanır (örn. --[------->++<]>, Döngünün toplamda 4 azalan ve 1 artan sargıyla birlikte 146 kez çalıştığı 0'dan 36'yı oluşturur).

Puanımı hesaplamak için çok tembelim, ancak bayt başına yaklaşık 12,3 BF işlemi kullanıyor 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]);
    }
}

Yaklaşık iki buçuk yıl geç kaldığımı ve bunun golf olmadığını biliyorum, ancak yineleme metodu sadece yeni String (yeni karakter [uzunluk]).
Loovjo

13

Peki, işte olası en kötü çözüm, Brainfuck’ın kendisinde oldukça hoş görünümlü olmasına rağmen:

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

Skor muhtemelen kasıtlı olarak kötü yapmadan görmemiz gereken en kötü ihtimaldir.

Gerçek skoru hesaplamaya çalışmak.


Bunun ne yaptığını açıklayabilir misiniz? BF kodunu okumak oldukça zordur.
BMac

3
Girişin her bir baytı için, basitçe N +'ler ve a.
captncraig basar.

[-]Her karakter arasındaki hücreyi temizlemek için bir inanıyorum .
captncraig

8

Python 3.x

Eh, en kısa çıkış kodu için herhangi bir ödül kazanmayacağım ama belki programın kodu oluşturması için ...

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

'Merhaba, Dünya! \ N':

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

1
Yanlışlıkla Madisons cevabına cevap verdi. Daha kısa jeneratör:print("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError, 8:17,

Sen değiştirerek golf 2 karakter ile programınızı yapabilirsiniz .[-]ile.>
MilkyWay90


8

Ne kadar iyi olduğundan emin değilim, ama bunu yazarken eğlendim. (Clojure'da ...)

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

Muhtemelen daha verimli çözümler ve daha zarif çözümler var, ancak bu benim düşünce biçimimi biraz doğrusal olarak izliyor, bu yüzden en kolayıydı.


8

Gol: 4787486 41439404086426 (rastgele oluşturulmuş veri olmadan)

(4085639 bunun Lenna.png'den olduğunu. Bu% 99.98)

Rastgele veri içeren kısmı anlamıyorum. Verileri almak için ödemem gereken bir hesaba ihtiyacım yok mu?

Oldukça saf. İşte küçük bir dokümantasyon ile "1Aa" (49, 65, 97) için oluşturulan kod:

                   // 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 kodu biraz çirkin ancak çalışıyor. Girdi başına byte başına oluşturulan komut, ortalama byte değeri ne kadar yüksekse o kadar iyidir.

Çalıştırmak istiyorsanız, Lenna.png dosyasını .class dosyasıyla aynı dizine koymanız gerekir. Konsola skoru basar ve oluşturulan BF kodunu "output.txt" adlı bir dosyaya yazar.

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

Bazı küçük iyileştirmeler yapacağım ama muhtemelen çok fazla değil. Bitti.


Bu bozulur, oluşturulan BF NUL bayt veya '?' 1..127'de olmayan herhangi bir karakter için yerel ayarlara bağlı olarak Düz ASCII (1-127) olsa iyi görünüyor. (Baytların) imzalandığını ve dikkatlice bir yerel ayarın seçildiğini fark etmek (bunlardan 5800000'in üzerinde puan almak) bir sürü alır ancak Lenna.png'nin bf dönüşümünden hala birkaç NUL vardır. Yani başka bir şey var.
user3710044 5:15

4

Brainf ** k

Ben oldukça kötü bir BF programcısıyım, bu yüzden bu cevap muhtemelen oldukça verimsiz. Skordan emin değilim, ancak ortalama metninizdeki mevcut cevaptan biraz daha iyi performans göstermesi gerekiyor. Her karakterden sonra hücreyi sıfırlamak yerine, verilen karakter daha büyükse, bu karakter çıkarma işlemiyle yeni bir karaktere "ayarlanır".

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

(Not, bu uzun zaman önce yazdığım kod ve bu yarışma için tekrar önerildi. İçtenlikle dönüştürmeyi doğru yaptığımı umuyorum, ancak herhangi bir giriş için başarısız olursa bana bildirin.)

Kod boyunca bandın durumunu gösteren bir sürüm:

>>++++++[-<+++++++>]<+>             [0 '+' 0]
                                           ^
>+++++[-<+++++++++>]                [0 '+' '-' 0]
                                               ^
>+++++[-<+++++++++>]<+>             [0 '+' '-' '.' 0]
                                                   ^
>,[-<+>>>>>>+<<<<<]                 [0 '+' '-' '.' a 0 0 0 0 0 a]
                                                     ^
<[-<<<.>>>]<.>>+>                   [0 '+' '-' '.' 0 1 0 0 0 0 a]
                                                       ^
,[[-<<+>>>+>>+<<<]                  [0 '+' '-' '.' b 1 0 b 0 b a]
                                    [b is not 0]       ^
>>>>[-<<+>>]<[->+<]                 [0 '+' '-' '.' b 1 0 b a 0 b]
                                                             ^    
<<[->-[>]<<]

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

>+[-<<->>>[-<<<<<<.>>>>>>]<]        [0 '+' '-' '.' b 0 0 0 0 0 b]
                                                       ^|^
                                    [OUTPUT ONE CHARACTER BY THIS POINT]
<<<[>]<<.>[-]>                      [0 '+' '-' '.' 0 0 0 0 0 0 b]
                                                     ^
+>,]                                [End when b == 0]
                                    [GOAL: '+' '-' '.' b 1 0 b a 0 a]

İçin oluşturulan kod Hello, World!:

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

Bu CG.SE'deki ilk cevabım! Bir şeyi batırdıysam bana haber ver!


4

> <>

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

Bunu yinelemeli olarak işaretlenmiş bir soruya cevap olarak yazdım ve bu en büyük golf olmasa da (en azından bu özel soru için) paylaşmasaydım, bunun bir tür israf olacağını düşündüm. tüm iğrenç bir şekilde saçma sapan y ihtişamı. Gerçekten, işe yarıyor olmasına bile şaşırdım. Yaratılmasında asıl amacım olduğundan golf oynamak için herhangi bir öneride bulunacağım.

Not olarak, ikinci satırda başlangıçtaki üç karakter .21 ile değiştirilmesi mümkündür vokumak için hiç kolay yaparsa iki boşluklarla izledi. Programlarımda boşluk görmekten hoşlanmıyorum, çünkü boşa harcanmış alan var (kelimenin tam anlamıyla). Aynı zamanda birçok prototipten birinden de kalmıştır.

İşleyiş şekli gerçekten basit ve açıkçası başka bir algoritma uygulamanın bir yolunu düşünmekte zorlanıyorum. Bununla birlikte, ilk karakter için birçok "+" nın basılması gerekir ve ardından her bir bölümü periyotlarla ayırarak, her ek karakter için gerektiği şekilde daha fazla "+" veya "-" s yazdırır. Program hakkında havalı bulduğum şey, kendi kaynak kodunu "+" veya "-" yazdıracak şekilde değiştirmesidir (şu anki karakterin daha büyük olup olmadığını belirledikten sonra 3. satırdaki "+" yerine uygun karakterle değiştirir) öncekinden daha az).

İçin çıktı Hello, World!:

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

Bunu skorlanmaya çalışıldığı şekilde puanlayabilirim, ancak kaybedeceğim neredeyse pozitifim ve>>> lenna.png gibi bir şeyi nasıl okuyacağımı tam olarak bilmiyorum.

Eğer bu cevap sizi ilgilendiriyorsa ve bir açıklama yapmak isterseniz, elbette isteyin, ama şimdilik sadece ne kadar kıvrımlı ve çürük olduğu için bir tane olmadan bırakacağım.

1 EDIT: Bir süre oldu ama 2 bayt golf neredeyse başarmak için bir artı veya eksi yazdırmak karar verirken nasıl tamamen elden geçirme başardı. Bu büyük bir revizyon için biraz hayal kırıklığı yaratıyor ama en azından işe yarıyor.


Bu saçma program başka saçma program yapar! Bu şimdiye kadar gördüğüm en iyi program!
Aequitas

1

JavaScript çözümüm hızlı ve kirli :)

çıktı Hello World\n

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

Kaynak:

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
Siteye Hoşgeldiniz! Skoru cevabınızın başlığına dahil etmelisiniz.
Buğday Sihirbazı

Ben sadece bf üretecini yaptım, orijinal skor sistemi, alakalı olmayan görüntü işleme sahiptir :( Merhaba dünya oranı 9'dan daha azdır (bf uzunluğu / orijinal metin uzunluğu)
Peter

1

Java'da bir şey yaptım. Puanı hesaplamadı. 3 veya daha az karakter içeren metinler, harf başına çarpma ile kodlanır, örneğin "A" = ++++++++[>++++++++<-]>+.. 3'ten fazla karakter içeren metinler, 3 alana bölünmüş hesaplanmış bir liste ile kodlanır. İlk alan x çarpı 49, ardından artı x çarpı 7 ve nihayet artı x. Örneğin, "A" 1 * 49 + 2 * 7 + 2'dir

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

Sağlanan "" ### INSERT TEXT HERE ### "dizesi --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"Selam Dünya!" olur --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]


1

Python 3

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

Bu aslında buzlu değişkenlerin cevabının sadece biraz geliştirilmiş bir versiyonudur. (Buğday Sihirbazı'ndan -1 Bayt, FatalError'dan -5, jez'den -2)


Bunun python 3 olduğuna inanıyorum. Eğer öyleyse, başlığınıza da eklemelisiniz. Öyleyse, sizden sonra satır sonunu da kaldırabilirsiniz :. Bu muhtemelen baytları kurtarmak için bir liste kavrayışı olarak da yapılabilir.
Buğday Sihirbazı,

-5 bayt ileprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError

-2 bayt: köşeli parantezleri kaybettiniz, böylece join()liste kavrama yerine bir jeneratör ifadesini çağırıyorsunuz : print("".join("+"*ord(i)+".[-]"for i in input()))
jez

-2 bayt: basitçe bir sonraki hücreye geçebilirsiniz (soru, her iki yönde de sonsuz bir bant üstlenmeniz gerektiğini belirtir print("".join("+"*ord(i)+".>"for i in input()))(bu, çıktıda 2 byte kaybettikten sonra puanı da düşürür)
MegaIng
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.