Tugas Anda adalah mencetak teks Good morning, Green orb!, dengan setiap karakter diulangi sebanyak byte yang paling sering di sumber Anda (mode). Baris baru tambahan diizinkan dan tidak perlu diulang.

Misalnya jika sumber Anda

print p

Karena pmuncul dua kali dan setiap byte lainnya muncul begitu Anda harus mencetak

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Jawaban akan dinilai oleh produk dari jumlah byte mereka dan berapa kali output diulang. Misalnya kode di atas (jika berhasil) akan mendapat skor 7 * 2 = 14 . Tujuannya adalah untuk meminimalkan skor seseorang.

Kode Anda harus mengandung setidaknya 1 byte.

Gunakan program ini untuk memverifikasi bahwa kode dan output Anda cocok

Brain-Flak , 384 * 106 366 * 100 = 36.600

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

Cobalah online!

Penjelasan

Hal pertama yang saya lakukan adalah mendorong tali

!bro neerG ,gninrom dooG

ke tumpukan menggunakan taktik Kolmogorov-kompleksitas otak-flak cukup standar.

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

Kemudian kami mendorong penghitung ke tumpukan off untuk memberi tahu kami berapa kali untuk menduplikasi setiap karakter. Namun saya tidak akan dapat menentukan apa penghitung ini sampai saya selesai menulis program.

Selanjutnya kita secara bersamaan membalikkan string dan menduplikasi setiap karakter di tempat dengan jumlah yang benar. Khususnya penghitung + 1.

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

Kedua bagian dari program ini memiliki mode 99 tanda kurung terbuka. Namun karena kita pasti akan membutuhkan setidaknya 1 tanda kurung. Di sinilah saya perhatikan bahwa karakter terakhir yang kami dorong dengan !nyaman memiliki kode karakter 33 yang berarti kami dapat menggunakannya untuk membuat 99, angka persisnya yang kami inginkan hanya menggunakan satu kurung tambahan. Ini adalah kebetulan tetapi berhasil.

Haskell , 37 byte × 3 = 111

-20 Terima kasih kepada H.PWiz. -25 terima kasih kepada nimi.

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

Cobalah online!

Operator Haskell, FTW.

_{Pengingat diri untuk tidak pernah bermain golf di ponsel. Saya terus membuat kesalahan bodoh. Saya bisa mendorong setidaknya setengah kesalahan pada ponsel. : P}

brainfuck , 235 x 77 = 18.095 poin

Edit: -2 byte terima kasih kepada @Dennis

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

Cobalah online!

Tes TIO

Tunggu, ini bukan kode bowling ?? \ s

Dengan hanya 8 karakter yang dapat digunakan, brainfuck adalah salah satu bahasa terburuk untuk melakukan pertanyaan ini. Saya harus mulai dengan meminimalkan karakter mana yang mau tidak mau akan muncul paling, biasanya +atau -. Setelah menulis iterasi pertama dari kode, saya merasa sangat tidak seimbang dalam mendukung +s. Saya mengatur ulang bagian kode, seperti generasi nomor yang lebih besar, untuk menggunakan lebih banyak -. Akhirnya, saya akhirnya di sebuah sama besarnya dua karakter pada 77 satu kurang -dari +. Tentunya mungkin untuk mengurangi ini lebih jauh, yang akan saya coba besok.

Tapi hei, setidaknya saya mengalahkan jawaban Brainflak

Jelly , 13 byte * 1 = 13

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

Cobalah online!

Alice , 49 byte * 2 = 98 144

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

Cobalah online!

Penjelasan

/...@
\.../

Ini adalah kerangka kerja biasa untuk program linier yang beroperasi sepenuhnya dalam mode Ordinal. Membuka kontrol aliran zigzag, kita mendapatkan:

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

Ide dasarnya adalah untuk menghindari karakter yang diulang lebih dari dua kali dengan bantuan transliterasi. Transliterasi yang akan kami lakukan adalah sebagai berikut:

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

Cara transliterasi bekerja di Alice adalah string fromdan topertama kali diulang ke LCM dari panjangnya, meskipun dalam kasus ini, semua hal adalah panjang fromstring, jadi kita dapatkan:

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

Dengan cara ini, kita mendapatkan empat karakter berbeda untuk mewakili huruf os, dan tiga masing-masing untuk n, rdan ruang. Kami dapat menghasilkan fromstring menggunakan ekspansi rentang sebagai berikut:

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

Satu-satunya masalah sekarang adalah bahwa kita akan membutuhkan empat "untuk kedua inputdan tostring. Untuk menghindarinya, kita menempatkan keduanya menjadi satu string dan membaginya =menjadi pemisah.

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

Sisanya hanya:

~   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]

Cobalah online!

C (gcc) , ^{74 × 6 =} 444 ^{_{dicoret 444 masih teratur 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]);}

Cobalah online!

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

Terima kasih kepada @MDXF karena telah menghemat 9 poin dan membuka jalan untuk 6 poin lagi!

Cobalah online!

Versi alternatif, ASCII yang dapat dicetak, 69 × 3 = 207

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

Cobalah online!

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

(Berisi unsintables)

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

Cobalah online!

+ Banyak byte karena halaman kode Dyalog, terima kasih kepada @ Adám karena menunjukkannya.

Vim, 42 41 penekanan tombol × 3 = 123

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

Penjelasan:

1. iGod morning, Green orb!<Esc>
   Tulis string God morning, Green orb!(satu ohilang).
2. 2|
   Lompat ke yang pertama o.
