Nhiệm vụ của bạn là in văn bản Good morning, Green orb!, với mỗi ký tự được lặp lại tại chỗ nhiều lần như byte thường xuyên nhất trong nguồn của bạn (chế độ). Một dòng mới được cho phép và không cần phải lặp lại.

Ví dụ: nếu nguồn của bạn là

print p

Vì pxuất hiện hai lần và mỗi byte khác xuất hiện một lần bạn sẽ cần in

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Câu trả lời sẽ được tính bằng tích của số byte của chúng và số lần lặp lại đầu ra. Ví dụ, đoạn mã trên (nếu nó hoạt động) sẽ đạt điểm 7 * 2 = 14 . Mục tiêu nên là để giảm thiểu điểm số của một người.

Mã của bạn phải chứa ít nhất 1 byte.

Sử dụng chương trình này để xác minh rằng mã và đầu ra của bạn khớp

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

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

Hãy thử trực tuyến!

Giải trình

Điều đầu tiên tôi làm là đẩy chuỗi

!bro neerG ,gninrom dooG

để ngăn xếp bằng cách sử dụng chiến thuật phức tạp Kolmogorov khá phức tạp.

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

Sau đó, chúng tôi đẩy một bộ đếm vào ngăn xếp tắt để cho chúng tôi biết nhân đôi mỗi nhân vật bao nhiêu lần. Tuy nhiên tôi sẽ không thể xác định được quầy này là gì cho đến khi tôi viết xong chương trình.

Tiếp theo, chúng tôi đồng thời đảo ngược chuỗi và nhân đôi mỗi ký tự vào đúng số lần. Cụ thể là bộ đếm + 1.

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

Hai phần của chương trình có chế độ 99 dấu ngoặc đơn mở. Tuy nhiên vì chúng tôi chắc chắn sẽ cần ít nhất 1 dấu ngoặc đơn. Đây là nơi tôi nhận thấy rằng ký tự cuối cùng chúng ta đẩy !thuận tiện có mã ký tự 33, có nghĩa là chúng ta có thể sử dụng nó để tạo 99, con số chính xác mà chúng ta muốn chỉ sử dụng một dấu ngoặc đơn bổ sung. Đây là khá trùng hợp nhưng nó hoạt động.

Haskell , 37 byte × 3 = 111

-20 cảm ơn H.PWiz. -25 nhờ nimi.

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

Hãy thử trực tuyến!

Các nhà khai thác của Haskell FTW.

_{Tự nhắc nhở để không bao giờ chơi golf trên điện thoại di động. Tôi cứ mắc sai lầm ngớ ngẩn. Tôi có thể đẩy ít nhất một nửa lỗi trên di động. : P}

cân não , 235 x 77 = 18.095 điểm

Chỉnh sửa: -2 byte nhờ @Dennis

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

Hãy thử trực tuyến!

Kiểm tra TIO

Đợi đã, đây không phải là trò bowling à ?? \S

Chỉ với 8 nhân vật có thể sử dụng, brainfuck là một trong những ngôn ngữ tồi tệ nhất để thực hiện câu hỏi này. Tôi đã phải bắt đầu với việc giảm thiểu nhân vật nào chắc chắn sẽ xuất hiện nhiều nhất, điển hình là +hoặc -. Sau khi viết lần lặp đầu tiên của mã, tôi thấy nó mất cân bằng khủng khiếp theo hướng có lợi cho +s. Tôi sắp xếp lại các phần của mã, chẳng hạn như tạo số lớn hơn, để sử dụng nhiều hơn -. Cuối cùng, tôi đã kết thúc tại một bằng số lượng của hai nhân vật tại 77 một ít -hơn +. Chắc chắn có thể giảm điều này hơn nữa, mà tôi sẽ đi vào ngày mai.

Nhưng này, ít nhất tôi đã đánh bại câu trả lời Brainflak

Thạch , 13 byte * 1 = 13

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

Hãy thử trực tuyến!

Alice , 49 byte * 2 = 98 144

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

Hãy thử trực tuyến!

Giải trình

/...@
\.../

