Brainf *** Golffer

32

Um dos códigos mais fáceis de escrever por uma linguagem de programação é uma sequência de caracteres de impressão de programas (ex. "Olá, mundo!"). No entanto, é o m e e s o t e r i c linguagens de programação como Brainfuck , mesmo este código mais simples é muito chato para escrever.

Sua tarefa é escrever um programa (não precisa ser escrito no cérebro), que imprime um programa Brainfuck (tamanho mínimo) imprimindo o texto fornecido.

Entrada

Uma sequência de caracteres (entre 1e 255) é fornecida por qualquer formato (variável, argumento, stdin, arquivo, ...).

Saída

A saída é um código válido (sem correspondência [e ]) de falha cerebral (suponha uma célula de quebra automática de 8 bits não assinada e um número ilimitado de células para a esquerda e a direita) imprimindo a seqüência exata que foi fornecida como entrada.

Por exemplo, uma saída possível para entrada Aé ++++++++[<++++++++>-]<+..

Seu programa não deve levar muito tempo ( >2m) para ser executado.

O programa BF não deve levar muito tempo ( >10s) para ser executado.

Pontuação

(Observação: o método de pontuação atual pode mudar, pois não é fácil calcular ...)

O tamanho do programa (gerando código BF) em si não importa. No entanto, os códigos BF codificados no código do programa não estão OK. Apenas intervalo aceitável (ex um código BF imprimir um único personagem. 0x01: +.) De códigos BF pode ser codificado.

A pontuação é a soma do comprimento dos códigos BF que imprimem essas seqüências.

  • Uma string Hello, world!anexada a um único 0x0A( \n) (ou seja, o programa "Olá, mundo!")
  • Caractere único de 0x01~0xFF
    • A soma do comprimento desses códigos de 255 BF é multiplicada 1/16, arredondada e adicionada à pontuação.
  • Lista dos primeiros 16 cordões, gerados por divisão uma sequência aleatória de bytes gerado em 11-11-11 por 0x00, remover todas as cadeias de comprimento zero.
  • Lenna.png , removendo todos os 0x00s.
  • Letras da música 99 garrafas de cerveja , começando com 99 bottles~, novas linhas são 0x0A, parágrafos são separados por dois se 0x0Anenhum caractere de nova linha no final.
  • Outras strings que você pode fornecer.

Seu programa pode incluir o cálculo da própria pontuação.

Obviamente, o código de menor pontuação será o vencedor.

JiminP
fonte
Duplicar (embora melhor formulado) de codegolf.stackexchange.com/questions/3450/…
copiar
4
Parece um pouco difícil calcular as pontuações. São muitos os arquivos diferentes que precisamos rastrear e executar. Qual é o objetivo de 'Outras strings que você pode fornecer'. Por que eu adicionaria mais se adicionaria à minha pontuação?
Captncraig
11
Lenna.pngvai dominar a pontuação, pois é de longe a maior contribuição. Talvez normalizar um pouco por tamanho?
Keith Randall
11
O código de tamanho mínimo para 'A' é ---- [----> + <]> ++.
Sconha
11
O OP obviamente não se importa com esse desafio. Vamos editar as regras de pontuação para algo sensato? Atualmente, apenas uma resposta (sem êxito) tentou usar essas regras, portanto, alterar regras não invalidará as respostas.
anatolyg

Respostas:

15

Em Java, calcula um pequeno fragmento de BF que pode converter qualquer número em qualquer outro número. Cada byte de saída é gerado transformando o último byte de saída ou um 0 novo na fita.

Os trechos são gerados de três maneiras. Primeiro, por simples repetições de +e -(por exemplo, ++++converte 7 para 11), combinando trechos conhecidos (por exemplo, se A converte 5 em 50 e B converte 50 em 37, AB converte 5 em 37) e multiplicações simples (por exemplo, [--->+++++<]multiplica o número atual por 5/3). As multiplicações simples aproveitam a envolvente para gerar resultados incomuns (por exemplo, --[------->++<]>gera 36 a partir de 0, onde o loop executa 146 vezes, com um total de 4 envolventes descendentes e 1 ascendente).