3. qsyl2pl@sq
   Buat makro rekursif s. Sebagai efek samping, lipat tiga arus o.
4. X0
   Hapus satu odan lompat ke awal.
5. @s
   Jalankan makro s, yang ulangi setiap karakter dua kali.

C, 78 × 4 = 312

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

Cobalah online!

356 332

Japt , 24 byte * 2 = 48

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

Berisi yang tidak patut dicetak. Uji secara online!

Mayoritas program hanya berupa string terkompresi, yang didekompresi ke

Good morning,
Green orb!

dan m²kemudian maps masing-masing karakter dengan mengulanginya ²wice ^{apa-apa, itu adalah sedikit peregangan} . Spasi adalah satu-satunya karakter yang muncul 3 kali dalam string terkompresi; untuk menyimpan satu contoh, kami menggantinya dengan baris baru, lalu gunakan·¸ untuk membagi baris baru dan segera bergabung di spasi. Sementara 2 byte lebih lama, secara substansial mengurangi skor (66-48).

Sekarang seandainya ada cara singkat untuk melakukannya tanpa menggunakan karakter dua kali ...

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

Cobalah online!

ya ........ SNOBOL mengharuskan operator dipisahkan oleh spasi, dan ada persyaratan spasi yang cukup canggung. Ada 9 '\t'dan 10 ' 'dalam kode, sehingga setiap perbaikan akan membutuhkan perubahan pendekatan yang cukup signifikan.

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

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

Cobalah online!

Ada 4 (or,')karakter.

Ruby , 52 byte × 3 = 156

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

Cobalah online!

Perl 5 , 59 × 2 = 118 poin

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

Cobalah online!

Perl 5 , 51 × 3 = 153156 poin

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

Cobalah online!

Perl 5 , 43 × 4 = 172 poin

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

Cobalah online!

Disimpan 2 byte dalam setiap solusi berkat @Xcali (beberapa perubahan yang lalu). Untuk semua optimasi, lihat hasil edit.

V , 35 byte * 2 = 70

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

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

SOGL V0.12 , 16 byte * 1 = 16

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

Coba Di Sini!

Kompresi!

Padahal, jika Greentidak dikapitalisasi seperti itu, ini bisa menjadi 3 byte lebih pendek: /

Python 2 , 62 * 4 = 248

Terima kasih kepada @ovs dan @Giuseppe!

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

Cobalah online!

Python 2 , 51 * 6 = 306

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

Cobalah online!

Python 2 , 70 * 5 = 350

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

Cobalah online!

Terima kasih untuk @Mr. Xcoder untuk menyimpan byte dari kedua versi!

Ohm v2 , 20 byte * 1 = 20

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

Cobalah online!

Harus menyukai kompresi, meskipun sayangnya itu tidak sebagus SOGL.

Bersih , 77 byte * 3 = 231

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

Cobalah online!

CJam , 32 byte × 2 = 64

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

Cobalah online!

Dorong string, lalu XOR dengan 20 karakter pertama [0, 1, …, 19], lalu duplikat setiap karakter.

05AB1E , Nilai: 22 (22 byte * 1)

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

Cobalah online.

Penjelasan:

CATATAN 1: Bungkus tumpukan ke dalam daftar bawaan )digunakan sebagai ganti pasangan bawaan ‚, karena ‚sudah menjadi bagian dari kata kamus good.
CATATAN 2: Kedua koma dalam kode ‚dan ,mungkin terlihat sama, tetapi merupakan karakter unicode yang berbeda . Yang pertama biasanya digunakan untuk pasangan builtin , dan yang kedua untuk cetak builtin ke STDOUT dengan trailing newline . Dalam hal ini mereka digunakan untuk kata kamus good, dan koma yang diharapkan dalam output.

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

Lihat tip tambang 05AB1E ini (bagian Cara menggunakan kamus? ) Untuk memahami mengapa …‚¿•´,ini "good morning,"dan „ˆ¨èãitu "green orbit".

PowerShell , 46 byte * 4 = 184 poin

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

Cobalah online!

PowerShell , 49 * 5 58 byte * 4 = 232 poin

^{-13 Poin berkat ASCII saja}

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

Cobalah online!

Menggunakan pemformatan untuk beralih dari 5 os ke 4 untuk memecahkan beberapa angka

Jelly , 31 byte × 2 = 62 poin

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

Cobalah online!

Penjelasan

“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 byte * 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 byte * 4 = 204

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

Jawaban yang disarankan oleh @ETHproductions .

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

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

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

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

Retina , 36 × 4 = 144

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

Cobalah online! Ada tiga baris baru dan empat o, jadi tidak ada lagi yang bisa dilakukan.

Ruby, 55x4 = 220 poin

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

Saya cukup kesal karena menggunakan each_char membuat hitungan r's 5 ..

Pushy , 36 * 2 = 72

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

Cobalah online!

Prinsip utama dari jawaban ini adalah bahwa setiap karakter ndisimpan sebagai n + index - 29untuk menghindari pengulangan dalam string asli. Pemetaan ini menciptakan string di backticks. Program lainnya hanya menerjemahkan ini dan mencetak setiap karakter dua kali:

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

Bytes digunakan dua kali: `'W

Changelog

• Panjang golf dari 41 ke 38, dengan mengubah metode decoding.
• Panjang golf dari 38 hingga 37 dengan mengurangi 29 dari setiap karakter yang disandikan untuk mencegah karakter multibyte.
• Panjang golf dari 37 hingga 36 dengan menggunakan 'ujung lingkaran' implisit