Đây là khung thông thường cho các chương trình tuyến tính hoạt động hoàn toàn trong chế độ Thông thường. Mở ra luồng điều khiển ngoằn ngoèo, chúng tôi nhận được:

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

Ý tưởng cơ bản là tránh các ký tự lặp lại nhiều hơn hai lần với sự trợ giúp của phiên âm. Phiên âm chúng ta sẽ làm như sau:

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

Cách chuyển ngữ hoạt động trong Alice là chuỗi fromvà tolần đầu tiên được lặp lại với LCM theo độ dài của chúng, mặc dù trong trường hợp này, tất cả các vấn đề là độ dài của fromchuỗi, vì vậy chúng tôi nhận được:

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

Bằng cách này, chúng tôi nhận được bốn nhân vật khác nhau để đại diện cho os, và ba từng cho n, rvà không gian. Chúng ta có thể tạo fromchuỗi bằng cách mở rộng phạm vi như sau:

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

Vấn đề duy nhất bây giờ là chúng ta cần bốn "cho cả chuỗi inputvà tochuỗi. Để tránh điều đó, chúng tôi đặt cả hai thành một chuỗi và tách nó tại =một dấu phân cách.

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

Phần còn lại chỉ là:

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

Con trăn 2 , 62 × 3 = 186

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

Hãy thử trực tuyến!

C (gcc) , ^{74 × 6 =} 444 ^{_{gạch chéo 444 vẫn là thông thường 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]);}

Hãy thử trực tuyến!

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

Cảm ơn @MDXF vì đã tiết kiệm được 9 điểm và mở đường cho 6 điểm nữa!

Hãy thử trực tuyến!

Phiên bản thay thế, ASCII có thể in, 69 × 3 = 207

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

Hãy thử trực tuyến!

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

(Chứa không thể in được)

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

Hãy thử trực tuyến!

+ Rất nhiều byte nhờ trang mã của Dyalog, cảm ơn @ Adám đã chỉ ra điều đó.

Vim, 42 41 tổ hợp phím × 3 = 123

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

Giải trình:

1. iGod morning, Green orb!<Esc>
   Viết chuỗi God morning, Green orb!( othiếu một ).
2. 2|
   Nhảy lên đầu tiên o.
3. qsyl2pl@sq
   Tạo một macro đệ quy s. Là một tác dụng phụ, gấp ba hiện tại o.
4. X0
   Hủy bỏ một ovà nhảy đến đầu.
5. @s
   Chạy macro s, lặp lại mỗi ký tự hai lần.

C, 78 × 4 = 312

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

Hãy thử trực tuyến!

356 332

Japt , 24 byte * 2 = 48

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

Chứa một không thể in. Kiểm tra nó trực tuyến!

Phần lớn chương trình chỉ là một chuỗi nén, giải nén thành

Good morning,
Green orb!

và m²sau đó mAPS mỗi nhân vật bằng cách lặp lại nó ²wice ^{sao, đó là một chút của một căng} . Space là ký tự duy nhất xuất hiện 3 lần trong chuỗi nén; để lưu một thể hiện, chúng tôi thay thế nó bằng một dòng mới, sau đó sử dụng ·¸để phân chia trên dòng mới và ngay lập tức tham gia vào khoảng trắng. Mặc dù dài hơn 2 byte, nhưng nó làm giảm đáng kể điểm số (từ 66 xuống 48).

Bây giờ nếu chỉ có một cách ngắn để làm điều đó bằng cách không sử dụng ký tự hai lần ...

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

Hãy thử trực tuyến!

yeah ........ SNOBOL yêu cầu các toán tử phải được phân tách bằng khoảng trắng và có những yêu cầu về khoảng trắng khá khó xử. Có 9 '\t'và 10 ' 'trong mã, vì vậy mọi cải tiến sẽ yêu cầu thay đổi khá đáng kể trong cách tiếp cận.

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

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

Hãy thử trực tuyến!

