Componi due programmi Brainfuck

10

Dato 2 frammenti di codice brainfuck Ae B, genera un po 'di codice brainfuck Cche ha lo stesso comportamento dell'esecuzione Bcon l'inserimento del Arisultato s. Si noti che Cdeve funzionare per qualsiasi input che corrisponda ai seguenti presupposti, come se fosse stato dato a A.

Puoi presumere:

  1. Input finito.
  2. sia A che B si fermano.
  3. EOF è costantemente 0 o costantemente -1.
  4. Consentire o impedire coerentemente le celle a sinistra
  5. Nastro illimitato (altrimenti il ​​requisito potrebbe essere impossibile)
  6. Involucro coerente a 8 bit o numero intero illimitato
  7. Nessun flusso (input o output per A o B) contiene il byte che rappresenta EOF
  8. I codici A e B possono contenere caratteri che potrebbero apparire nella tua C e +-[]<>,.

Ad esempio (EOF = 0)

A = ,[..,]
B = ,[...,]
C = ,[......,]

A = >,[>,]<[.<]
B = ,[...,]
C = >>>>,[[-<+<+<+>>>]>>>,]<<<<[.<]

A = >,[>,]<[.<]
B = ,[...,]
C = >,[>,]<[...<]

A = ,.
B = ,.
C = ,>,[,]<.

A = ,.
B = ,.
C = ,.

sono test validi

Vincono il codice più corto in ogni lingua. Il vincitore in Brainfuck sarà accettato.

code-golf  code-generation  brainfuck 
— l4m2
fonte
7
Shortest code in each language wine Shortest Brainfuck solution will be acceptedsono due diversi criteri vincenti.
— Mego,
2
@Mego intendevo dire che se rispondi in brainfuck e vinci, sei accettato
— l4m2
1
Anche. puoi approfondire 4.Consistently allow or disallow cells to left. La risposta iniziale richiede che le celle a sinistra nella risposta funzionino ma non consente A, B e C di non spostarsi oltre il primo byte. I miei quadranti di risposta si spostano a sinistra in risposta, A, B e C. Se le regole per il mio programma e C possono essere diverse da A e B, allora posso sicuramente abbreviare molto la mia risposta.
— Sylwester,
1
L'intera affermazione del problema riguarda A, B e C, e solo le ultime due frasi fanno riferimento alla lingua della risposta. Forse l'autore intendeva che la risposta avesse lo stesso sapore di A, B e C, ma non sarebbe stata colpa mia. I risolutori non dovrebbero essere puniti per la mancanza di lungimiranza degli autori problematici. Ad ogni modo è davvero banale aggiungere qualche >s all'inizio della mia risposta per renderlo conforme a un sapore più restrittivo (ma per il golf, dovremmo anche considerare delle alternative). Inoltre, mi sembra chiaro che A, B e C debbano avere lo stesso sapore reciproco.
— Mitch Schwartz,
1
Forse sto completamente fraintendendo la sfida, ma i casi di test n. 3 e n. 4 sembrano scontrarsi.
— James,

Risposte:

8

Brainfuck, 526 byte

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

formattato:

-<+++++<+<+++++<-[+++++++[<++++++++>-]<--->>]
<<--<--<+..<<<<
,
[
  [<+> >+<-]
  ----[>-<----]>
  [
    not question mark
    +
    [
      not greater than
      ++
      [
        not less than
        ++++++++++++++
        [
          not period
          ++
          [
            not comma
            [-]<
          ]
          <<<
          [
            comma B
            >-->>> -.>>>.<<<.>.>.<<.+>>--..>.<..<.>.>..<++.<.>..>.<..<.>--.>>.<<
            .>.<..<.>.>.<.<.>++.<<.>.>.>.<.<.>..>.<..<.>>>.<<--.++<<<
          ]
          >>>>[<]<
        ]
        >
        [
          period
          <<<<
          [
            B
            >
          ]
          >
          [
            A
            +>>> >>.>.<<<.>.<.>>>.<.[.<.>>>]<++[<<.<.>>.<<--.<<.>.>.++>>>-]<<<<.
            >.>>.<.<<<.>>..>>.<<<.>--.>.<++...<<.>>--..>>.<.<..<.>.>>.<<++...>.<
            ..<.>>>.<<--...++<<[.>]<<<--.<<.>>++.<.>>>.<<--.++<<<
          ]
        ]
        <
      ]
      >
      [
        less than
        <<<.>>
      ]
      <
    ]
    >
    [
      greater than
      >>.>.<<<.>.>>>.[<]
    ]
    <
  ]
  >
  [
    question mark
    >>.>.<..<.>>>.[<]
    <<<+>->>
  ]
  <<.[-]>,
]

