42
\$\begingroup\$

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

\$\endgroup\$
6
  • \$\begingroup\$ Functions are allowed, right? \$\endgroup\$ Dec 28, 2017 at 20:05
  • 1
    \$\begingroup\$ @totallyhuman Yes, so long as they don't take input. \$\endgroup\$
    – Wheat Wizard
    Dec 28, 2017 at 20:05
  • 1
    \$\begingroup\$ Shouldn't this be tagged quine? \$\endgroup\$ Dec 29, 2017 at 16:12
  • \$\begingroup\$ Morning can't be capitalized, can it haha? \$\endgroup\$ Jan 10, 2018 at 19:56
  • \$\begingroup\$ @magicoctopusurn Nope the text should be the same. \$\endgroup\$
    – Wheat Wizard
    Jan 10, 2018 at 20:06

44 Answers 44

19
\$\begingroup\$

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.

\$\endgroup\$
2
  • 10
    \$\begingroup\$ Ah yes, just pretty standard brain-flak Kolmogorov-complexity tactics. Those are the thing. \$\endgroup\$ Dec 30, 2017 at 2:49
  • \$\begingroup\$ You, my good fellow, must be mad to even try this. I'm just going to +1 and walk away before my brain explodes from trying to understand all the brackets. \$\endgroup\$ Jan 3, 2018 at 14:51
15
\$\begingroup\$

Jelly, 13 bytes * 1 = 13

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

Try it online!

\$\endgroup\$
5
  • 3
    \$\begingroup\$ Finally someone manages the elusive *1 answer. I had a feeling Jelly would be the language to do it... \$\endgroup\$ Dec 28, 2017 at 20:25
  • \$\begingroup\$ @ETHproductions Haha, just halved my code while keeping * 1 \$\endgroup\$
    – Mr. Xcoder
    Dec 28, 2017 at 20:27
  • \$\begingroup\$ Haha dang I just found that right after you edited it \$\endgroup\$
    – dylnan
    Dec 28, 2017 at 20:30
  • \$\begingroup\$ Out of curiousity, what exactly is the difference? How is the new compressed string half the length of the old one? \$\endgroup\$ Dec 28, 2017 at 20:30
  • \$\begingroup\$ @ETHproductions I basically used a non-optimal compressed string at first, then I used the optimised Jelly compressor which found the matches in the dictionary. \$\endgroup\$
    – Mr. Xcoder
    Dec 28, 2017 at 20:32
15
\$\begingroup\$

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

\$\endgroup\$
2
  • 5
    \$\begingroup\$ Using <* to save bytes (Note that I haven't checked its validity) \$\endgroup\$
    – H.PWiz
    Dec 28, 2017 at 20:42
  • \$\begingroup\$ ...Bloody hell, Haskell almost has too many operators. Thanks! \$\endgroup\$ Dec 28, 2017 at 20:44
15
\$\begingroup\$

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

\$\endgroup\$
1
  • \$\begingroup\$ Hey, congratulations! I can't believe that it's even possible to do this in BF... Pretty if it can be done in the ;# language ( ͡° ͜ʖ ͡°) \$\endgroup\$
    – RedClover
    Dec 29, 2017 at 18:45
10
\$\begingroup\$

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.
\$\endgroup\$
7
\$\begingroup\$

C (gcc), 74×6=444crossed 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!

\$\endgroup\$
3
  • 18
    \$\begingroup\$ o0 wat did you do to your post header \$\endgroup\$ Dec 28, 2017 at 20:35
  • 12
    \$\begingroup\$ had a bit of fun \$\endgroup\$
    – betseg
    Dec 28, 2017 at 20:41
  • 1
    \$\begingroup\$ where did the crossed out 44 meta post go? \$\endgroup\$
    – NieDzejkob
    Jan 1, 2018 at 18:40
6
\$\begingroup\$

Python 2, 62 × 3 = 186

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

Try it online!

\$\endgroup\$
6
\$\begingroup\$

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.
\$\endgroup\$
5
\$\begingroup\$

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!

\$\endgroup\$
1
5
\$\begingroup\$

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.

\$\endgroup\$
3
  • \$\begingroup\$ 84 \$\endgroup\$
    – Adám
    Dec 28, 2017 at 20:34
  • \$\begingroup\$ That's really genius, @Adám \$\endgroup\$
    – Adalynn
    Dec 28, 2017 at 20:45
  • \$\begingroup\$ I'm afraid you have to settle for 92 since ~⎕AV∊⍨⎕UCS 18. \$\endgroup\$
    – Adám
    Dec 28, 2017 at 23:08
4
\$\begingroup\$

C, 78 × 4 = 312

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

Try it online!

356 332

\$\endgroup\$
2
  • \$\begingroup\$ Commenting because I'm tired of finding it in my browser history every time I want to golf: I used this to find the number of character repetitions. \$\endgroup\$
    – MD XF
    Dec 29, 2017 at 23:47
  • \$\begingroup\$ And this to encode the string. \$\endgroup\$
    – MD XF
    Dec 29, 2017 at 23:57
3
\$\begingroup\$

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

\$\endgroup\$
7
  • \$\begingroup\$ Because I can't see it: which character is in the source three times? I see several things that have a count of 2, but not 3. \$\endgroup\$ Dec 28, 2017 at 20:14
  • 1
    \$\begingroup\$ @Draco18s None, the score is 24*2. \$\endgroup\$ Dec 28, 2017 at 20:16
  • \$\begingroup\$ Then the output is wrong. You're printing each character 3 times instead of twice. \$\endgroup\$ Dec 28, 2017 at 20:17
  • \$\begingroup\$ @Draco18s Dangit, posted the wrong link... Thanks for pointing that out. \$\endgroup\$ Dec 28, 2017 at 20:18
  • \$\begingroup\$ *salute* And now that I look at your answer I see it has ² whereas the link had ³ :) \$\endgroup\$ Dec 28, 2017 at 20:19