Estou com preguiça de calcular minha pontuação, mas ele usa cerca de 12,3 operações de BF por byte 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]);
    }
}
Keith Randall
fonte
Eu sei que estou com dois anos e meio de atraso e isso não é golfe, mas o método repeat pode apenas retornar new String (new char [length]). ReplaceAll ("\ 0", str);
Loovjo 19/10/2015
13

Bem, aqui está a pior solução possível, apesar de uma boa aparência no próprio Brainfuck:

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

A pontuação é provavelmente a pior que provavelmente veremos sem torná-la intencionalmente ruim.

Trabalhando no cálculo da pontuação real.

captncraig
fonte
Você poderia explicar o que isso faz? A leitura do código BF é bastante difícil.
BMac 4/15
3
Para cada byte de entrada que simplesmente imprime N +'s e uma.
captncraig
Com eu acredito a [-]para limpar a célula entre cada personagem.
captncraig
8

Python 3.x

Bem, não vou ganhar nenhum prêmio pelo código de saída mais curto, mas talvez pelo programa gerar o código ...

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

'Olá, mundo! \ N':

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++++++
++++.[-]++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++.[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++.[-]++++++++++.[-]
icedvariables
fonte
11
Acidentalmente respondeu a Madisons resposta. Gerador mais curto:print("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError
Você pode jogar golfe em 2 caracteres substituindo .[-]por.>
MilkyWay90
47 bytes
MilkyWay90
8

Não sei ao certo como é bom, mas me diverti escrevendo isso. (Em 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
   )
  )

Provavelmente existem soluções mais eficientes e mais elegantes, mas isso segue meu padrão de pensamento de maneira linear, por isso foi mais fácil.

Marty
fonte
8

Ponto: 4787486 41439404086426 (sem dados gerados aleatoriamente)

(4085639 dos quais são de Lenna.png. Isso é 99,98%)

Eu não entendo a parte com os dados aleatórios. Não preciso de uma conta pela qual tenho que pagar para obter os dados?

Muito ingênuo. Aqui está o código gerado para "1Aa" (49, 65, 97) com uma pequena documentação:

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

O código Java é um pouco feio, mas funciona. A instrução gerada por taxa de bytes de entrada é provavelmente melhor quanto maior o valor médio de bytes.

Se você deseja executá-lo, é necessário colocar o Lenna.png no mesmo diretório que o arquivo .class. Ele imprime a pontuação no console e grava o código BF gerado em um arquivo chamado "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");
}

Vou fazer algumas pequenas melhorias, mas provavelmente não muito. Feito.

IchBinKeinBaum
fonte
Isso está quebrado, o BF gerado gera NUL bytes ou '?' caracteres dependendo do código do idioma para qualquer caractere que não esteja em 1..127. O ASCII simples (1-127) parece estar bem. Observando que (byte) s são assinados e a escolha cuidadosa de um código de idioma obtém muitos deles (levando a pontuação acima de 5800000), mas ainda existem vários milhares de NULs na conversão bf do Lenna.png. Então, há algo mais também.
user3710044
4

BrainF ** k

Eu sou um péssimo programador de BF, então essa resposta provavelmente é bastante ineficiente. Não tenho certeza da pontuação, mas ela deve ter um desempenho um pouco melhor do que a resposta existente no seu texto médio. Em vez de zerar a célula após cada caractere, este se "ajustará" a um novo caractere com subtração se o caractere anterior fornecido for maior.

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

(Observe que este é o código que escrevi há muito tempo e que me adaptei novamente para esta competição. Espero sinceramente que tenha feito a conversão corretamente, mas se ela falhar em alguma entrada, avise-me.)

Uma versão mostrando o estado da fita em todo o código:

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

Código gerado para Hello, World!:

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

Esta é minha primeira resposta no CG.SE! Se eu estraguei alguma coisa, me avise!

BrainSteel
fonte
4

> <>

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

Escrevi isso em resposta a uma pergunta marcada como duplicada, e mesmo que este não seja o melhor golfe (para essa pergunta específica, pelo menos), achei que seria um desperdício se não a compartilhasse. toda a sua glória nojenta e repugnante. Realmente, estou meio surpreso que isso funcione. Vou dar algumas sugestões para jogar golfe, já que esse foi meu principal objetivo em sua criação.

