Un puzzle de programmation du mode golf

43

Votre tâche consiste à imprimer le texte Good morning, Green orb!, chaque caractère étant répété à la place autant de fois que l’octet le plus fréquent de votre source (le mode). Un retour à la ligne est autorisé et n’a pas besoin d’être répété.

Par exemple, si votre source était

print p

Depuis papparaît deux fois et chaque autre octet apparaît une fois que vous devez imprimer

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Les réponses seront notées par le produit du nombre d'octets et du nombre de répétitions de la sortie. Par exemple, le code ci-dessus (s'il fonctionnait) donnerait 7 * 2 = 14 . L'objectif devrait être de minimiser son score.

Votre code doit contenir au moins 1 octet.

Utilisez ce programme pour vérifier que votre code et votre sortie correspondent

code-challenge  kolmogorov-complexity  hello-world  self-referential 
— Assistant de blé
source
Les fonctions sont autorisées, non?
— totalement humain
1
@totallyhuman Oui, tant qu'ils ne prennent pas d'entrée.
— Wheat Wizard
1
Cela ne devrait-il pas être étiqueté quine ?
— FantaC
Le matin ne peut pas être capitalisé, peut-il haha?
— Urne magique Octopus le
@magicoctopusurn Nope le texte devrait être le même.
— Wheat Wizard

Réponses:

18

Flak cérébrale , 384 * 106 366 * 100 = 36 600