Rispetto ad A, B e C: EOF = 0, le celle a sinistra dell'inizio non sono consentite, celle a capo da 8 bit.

Si aspetta A seguito da ?seguito da B.

Provalo online

(Questa risposta può essere resa conforme a un interprete brainfuck che non consente di andare a sinistra dell'inizio al costo di un byte traslitterando y/<>/></e anteponendo a >.)

L'idea di base è quella di utilizzare una serie di sostituzioni di stringhe al fine di simulare i nastri di A e B utilizzando nodi a 2 celle, con particolare attenzione alla sostituzione .in A e ,in B in modo che il flusso di dati intermedio venga mantenuto in un blocco di celle a sinistra del nastro simulato. Lo schema di sostituzione della stringa è:

  • Inserisci >>prima di A

  • In A e B, sostituire >con >[-]+>e <con<<

  • In A, sostituire .con>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • Inserisci >[>>]+>dopo A e prima di B

  • In B, sostituire ,con,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

— Mitch Schwartz
fonte
,[>,]<[.<]?,[...,]input 12345restituisce 111, anche con abbastanza >prima?
— l4m2
@ l4m2 Hmm, sta funzionando per me su TIO . ( ,[>,]<[.<]non è valido ma lo >,[>,]<[.<]è.)
— Mitch Schwartz,
Allora, qual è il tuo "permette di andare a sinistra della cella iniziale"?
— l4m2
1
Quindi la tua risposta ha bisogno di un BF che inizia nel mezzo di un nastro infinito, ma la natura di A e B è limitata allo standard in cui uno inizia dalla prima cella su un nastro infinito a destra?
— Sylwester,
1
Per questa soluzione, andare a sinistra della cella iniziale non è consentito in A, B e C, ma è consentito nel programma (potremmo chiamarlo D per comodità) che prende A e B e quindi produce C. I don non credo che sia davvero notevole, ed è una scelta naturale data la natura della soluzione. Andare a sinistra dell'inizio ha conseguenze importanti nel contesto di A, B e C, ma è abbastanza banale per D, e soggettivamente rende un'esperienza di golf più piacevole e un punteggio leggermente più breve, e inoltre non dovrebbe fare testare ancora più noioso, in quanto è facile anteporre >a D secondo necessità.
— Mitch Schwartz,
6

Brainfuck , 1287 byte

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

Provalo online!

Ecco qui! Il codice Brainfuck che compone due codici Brainfuck. Usare un "!" per separare i due frammenti di codice di input. Per esempio frammento di A: >,[>,]<[.<], frammento B: ,[...,]. Ingresso per il mio programma: >,[>,]<[.<]!,[...,]. Non terminerà se non compare "!" è stato trovato.

Questo è essenzialmente lo stesso della mia versione VBA. Il codice generato è lo stesso della versione VBA (si noti che gli esempi nel post VBA sono stati fatti prima dell'ultima modifica negli snippet del brainfuck).

Spiegazione

Questo è il mio codice sorgente:

[ 
Tape: "+"(43) "-"(45) "<"(60) ">"(62) "["(91) "]"(93) readA(1) printInput(0) input else exitIf exitElse
]

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

<<<.....<<.>>....<<.>>.<<..>... print init routine
>>>>[                           while readA
  >+                              set printInput = true
  >,                              read character
  ->[-]++++[-<-------->]          decrease input by 33 to check for "!"
  +                               set else flag

  # A check for "!"
  <[                              if input not "!"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <-                              set readA = false
    <<<..>.<.....>>.<<<.....>>.<<<< print routine between A and B
    .>>..>>.<<<.>>>>.<<<...>>>.<<.<
    <<..>>>>.<<<..>>.....<<<..>>>>>
    .<<<<<.>>>>.<<<.>.....<<.>>>>>.
    <<<<.>>..>>>
    >>>>>                           go to exitElse
  ]

  # A check for "dot"
  <<<----- ----- ---              decrease input by 13 (total 46) to check for dot
  [                               if input not dot
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<..<<.>..>>.<<<.>.<<.>>>.... print list storing routine
    <<<.>>>>.<<<.>.....<<.>>>>>.<<<
    <<.>>>>.<<<..>>.....<<<..>>>>>.
    <<<<..>..<<.>>>..<<<.>>>>.<<<.>
    .....<<.>>>>>.<<<<.>.<<..>>>>.<
    <<..>>.....<<<..>>>>>.<<<<..>..
    >>>.<<<.>>.<<<.>>.<<<.>>.>>>.<<
    ....<<<.>>>>.<<<.>.....<<.>>>>>
    .<<<<<.>>>>.<<<..>>.....<<<..>>
    >>>.<<.....<<.>>>.<<<.>.....<<.
    >>>>>.<<<<.>.<<..>>>>.<<<..>>..
    ...<<<..>>>>>.<<<<.>..>>>>>
    >>>>                            go to exitElse
  ]

  # A check for "less than"
  <<<----- ----- ----             decrease input by 14 (total 60) to check for "less than"
  [                               if input not "less than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<<...>>.<<<<.>>>>>.<<<<.>..>>>>> print A move left routine
    >>>>                            go to exitElse
  ]

  # A check for "greater than"
  <<<--                           decrease input by 2 (total 62) to check for "greater than"
  [                               if input not "greater than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<.......>.<<<<.>>>>>.<<<<.>..>>>>> print A move right routine
    >>>>                            go to exitElse
  ]

  # print remaining character
  <<<<[                           if printInput
    +++++++[->++++++++<]>--.<     print original character
  ]

<                               go to readA
]

>>,                             read next character
[                               while input
  <+                              set printInput = true

  # B check for comma
  >>++++[-<----- ---->]+<+        decrement input by 44 to check for comma
  [                               if input not comma
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<.<<<.>>>>.<<..<<.>>.>.<..... print B list reading routine
    >>.<<<<<.>>>>.<<<.>.....<<.>>>>
    >.<<<<.>>...>.<<<.>...>>.<<....
    .>>>.<<....<<<.>>>>.<<<.>>.....
    <<<.>>>>>.<<<<.>..<<.>>>...>.<.
    ....>>.<<<<<.>>>>.<<<.>.....<<.
    >>>>>.<<<<.>>...>>.<<..<<.>>>.<
    <.....>>>.<<....<<<.>>>>.<<<.>>
    .....<<<.>>>>>.<<<..>>>>> 
    >>>>                            go to exitElse
  ]

  # B check for "less than"
  <<<----- ----- ----- -          decrease input by 16 (total 60) to check for "less than"
  [                               if input not "less than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<<.....>>>>>                 print B move left routine
    >>>>                            go to exitElse
  ]

  # B check for "greater than"
  <<<--                           decrease input by 2 (total 62) to check for "greater than"
  [                               if input not "greater than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<.....>>>>                   print B move right routine
    >>>>                            go to exitElse
  ]

  # print remaining character
  <<<<[                           if printInput
    +++++++[->++++++++<]>--.<     print original character
  ]

>,                              input next character
]
— Dorian
fonte
1
— l4m2
@ l4m2: mi spiace, ho fatto un piccolo errore nei dati del test. Ho scritto >[,>]<[.<]!,[...,], quindi lo snippet A non produce nulla. Ovviamente deve essere >,[>,]<[.<]!,[...,]per un esempio funzionante.
— Dorian,
5

VBA, 512 489 479 byte

Sub f(A,B):Debug.?">>>>>->>>>->--<<<"&Replace(Replace(Replace(A,"<","<<<[+]-<<"),">",">>>>>>>[+]-<<"),".",">>-<<[-<+>>>>+[-<<<<<+]+[-->>>>>++]--<<+>>+[-<<<<<+]-<++[-->>>>>++]--<<]<[->+<]>>>>+[-<<<<<+]+[-->>>>>++]>>>>>-[-<<<<<+]-<++[-->>>>>++]-<<")&">>[>>>>>]<<<<<[+<<[-]<<<]>++[-->>>>>++]+[-<<<<<+]->>"&Replace(Replace(Replace(B,"<","<<<<<"),">",">>>>>"),",","[-]>>->[>>>>>]+[-<<<<<+]->>>[-<<<[<<<<<]>>>>+[->>>>>+]-<<+>>>[>>>>>]+[-<<<<<+]->>>]>>-[<<<<<]>>>>+[->>>>>+]<<"):End Sub

Spiegazione

Il codice VBA modifica il codice brainfuck in un modo, che l'output dello snippet A verrà memorizzato in un elenco e l'input dello snippet B verrà letto da tale elenco.

Inizializza prima alcune variabili 

>>>>>->>>>->--<<<

Poi si legge frammento di A e sostituisce ogni <da <<<[+]-<<ogni >da >>>>>>>[+]-<<ed ogni .dalla routine di memorizzazione

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

successivamente elimina la memoria dello snippet A e apporta modifiche all'elenco memorizzato, in modo che possa essere letto come input per lo snippet B:

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

Quindi verrà letto lo snippet B, ciascuno <verrà sostituito da <<<<<, ogni >verrà sostituito da >>>>>e ogni ,verrà sostituito dalla routine di lettura dell'elenco:

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

Codice sorgente di Brainfuck

Questa è la mia fonte per le porzioni di codice del cervello. Lo spiegherò in dettaglio più avanti.

[
Tape: tempMem data out/in dataAnchors outAnchors (all repeating)
dataAnchors of Snippet A: -1 = memory has been used, -2 = active memory cell for copying to out/in
dataAnchors of Snippet B: -1 = active memory cell for copying from out/in
outAnchors of Snippet A: -1 = start of list, -2 = next output position
outAnchors of Snippet B: -1 = character has been read (or start of input)
]

### Init
>>              two blank data cells (for non wrapping pointer)
>>>-            set start of input
>> >>-          set first "used" flag
>--             set end of input
<<<             return to first usable data cell

### A move right routine
>>>>>           move to the next data cell
>>[+]-          clear and set "used" flag
<<              return to data cell

### A move left routine
<<<[+]-         clear and set "used" flag of previous data cell
<<              go to data cell

### A print routine
>>-             set flag
<<[             while value greater 0
  -               decrement value
  <+              increment tempMem
  >>>>+[-<<<<<+]  find start of input
  +[-->>>>>++]--  find end of input
  <<+             increment input
  >>+[-<<<<<+]-   find start of input
  <++[-->>>>>++]--find flag
  <<              go to active data cell
]
<[->+<]         move stored value back to data
>>>>+[-<<<<<+]  find start of input
+[-->>>>>++]    find end of input
>>>>>-          set new end of input
[-<<<<<+]-      return to start of input
<++[-->>>>>++]- return to and delete data flag
<<              go to data cell

### After snippet A: Delete memory of A and configure out/in list
>>[>>>>>]<<<<< go to last used data
[+<<[-]<<<]    delete each data
>++[-->>>>>++] find and delete end of input flag
+[-<<<<<+]-    go to start of input
>>             go to first data cell

### B move right routine
>>>>>          go to next data cell

### B move left routine
<<<<<          go to previous data cell

### B reading routine
[-]                      set cell = 0
>>-                      set flag
>[>>>>>]+[-<<<<<+]-      find start of input
>>>[                     if value greater 0
  -                        decrement value
  <<<[<<<<<]>>>>           go to initial start of input (combined with next)
  +[->>>>>+]-              find mem cell flag
  <<+                      increment mem cell
  >>>[>>>>>]+[-<<<<<+]->>> return to input cell
]
>>-                      set new start of input
[<<<<<]>>>>              go to initial start of input (combined with next)
+[->>>>>+]               find and delete mem cell flag
<<                       go to mem cell

Uscita per test case 1: f ",[..,]",",[...,]"

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

Provalo online!

Uscita per test case 2: f ">,[>,]<[.<]",",[...,]"

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

Provalo online!

Uscita per test case 3: f ",.",",."

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

Provalo online!

Caso di test complesso: frammento A: costruisci triangolo alfabetico >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Provalo online!

Snippet B: ordina l'ingresso in ordine crescente >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Provalo online!

Risultato:

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

Provalo online!

— Dorian
fonte
Grazie. So che questo è praticamente ungolfed. Volevo solo fornire il primo codice funzionante. Apporterà anche modifiche alla parte del codice di brainfuck.
— Dorian,
5

Brainfuck , 785 byte

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

Provalo online!

Per dividere A dalla BI si è optato per /.

spiegazione:

Il codice che genera questa è solo una lettura ad anello con una bandierina per A / B e un interruttore che riduce l'ingresso di cercare >, <, /, ,, e .e altrimenti solo uscita all'ingresso. In realtà è solo un transpiler in cui il codice traspilato vive all'interno di una struttura di dati in modo tale da non interferire con i dati memorizzati da A o l'uno dall'altro. Il /solo sposta la cella attiva alla prima cella inutilizzata. Inizialmente l'ho ripulito, ma ciò rende il programma e l'output più grandi.

Il risultato del programma ha il seguente modello di memoria:

|0|input*|cz|d0|c0|d2|c0|...

Si csbriciola. czè sempre 0Indica dove si trova il puntatore nei miei dati BF emulati. Il valore attivo è -1 mentre tutte le celle visitate avranno 1. In operazioni come aprinte breadalcuni cottengono un significato speciale.

La stampa con codice A salta tutte le celle di 1 byte per lasciare spazio per un ulteriore input di byte che viene copiato con un backup nei byte successivi per sbriciolarsi.

La lettura del codice B recupera l'input dall'input. Qui essere distruttivi va bene e quando "leggi" l'ultimo byte ottieni 0 come EOF indipendentemente dall'implementazione.

Ho iniziato con il codice Extended BrainFuck ottenendo il risultato EBF. La maggior parte del debug è stata eseguita sui file dei risultati e quindi è stata aggiornata alla fonte che lo ha generato. Quindi ho eseguito le operazioni in modo indipendente per ottenere l'output BF, ma ho notato la risposta di Dorian, che mi ha battuto in lunghezza, quindi ho continuato a giocare a golf con la fonte EBF per un output BF più piccolo. La fonte originale è abbastanza leggibile e semplice rispetto ad altre cose che ho fatto con esso:

:bck
:i
:t
:z
:r
:rc
:rz

;;; outputs a header with most of the result logic
{cinit
  |"
    ;; memory model of the result 
    ML/i/z/d/c
    PTR=1/1/2
    :iz:i:z:d:c:d2:c2

    ;; moves pointer back. Bad things will happen to 
    ;; A output if out of bounds
    {backward @d2 $c2++ $c-- $d
    }

    ;; moves pointer forward
    {forward $c++ $c2[-]- $d2 @d
    }

    ;; stores the current cell in input a the start of bf data
    {aprint
      $c2(-)+                 ; mark next cell as used even if it maybe
      $c[$c2]                 ; go to the end of used data
      $c((->+)$d(->+)@d2)     ; as long as c is something move d and c one place right
      @i$c+[->>+]@c           ; go to active cell, zero it
      $d(-                    ; copy: 
        $c2+                  ; backup in c2 
        $z[<<]@z              ; back to i
        $i+ $c[>>]@c          ; increement and back to zero carry
      )
      $c2-(- $d+)+            ; copy backup in c2 back to d
      $c-                     ; mark active cell
      $d                      ; move to d
    }

    ;; removes all the data from A. And initializes for B
    {aend
      $c[$c2]
      $c((-)<(-)<@c)@z
      $c-$d
    }

    ;; instead of read b fetched from input area
    {bread
      (-)>+@c2          ; clear d and c
      $c[$z]            ; go to z
      $i<[<] @iz        ; go to iz
      $i(-$iz+)         ; switch places between i and iz
      $iz(-             ; copy from iz to d
         $z[>]@z        ; move to z
         $c[$c2]        ; move to the current c 
         $d2+           ; increase d
         $c[$z]         ; back to z
         $i[$iz]        ; back to iz
         @i             ; but since we shave switched correct
      )
      $z[>]@z           ; go back to z
      $c[$c2]-          ; move to active cell and make it -1
      $d2 @d            ; go to d
    }

    $c-$d               ; init. Go to c t mark it active, then go to d
    "
  (-)
}

{cmain
  &cinit
  $t,(
    (-$i+$bck+) ; pour to i and bck

    ;; switch ( $i ) cases '<>,./' using $t
    $t+++++++(-$i------)+$i--; ,
    ($i--; .
      ($i-; /
        ($i-------------; <
          ($i--; >
            ((-) $t(-)  $bck.)
              $t (- |"&forward "(-) )
          ) $t (- |"&backward "(-) )
        ) $t (- |"&aend "(-) $r+ )
      ) $t (- $rc+$r[$rc-$bck.$rc]@r$rc[- |"&aprint "(-) $rz])
    ) $t (- $rc+$r[$rc-|"&bread "(-)]@r$rc[-$bck.$rz])
    $bck (-) ; clear backup
      $t,    ; read into t
  )
}

&cmain
— Sylwester
fonte
Se ho capito bene, [->+]nel programma C provoca errori per input simili ->->,./,.e questo potrebbe essere risolto usando [->>+](assicurandosi che il puntatore si avvii su una cella con la parità desiderata). Perché [-<+], penso che puoi cambiare lo schema di navigazione per fare affidamento sul fatto che tutto l'output di A è diverso da zero?
— Mitch Schwartz,
Non sono sicuro di cosa intendi. Quando A è ->->,.e B è ,., il tuo interprete preferito produce la stessa C di TIO e C funziona come previsto sul tuo interprete? Perché non riesce su TIO . (L'ho scritto in risposta a un commento che ora è stato cancellato.)
— Mitch Schwartz,
@MitchSchwartz Grazie per il tuo commento. Ero un po 'arrogante poiché non mi aspettavo di scansionare -1i dati dell'utente, ma in effetti ho fatto sulla linea "vai alla cella attiva, azzera". Ho aggiornato la mia risposta e poi ho aggiunto un byte: -O ma almeno funziona. BTW. Se non sto usando scan for -1to durante il recupero di input in B >[-<+]<dovrò spostare il byte attivo con una copia e quindi aggiungo più caratteri di quanti ne risparmi sostituendo +[-<+]-con [<]. Se non copi, non sarai in grado di sapere se il byte che hai compilato era terminato e copi tutti i byte.
— Sylwester,
Bene, la mia menzione [-<+]era in realtà anche per quanto riguarda l'eliminazione dei bug (anziché il salvataggio di byte), per input come -./,>++++++[<++++++>-]<., che dovrebbero stampare #piuttosto che %. :) Ma vedo anche alcune opportunità per salvare byte. In bocca al lupo! Cercherò di ottimizzare la mia soluzione doppiamente infinita di nastro, anche se vedere quello che hai fatto mi fa pensare che forse il nastro giusto-infinito alla fine sia più golfoso.
— Mitch Schwartz,
Quindi, dopo aver esaminato il tuo codice più da vicino, ho scoperto che le nostre configurazioni sono molto simili e che il tuo uso di un nastro infinito a destra è molto meglio per il golf rispetto al mio nastro doppiamente infinito. Si prega di consultare il mio recente aggiornamento sed per una soluzione che combina le nostre idee. Sento che il golf C è la parte più interessante di questo problema, ma c'è anche spazio per accorciare il programma di sostituzione delle corde al di fuori di questo ...
— Mitch Schwartz,
4

sed, 165 byte

s > >[-]+> g
s < << g
1s \. >[-]-R+[[>+<-]<[>+<-]<]>+[->>+]<[>+>>-<L+>R+<<<-]>[<+>-]+< g
1s .* R&<R+> 
2s , ,[,]>,<L[[>]R<+L[<]>-]>[>]R+< g
s L <[<<]< g
s R >>[>>] g

Per gli aromi con EOF = 0, le celle a sinistra dell'inizio non sono consentite, celle di avvolgimento a 8 bit.

Prevede il programma A sulla prima riga e B sulla seconda riga.

Provalo online

Questo utilizza nodi a 2 celle per simulare i nastri di A e B, con l'output di A che occupa celle contigue alla sinistra del nodo più a sinistra.

Soluzione alternativa a 173 byte:

1i>>
s > >[-]+> g
s < << g
1s \. >[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[<+>-]+< g
1a>[>>]+>
2s , ,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+< g

Provalo online

Inizialmente il mio progetto si basava su un nastro doppiamente infinito, che richiedeva molto più lavoro per spostare a sinistra (spostare i dati quando si superava la cella all'estrema sinistra precedentemente incontrata) e per passare da A a B (cancellare i dati invece di viaggiare oltre la cella all'estrema destra incontrato in precedenza).

Grazie a Sylwester e Dorian per i trucchi e le idee.

— Mitch Schwartz
fonte
Questo sembra fantastico. Purtroppo al primo test fallisce. Programma A ,[..,]e B del programma ,[...,].
— Dorian,
Oh, questa è una stupida supervisione da parte mia, mi sono affrettato troppo. È risolvibile, ma dovrei eliminarlo per ora.
— Mitch Schwartz,
@Dorian Ora dovrebbe essere risolto. (Continuerò a guardarlo.) Grazie per aver segnalato l'errore e scusate per l'inconveniente.
— Mitch Schwartz,
Sono consapevole che alcuni byte possono essere salvati, ad esempio, avendo s/x/>>/galla fine, ma sono più interessato ai miglioramenti che accorceranno l'output per ora.
— Mitch Schwartz,
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.