Brainf *** Golfer


32

Uno dei codici più semplici scritti da un linguaggio di programmazione è una sequenza di caratteri per la stampa di programmi (es. "Ciao, mondo!"). Tuttavia, s o m e e s o t e r i c linguaggi di programmazione come Brainfuck , anche questo codice più semplice è abbastanza fastidioso per scrittura.

Il tuo compito è scrivere un programma (non devi scrivere in brainfuck), che stampa un programma Brainfuck (di lunghezza minima) che stampa il testo dato.

Ingresso

Una sequenza di caratteri (tra 1e 255) è data da qualsiasi formato (variabile, argomento, stdin, file, ...).

Produzione

L'output è un codice brainfuck valido (non corrispondente [e ]) (presuppone una cella a capo a 8 bit senza segno e un numero illimitato di celle a sinistra e a destra) che stampa la stringa esatta che è stata fornita come input.

Ad esempio, un possibile output per input Aè ++++++++[<++++++++>-]<+..

L' >2mesecuzione del programma non dovrebbe richiedere molto tempo ( ).

L' >10sesecuzione del programma BF non dovrebbe richiedere molto tempo ( ).

punteggio

(Nota: l'attuale metodo di punteggio può cambiare, poiché non è facile da calcolare ...)

La durata del programma (generazione del codice BF) non ha importanza. Tuttavia, i codici BF codificati nel codice del programma non sono corretti. Solo intervallo accettabile (es un codice BF stampa di un singolo carattere. 0x01: +.) Di codici BF potrebbe essere hard-coded.

Il punteggio è la somma della lunghezza dei codici BF che stampano queste stringhe.

  • Una stringa Hello, world!aggiunta con un singolo 0x0A( \n) (ovvero il programma "Hello, world!")
  • Carattere singolo da 0x01~0xFF
    • La somma della lunghezza di questi 255 codici BF viene moltiplicata per 1/16, arrotondata e aggiunta al punteggio.
  • Elenco dei primi 16 stringhe, generate dalla scissione una sequenza casuale di byte generato 11-11-11 da 0x00, rimuovendo tutte le stringhe di lunghezza zero.
  • Lenna.png , rimuovendo tutti 0x00i messaggi.
  • Il testo della canzone 99 bottiglie di birra , a cominciare da 99 bottles~, le nuove righe sono 0x0A, i paragrafi sono separati da due 0x0Asecondi e nessun carattere di nuova riga alla fine.
  • Altre stringhe che puoi fornire.

Il tuo programma può includere il calcolo del punteggio di se stesso.

Naturalmente, il codice con il punteggio più basso sarà il vincitore.


Duplicato (sebbene meglio espresso) di codegolf.stackexchange.com/questions/3450/…
copia l'

4
Sembra piuttosto difficile calcolare i punteggi. Ci sono molti file diversi che dobbiamo rintracciare ed eseguire. Qual è il punto di "Altre stringhe che potresti fornire". Perché dovrei aggiungere altro se aggiungerà al mio punteggio?
captncraig

1
Lenna.pngdominerà il punteggio, in quanto è di gran lunga il più grande input. Forse normalizzare un po 'per dimensione?
Keith Randall,

1
Il codice di lunghezza minima per 'A' è ---- [----> + <]> ++.
Scony,

1
OP ovviamente non si preoccupa di questa sfida. Modifichiamo le regole del punteggio in qualcosa di sensato? Attualmente, solo una risposta (non riuscita) ha tentato di utilizzare queste regole, pertanto la modifica delle regole non invaliderà le risposte.
Anatolyg

Risposte:


15

In Java, calcola un breve frammento BF che può convertire qualsiasi numero in qualsiasi altro numero. Ogni byte di output viene generato trasformando l'ultimo byte di output o uno 0 nuovo sul nastro.

I frammenti sono generati in tre modi. Innanzitutto mediante semplici ripetizioni di +e -(ad esempio ++++converte da 7 a 11), combinando frammenti noti (ad esempio se A converte da 5 a 50 e B converte da 50 a 37, quindi AB converte da 5 a 37) e semplici moltiplicazioni (ad esempio [--->+++++<]moltiplica il numero corrente per 5/3). Le semplici moltiplicazioni sfruttano il wraparound per generare risultati insoliti (ad esempio --[------->++<]>genera 36 da 0, in cui il loop viene eseguito 146 volte, con un totale di 4 wraparound in ordine decrescente e 1 in ordine crescente).

Sono troppo pigro per calcolare il mio punteggio, ma utilizza circa 12,3 operazioni BF per byte su 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]);
    }
}

So che sono in ritardo di circa due anni e mezzo e questo non è golf, ma il metodo di ripetizione potrebbe essere semplicemente quello di restituire il nuovo String (new char [lunghezza]). ReplaceAll ("\ 0", str);
Loovjo,

13

Bene, ecco la peggiore soluzione possibile, anche se piuttosto carina in Brainfuck stesso:

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

