A Programming Puzzle of Mode Golf

Question

Your task is to print the text Good morning, Green orb!, with every character repeated in place as many times as the most frequent byte in your source (the mode). A trailing newline is permitted and need not be repeated.

For example if your source was

print p

Since p appears twice and every other byte appears once you would need to print

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Answers will be scored by the product of their byte count and the number of times the output is repeated. For example the above code (if it worked) would score 7*2 = 14. The goal should be to minimize one's score.

Your code must contain at least 1 byte.

Use this program to verify that your code and output match

Answer 1

Brain-Flak, 384 * 106 366 * 100 = 36,600

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

Try it online!

Explanation

The first thing I do is push the string

!bro neerG ,gninrom dooG

to the stack using pretty standard brain-flak Kolmogorov-complexity tactics.

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

Then we push a counter to the off stack to tell us how many times to duplicate each character. However I wasn't going to be able to determine what this counter was until I was done writing the program.

Next up we simultaneously reverse the string and duplicate each character in place the correct number of times. Specifically the counter + 1.

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

These two parts of the program have a mode of 99 open parentheses. However since we are most certainly going to need at least 1 parenthesis. Here is where I noticed that the last character we pushed ! conveniently has character code 33 which means we can use it to create 99, the exact number we want using only one additional parenthesis. This is quite the coincidence but it works.

Answer 2

Jelly, 13 bytes * 1 = 13

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

Try it online!

Answer 3

Haskell, 37 bytes × 3 = 111

-20 thanks to H.PWiz. -25 thanks to nimi.

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

Try it online!

Haskell's operators FTW.

_{Self-reminder to never golf on mobile. I keep making dumb mistakes. I can push at least half the blame on mobile. :P}

Answer 4

brainfuck, 235 x 77 = 18,095 points

Edit: -2 bytes thanks to @Dennis

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

Try it online!

TIO test

Wait, this isn’t code bowling?? \s

With only 8 usable characters, brainfuck is one of the worst languages to do this question. I had to start with minimising which character would inevitably appear the most, typically either + or -. After writing the first iteration of the code, I found it horribly unbalanced in favour of +s. I rearranged parts of the code, such as generation of larger numbers, to use more -. Finally, I ended up at an equal amount of the two characters at 77 one less - than +. It’s certainly possible to reduce this further, which I’ll have a go at tomorrow.

But hey, at least I beat the Brainflak answer

Answer 5

Alice, 49 bytes * 2 = 98 144

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

Try it online!

Explanation

/...@
\.../

This is the usual framework for linear programs that operate entirely in Ordinal mode. Unfolding the zigzag control flow, we get:

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

The basic idea is to avoid characters which repeat more than twice with the help of a transliteration. The transliteration we're going to do is the following:

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

The way transliteration works in Alice is that the from and to strings are first repeated to the LCM of their lengths, although in this case, all the matters is the length of the from string, so we get:

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

This way, we get four different characters to represent the os, and three each for n, r and the space. We can generate the from string using range expansion as follows:

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

The only issue now is that we'd need four " for both the input and the to string. To avoid that, we put them both into a single string and split it at a = used as a separator.

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

The rest is just:

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

Answer 6

C (gcc), ^74×6=444^{_{crossed out 444 is still regular 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]);}

Try it online!

Answer 7

Python 2, 62 × 3 = 186

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

Try it online!

Answer 8

Vim, 42 41 keystrokes × 3 = 123

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

Explanation:

1. iGod morning, Green orb!<Esc>
   Write the string God morning, Green orb! (one o missing).
2. 2|
   Jump to the first o.
3. qsyl2pl@sq
   Create a recursive macro s. As a side effect, triple the current o.
4. X0
   Remove one o and jump to the beginning.
5. @s
   Run the macro s, which repeat each character twice.

Answer 9

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                                      ]);}

Thanks to @MDXF for saving 9 points and paving the way for 6 more!

Try it online!

Alternate version, printable ASCII, 69 × 3 = 207

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

Try it online!

Answer 10

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

(Contains unprintables)

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

Try it online!

+Alot of bytes thanks to Dyalog's code page, thanks to @Adám for pointing that out.

Answer 11