Como observação lateral, na segunda linha, os três caracteres iniciais .21poderiam ser substituídos vpor dois espaços, se isso facilitar a leitura. Não gosto de ver espaços nos meus programas, porque isso significa que há espaço desperdiçado (literalmente). Também é um remanescente de um dos muitos protótipos.

O modo como ele funciona é realmente simples e, francamente, seria difícil pensar em uma maneira de implementar outro algoritmo. Ele imprime no entanto muitos "+" s precisam ser impressos para o primeiro caractere e, em seguida, imprime mais "+" s ou "-" s conforme necessário para cada caractere adicional, separando cada seção com pontos. O que eu acho interessante sobre o programa é que ele modifica seu próprio código-fonte para imprimir "+" ou "-" (substitui o "+" na linha 3 pelo caractere apropriado após determinar se o caractere atual é maior que ou inferior ao anterior).

Saída para Hello, World!:

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

Eu posso pontuar isso da maneira que ele deveria ser pontuado, mas tenho quase certeza de que perderia e não sei ler algo como lenna.png em> <>.

Se essa resposta lhe interessa e você gostaria de uma explicação, pergunte por todos os meios, mas por enquanto deixarei sem uma só por causa da distorção e da distorção.

EDIÇÃO 1: Já faz um tempo, mas eu consegui jogar 2 bytes com uma revisão quase completa da maneira como o programa decide se imprime um sinal de mais ou menos. É um retorno decepcionante para uma grande revisão, mas pelo menos funciona.

Cole
fonte
Este programa sem sentido faz outro programa sem sentido! Este é o melhor programa que eu já vi!
Aequitas
1

minha solução JavaScript é rápida e suja :)

saída para 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);
}
Pedro
fonte
2
Bem vindo ao site! Você deve incluir a pontuação no título da sua resposta.
Assistente de trigo
Eu só fiz o gerador bf, sistema de pontuação original tem de processamento de imagem que não é relevante :( proporção mundo Olá é inferior a 9 (comprimento bf / comprimento do texto original)
Peter
1

Eu construí algo em Java. Não calculou a pontuação. Textos com 3 ou menos caracteres são codificados com uma multiplicação por letra, por exemplo, "A" = ++++++++[>++++++++<-]>+.. Os textos com mais de 3 caracteres são codificados com uma lista calculada dividida em 3 áreas. A primeira área é x vezes 49, depois mais x vezes 7 e finalmente mais x. Por exemplo "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);
        }
    }
}

A string fornecida "### INSERIR TEXTO AQUI ###" se torna --->-->-->-->-->->->->->->->-->->->->->-->->->->->-->-->-->-->+[-[>+++++++<-]<+++]>---->++>++>++>+>>+>+>->+>++>+>++>->++>++>+>>->+>->+>++>++>++>+[-[>+++++++<-]<++++]>---->--->--->--->+>>-->+++>+++>++>--->+>--->+++>+>--->+>->+++>++>+++>+>--->--->--->+[-<++++]>[.>]

"Olá Mundo!" torna-se --->->>>>>-->-->->>>>>-->+[-[>+++++++<-]<+++]>---->>--->-->-->-->+++>+>++>-->->-->--->+>+[-[>+++++++<-]<++++]>---->->>>>+++>->+>>+++>->>->++>+[-<++++]>[.>]

Dorian
fonte
1

Python 3

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

Esta é essencialmente apenas uma versão ligeiramente melhorada da resposta das variáveis ​​iced. (-1 Byte do Assistente de Trigo, -5 do FatalError, -2 do jez)

Madison Silver
fonte
Eu acredito que este é python 3. Se sim, você deve incluí-lo em seu cabeçalho. Nesse caso, você também pode remover a quebra de linha após o seu :. Provavelmente, isso também poderia ser feito como uma compreensão da lista para salvar bytes.
Assistente de trigo
-5 bytes comprint("".join(["+"*ord(i)+".[-]"for i in input()]))
FatalError
-2 bytes: perca os colchetes para que você esteja chamando join()uma expressão de gerador em vez de uma compreensão de lista: print("".join("+"*ord(i)+".[-]"for i in input()))
jez 28/01
-2 bytes: você pode simplesmente passar para a próxima célula (a pergunta indica que você deve assumir uma banda infinita em ambas as direções print("".join("+"*ord(i)+".>"for i in input()))(isso também reduz a pontuação, pois você perde 2 bytes na saída)
MegaIng