3
\$\begingroup\$

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.

\$\endgroup\$
3
\$\begingroup\$

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.

\$\endgroup\$
1
  • 2
    \$\begingroup\$ I've never seen strrep before, that should come in handy. \$\endgroup\$
    – BLT
    Dec 29, 2017 at 16:02
3
\$\begingroup\$

Ruby, 52 bytes × 3 = 156

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

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Nice way to avoid repeating characters \$\endgroup\$ Dec 29, 2017 at 16:37
3
\$\begingroup\$

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.

\$\endgroup\$
3
  • \$\begingroup\$ Making this a program instead of a function would save 2 bytes (4 points): Try it online! \$\endgroup\$
    – Xcali
    Dec 30, 2017 at 6:53
  • \$\begingroup\$ @Xcali, but your change needs a nonstandard option -M5.010, which also counts \$\endgroup\$
    – mik
    Dec 31, 2017 at 18:09
  • \$\begingroup\$ That one is free: codegolf.meta.stackexchange.com/questions/11924/… \$\endgroup\$
    – Xcali
    Jan 2, 2018 at 3:51
2
\$\begingroup\$

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                                  /..
\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
0
2
\$\begingroup\$

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!

\$\endgroup\$
4
  • \$\begingroup\$ You can remove the space between 6 and for. \$\endgroup\$
    – Mr. Xcoder
    Dec 28, 2017 at 20:33
  • \$\begingroup\$ @Mr.Xcoder Thanks! \$\endgroup\$
    – Steadybox
    Dec 28, 2017 at 20:36
  • \$\begingroup\$ 57*4=228 \$\endgroup\$
    – ovs
    Dec 28, 2017 at 22:23
  • \$\begingroup\$ @ovs that's not quite right, I think you need two \x6fs which is still good for 244 \$\endgroup\$
    – Giuseppe
    Dec 28, 2017 at 22:53
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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!

\$\endgroup\$
0
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

PowerShell, 46 bytes * 4 = 184 points

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

Try it online!

\$\endgroup\$
3
  • 1
    \$\begingroup\$ That's clever. I completely forgot about $0 \$\endgroup\$
    – Veskah
    Feb 12, 2019 at 21:22
  • \$\begingroup\$ :| wait i tried this but only after doing the format so it didn't work as well as this did \$\endgroup\$
    – ASCII-only
    Feb 16, 2019 at 11:55
  • \$\begingroup\$ ¯\_(ツ)_/¯ what about TIO link? \$\endgroup\$
    – mazzy
    Feb 16, 2019 at 18:28
2
\$\begingroup\$

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

\$\endgroup\$
2
  • 2
    \$\begingroup\$ 232? \$\endgroup\$
    – ASCII-only
    Feb 12, 2019 at 8:52
  • \$\begingroup\$ close \$\endgroup\$
    – ASCII-only
    Feb 12, 2019 at 9:02
2
\$\begingroup\$

Vyxal, 19 bytes, score 38

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

Try it Online!

‛ƛ⁋                 # Compressed string
   `øø, ×ŀ ⋎Ė!`     # Compressed string
               "Ṅ   # Pair and join by spaces
                 2• # Double each character
\$\endgroup\$
4
  • \$\begingroup\$ Am I foolish, or is space thrice present? \$\endgroup\$ Nov 18, 2021 at 4:42
  • \$\begingroup\$ @thejonymyster slaps face fixing \$\endgroup\$
    – emanresu A
    Nov 18, 2021 at 4:42
  • 1
    \$\begingroup\$ @thejonymyster Fixed. \$\endgroup\$
    – emanresu A
    Nov 18, 2021 at 4:47
  • \$\begingroup\$ nice 38 score :D \$\endgroup\$ Nov 18, 2021 at 5:03
1
\$\begingroup\$

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)
\$\endgroup\$
0
1
\$\begingroup\$

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

\$\endgroup\$
3
  • \$\begingroup\$ Alternatively, change _=>_ to '$&' \$\endgroup\$ Dec 28, 2017 at 20:19
  • 1
    \$\begingroup\$ Alternaternatively, I think you can just do '$&$&$&$&$&$&' for the replacement, which then I think allows you remove two instances and go down to having several characters tied at 4, drastically reducing the score... \$\endgroup\$ Dec 28, 2017 at 20:21
  • \$\begingroup\$ @ETHproductions Thanks, didn't know about that replacement pattern! \$\endgroup\$
    – darrylyeo
    Dec 28, 2017 at 20:30
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.