Il punteggio è probabilmente il peggiore che probabilmente vedremo senza farlo intenzionalmente male.

Lavorando sul calcolo del punteggio effettivo.


Potresti spiegare cosa fa questo? La lettura del codice BF è piuttosto difficile.
BMac

3
Per ogni byte di input stampa semplicemente N +'e a.
captncraig il

Con credo a [-]per cancellare la cella tra ogni personaggio.
captncraig

8

Python 3.x

Bene, non vincerò alcun premio per il codice di output più breve, ma forse per il programma per generare il codice ...

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

'Ciao, mondo! \ N':

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

1
Risposta accidentale alla risposta di Madison. Generatore più corto:print("".join(["+"*ord(i)+".[-]"for i in input()]))
Errore irreversibile

Puoi giocare a golf con 2 caratteri sostituendo .[-]con.>
MilkyWay90


8

Non sono sicuro di quanto sia bello, ma mi sono divertito a scrivere questo. (In Clojure ...)

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

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

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

Probabilmente ci sono soluzioni più efficienti e più eleganti, ma questo segue il mio modello di pensiero in modo un po 'lineare, quindi è stato più semplice.


8

Punto: 4787486 41439404086426 (senza dati generati casualmente)

(Di cui 4085639 provengono da Lenna.png. È il 99,98%)

Non ricevo la parte con i dati casuali. Non ho bisogno di un account che devo pagare per ottenere i dati?

Abbastanza ingenuo. Ecco il codice generato per "1Aa" (49, 65, 97) con una piccola documentazione:

                   // 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"

Il codice Java è un po 'brutto ma funziona. L'istruzione generata per rapporto di byte di ingresso è probabilmente migliore quanto più alto è il valore medio di byte.

Se vuoi eseguirlo, devi mettere Lenna.png nella stessa directory del file .class. Stampa lo spartito sulla console e scrive il codice BF generato in un file chiamato "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");
}

Farò alcuni piccoli miglioramenti, ma probabilmente non molto. Fatto.


Questo è rotto, il BF generato genera byte NUL o '?' caratteri a seconda della locale per qualsiasi carattere non compreso tra 1..127. La semplice ASCII (1-127) sembra andare bene però. Notare che (byte) sono firmati e scegliere con cura un locale ne ottiene molti (prendendo il punteggio oltre 5800000) ma ci sono ancora diverse migliaia di NUL dalla conversione bf di Lenna.png. Quindi c'è anche qualcos'altro.
user3710044

4

Brainf ** k

Sono un pessimo programmatore di BF, quindi questa risposta è probabilmente piuttosto inefficiente. Non sono sicuro del punteggio, ma dovrebbe avere prestazioni leggermente migliori rispetto alla risposta esistente sul testo medio. Invece di azzerare la cella dopo ogni carattere, questo "si adatterà" a un nuovo personaggio con sottrazione se il carattere precedente dato è più grande.

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

(Nota, questo è il codice che ho scritto molto tempo fa e che ho riproposto per questa competizione. Spero sinceramente di aver fatto la conversione correttamente, ma se fallisce per qualsiasi input fammelo sapere.)

Una versione che mostra lo stato del nastro in tutto il codice:

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

Codice generato per Hello, World!:

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

Questa è la mia prima risposta su CG.SE! Se ho rovinato qualcosa, fammi sapere!


4

> <>

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

Ho scritto questo in risposta a una domanda contrassegnata per un duplicato, e anche se questo non è il più grande golf (almeno per questa domanda specifica) ho pensato che sarebbe stato un vero spreco se non lo avessi condiviso tutta la sua gloria disgustosamente incomprensibile. Davvero, sono quasi sorpreso che funzioni. Prenderò qualche suggerimento per giocare a golf poiché quello era il mio obiettivo principale nella sua creazione.

Come nota a margine, nella seconda riga i tre caratteri iniziali .21potrebbero essere sostituiti da vseguiti da due spazi se ciò facilita la lettura. Non mi piace vedere gli spazi nei miei programmi> <> perché ciò significa che c'è spazio sprecato (letteralmente). È anche un residuo di uno dei molti prototipi.

Il modo in cui funziona è davvero semplice, e francamente mi sarebbe difficile pensare a un modo per implementare un altro algoritmo. Stampa comunque molti "+" devono essere stampati per il primo carattere, quindi stampa più "+" se "-" secondo necessità per ciascun carattere aggiuntivo, separando ogni sezione con punti. Quello che trovo interessante del programma è che modifica il proprio codice sorgente in modo che stampa "+" o "-" (sostituisce "+" alla riga 3 con il carattere appropriato dopo aver determinato se il carattere corrente è maggiore di o meno di quello precedente).

Uscita per Hello, World!:

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

Potrei segnare questo nel modo in cui doveva essere segnato, ma sono quasi sicuro che perderei e non so del tutto come leggere qualcosa come lenna.png in> <>.

