Unaire qui est très utile dans les sources restreintes et d'autres défis de ce type est Unary , un dérivé de brainfuck dans lequel les programmes sont écrits avec un seul caractère. Votre travail consiste à écrire un programme pour convertir des programmes de brainfuck en unaire et un programme pour faire le contraire, les deux programmes dans la même langue. Votre score sera la somme des durées des deux programmes.
Comment passez-vous du brainfuck au unary?
- Convertissez d'abord votre code brainfuck en binaire selon ce tableau:
- Maintenant, concaténez le code en un nombre binaire géant dans l'ordre du code.
- Ajoutez un
1
à la chaîne pour garantir un nombre binaire unique. - Convertissez d'un nombre binaire en un nombre unaire en utilisant n'importe quel caractère.
- Ex:
+.
serait000000000000000000000000000000000000000000000000000000000000000000000000000000000000
(84 zéros).
Brainfuck -> Spécifications unaires
- Étant donné que les programmes résultants seront incroyablement énormes, n'imprimez pas le programme réel mais simplement la longueur du programme résultant.
- Prenez le programme brainfuck sous forme de chaîne via stdin, la fonction arg, etc. et affichez la longueur.
- Le programme sera toujours valide et ne comportera que ces 8 caractères.
Unaire -> Spécifications Brainfuck
- Vous devrez implémenter l'inverse de l'algorithme ci-dessus.
- Encore une fois, en raison des énormes tailles en question, l'entrée sera un nombre décrivant la longueur du code Unary.
- Mêmes règles d'E / S que d'habitude.
- Le programme sera toujours valide et ne comportera que ces 8 caractères.
Cas de test
- Bonjour tout le monde -
++++++[>++++++++++++<-]>.>++++++++++[>++++++++++<-]>+.+++++++..+++.>++++[>+++++++++++<-]>.<+++[>----<-]>.<<<<<+++[>+++++<-]>.>>.+++.------.--------.>>+.
=239234107117088762456728667968602154633390994619022073954825877681363348343524058579165785448174718768772358485472231582844556848101441556
- Fibonacci -
++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++>++++++++++++++++>>+<<[>>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[<+>-]>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<.>.>>[>>+<<-]>[>+<<+>-]>[<+>-]<<<-]<<++...
=13067995222095367150854793937817629722033205198624522624687536186118993888926522550140580142585590431635487113180955099384652678100247403485397450658564826143160529351955621991895221530908461364045400531236124980271740502887704217664044858614821622360156740992393765239123681327824577149595724956207165558106099868913919959549896553103116795519592552089266360725543244154867904980260
C'est le code-golf donc le score le plus bas en octets gagne!
Quelqu'un veut une solution dans Unary? ; P
code-golf
brainfuck
base-conversion
compiler
Maltysen
la source
la source
10101010101010
, lorsqu'ils devraient l'être1010010010010
Réponses:
Pyth, 17 + 17 = 34 octets
BF -> Unaire, 17 octets
Unaire -> BF, 17 octets
la source
brainfuck ,
563 335 318 316296 +529 373 366336 = 632 octetsComme il manquait manifestement une solution dans une langue apparentée, voici la solution dans brainfuck et Golunar. Je ne pouvais pas poster une réponse à l'unaire, car cela nécessiterait quelques fantastiques milliards de fois plus de mémoire qu'il n'y a d'atomes dans l'univers ^^
La routine "retour" ne vérifiera pas si le code Golunar / Unary est valide. Si le nombre de bits mod 3! = 1, il s'exécutera dans une boucle sans fin imprimant beaucoup de ">".
Merci à Nitrodon de m'avoir aidé à descendre en dessous de 300 caractères pour le code bf en unaire
brainfuck to unary
Essayez-le en ligne!
et retour
Essayez-le en ligne!
Golunar / chiffres unaires,
509 303 288 286268 +478 337 331304 = 572 octetsbrainfuck to unary
et retour
Codes sources
brainfuck to unary
et retour
la source
Python 2,
80796355 +8664 = 119 octetsMerci à Sp3000 pour ses nombreuses suggestions, permettant d' économiser beaucoup d'octets.
Brainfuck to Unary,
78776153 + 2 = 55 octetsAjout de deux octets pour tenir compte de l'entourage "en entrée.
Unaire à Brainfuck,
8664 octetsDécouvrez-le sur ideone ici.
la source
CJam, 35 octets
Brainfuck à Unary, 17 octets
Essayez-le en ligne.
Comment ça fonctionne
Unaire à Brainfuck, 18 octets
Essayez-le en ligne.
Comment ça fonctionne
la source
Bash + coreutils, 39 + 47 = 86
b2u.sh
:u2b.sh
:Sortie de test:
la source
tr -dc 0-9
(et dans le golf de code, vous pouvez supposer que tout?
va bien)Japt , 13 + 13 = 26 octets
Brainfuck to Unary
Essayez!
Explication:
Unaire à Brainfuck
Essayez!
Explication:
Remarques
Je ne trouve pas la méta-publication, mais si ma mémoire est correcte, les réponses sont autorisées à limiter les E / S aux nombres que leur langue peut prendre en charge, tant qu'ils implémentent un algorithme qui fonctionnerait si la langue commençait à prendre en charge des nombres plus importants. C'est le cas ici, la capacité de Japt à traiter une chaîne comme "base
n
utilisant cesn
caractères pour les chiffres" ne peut utiliser que lenumber
type de données de l'autre côté de l'opération, et donc les cas de test ne s'exécuteront pas correctement; la sortie du premier programme et l' entrée du deuxième programme contraindront le nombre à un qui peut être représenté comme unnumber
, plutôt que d'utiliser le nombre réel. Pour les nombres qui peuvent être parfaitement représentés par Japtnumber
type de données ces programmes fonctionneront comme vous le souhaitez et si lenumber
type de données change pour prendre en charge de plus grands nombres, ces programmes commenceront également à prendre en charge ces nombres.la source
05AB1E , 33 (17 + 16) octets
Brainfuck à Unary-length:
Essayez-le en ligne ou vérifiez tous les cas de test .
Explication:
Unaire à Brainfuck
Essayez-le en ligne ou vérifiez tous les cas de test .
Explication:
la source
Fléchette , 77 + 142 = 219 octets
Essayez-le en ligne!
la source
C (gcc) , 254 octets
Essayez-le en ligne!
Détermine la direction à prendre en fonction de input (
i
), stocke le résultat dans le tampon passé (o
). Notez que certains compilateurs permettent d'économiser 4 octets en fonction de l'ordre défini par l'implémentation de l'o ++. Dans ces cas, la solution fournie tronquera un caractère supplémentaire de la conversion Unary-> BF eto[1]
tous les caractères peuvent être remplacés par*o
pour récupérer le comportement.la source
#include <string.h>
le pied de page au lieu de l'en-tête pour montrer que cela fonctionne sans cette importation. De plus, le C ++ ne serait-il pas plus court en raison de la surcharge de son opérateur? : Psi
enui
peut*i>47&*i<58
->*i%48<10
?mpz_init_set_str
->mpz_set_str