Composez deux programmes Brainfuck

10

Étant donné 2 extraits de code brainfuck Aet B, sortez du code brainfuck Cqui a le même comportement que l'exécution Bavec l'entrée de As result. Notez que cela Cdoit fonctionner pour toute entrée qui correspond aux hypothèses suivantes, comme si elle était donnée à A.

Vous pouvez supposer:

  1. Entrée finie.
  2. A et B s'arrêtent.
  3. EOF est systématiquement 0 ou -1.
  4. Autoriser ou interdire systématiquement les cellules à gauche
  5. Bande illimitée (sinon l'exigence peut être impossible)
  6. Habillage cohérent 8 bits ou entier illimité
  7. Aucun flux (entrée ou sortie pour A ou B) ne contient l'octet représentant EOF
  8. Les codes A et B peuvent contenir des caractères qui peuvent apparaître dans votre C, et +-[]<>,.

Par exemple (EOF = 0)

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

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

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

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

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

sont des tests valides

Code le plus court dans chaque langue. Le gagnant de Brainfuck sera accepté.

code-golf  code-generation  brainfuck 
— l4m2
source
7
Shortest code in each language winet Shortest Brainfuck solution will be acceptedsont deux critères gagnants différents.
— Mego
2
@Mego, je voulais dire que si vous répondez dans un brainfuck et que vous gagnez, vous êtes accepté
— l4m2
1
Aussi. pouvez-vous développer 4.Consistently allow or disallow cells to left. La réponse de tête requiert que les cellules de gauche de la réponse fonctionnent, mais interdisent à A, B et C de ne pas se déplacer après le premier octet. Ma réponse diallows se déplace vers la gauche dans la réponse, A, B et C. Si les règles pour mon programme et C peuvent être différentes de A, et B alors je peux sûrement raccourcir beaucoup ma réponse.
— Sylwester
1
L'énoncé complet du problème concerne A, B et C, et seules les deux dernières phrases font référence au langage de la réponse. L'auteur a peut-être voulu que la réponse soit de la même saveur que A, B et C, mais ce ne serait pas de ma faute. Les solveurs ne devraient pas être punis pour le manque de prévoyance des auteurs du problème. Quoi qu'il en soit, il est vraiment trivial d'ajouter quelques >s au début de ma réponse pour le rendre conforme à une saveur plus restrictive (mais pour le golf, nous devrions également envisager des alternatives). De plus, il me semble clair que A, B et C doivent être de la même saveur l'un que l'autre.
— Mitch Schwartz
1
Peut-être que je comprends mal le défi, mais les cas de test n ° 3 et n ° 4 semblent s'affronter.
— James

Réponses:

8

brainfuck, 526 octets

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

Formaté:

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

En ce qui concerne A, B et C: EOF = 0, les cellules restantes du début ne sont pas autorisées, les cellules d'encapsulation 8 bits.

Attend A ?suivi de B.

Essayez-le en ligne

(Cette réponse peut être rendue compatible avec un interprète brainfuck qui ne permet pas d'aller à gauche du début au prix d'un octet en translittérant y/<>/></et en ajoutant un >.)

L'idée de base est d'utiliser une série de remplacements de chaînes afin de simuler les bandes de A et B en utilisant des nœuds à 2 cellules, en accordant une attention particulière au remplacement .en A et ,en B afin que le flux de données intermédiaire soit conservé dans un bloc de cellules à gauche de la bande simulée. Le schéma de remplacement de chaîne est le suivant:

  • Insérer >>avant A

  • Dans A et B, remplacez >par >[-]+>et <par<<

  • Dans A, remplacer .par>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • Insérer >[>>]+>après A et avant B

  • En B, remplacer ,par,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

— Mitch Schwartz
source
,[>,]<[.<]?,[...,]entrée 12345retourne 111, même avec assez >avant?
— l4m2
@ l4m2 Hmm, ça marche pour moi sur TIO . ( ,[>,]<[.<]n'est pas valide mais l' >,[>,]<[.<]est.)
— Mitch Schwartz
Alors, quel est votre "ça permet d'aller à gauche de la cellule de départ"?
— l4m2
1
Votre réponse a donc besoin d'un BF qui commence au milieu d'une bande infinie, mais la nature de A et B est limitée au standard où l'on commence à la première cellule sur une bande infinie à droite?
— Sylwester
1
Pour cette solution, aller à gauche de la cellule de départ est interdit en A, B et C, mais il est autorisé dans le programme (nous pouvons l'appeler D par commodité) qui prend A et B et produit ensuite C. Je ne ne pense pas que ce soit très remarquable, et c'est un choix naturel étant donné la nature de la solution. Aller à gauche du départ a des conséquences majeures dans le contexte de A, B et C, mais c'est assez trivial pour D, et rend subjectivement une expérience de golf plus agréable ainsi qu'un score légèrement plus court, et ne devrait pas non plus faire tests plus fastidieux, car il est facile d'ajouter des >s à D au besoin.
— Mitch Schwartz
6

brainfuck , 1287 octets

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

Essayez-le en ligne!

C'est ici! Le code brainfuck qui compose deux codes brainfuck. Utiliser un "!" pour séparer les deux extraits de code d'entrée. Par exemple extrait A: >,[>,]<[.<]snippet B: ,[...,]. Entrée pour mon programme: >,[>,]<[.<]!,[...,]. Il ne se terminera pas si aucun "!" est trouvé.

Cela fait essentiellement la même chose que ma version VBA. Le code généré est le même que dans la version VBA (notez que les exemples dans le post VBA ont été faits avant le dernier changement dans les extraits de brainfuck).

Explication

Voici mon code source:

[ 
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
source
1
— l4m2
@ l4m2: Désolé, j'ai fait une petite erreur dans les données de test. J'ai écrit >[,>]<[.<]!,[...,], donc l'extrait A ne produit rien. Bien sûr, cela doit être >,[>,]<[.<]!,[...,]pour un exemple de travail.
— Dorian
5

VBA, 512 489 479 octets

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

Explication

Le code VBA modifie le code brainfuck d'une manière, que la sortie de l'extrait A sera stockée dans une liste et l'entrée de l'extrait B sera lue à partir de cette liste.

Il initialise d'abord certaines variables 

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

Ensuite, il lit l'extrait A et remplace chaque <par <<<[+]-<<, chaque >par >>>>>>>[+]-<<et chaque .par la routine de stockage

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

après cela, il supprime la mémoire de l'extrait A et apporte des modifications à la liste stockée, afin qu'il puisse être lu comme entrée pour l'extrait B:

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

Ensuite, l'extrait B sera lu, tous les < sera remplacé par <<<<<, tout >sera remplacé par >>>>>et tout ,sera remplacé par la routine de lecture de liste:

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

Code source de Brainfuck

Ceci est ma source pour les portions de cerveau du code. J'expliquerai cela en détail plus tard.

[
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

Sortie pour le cas de test 1: f ",[..,]",",[...,]"

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

Essayez-le en ligne!

Sortie pour le cas de test 2: f ">,[>,]<[.<]",",[...,]"

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

Essayez-le en ligne!

Sortie pour le cas de test 3: f ",.",",."

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

Essayez-le en ligne!

Cas de test complexe: extrait A: construction d'un triangle alphabétique>+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Essayez-le en ligne!

Extrait B: trier les entrées par ordre croissant >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Essayez-le en ligne!

Résultat:

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

Essayez-le en ligne!

— Dorian
source
Je vous remercie. Je sais que c'est à peu près non golfé. Je voulais juste fournir le premier code de travail. Apportera également des modifications à la partie brainfuck du code.
— Dorian
5

Brainfuck , 785 octets

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

Essayez-le en ligne!

Pour séparer A de BI opté pour /.

Explication:

Le code réel qui génère ceci est juste une lecture en boucle avec un drapeau pour A / B et un commutateur qui permet de réduire l'entrée à comparer >, <, /, ,, et .et par ailleurs juste sortie de l'entrée. C'est en fait juste un transpilateur où le code transpilé vit dans une structure de données de sorte qu'il n'interfère pas avec les données stockées de A ou les uns des autres. le/ déplace simplement la cellule active vers la première cellule inutilisée. Je l'ai nettoyé à l'origine, mais cela rend le programme et la sortie plus volumineux.

Le résultat du programme a le modèle de mémoire suivant:

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

L' ceffondrement. czest toujours 0Il indique où se trouve le pointeur dans mes données BF émulées. La valeur active est -1 alors que toutes les cellules visitées auront 1. Dans des opérations comme aprintet breadcertaines cont une signification particulière.

L'impression de code A saute toutes les cellules de 1 octet pour laisser de la place pour une entrée de plus d'octets qui est des copies avec une sauvegarde dans les octets suivants s'effondrer pour recopier.

La lecture du code B récupère l'entrée de l'entrée. Ici, être destructeur est correct et lorsque vous "lisez" le dernier octet, vous obtenez 0 en EOF quelle que soit l'implémentation.

J'ai commencé en tant que code Extended BrainFuck faisant un résultat EBF. La plupart du débogage a été effectué sur les fichiers de résultats, puis mis à jour vers la source qui l'a généré. Ensuite, j'ai simplement exécuté les opérations indépendamment pour obtenir une sortie BF, mais j'ai remarqué la réponse de Dorian, qui m'a battu longuement, j'ai donc continué à jouer au golf avec la source EBF pour une sortie BF plus petite. La source d'origine est assez lisible et simple par rapport à d'autres choses que j'ai faites avec:

: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
source
Si j'ai bien compris, [->+] dans le programme C provoque l'échec des entrées comme ->->,./,., et cela pourrait être corrigé en utilisant [->>+](en s'assurant que le pointeur démarre sur une cellule avec la parité souhaitée). Pour [-<+], je pense que vous pouvez changer le schéma de navigation pour que toute la sortie de A soit différente de zéro?
— Mitch Schwartz
Je ne sais pas ce que tu veux dire. Lorsque A est ->->,.et B est ,., votre interprète préféré produit-il le même C que TIO et C fonctionne-t-il comme prévu sur votre interprète? Parce qu'il échoue sur TIO . (J'ai écrit ceci en réponse à un commentaire qui est maintenant supprimé.)
— Mitch Schwartz
@MitchSchwartz Merci pour votre commentaire. J'étais un peu arrogant car je ne m'attendais pas à rechercher -1des données utilisateur, mais en fait je l'ai fait sur la ligne "aller à la cellule active, mettre à zéro". J'ai mis à jour ma réponse puis j'ai ajouté un octet: -O mais au moins ça marche. BTW. Si je n'utilise pas scan for -1to lors de la récupération de l'entrée dans B je devrai déplacer l'octet actif avec une copie>[-<+]< et j'ajouterai donc plus de caractères que je n'enregistre en le remplaçant +[-<+]-par [<]. Si vous ne copiez pas, vous ne pourrez pas savoir si l'octet que vous avez compilé était terminé et copier tous les octets.
— Sylwester
Eh bien ma mention de [-<+] également l'élimination des bogues (par opposition à la sauvegarde des octets), pour les entrées telles que -./,>++++++[<++++++>-]<., qui devraient s'imprimer #plutôt que %. :) Mais je vois aussi des opportunités pour économiser des octets. Bonne chance! J'essaierai d'optimiser ma solution de bande doublement infinie, bien que voir ce que vous avez fait me fait penser que peut-être la bande infinie droite est plus golfique à la fin.
— Mitch Schwartz
Donc, après avoir examiné votre code de plus près, j'ai constaté que nos configurations sont très similaires et que votre utilisation d'une bande infinie droite est bien meilleure pour le golf que ma bande doublement infinie. Veuillez consulter ma récente mise à jour sed pour une solution qui combine nos idées. Je pense que jouer au golf C est la partie la plus intéressante de ce problème, mais il y a aussi de la place pour raccourcir le programme de remplacement des cordes en dehors de cela ...
— Mitch Schwartz
4

sed, 165 octets

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

Pour les saveurs avec EOF = 0, les cellules restantes du début ne sont pas autorisées, les cellules d'emballage 8 bits.

Attend le programme A sur la première ligne et B sur la deuxième ligne.

Essayez-le en ligne

Celui-ci utilise des nœuds à 2 cellules pour simuler les bandes de A et B, la sortie de A occupant des cellules contiguës à gauche du nœud le plus à gauche.

Solution alternative à 173 octets:

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

Essayez-le en ligne

À l'origine, ma conception était basée sur une bande doublement infinie, qui nécessitait beaucoup plus de travail pour se déplacer vers la gauche (déplacer les données en passant au-delà de la cellule la plus à gauche rencontrée précédemment) et pour passer de A à B (effacer les données au lieu de simplement passer devant la cellule la plus à droite) rencontré précédemment).

Merci à Sylwester et Dorian pour leurs astuces et leurs idées.

— Mitch Schwartz
source
Ça a l'air génial. Malheureusement, il échoue au premier test. Programme A ,[..,]et B programme ,[...,].
— Dorian
Oh, c'est un oubli stupide de ma part, je me suis trop pressé. Il est réparable mais je devrais le supprimer pour l'instant.
— Mitch Schwartz
@ Dorian Il devrait être corrigé maintenant. (Je vais continuer à regarder.) Merci d'avoir signalé l'erreur, et désolé pour la gêne occasionnée.
— Mitch Schwartz
Je suis conscient que certains octets peuvent être enregistrés en ayant par exemple s/x/>>/gà la fin, mais je suis plus intéressé par les améliorations qui raccourciront la sortie pour l'instant.
— Mitch Schwartz
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.