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

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.

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}

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

Gelée , 13 octets * 1 = 13

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

Essayez-le en ligne!

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.

Python 2 , 62 × 3 = 186

lambda:`sum(zip(*['Good morning, Green \x6frb!']*3),())`[2::5]

Essayez-le en ligne!

C (gcc) , ^{74 × 6 =} 444 ^{_{barrés 444 est encore régulier 444} 77 × 5 =} 385 81 × 4 = 324

f(q){char*a="Go\157d morning, G\162een o\162b!";for(q=0;q<96;)putchar(a[q++/4]);}

Essayez-le en ligne!

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!

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é.

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.

C, 78 × 4 = 312

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

Essayez-le en ligne!

356 332

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 ...

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.

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.

Ruby , 52 octets × 3 = 156

puts"Good morning, Green \x6frb!".gsub(/(.)/,'\1'*3)

Essayez-le en ligne!

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.

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                                  /..

SOGL V0.12 , 16 octets * 1 = 16

7n]ēæ¬⁹≡qa╔αXE‘⁽

Essayez-le ici!

Compression!

Cependant, si ce Greenn’est pas le cas, cela pourrait être plus court de 3 octets: /

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!

Ohm v2 , 20 octets * 1 = 20

”1Gäåa¬Î|òÙγy[õ↕~LzN

Essayez-le en ligne!

Je dois aimer la compression, même si malheureusement ce n'est pas aussi bon que celui de SOGL.

Nettoyer , 77 octets * 3 = 231

import StdEnv
f=[[b,b..]%(0,2)\\a<-:"Qyyn*wy|xsxq6*Q|oox*\171|l+",b<-[a-'
']]

Essayez-le en ligne!

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.

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".

PowerShell , 46 octets * 4 = 184 points

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

Essayez-le en ligne!

PowerShell , 49 * 5 58 octets * 4 = 232 pts

^{-13 pts grâce à ASCII uniquement}

-join("Good m{0}rning, Green {0}rb!"-f'o'|% t*y|%{"$_"*4})

Essayez-le en ligne!

Utilise le formatage pour passer de 5 os à 4 et émettre des chiffres

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)

JavaScript (ES6), 61 octets * 3 = 183

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

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

JavaScript (ES6), 51 octets * 4 = 204

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

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

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

JavaScript (ES6), 73 octets * 4 = 292

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

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

JavaScript (ES6), 58 octets * 6 = 348

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

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

Rétine , 36 × 4 = 144

Good morning, Green orb!
.
$&$&$&$&

Essayez-le en ligne! Il y a trois nouvelles lignes et quatre os, donc il n'y a plus rien à faire.

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.

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