Cette question fait partie d'une série de défis Brain-Flak Birthday conçus pour célébrer le premier anniversaire de Brain-Flak. Vous pouvez trouver plus d'informations sur l'anniversaire de Brain-Flak ici .
C'est aujourd'hui le premier anniversaire de Brain-Flak! Alors j'ai pensé que nous organiserions une fête d'anniversaire surprise. Donc dans votre langue préférée imprimer
Surprise!
Happy Birthday, Brain-Flak!
(Les espaces de fin sont autorisés)
Comme toujours, les programmes devraient être joués au golf. Cependant, comme les programmes Brain-Flak sont constitués de crochets, les crochets de votre source ne seront pas comptabilisés. (Les caractères ()[]<>{}
ne comptent pas dans votre total d'octets), mais ils doivent être équilibrés pour ne pas contrarier Brain-Flak.
Règles
Voici le détail des règles
Les parenthèses dans votre source doivent être équilibrées. C'est-à-dire que les parenthèses de votre programme doivent être couvertes par la grammaire suivante:
S -> SS | (S) | [S] | <S> | {S} | E
où
E
est la chaîne vide.Cela signifie qu'une chaîne équilibrée est soit la concaténation de deux chaînes équilibrées, des accolades autour d'une chaîne équilibrée, soit la chaîne vide.
Le score d'un programme est le nombre d'octets sans crochet.
Votre objectif devrait être de minimiser votre score dans la langue de votre choix.
Les règles standard s'appliquent afin que vous puissiez écrire un programme complet ou une fonction.
en cas d'égalité, le nombre d'octets bruts joue le rôle d'égaliseur
Il va certainement être des solutions d'octets zéro dans certaines langues ( Parenthèses Enfer , parenthetic , Glypho , Lenguage ). Essayez de trouver des moyens de bien jouer dans des langues où ce n’est pas une tâche facile.
la source
><
considéré comme équilibré ou les accolades doivent-elles être placées dans le bon ordre (<>
)?Réponses:
Python 2 ,
39373634 octets-1 grâce à dzaima
-2 grâce à Erik l'Outgolfer
Essayez-le en ligne!
Caractères pertinents:
Explication
Ce programme construit la chaîne:
Pour ce faire, il convertit une longue chaîne de parenthèses en codes de caractères. Une fois que la chaîne est construite, elle l'exécute.
Il construit la chaîne avec le squelette:
Cela divise la chaîne
{}
et mappe chaque section au code de caractère correspondant à sa longueur. Nous pouvons alors construire la chaîne entière à partir de parenthèses pour un coût de zéro octet.la source
()
autour de lax
sauver 2.Haskell (avant GHC 8.4), (
10119 7767 76267540 octets), score15 1410Essayez-le en ligne!
La dernière ligne définit une fonction anonyme
(<>)'y'pred(:)
. Appelez avec(<>)'y'pred(:)()
pour donner la chaîne.Edit: Un grand merci à @ Ørjan Johansen pour avoir suggéré de transmettre les fonctions d’aide en tant que paramètres au lieu de les déclarer, ce qui a permis d’économiser quatre octets de score!
Les octets non-crochets sont
Comment ça marche?
Une chaîne
"wxy"
en Haskell est du sucre syntaxique pour une liste de caractères['w','x','y']
, qui est à nouveau le sucre syntaxique pour la construction ultérieure avec l'opérateur contre:
et la liste vide:'w':'x':'y':[]
. En définissant,(<<>>)=(:)
nous produisons la même chaîne en écrivant'w'<<>>('x'<<>>('y'<<>>[]))
.Comme les caractères sont ordonnés, nous pouvons calculer le prédécesseur de chaque caractère avec une fonction appelée
pred
. En utilisant uniquement le caractère'y'
etpred
, la chaîne devientpred(pred 'y')<<>>(pred 'y'<<>>('y'<<>>[]))
. En définissant(<>)=pred
et,(<><>)='y'
nous pouvons représenter la chaîne en utilisant des crochets équilibrés uniquement:(<>)((<>)(<><>))<<>>((<>)(<><>)<<>>((<><>)<<>>[]))
Cependant, au final, nous ne voulons pas d'une chaîne mais d'une fonction renvoyant une chaîne, nous définissons donc notre opérateur contre comme
(<<>>) x xs ()=x:xs
. (Bien sûr avecx
etxs
remplacé par des identificateurs utilisant uniquement des crochets équilibrés:)(<<>>)(<>)(<><>)()=(<>):(<><>)
. Par ici,((<>)((<>)(<><>))<<>>((<>)(<><>)<<>>((<><>)<<>>[])())())
est une fonction de type
() -> String
et ajouter une finale()
donne la chaîne d'origine:((<>)((<>)(<><>))<<>>((<>)(<><>)<<>>((<><>)<<>>[])())())()
En utilisant cette méthode , nous obtenons une solution avec un score 15. Cependant, on peut condenser les trois déclarations en un seul en déclarant une fonction qui prend quatre arguments:
'z'
,pred
,(:)
et()
pour appeler.La fonction suivante
encode
code une chaîne avec des caractères plus petits ou égaux, de la'y'
manière suivante: (Pourquoiy
? Parce que c'est le plus gros caractère"Surprise!\nHappy Birthday, Brain-Flak!"
et donne ainsi la représentation la plus courte. Merci encore à Ørjan Johansen pour l'avoir signalé.)Essayez-le en ligne!
la source
'z'
n’apparaît pas dans la chaîne d’objectifs, je pense que vous pouvez réduire le nombre d’octets en utilisant à la'y'
place.(<<<>>>)(<><>)(<>)(<<>>)()=...;(<<<>>>)'y'pred(:)
Rétine , 59 - 24 = 35 octets
Essayez-le en ligne! En comparaison, la solution ennuyeuse prend 38 octets.
la source
Gelée ,
7 à6 octetsDans le,
“”
vous devez mettre la sortie de ce programme Jelly:-1 octet grâce à Jonathan Allan (autorisé retour à la ligne)
Il y a 53127666317289661939246122975355844970973062889031671423309402549417051416384149 80886139013 (nous appellerons cela
n
)()
entre“”
.Explication :
la source
Durée , 0 octet
Juste 10024793746353848520175158940670214213802394805963081469362831141755126591573942436182287015467334956253918417576118983828148929806934751198148656645940502264502520032312455157880058174845907554602116807351044784410936407102892289953027884533102082518964744402664917253792543505897552998982122997648280947470217067174451441654554437678556775097996646071948 octets en crochets équilibrés.
Programme Python 3 pour générer ma version préférée, avec suffisamment de temps et de mémoire:
la source
Haskell , (
1200613485 octets), score1817MODIFIER:
toEnum
version fonctionne sans extensions en déplaçant la fonctiontoEnum
vers la fonction principale, au prix de$
.Utiliser comme
putStrLn$(<<>>)()
.Essayez-le en ligne!
où
...
est la chaîne de résultat de l'expression suivante:Les seuls caractères non équilibrés sont
La variante suivante (13484 octets) a un score de 16 sauf qu'elle a besoin de l'
ExtendedDefaultRules
extension GHC et ne fonctionne donc que dans GHCi par défaut. (À moins que vous n'aimiez des tas d'avertissements, vous voulez aussi-fdefer-type-errors
et-Wno-deferred-type-errors
pour une raison quelconque.)Essayez-le en ligne!
Comment ça marche
<>
sont des caractères d'opérateurs légaux. De plus, si elles sont entre parenthèses, elles peuvent être utilisées pour n’importe quelle valeur, pas seulement pour des fonctions à deux arguments.(<<>>)
sur la deuxième ligne est la fonction principale, il prend un seul argument factice()
et retourne la chaîne finale.<>
prend deux listes et ajoute la longueur de la seconde à la première (dans la deuxième version, convertissant également d'abord la longueur en caractère). Les opérateurs restent associatifs par défaut, ce qui permet de les chaîner facilement.[]
avec<>
.()<>[]
caractères sont équilibrés) , puis (dans la version principale) en correspondancetoEnum
avec la liste résultante.la source
Japt ,
1914131098 octetsoù la chaîne au début est:
Le nombre total d'octets est "seulement"
669433943354, vous pouvez donc l' essayer en ligne!Explication
La méthode réellement utilisée est expliquée dans d’autres réponses: Fractionner
<>
, mapper chaque exécution de parenthèses surchr(len(x))
, rejoindre à nouveau sur la chaîne vide. Ici, le golf est la partie la plus amusante.Avant de "jouer au golf", le code original pourrait ressembler à
ce qui est une description assez littérale:
"...".split("<>").map(Z => Z.length.toChar()).join("")
Maintenant, nous devons minimiser les caractères sans crochet. Comment? Eh bien, d’abord, nous pouvons faire du golf réel:Cela représente à peu près
"...".split("<>").map(Z => Z.length).map(Z => Z.toChar()).join()
.Nous pouvons maintenant abuser de la façon confuse dont Japt traite les parenthèses.
(
représente la hausse d'un niveau, comme dans la plupart des langues, mais la)
réduction de deux niveaux (un espace diminue d'un niveau), ce qui signifie que nous pouvons optimiser le code pour:Ce code fonctionne exactement comme ci-dessus, mais utilise deux caractères de moins sans crochets.
De plus, si un opérateur est la première entrée d'une fonction, il est transformé en une chaîne afin que la fonction puisse décider quoi faire avec. Cela signifie que nous pouvons éviter les guillemets si nous réduisions simplement chaque série de parenthèses d'un octet et divisions à la
>
place (avec une disposition astucieuse pour annuler le résultat>)
dans le code):Cela nous évite deux octets supplémentaires, puisque nous avons supprimé deux des guillemets.
la source
Haskell , (
1965 313118073 octets), partition31 2319Essayez-le en ligne! Utilisation: La dernière ligne est une fonction anonyme. Liez-le à par exemple
f
et appelez avecf()
.Les 19 octets sans parenthèse sont
plus un retour à la ligne.
Version 23 de la partition (3131 octets):
Essayez-le en ligne! Les 23 octets non-crochets sont
Score 31 version (1965 octets):
Essayez-le en ligne!
Une fois tous les crochets supprimés, il reste 31 octets:
Comment ça marche?
['\n'..'~']
donne la liste de tous les caractères de la nouvelle ligne à~
laquelle sont inclus tous les caractères imprimables ASCII.(<<>>)
est un identifiant choisi pour avoir zéro octet sous la règle de scoring donnée.(<<>>)=['\n'..'~']++(<<>>)
donne ainsi une répétition infinie de la liste des caractères.Dans la deuxième ligne,
zip"> ... "(<<>>)
ferme une longue chaîne de crochets avec la chaîne infinie, ce qui donne une liste de tuples avec un caractère de crochet dans le premier composant et un caractère ASCII dans le second. Pour chaque tuple de cette liste, nous vérifions s'il correspond au modèle('{'{-}-},(<>))
, c'est-à-dire s'il comporte un{
crochet comme premier composant.{- ... -}
est un commentaire en ligne dans Haskell et'{'{-}-}
une version équilibrée de'{'
. Si la correspondance est réussie, le second composant du tuple est lié à l'identifiant(<>)
et ajouté à la construction de chaîne via la liste de compréhension. EnfinputStr
imprime la chaîne.putStr[(<>)|('{'{-}-},(<>))<-zip"> ... "(<<>>)]
L'impression directe de la chaîne est de 46 octets:
la source
HTML, 37 octets
la source
<br>
tag comme celui-ci:Surprise!<br>Happy Birthday, Brain-Flak!
<br>
est un octet plus long que<p>
j'ai essayé avant de poster. C'est un peu plus joli. Je n'utilise pas d'étiquette de fermeture<p>
cependant.05AB1E , 24 octets
Utilise le codage 05AB1E . Essayez-le en ligne!
la source
Pyth,
4⃠3⃠2 octets4
barrén'est pas régulier 4 si vous utilisezzalgoUnicode magicMerci à Roman Gräf et à Neil d’avoir économisé 1 octet.
Le code est
Cl(()()()
…()()())
où la parenthèse externe contient des41505989310382548390036033574496753883572705382055993299460470741732071419050117038172961
copies concaténées de()
. (Stack Exchange ne m'a pas permis d'afficher le code complet.)Crée un tuple (
(
…)
) de tuples vides (()
), prend la longueur (l
) et le convertit en chaîne de base 256 (C
).la source
h
ajouter une autre paire de crochets?h
deux positions vers la droite et cela fonctionnerait toujours parfaitement ;-)Japt , 6687 octets, score 5
Essayez-le en ligne!
Cela ressemble à mon autre réponse Japt , mais il utilise des tableaux imbriqués au lieu d'une chaîne. Ce qui est bien avec les tableaux imbriqués (en plus du fait que leur définition ne prend aucun octet), c’est qu’ils sont pré-organisés, vous n’avez donc pas à faire de
<>
magie dédoublée , ni à décoder à partir d’un énorme nombre de base 256, ou quelque chose comme ça. La logique actuelle est juste.map(X => X.length).map(X => String.fromCharCode(X)).join("")
.la source
Puce , 553 + 3 = 556 octets, score 127 + 3 = 130
+3 pour arg
-w
. Essayez-le en ligne!Les octets non-crochets sont
Ungolfed / unbalanced:
Comme vous pouvez le constater, le code d'origine n'utilise que des crochets du côté droit. Par conséquent, tous les crochets du côté gauche servent uniquement à l'équilibrage. En élaborant cette solution, j’ai trouvé une représentation de chaîne beaucoup plus dense dans Chip que j’avais eu pour mes réponses précédentes, par exemple hello world , et j’ai donc également mis à jour celles-ci.
Comment ça marche:
Le bit suspendu à gauche produit une impulsion d'un cycle pour que les choses commencent. Cette impulsion se déplace le long du
Z
canal à raison de 1 par cycle, ce qui fournit la synchronisation. Lorsque chacuneZ
est alimentée, la colonne correspondante produit le code ASCII du caractère à cet index, qui est ensuite transmis par les élémentsa
viag
(un par bit de l'octet de sortie, sauf le bit de poids forth
qui est toujours à 0). Lorsque terminé, l't
exécution se termine.Le codage ascii est simple:
)
signifie 1 etx
signifie 0. Cependant, les 5 lignes du bas sont pour la plupartx
, donc j'inverse ces bits dans la solution finale en échangeant efficacement les deux symboles.Est-ce le meilleur score possible?
J'en doute. Au minimum absolu, je pense que nous avons besoin de ce qui suit: 1 chaque à
a
traversg
, puisque ce sont les bits de sortie actifs, 1*
ou similaire pour fournir un signal de départ, 1t
pour terminer l’exécution, 36Z
s ouz
s pour temporiser chaque lettre, et commande arg-w
. Ceci tout à un score de 48.Au-dessus de ce minimum théorique, ma solution comporte 7 nouvelles lignes, une seconde
*
, une supplémentaireZ
et 73x
s.la source
C, 9265 octets, score 37
Voir le travail en ligne .
C, 8589934626 octets, score 34
Où
STRING
est le même littéral de chaîne de grande taille que celui utilisé dans l'exemple ci-dessus, à ceci près qu'il existe deux différences au centre même de la chaîne où se trouve une sous-chaîne<>
. Juste avant<
, il y a 4294962688[
caractères supplémentaires , et juste après>
sont 4294962688]
caractères supplémentaires .Le programme fonctionnera selon les hypothèses suivantes:
INT_MAX est 2 ^ 31-1 et INT_MIN est -2 ^ 31.
Compilé avec un comportement de recouvrement pour l'arithmétique signée. (-fwrapv)
La fonction strspn est capable de traiter 4294962689 caractères à la fois.
Le compilateur est capable de compiler un littéral de chaîne composé de 8589934592 caractères.
Ces hypothèses sont possibles sur les architectures 64 bits modernes, où le type int est de 4 octets et le type size_t de 8 octets. La fonction strspn renvoie le type size_t et le même type est associé à la limite interne pour la taille maximale de l'objet. Tapez size_t, 8 octets satisfaisant les deux dernières hypothèses.
Cette différence dans cette version est que la variable i n'a pas à être réinitialisée à 0, car elle est renvoyée à 0 après l'impression du dernier caractère.
la source
Haskell , 9735 octets, score 9
Essayez-le en ligne!
Les 9 octets de scoring sont
Cela fonctionne dans les versions actuelles de Haskell (GHC 8.4 ou plus récent) où se
(<>)
trouvePrelude
. Merci à Ørjan Johansen de m'avoir signalé que cela casse ma solution précédente mais permet de sauvegarder un autre octet de score.Explication
Comme
(<>)
sur deux listes est identique à(++)
, nous pouvons représenter une chaîne"abc"
comme à la"a"<>"b"<>"c"
place. Les chaînes sont des listes de caractères, elles['a']<>['b']<>['c']
désignent donc la même chaîne. Maintenant, comme dans la réponse précédente, nous voulons seulement un littéral de caractère, donc nous en tenir à un plus haut il'c'
et représentent les autres comme les prédécesseurs de celui - ci:[pred(pred 'c')]<>[pred 'c']<>['c']
. Enfin, en remplaçant'c'
par ce(<><>)
qui est un identifiant valide etpred
avec(<<>>)
, nous obtenons un codage de la chaîne"abc"
qui se compose uniquement de parenthèses équilibrée:[(<<>>)((<<>>)(<><>))]<>[(<<>>)(<><>)]<>[(<><>)]
.La fonction suivante code une chaîne arbitraire de cette manière:
Essayez-le en ligne!
la source
(<<>>)
est utilisé tellement de fois, je pense que cela économisera beaucoup d'octets si vous échangez son nom avec celui de<>
(en passant ce dernier comme paramètre supplémentaire).C # Interactive, 45 octets
Je sais que c'est assez ennuyeux, mais si elle est exécutée en mode interactif C #, elle produit le résultat souhaité - et en réalité, je doute qu'il existe un moyen plus simple de résoudre ce problème en C #.
Cependant, il existe un moyen plus efficace:
Mais c'est 145 octets gros.
Avec les sauts de ligne, ça ressemble à ça:
Cela interprète les crochets comme des valeurs booléennes, puis comme une chaîne.
En fait, je ne suis pas un golfeur avancé, donc toutes les suggestions sont les bienvenues!
la source
.Select(s =>
pour vous conformerS -> <S>
, vous pouvez le remplacer par.Select(/*<*/s =>
C# Interactive
, je pense aussi qu'il est interprété en C # interactif, pas compilé, mais il est toujours considéré comme un programme \ scriptCJam , 6683 octets, score 3
J'ai raccourci le code ici pour ne pas trop encombrer la page. Vous pouvez voir le code complet dans le lien TIO. Les seuls caractères autres que les crochets sont
,c%
.Essayez-le en ligne!
Explication
Le programme commence en poussant un tableau de tableaux de tableaux vides. Chaque sous-tableau contient un nombre de tableaux vides correspondant à la valeur ASCII d'un caractère de la chaîne souhaitée. Ensuite, pour chaque sous
{...}%
-tableau ( ), il obtient la longueur du tableau (,
) et convertit cette longueur en caractère (c
).La chaîne résultante est imprimée implicitement.
la source
C,
6964 octetsEssayez en ligne
Comment je l'ai fait
*
par{}
,>
avec<>
et<
avec[]
afin qu'ils ne comptent pas, donc maintenant ce nombre de codes est 1 en raison du caractère de départS
.<>
, soustrait[]
, affiche la somme actuelle{}
et se termine à la fin de la chaîne\0
.C, 49 bytes Essayer en ligne
la source
p
pour sauver des octets?Lua 5.3, 108097107033101 octets, score
2827Ici,
REPLACE
est remplacée par une longueur de 108097107033034 chaîne de caractères libres. La chaîne code les données en mettant{}
à certaines positions clés. Le premiergsub
remplacera la chaîne par les index du{}
s (via le groupe de capture vide()
). Le secondgsub
casse cette chaîne résultante en blocs de 3 chiffres et remplace chaque bloc par sa représentation ASCII.Notez que la syntaxe pour les chaînes brutes dans Lua est (fondamentalement)
[[string contents]]
, ce qui est très utile pour réduire le score.La chaîne (non échappée) que je génère est
print"Surprise!\nHappy Birthday, Brain-Flak!"
. Remplacer chaque caractère par son code ASCII décimal à 3 chiffres donne112114105110116034083117114112114105115101033092110072097112112121032066105114116104100097121044032066114097105110045070108097107033034
. Le code que j'utilise ne peut générer que des séquences de nombres naturels croissants (au moins 2 séparés) qui ne commencent pas par des zéros initiaux. Donc, ce nombre est divisé en11, 2114, 105110, 1160340, 83117114, 112114105, 1151010330, 9211007209, 71121121210, 320661051141, 1610410009712, 10440320661140, 97105110045070, 108097107033034
. (Ce dernier nombre correspond exactement à la longueur de laREPLACE
valeur, car la dernière correspondance du motif donne l'indice de la finale}
, en notant que les indices Lua commencent à 1. Si le dernier nombre était impair, alors le motif et la chaîne auraient être légèrement modifié, bien que ce ne soit pas difficile.)Je n'ai pas réellement généré et exécuté ce programme car il est trop volumineux (bien qu'il puisse théoriquement fonctionner sur une machine 64 bits, il ne tiendrait pas sur mon disque dur).
Pour prouver le concept, voici un petit programme qui imprime
3
selon le même principe:Ceci génère la chaîne de code
p"3"
via le numéro112034051034
via le fractionnement11, 203, 405, 1034
.la source
Pip , 6681 octets, score 3
(avec beaucoup de parenthèses et des crochets expurgés). Essayez-le en ligne!
Nous construisons une liste de listes, chacune contenant
()
(nil) un certain nombre de fois.#*
mappe l'opérateur de longueur, résultant en une liste de nombres.C
prend chaque nombre en tant que code ASCII et le convertit en un caractère. La liste de caractères résultante est ensuite automatiquement concaténée et imprimée.Joyeux anniversaire tardif, Brain-Flak!
la source
Mathematica, 40 octets
Fonction anonyme. Ne prend aucune entrée et retourne une chaîne en sortie.
la source
Gelée ,
1921 octetsRien du tout malin ici, juste une compression dictionnaire + chaîne du texte plus un retour à la ligne final pour supprimer une incomparable
<
.Pour une approche vraiment golfique, voir cette réponse de Erik the Outgolfer.
Essayez-le en ligne!
la source
PHP, 42 octets
Essayez-le en ligne!
-5 octets la solution ennuyeuse
PHP, 60 octets
Essayez-le en ligne!
la source
<?=""?>
Empilé , score 23
Où
...
est la chaîne omise. (Cela peut être généré avec cela .)Essayez-le en ligne!
Ouais pas si créatif. Obtient le nombre de tous
<>
s et les convertit en codes de caractères.la source
Perl 5 , 3304 octets, 16 partitions
Essayez-le en ligne!
Utilise le codage de longueur de texte de la solution Python de @ HeebyJeebyManMan.
la source
Java, 140 octets
Essayez en ligne
la source
C, 52 octets, score 46
Version naïve. Voici la version optimisée .
la source
Charbon de bois , 37 octets
Essayez-le en ligne!
Juste imprime la chaîne.
la source