Có 4 (or,')nhân vật.

Ruby , 52 byte × 3 = 156

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

Hãy thử trực tuyến!

Perl 5 , 59 × 2 = 118 điểm

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

Hãy thử trực tuyến!

Perl 5 , 51 × 3 = 153156 điểm

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

Hãy thử trực tuyến!

Perl 5 , 43 × 4 = 172 điểm

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

Hãy thử trực tuyến!

Đã lưu 2 byte trong mỗi giải pháp nhờ @Xcali (một vài thay đổi trước đây). Đối với tất cả các tối ưu hóa nhìn vào các chỉnh sửa.

V , 35 byte * 2 = 70

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

Hãy thử trực tuyến!

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‘⁽

Hãy thử nó ở đây!

Nén!

Mặc dù, nếu Greenkhông được viết hoa như vậy, thì điều này có thể ngắn hơn 3 byte: /

Con trăn 2 , 62 * 4 = 248

Cảm ơn @ovs và @Giuseppe!

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

Hãy thử trực tuyến!

Python 2 , 51 * 6 = 306

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

Hãy thử trực tuyến!

Con trăn 2 , 70 * 5 = 350

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

Hãy thử trực tuyến!

Cảm ơn @Mr. Xcoder để lưu một byte từ cả hai phiên bản!

Ohm v2 , 20 byte * 1 = 20

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

Hãy thử trực tuyến!

Phải yêu nén, mặc dù tiếc là nó không tốt bằng SOGL.

Sạch , 77 byte * 3 = 231

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

Hãy thử trực tuyến!

CJam , 32 byte × 2 = 64

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

Hãy thử trực tuyến!

Đẩy một chuỗi, sau đó XOR 20 ký tự đầu tiên với [0, 1, …, 19], sau đó nhân đôi mỗi ký tự.

05AB1E , Điểm: 22 (22 byte * 1)

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

Hãy thử trực tuyến.

Giải trình:

CHÚ THÍCH 1: Ngăn xếp bọc vào danh sách dựng sẵn )được sử dụng thay cho cặp dựng sẵn ‚, vì ‚nó đã là một phần của từ điển good.
CHÚ THÍCH 2: Hai dấu phẩy trong mã ‚và ,có thể trông giống nhau, nhưng là các ký tự unicode khác nhau . Cái đầu tiên thường được sử dụng cho cặp dựng sẵn và cái thứ hai cho bản in dựng sẵn thành STDOUT với dòng mới . Trong trường hợp này, chúng được sử dụng cho từ điển goodvà dấu phẩy dự kiến ​​trong đầu ra.

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

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để sử dụng từ điển? ) Để hiểu tại sao …‚¿•´,là "good morning,"và „ˆ¨èãlà "green orbit".

PowerShell , 46 byte * 4 = 184 điểm

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

Hãy thử trực tuyến!

PowerShell , 49 * 5 58 byte * 4 = 232 điểm

^{-13 điểm chỉ nhờ ASCII}

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

Hãy thử trực tuyến!

Sử dụng định dạng để đi từ 5 ogiây đến 4 để loại bỏ một số số

Thạch , 31 byte × 2 = 62 điểm

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

Hãy thử trực tuyến!

Giải trình

“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,'$&$&$&$&')

Trả lời được đề xuất bởi @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())

Võng mạc , 36 × 4 = 144

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

Hãy thử trực tuyến! Có ba dòng mới và bốn os, vì vậy không còn gì để làm nữa.

Ruby, 55x4 = 220 điểm

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

Tôi khá bực mình vì sử dụng Each_char làm cho số 5 r ..

Đẩy , 36 * 2 = 72

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

Hãy thử trực tuyến!

Nguyên tắc chính của câu trả lời này là mỗi ký tự nđược lưu trữ như n + index - 29để tránh sự lặp lại trong chuỗi gốc. Ánh xạ này đã tạo ra chuỗi trong backticks. Phần còn lại của chương trình chỉ đơn giản là giải mã điều này và in mỗi ký tự hai lần:

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

Byte được sử dụng hai lần: `'W

Thay đổi

• Chiều dài golf từ 41 đến 38, bằng cách thay đổi phương pháp giải mã.
• Golf có chiều dài từ 38 đến 37 bằng cách trừ 29 từ mỗi ký tự được mã hóa để ngăn các ký tự đa nhân.
• Độ dài đánh gôn từ 37 đến 36 bằng cách sử dụng 'vòng lặp kết thúc' ẩn