(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>(((({}<>()))))({}{}{}<>)<>{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}

Essayez-le en ligne!

Explication

La première chose que je fais est de pousser la corde

!bro neerG ,gninrom dooG

à la pile en utilisant assez tactique cerveau-flak Kolmogorov-complexité.

(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>({}<>())

Ensuite, nous mettons un marqueur hors pile pour nous dire combien de fois dupliquer chaque caractère. Cependant, je n'allais pas être capable de déterminer ce compteur avant d'avoir fini d'écrire le programme.

Ensuite, nous inversons simultanément la chaîne et dupliquons chaque caractère à la place le nombre correct de fois. Plus précisément le compteur + 1.

{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}

Ces deux parties du programme ont un mode de 99 parenthèses ouvertes. Cependant, puisque nous allons très certainement avoir besoin d'au moins une parenthèse. C’est ici que j’ai remarqué que le dernier caractère que nous avons poussé de manière !pratique contient le code de caractère 33, ce qui signifie que nous pouvons l’utiliser pour créer 99, le nombre exact que nous souhaitons à l’aide d’une seule parenthèse supplémentaire. C'est tout à fait la coïncidence, mais ça marche.

— Assistant de blé
source
9
Ah, tout simplement, une tactique assez classique de stratification cérébrale de Kolmogorov. Ce sont la chose.
— John Keates
Vous, mon bon ami, devez être fou pour même essayer cela. Je vais juste à +1 et partir avant que mon cerveau n'explose d'essayer de comprendre toutes les parenthèses.
— Caird coinheringaahing
15

Haskell , 37 octets × 3 = 111

-20 grâce à H.PWiz. -25 Merci à Nimi.

"Good m\111rning, Green orb!"<*[2..4]

Essayez-le en ligne!

Les opérateurs de Haskell, FTW.

Rappelez-vous de ne jamais jouer au golf sur mobile. Je continue à faire des erreurs stupides. Je peux pousser au moins la moitié du blâme sur mobile. : P

— totalement humain
source
5
Utilisation <*de la sauvegarde d’octets (notez que je n’ai pas vérifié sa validité)
— H.PWiz
Bon sang, Haskell a presque trop d'opérateurs. Merci!
— totalement humain
15

brainfuck , 235 x 77 = 18 095 points

Edit: -2 octets grâce à @Dennis

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

Essayez-le en ligne!

Test TIO

Attendez, ce n'est pas du code bowling? \ s

Avec seulement 8 caractères utilisables, le brainfuck est l’une des pires langues à poser cette question. Je devais commencer par minimiser le personnage qui apparaîtrait le plus inévitablement, généralement l'un +ou l' autre -. Après avoir rédigé la première version du code, je l’ai trouvé horriblement déséquilibré en faveur de l’ +al. J'ai réarrangé des parties du code, telles que la génération de grands nombres, pour en utiliser davantage -. Enfin, je me suis retrouvé à une égale quantité des deux caractères à 77 un de moins -que +. Il est certainement possible de réduire cela davantage, ce que je tenterai demain.

Mais bon, au moins je bat la réponse de Brainflak

— Jo King
source
Hé, félicitations! Je n'arrive pas à croire qu'il soit même possible de faire cela en BF ... Assez si cela peut être fait dans la ;#langue (° ͜ʖ °)
— RedClover
13

Gelée , 13 octets * 1 = 13

“¢Ȧ@XĊ'WÑṭḂ#»

Essayez-le en ligne!

— M. Xcoder
source
3
Enfin, quelqu'un gère l'insaisissable * 1 réponse. J'avais le sentiment que Jelly serait la langue pour le faire ...
— ETHproductions
@ETHproductions Haha, je viens de réduire de moitié mon code tout en conservant * 1
— Mr. Xcoder
Haha dang Je viens de constater que juste après l'avoir modifiée
— Dylnan
Par curiosité, quelle est exactement la différence? Comment la nouvelle chaîne compressée est-elle la moitié de la longueur de l'ancienne?
— ETHproductions
@ETHproductions J'ai d'abord utilisé une chaîne compressée non optimale, puis le compresseur Jelly optimisé, qui a trouvé les correspondances dans le dictionnaire.
— M. Xcoder
10

Alice , 49 octets * 2 = 98 144

/:G!4o3r8"1=5',0Grey9Z<@
\"b0=dnm 2'i%g<7R6~e.;o/

Essayez-le en ligne!

Explication

/...@
\.../

C'est le cadre habituel des programmes linéaires qui fonctionnent entièrement en mode ordinal. En dépliant le flux de contrôle en zigzag, nous obtenons:

"G04d3m821i5g,7G6ee9;<:b!=onr "'=%'<0Rr~y.Zo@

L'idée de base est d'éviter les caractères qui se répètent plus de deux fois à l'aide d'une translittération. La translittération que nous allons faire est la suivante:

input: "G04d3m821i5g,7G6ee9;<:b!"
from:  "0123456789:;<"
to:    "onr "

La translittération fonctionne bien dans Alice, c'est que les chaînes fromet tosont d'abord répétées dans le LCM, bien que dans ce cas, la longueur de la fromchaîne dépende de la longueur de la chaîne. Nous avons donc:

from:  "0123456789:;<"
to:    "onr onr onr o"

De cette façon, nous obtenons quatre personnages différents pour représenter les os, et trois pour chacun n, ret l'espace. Nous pouvons générer la fromchaîne en utilisant l'extension de la plage comme suit:

'<   Push "<".
0    Append a zero.
R    Reverse.
r    Range expansion.

Le seul problème maintenant est qu'il nous en faudrait quatre "pour le inputet la tochaîne. Pour éviter cela, nous les mettons tous les deux dans une seule chaîne et nous les séparons à l' =aide d'un séparateur.

"G04d3m821i5g,7G6ee9;<:b!=onr "
     Push the string containing both parts.
'=%  Split around "=".

Le reste est juste:

~   Swap "from" and "to".
y   Transliterate.
.Z  Duplicate and interleave. This duplicates each character.
o   Print.
@   Terminate the program.
— Martin Ender
source
5

C (gcc) , 68 × 3 = 204

0000000: 6a 3b 6d 61 69 6e 28 29 7b 77 68 69 6c 65 28 6a  j;main(){while(j
0000010: 3c 37 32 29 70 75 74 63 68 61 72 28 7e 22 b8 90  <72)putchar(~"..
0000020: 90 9b df 92 90 8d 91 96 91 98 d3 df b8 8d 9a 9a  ................
0000030: 91 df 5c 32 32 30 8d 9d de 22 5b 6a 2b 2b 2f 33  ..\220..."[j++/3
0000040: 5d 29 3b 7d                                      ]);}

Merci à @MDXF pour avoir économisé 9 points et ouvert la voie à 6 autres!

Essayez-le en ligne!

Version alternative, ASCII imprimable, 69 × 3 = 207

j;main(k){while(j<72)putchar("Gnmg$hiuf`dl -I}ut|3{gt6"[k=j++/3]^k);}

Essayez-le en ligne!

— Dennis
source
— Dennis
5

APL (Dyalog Unicode) , 46 octets × 2 = 92

(Contient des éléments non imprimables)

2/⎕UCS(¯18+⍳24)+⎕UCS'X~r-yz|wqum1$Jtfemln]'

Essayez-le en ligne!

+ Beaucoup d'octets, merci à la page de code de Dyalog, merci à @ Adám pour l'avoir signalé.

— Zacharý
source
84
— Adám
C'est vraiment du génie, @ Adám
— Zacharý
Je crains que vous deviez vous contenter de 92 depuis ~⎕AV∊⍨⎕UCS 18.
— Adám
5

Vim, 42 41 frappes × 3 = 123

iGod morning, Green orb!<Esc>2|qsyl2pl@sqX0@s

Explication:

  1. iGod morning, Green orb!<Esc>
    Écrivez la chaîne God morning, Green orb!(une omanquante).
  2. 2|
    Aller au premier o.
  3. qsyl2pl@sq
    Créez une macro récursive s. Comme effet secondaire, tripler le courant o.
  4. X0
    Supprimez-en un oet sautez au début.
  5. @s
    Exécutez la macro s, qui répète chaque caractère deux fois.
— utilisateur285259
source
4

C, 78 × 4 = 312

*s=L" ÞÞÈ@ÚÞäÜÒÜÎX@äÊÊÜ@ÞäÄB";main(y){while(*++s)for(;y++%5;putchar(*s/2));}

Essayez-le en ligne!

356 332

— MD XF
source
Commenter parce que je suis fatigué de le trouver dans l'historique de mon navigateur chaque fois que je veux jouer au golf: j'ai utilisé cela pour trouver le nombre de répétitions de personnages.
— MD XF
Et ceci pour encoder la chaîne.
— MD XF
3

Japt , 24 octets * 2 = 48

`Good ¶rÍÁ,
GÎ9 b!`m²·¸

Contient un non imprimable. Testez-le en ligne!

La majorité du programme est juste une chaîne compressée, qui se décompresse en

Good morning,
Green orb!

et m²ensuite, men répétant chaque personnage en répétant ²wice ok, c’était un peu exagéré . L'espace est le seul caractère qui apparaît 3 fois dans la chaîne compressée; pour sauvegarder une instance, nous la remplaçons par une nouvelle ligne, puis nous utilisions ·¸pour scinder les nouvelles lignes et joindre immédiatement des espaces. Bien que 2 octets plus long, il réduit considérablement le score (de 66 à 48).

Maintenant, si seulement il y avait un court chemin à faire en utilisant aucun caractère deux fois ...

— ETHproductions
source
Parce que je ne peux pas le voir: quel personnage est dans la source trois fois? Je vois plusieurs choses qui ont un compte de 2, mais pas de 3.
— Draco18s
1
@ Draco18s Aucun, le score est de 24 * 2.
— ETHproductions
Alors la sortie est fausse. Vous imprimez chaque caractère 3 fois au lieu de deux fois.
— Draco18s
@ Draco18s Dangit, posté le mauvais lien ... Merci de l'avoir signalé.
— ETHproductions
*salute*Et maintenant que je regarde votre réponse, je vois qu’elle a ² alors que le lien avait ³ :)
— Draco18s
3