C, 78 × 4 = 312

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

Try it online!

356 332

Answer 12

Japt, 24 bytes * 2 = 48

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

Contains an unprintable. Test it online!

The majority of the program is just a compressed string, which decompresses to

Good morning,
Green orb!

and m² then maps each character by repeating it ²wice ^{okay, that was a bit of a stretch}. Space is the only character that appears 3 times in the compressed string; to save one instance we replace it with a newline, then use ·¸ to split on newlines and immediately join on spaces. While 2 bytes longer, it substantially reduces the score (from 66 to 48).

Now if only there were a short way to do it using no character twice...

Answer 13

SNOBOL4 (CSNOBOL4), 97 bytes * 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

Try it online!

yeah........SNOBOL requires operators to be separated by whitespace, and there are whitespace requirements that are quite awkward. There are 9 '\t' and 10 ' ' in the code, so any improvements will require a fairly significant change in approach.

Answer 14

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

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

Try it online!

There are 4 (or,') characters.

Answer 15

Ruby, 52 bytes × 3 = 156

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

Try it online!

Answer 16

Perl 5, 59 × 2 = 118 points

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

Try it online!

Perl 5, 51 × 3 = 153 156 points

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

Try it online!

Perl 5, 43 × 4 = 172 points

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

Try it online!

Saved 2 bytes in each solution thanks to @Xcali (a few changes ago). For all optimizations look at the edits.

Answer 17

V, 35 bytes * 2 = 70

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

Try it online!

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

Answer 18

SOGL V0.12, 16 bytes * 1 = 16

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

Try it Here!

Compression!

Though, if Green wasn't capitalized like that, this could be 3 bytes shorter :/

Answer 19

Python 2, 62*4 = 248

Thanks to @ovs and @Giuseppe!

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

Try it online!

Python 2, 51*6 = 306

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

Try it online!

Python 2, 70*5 = 350

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

Try it online!

Thanks to @Mr. Xcoder for saving a byte from both versions!

Answer 20

Ohm v2, 20 bytes * 1 = 20

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

Try it online!

Gotta love compression, although unfortunately it's not as good as SOGL's.

Answer 21

Clean, 77 bytes * 3 = 231

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

Try it online!

Answer 22

CJam, 32 bytes × 2 = 64

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

Try it online!

Pushes a string, then XORs the first 20 character with [0, 1, …, 19], then duplicates each character.

Answer 23

05AB1E, Score: 22 (22 bytes * 1)

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

Try it online.

Explanation:

NOTE 1: The wrap stack into list builtin ) is used instead of the builtin pair ‚, because the ‚ is already part of the dictionary word good.
NOTE 2: The two commas in the code ‚ and , may look the same, but are different unicode characters. The first one is usually used for the builtin pair, and the second for the builtin print to STDOUT with trailing newline. In this case they are used for the dictionary word good, and the expected comma in the output however.

…‚¿•´,        # 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)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why …‚¿•´, is "good morning," and „ˆ¨èã is "green orbit".

Answer 24

PowerShell, 46 bytes * 4 = 184 points

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

Try it online!

Answer 25

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

^{-13 pts thanks to ASCII-only}

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

Try it online!

Uses formatting to go from 5 os to 4 to chip out some numbers

Answer 26

Vyxal, 19 bytes, score 38

‛ƛ⁋`øø, ×ŀ ⋎Ė!`"Ṅ2•

Try it Online!

‛ƛ⁋                 # Compressed string
   `øø, ×ŀ ⋎Ė!`     # Compressed string
               "Ṅ   # Pair and join by spaces
                 2• # Double each character

Answer 27

Jelly, 31 bytes × 2 = 62 points

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

Try it online!

Explanation

“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)

Answer 28

JavaScript (ES6), 61 bytes * 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 bytes * 4 = 204

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

Answer suggested by @ETHproductions.

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

JavaScript (ES6), 73 bytes * 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 bytes * 6 = 348

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

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

Answer 29

Retina, 36×4=144

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

Try it online! There are three newlines and four os, so there's nothing more to be done.

Answer 30

Ruby, 55x4 = 220 points

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

Im quite annoyed that using each_char makes the count of r's 5..