Se questa risposta ti interessa e desideri una spiegazione, chiedi in ogni caso, ma per ora la lascerò senza una solo per quanto è contorta e complicata.

EDIT 1: È passato un po 'di tempo, ma sono stato in grado di golfare 2 byte con una revisione quasi completa del modo in cui il programma decide se stampare un segno più o meno. È un ritorno un po 'deludente per una grande revisione ma almeno funziona.


Questo programma gibberish rende un altro programma gibberish! Questo è il miglior programma che abbia mai visto!
Aequitas,

1

la mia soluzione JavaScript è veloce e sporca :)

uscita per Hello World\n

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

Fonte:

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
Benvenuti nel sito! Dovresti includere il punteggio nel titolo della tua risposta.
Wheat Wizard

ho appena creato il generatore di bf, il sistema di punteggio originale ha l'elaborazione delle immagini che non è rilevante :( Hello world ratio è inferiore a 9 (bf length / lunghezza del testo originale)
Peter

1

Ho costruito qualcosa in Java. Non ho calcolato il punteggio. I testi con 3 o meno caratteri sono codificati con una moltiplicazione per lettera, ad es. "A" = ++++++++[>++++++++<-]>+.. I testi con più di 3 caratteri sono codificati con un elenco calcolato che è diviso in 3 aree. La prima area è x volte 49, quindi più x volte 7 e infine più x. Ad esempio "A" è 1 * 49 + 2 * 7 + 2

public class BFbuilder {
    public static void main(String[] args) {
        String text = "### INSERT TEXT HERE ###";

        if (text.length()<=3){
            String result = "";
            for (char c:text.toCharArray()) {
                result += ">";
                if (c<12) {
                    for (int i=0;i<c;i++) {
                        result += "+";
                    }
                    result += ".>";
                } else {
                    int root = (int) Math.sqrt(c);
                    for (int i = 0; i<root;i++) {
                        result += "+";
                    }
                    result += "[>";
                    int quotient = c/root;
                    for (int i = 0; i<quotient;i++) {
                        result += "+";
                    }
                    result += "<-]>";
                    int remainder = c - (root*quotient);
                    for (int i = 0; i<remainder;i++) {
                        result += "+";
                    }
                    result += ".";
                }
            }
            System.out.println(result.substring(1));
        } else {
            int[][] offsets = new int[3][text.length()];
            int counter = 0;
            String result = "---";

            for(char c:text.toCharArray()) {
                offsets[0][counter] = c/49;
                int temp = c%49;
                offsets[1][counter] = temp/7;
                offsets[2][counter] = temp%7;
                counter++;
            }

            for (int o:offsets[0]) {
                switch (o) {
                case 0: result+=">--";
                break;
                case 1: result+=">-";
                break;
                case 2: result+=">";
                break;
                case 3: result+=">+";
                break;
                case 4: result+=">++";
                break;
                case 5: result+=">+++";
                break;
                }
            }
            result += ">+[-[>+++++++<-]<+++]>----";
            for (int o:offsets[1]) {
                switch (o) {
                case 0: result+=">---";
                break;
                case 1: result+=">--";
                break;
                case 2: result+=">-";
                break;
                case 3: result+=">";
                break;
                case 4: result+=">+";
                break;
                case 5: result+=">++";
                break;
                case 6: result+=">+++";
                break;
                }
            }
            result += ">+[-[>+++++++<-]<++++]>----";
            for (int o:offsets[2]) {
                switch (o) {
                case 0: result+=">---";
                break;
                case 1: result+=">--";
                break;
                case 2: result+=">-";
                break;
                case 3: result+=">";
                break;
                case 4: result+=">+";
                break;
                case 5: result+=">++";
                break;
                case 6: result+=">+++";
                break;
                }
            }
            result += ">+[-<++++]>[.>]";
            System.out.println(result);
        }
    }
}

La stringa fornita "### INSERT TEXT HERE ###" diventa --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"Ciao mondo!" diventa --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]


1

Python 3

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

Questa è essenzialmente solo una versione leggermente migliorata della risposta di icedvariables. (-1 byte da Wheat Wizard, -5 da FatalError, -2 da jez)


Credo che questo sia Python 3. In tal caso dovresti includerlo nella tua intestazione. In tal caso, puoi anche rimuovere l'interruzione di riga dopo il tuo :. Questo potrebbe anche essere fatto come una comprensione dell'elenco per salvare i byte.
Wheat Wizard

-5 byte conprint("".join(["+"*ord(i)+".[-]"for i in input()]))
Errore irreversibile

-2 byte: perdi le parentesi quadre quindi stai invocando join()un'espressione del generatore piuttosto che una comprensione della lista: print("".join("+"*ord(i)+".[-]"for i in input()))
jez

-2 byte: puoi semplicemente passare alla cella successiva (la domanda afferma che dovresti assumere una banda infinita in entrambe le direzioni print("".join("+"*ord(i)+".>"for i in input()))(questo riduce anche il punteggio poiché perdi 2 byte nell'output)
MegaIng
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.