SNOBOL4 (CSNOBOL4) , 97 octets * 10 = 970

	S ='Good Morning, Green orb!'
y	S	LEN(1) . y rem . s	:f(p)
	x	=x DUPL(y,10)	:(y)
p	OUTPUT	=x
END

Essayez-le en ligne!

ouais ........ SNOBOL exige que les opérateurs soient séparés par des espaces, et certaines exigences sont assez délicates. Le code contient 9 '\t'et 10 ' ', de sorte que toute amélioration nécessitera un changement d'approche assez important.

— Giuseppe
source
3

R , 65 octets * 5 = 325 59 octets * 5 = 295 62 octets * 4 = 248

cat(gsub('(.)',strrep('\\1',4),"Good Mo\x72ning, Green orb!"))

Essayez-le en ligne!

Il y a 4 (or,')personnages.

— Giuseppe
source
2
Je n'ai jamais vu strrepauparavant, cela devrait être utile.
— BLT
3

Perl 5 , 59 × 2 = 118 points

$_="GSSdYmoVRing,YGVIen orb!";y<H-Z>[d-t ],s<.>[$&x2]eg;say

Essayez-le en ligne!

Perl 5 , 51 × 3 = 153156 points

s""GOOd morning, Green orb!";y'O'o';s/./$&x3/eg;say

Essayez-le en ligne!

Perl 5 , 43 × 4 = 172 points

say"Good morning, Green orb!"=~s/./$&x4/egr

Essayez-le en ligne!

Sauvegardé 2 octets dans chaque solution grâce à @Xcali (quelques modifications auparavant). Pour toutes les optimisations, regardez les modifications.

— mik
source
Faire de ce programme un programme au lieu d’une fonction permettrait d’économiser 2 octets (4 points): Essayez-le en ligne!
— Xcali
@Xcali, mais votre changement nécessite une option non standard -M5.010, qui compte également
— dimanche
— Xcali
2

V , 35 octets * 2 = 70

IG²od morning, GreeN ORb!5h3~Óˆ/°°

Essayez-le en ligne!

Hexdump:

00000000: 4947 b26f 6420 6d6f 726e 696e 672c 2047  IG.od morning, G
00000010: 7265 654e 204f 5262 211b 3568 337e d388  reeN ORb!.5h3~..
00000020: 2fb0 b0                                  /..
— DJMcMayhem
source
2

Python 2 , 62 * 4 = 248

Merci à @ovs et @Giuseppe!

lambda:"".join(c*4for(c)in"G\x6f\x6fd mor\x6eing, Green orb!")

Essayez-le en ligne!

Python 2 , 51 * 6 = 306

print"".join(c*6for c in"Good morning, Green orb!")

Essayez-le en ligne!

Python 2 , 70 * 5 = 350

lambda:"".join(c*5for(c)in"Gxxd mxrning, Green xrb!".replace('x','o'))

Essayez-le en ligne!

Merci à Xcoder pour sauvegarder un octet des deux versions!

— Steadybox
source
Vous pouvez supprimer l'espace entre 6et for.
— M. Xcoder
@ Mr.Xcoder Merci!
— Steadybox
— ovs
@ovs c'est pas tout à fait ça, je pense qu'il te faut deux \x6fs qui reste bon pour 244
— Giuseppe
2

CJam , 32 octets × 2 = 64

"Gnmg$hiuf`dl -I}ut|3orb!"K,.^:_

Essayez-le en ligne!

Pousse une chaîne, puis XOR les 20 premiers caractères avec [0, 1, …, 19], puis duplique chaque caractère.

— Lynn
source
2

05AB1E , score: 22 (22 octets * 1)

…‚¿•´,„ˆ¨èã).ªðý23£'!«

Essayez-le en ligne.

Explication:

REMARQUE 1: La pile intégrée dans la liste intégrée )est utilisée à la place de la paire intégrée ‚, car elle ‚fait déjà partie du mot du dictionnaire good.
Remarque 2: les deux virgules dans le code ‚et ,peut sembler identique, mais sont des caractères unicode différents . Le premier est généralement utilisé pour la paire intégrée et le second pour l’ impression intégrée à STDOUT avec une nouvelle ligne . Dans ce cas, ils sont utilisés pour le mot du dictionnaire goodet la virgule attendue dans le résultat.

…‚¿•´,        # 3-word dictionary string "good morning," (the comma counts as the third word)
„ˆ¨èã         # 2-word dictionary string "green orbit"
)             # Wrap everything on the stack into a list: ["good morning,","green orbit"]
 .ª           # Sentence capitalize all strings: ["Good morning,","Green orbit"]
   ðý         # Join by spaces: "Good morning, Green orbit"
     23£      # Only leave the first 23 characters: "Good morning, Green orb"
        '!«  '# Append a "!": "Good morning, Green orb!" (and output the result implicitly)

Voir ce conseil 05AB1E (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi …‚¿•´,est "good morning,"et „ˆ¨èãest "green orbit".

— Kevin Cruijssen
source
2

PowerShell , 46 octets * 4 = 184 points

"Good morning, Green orb!"-replace'.',('$0'*4)

Essayez-le en ligne!

— mazzy
source
1
C'est malin. J'ai complètement oublié à propos de$0
— Veskah
: | attends j'ai essayé cela, mais seulement après avoir fait le format afin que cela ne fonctionne pas aussi bien que cela a fait
— ASCII-seulement
¯ \ _ (ツ) _ / ¯ Qu'en est-il du lien TIO?
— mazzy
1

Gelée , 31 octets × 2 = 62 points

“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2

Essayez-le en ligne!

Explication

“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2
“2ðƈZ(Øṡdȷ¿Ɱ’                     Base 250 number
              “God mrnig,eb!”     Unique characters of "Good morning..."
             ṃ                    Convert the base 250 number in base 13 then index into the string "God mr..."
                             x2   Repeat each character twice because “ occurs twice in the source (and now 2)
— Dylnan
source
1

JavaScript (ES6), 61 octets * 3 = 183

_=>'Good morning, Gr\145en \x6f\x72b!'.replace(/./g,"$&$&$&")

Afficher l'extrait de code

JavaScript (ES6), 51 octets * 4 = 204

_=>'Good morning, Green orb!'.replace(/./g,'$&$&$&$&')

Réponse suggérée par @ETHproductions .

Afficher l'extrait de code

JavaScript (ES6), 73 octets * 4 = 292

_=>`G00d mo1ning, G244n orb!`.replace(/./g,_=>(('o'+!0)[_]||_).repeat(4))

Afficher l'extrait de code

JavaScript (ES6), 58 octets * 6 = 348

_=>'Good morning, Green orb!'.replace(/./g,_=>_.repeat(6))

Afficher l'extrait de code

— Darrylyeo
source
Alternativement, _=>_'$&'
— passez
1
Alternativement, je pense que vous pouvez juste faire '$&$&$&$&$&$&'pour le remplacement, ce qui ensuite, je pense, vous permet de supprimer deux instances et de descendre à avoir plusieurs personnages à égalité à 4, réduisant considérablement le score ...
— ETHproductions
@ETHproductions Merci, je ne connaissais pas ce modèle de remplacement!
— darrylyeo
1

Ruby, 55x4 = 220 points

"Good morning, Green orb!".split(//).each{|x|print x*4}

Je suis assez contrarié par l'utilisation de each_char qui fait le nombre de r 5.

— Håvard Nygård
source
1

Pushy , 36 * 2 = 72

`GXVWOP^4W_[afdc\hiB`N$29+L-''.

Essayez-le en ligne!

Le principe de base de cette réponse est que chaque caractère nest stocké de n + index - 29manière à éviter la répétition dans la chaîne d'origine. Ce mapping a créé la chaîne dans les backticks. Le reste du programme le décode simplement et imprime chaque caractère deux fois:

` ... `              \ Push the encoded string
       N             \ Remove printing delimiter
        $            \ While there are items left on stack:
         29+         \   Add 29 to top of stack
            L-       \   Subtract current length from top of stack
              ''.    \   Print twice, then pop

Octets utilisés deux fois: `'W

Changelog

  • Longueur golfée de 41 à 38, en changeant la méthode de décodage.
  • Longueur golfée de 38 à 37 en soustrayant 29 de chaque caractère codé pour empêcher les caractères multi-octets.
  • Longueur golfée de 37 à 36 en utilisant une "boucle d'extrémité" implicite
— FlipTack
source
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.