ปริศนาการเขียนโปรแกรมของโหมดกอล์ฟ

43

งานของคุณคือการพิมพ์ข้อความGood morning, Green orb!โดยให้ตัวละครทุกตัวซ้ำหลาย ๆ ครั้งซึ่งเป็นไบต์ที่บ่อยที่สุดในแหล่งที่มาของคุณ (โหมด) บรรทัดใหม่ต่อท้ายได้รับอนุญาตและไม่จำเป็นต้องทำซ้ำ

ตัวอย่างเช่นถ้าแหล่งที่มาของคุณคือ

print p

เนื่องจากpปรากฏสองครั้งและทุกไบต์อื่น ๆ จะปรากฏขึ้นเมื่อคุณต้องการพิมพ์

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

คำตอบจะได้คะแนนจากผลคูณของจำนวนไบต์และจำนวนครั้งที่ส่งออกซ้ำ ตัวอย่างเช่นโค้ดข้างต้น (ถ้ามันทำงาน) จะให้คะแนน7 * 2 = 14 เป้าหมายควรเพื่อลดคะแนน

รหัสของคุณต้องมีอย่างน้อย 1 ไบต์

ใช้โปรแกรมนี้เพื่อตรวจสอบว่ารหัสและผลลัพธ์ของคุณตรงกัน

code-challenge  kolmogorov-complexity  hello-world  self-referential 
— ข้าวสาลีวิซาร์ด
แหล่งที่มา
อนุญาตให้ใช้งานได้ใช่ไหม
— มนุษย์
1
@tallyallyhuman ใช่แล้วตราบใดที่พวกเขาไม่รับข้อมูล
— ข้าวสาลีตัวช่วยสร้าง
1
สิ่งนี้ไม่ควรถูกแท็กquineหรือไม่
— FantaC
เช้าไม่สามารถพิมพ์ใหญ่ได้ใช่ไหมฮ่าฮ่า?
— Magic Octopus Urn
@magicoctopusurn ไม่ข้อความควรจะเหมือนกัน
— ข้าวสาลีตัวช่วยสร้าง

คำตอบ:

18

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

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

ลองออนไลน์!

คำอธิบาย

สิ่งแรกที่ฉันทำคือกดสตริง

!bro neerG ,gninrom dooG

ไปยังสแต็กโดยใช้กลลอฟ Kolmogorov ที่ซับซ้อนและมีมาตรฐานในสมอง

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

จากนั้นเราดันตัวนับไปที่สแต็กปิดเพื่อบอกให้เราทราบถึงจำนวนครั้งในการทำซ้ำอักขระแต่ละตัว อย่างไรก็ตามฉันจะไม่สามารถระบุได้ว่าตัวนับนี้คืออะไรจนกระทั่งฉันเขียนโปรแกรมเสร็จ

ต่อไปเราจะย้อนกลับสตริงพร้อมกันและทำซ้ำอักขระแต่ละตัวในจำนวนครั้งที่ถูกต้อง ตัวนับ + 1 โดยเฉพาะ

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

โปรแกรมสองส่วนนี้มีโหมดวงเล็บเปิด 99 อัน อย่างไรก็ตามเนื่องจากเราต้องการวงเล็บอย่างน้อยที่สุด นี่คือที่ฉันสังเกตเห็นว่าตัวละครตัวสุดท้ายที่เราผลัก!ได้อย่างสะดวกมีรหัสตัวอักษร 33 ซึ่งหมายความว่าเราสามารถใช้มันเพื่อสร้าง 99 จำนวนที่แน่นอนที่เราต้องการโดยใช้วงเล็บเพิ่มเติมเพียงหนึ่ง นี่เป็นเรื่องบังเอิญ แต่มันได้ผล

— ข้าวสาลีวิซาร์ด
แหล่งที่มา
9
อ่าใช่แค่สมองกล่อมเกลากลเม็ดที่ซับซ้อนของ Kolmogorov นั่นคือสิ่งที่
— John Keates
คุณ, เพื่อนที่ดีของฉัน, ต้องบ้าไปเลยแม้แต่ลอง ฉันจะ +1 และเดินออกไปก่อนที่สมองของฉันจะระเบิดจากการพยายามทำความเข้าใจกับวงเล็บทั้งหมด
— caird coinheringaahing
15

Haskell , 37 ไบต์× 3 = 111

-20 ขอบคุณ H.PWiz -25 ขอบคุณ nimi

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

ลองออนไลน์!

ผู้ประกอบการของ Haskell FTW

เตือนตัวเองให้ไม่เล่นกอล์ฟบนมือถือ ฉันทำผิดพลาดโง่ ๆ ฉันสามารถโทษอย่างน้อยครึ่งหนึ่งบนมือถือ : P

— totallyhuman
แหล่งที่มา
5
ใช้<*เพื่อบันทึกไบต์ (โปรดทราบว่าฉันไม่ได้ตรวจสอบความถูกต้อง)
— H.PWiz
... เลือดบ้า ๆ Haskell มีผู้ให้บริการมากเกินไป ขอบคุณ!
— สิ้นเชิงมนุษย์
15

brainfuck , 235 x 77 = 18,095 คะแนน

แก้ไข: -2 ไบต์ขอบคุณ @Dennis

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

ลองออนไลน์!

ทดสอบ TIO

เดี๋ยวก่อนนี่ไม่ใช่รหัสโบลิ่ง? \ s

มีเพียง 8 ตัวอักษรที่สามารถใช้งานได้ brainfuck เป็นหนึ่งในภาษาที่แย่ที่สุดที่จะทำคำถามนี้ ผมต้องเริ่มต้นด้วยการลดที่ตัวละครย่อมจะปรากฏมากที่สุดโดยทั่วไปอย่างใดอย่างหนึ่งหรือ+ -หลังจากที่เขียนซ้ำแรกของรหัสที่ผมพบว่ามันน่ากลัวไม่สมดุลในความโปรดปรานของ+s -ผมจัดใหม่ชิ้นส่วนของรหัสเช่นรุ่นของตัวเลขขนาดใหญ่กับการใช้งานมากขึ้น สุดท้ายผมลงเอยที่เท่ากับปริมาณของตัวละครสองตัวที่ 77น้อยกว่า เป็นไปได้อย่างแน่นอนที่จะลดสิ่งนี้ลงอีกซึ่งฉันจะไปในวันพรุ่งนี้-+

แต่เดี๋ยวก่อนอย่างน้อยฉันก็เอาชนะBrainflak ได้

— โจคิง
แหล่งที่มา
เฮ้ขอแสดงความยินดีด้วย! ฉันไม่อยากจะเชื่อเลยว่ามันเป็นไปได้ที่จะทำเช่นนี้ใน BF ... ถ้ามันสามารถทำได้ใน;#ภาษา (͡°͜ʖ͡°)
— RedClover
13

เยลลี่ , 13 ไบต์ * 1 = 13

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

ลองออนไลน์!

— นาย Xcoder
แหล่งที่มา
3
ในที่สุดก็มีคนจัดการคำตอบที่เข้าใจยาก * 1 ฉันมีความรู้สึกว่าเยลลี่จะเป็นภาษาที่จะทำ ...
— ETHproductions
@ETHproductions ฮ่าฮ่าแค่แบ่งครึ่งรหัสของฉันในขณะที่รักษา * 1
— Mr. Xcoder
ฮ่าฮ่าแดงฉันเพิ่งพบว่าหลังจากคุณแก้ไขมัน
— dylnan
ความแตกต่างคืออะไร? สตริงที่ถูกบีบอัดใหม่มีความยาวครึ่งหนึ่งได้อย่างไร
— ETHproductions
@ ETHproductions โดยทั่วไปแล้วฉันใช้สตริงที่ไม่บีบอัดที่เหมาะสมที่สุดในตอนแรกจากนั้นฉันใช้Jelly jelly ที่ปรับให้เหมาะสมซึ่งพบการจับคู่ในพจนานุกรม
— Mr. Xcoder
10

อลิซ 49 ไบต์ * 2 = 98 144

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

ลองออนไลน์!

คำอธิบาย

/...@
\.../

นี่เป็นกรอบปกติสำหรับโปรแกรมเชิงเส้นที่ทำงานทั้งหมดในโหมด Ordinal ตีแผ่การควบคุมการไหลของซิกแซกเราได้รับ:

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

แนวคิดพื้นฐานคือการหลีกเลี่ยงตัวละครที่ทำซ้ำมากกว่าสองครั้งด้วยความช่วยเหลือของการทับศัพท์ การทับศัพท์ที่เรากำลังจะทำคือ:

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

วิธีการทับศัพท์ทำงานในอลิซก็คือfromและtoสตริงถูกทำซ้ำกับ LCM ของความยาวของพวกเขาเป็นครั้งแรกแม้ว่าในกรณีนี้ทุกเรื่องคือความยาวของfromสตริงดังนั้นเราจึงได้รับ:

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

วิธีนี้เราได้รับสี่ตัวอักษรที่แตกต่างกันเพื่อเป็นตัวแทนของos และสามแต่ละn, rและพื้นที่ เราสามารถสร้างfromสตริงโดยใช้การขยายช่วงดังนี้:

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

ปัญหาเดียวตอนนี้คือเราต้องการสี่"สำหรับทั้งinputและtoสตริง เพื่อหลีกเลี่ยงปัญหานั้นเราจึงใส่ทั้งสองเข้าไปในสายเดี่ยวและแยกมันที่=ใช้เป็นตัวคั่น

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

ที่เหลือก็แค่:

~   Swap "from" and "to".
y   Transliterate.
.Z  Duplicate and interleave. This duplicates each character.
o   Print.
@   Terminate the program.
— Martin Ender
แหล่งที่มา
6

C (gcc) , 74 × 6 = 444 ข้าม 444 ยังคงเป็นปกติ 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]);}

ลองออนไลน์!

— betseg
แหล่งที่มา
16
o0 คุณทำกับส่วนหัวของโพสต์ของคุณ
— สิ้นเชิงมนุษย์
9
สนุก
— นิดหน่อย
เมตาโพสต์ที่ถูกขีดฆ่าไปแล้ว 44 แห่งไปจากที่ใด
— NieDzejkob
5

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

ขอบคุณ @MDXF สำหรับการบันทึก 9 คะแนนและปูทางไปอีก 6!

ลองออนไลน์!

รุ่นสำรอง, ASCII ที่พิมพ์ได้, 69 × 3 = 207

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

ลองออนไลน์!

— เดนนิส
แหล่งที่มา
ขอให้เรายังคงอภิปรายนี้ในการแชท
— เดนนิส
5

APL (Dyalog Unicode) , 46 ไบต์× 2 = 92

(มี unprintables)

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

ลองออนไลน์!

+ ไบต์จำนวนมากต้องขอบคุณหน้ารหัสของ Dyalog ขอบคุณ @ Adámที่ชี้ให้เห็น

— Zachary
แหล่งที่มา
84
— อดัม
นั่นเป็นอัจฉริยะจริงๆ @ Adám
— Zacharý
ฉันเกรงว่าคุณต้องชำระสำหรับ92~⎕AV∊⍨⎕UCS 18ตั้งแต่
— อดัม
5

เป็นกลุ่ม42 42 การกดแป้น× 3 = 123

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

คำอธิบาย:

  1. iGod morning, Green orb!<Esc>
    เขียนสตริงGod morning, Green orb!( oขาดหายไปหนึ่งอัน)
  2. 2|
    oข้ามไปที่แรก
  3. qsyl2pl@sq
    sสร้างแมโคร recursive oเป็นผลข้างเคียงที่สามในปัจจุบัน
  4. X0
    ลบหนึ่งoและข้ามไปที่จุดเริ่มต้น
  5. @s
    เรียกใช้แมโครsซึ่งทำซ้ำแต่ละอักขระสองครั้ง
— user285259
แหล่งที่มา
4

C, 78 × 4 = 312

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

ลองออนไลน์!

356 332

— MD XF
แหล่งที่มา
การแสดงความคิดเห็นเพราะฉันเบื่อที่จะค้นพบมันในประวัติเบราว์เซอร์ของฉันทุกครั้งที่ฉันต้องการตีกอล์ฟ: ฉันใช้สิ่งนี้เพื่อค้นหาจำนวนตัวอักษรซ้ำ
— MD XF
และนี่เพื่อเข้ารหัสสตริง
— MD XF
3

Japt , 24 ไบต์ * 2 = 48

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

ประกอบด้วย unprintable ทดสอบออนไลน์!

โปรแกรมส่วนใหญ่เป็นเพียงสายอักขระที่ถูกบีบอัดซึ่งขยายไปถึง

Good morning,
Green orb!

และm²แล้วmaps ตัวละครแต่ละตัวโดยการทำซ้ำมัน²wiceโอเคที่เป็นบิตของการยืด Space เป็นอักขระตัวเดียวที่ปรากฏขึ้น 3 ครั้งในสตริงที่บีบอัด เพื่อบันทึกหนึ่งอินสแตนซ์เราจะแทนที่ด้วยการขึ้นบรรทัดใหม่จากนั้นใช้·¸เพื่อแยกบรรทัดใหม่และเข้าร่วมในช่องว่างทันที ในขณะที่อีก 2 ไบต์จะลดคะแนนลงอย่างมาก (จาก 66 เป็น 48)

ทีนี้ถ้ามีวิธีสั้น ๆ ที่จะทำโดยไม่มีตัวอักษรสองครั้ง ...

— ETHproductions
แหล่งที่มา
เพราะฉันไม่เห็น: ตัวละครตัวไหนที่อยู่ในแหล่งสามครั้ง? ฉันเห็นหลายสิ่งหลายอย่างที่มีจำนวนนับ 2 แต่ไม่ใช่ 3
— Draco18s
1
@ Draco18s ไม่มีคะแนนคือ 24 * 2
— ETHproductions
จากนั้นผลลัพธ์ก็ผิด คุณกำลังพิมพ์อักขระแต่ละตัว 3 ครั้งแทนที่จะเป็นสองครั้ง
— Draco18s
@ Draco18s Dangit โพสต์ลิงก์ผิด ... ขอบคุณที่ชี้ให้เห็น
— ETHproductions
*salute*และตอนนี้ที่ฉันดูคำตอบของคุณฉันเห็นว่ามันมี²ในขณะที่การเชื่อมโยงมี³ :)
— Draco18s
3

SNOBOL4 (CSNOBOL4) , 97 ไบต์ * 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

ลองออนไลน์!

ใช่ ........ SNOBOL ต้องการตัวดำเนินการแยกด้วยช่องว่างและมีข้อกำหนดของช่องว่างที่ค่อนข้างอึดอัด ในรหัสมี 9 '\t'และ 10 ' 'ดังนั้นการปรับปรุงใด ๆ จะต้องมีการเปลี่ยนแปลงที่สำคัญในวิธีการ

— จูเซปเป้
แหล่งที่มา
3

Perl 5 , 59 × 2 = 118 คะแนน

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

ลองออนไลน์!

Perl 5 , 51 × 3 = 153156 จุด

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

ลองออนไลน์!

Perl 5 , 43 × 4 = 172 คะแนน

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

ลองออนไลน์!

บันทึก 2 ไบต์ในโซลูชันแต่ละรายการด้วย @Xcali (การเปลี่ยนแปลงเล็กน้อยที่ผ่านมา) สำหรับการเพิ่มประสิทธิภาพทั้งหมดดูที่การแก้ไข

— MIK
แหล่งที่มา
การทำให้โปรแกรมนี้เป็นโปรแกรมแทนฟังก์ชั่นจะประหยัด 2 ไบต์ (4 คะแนน): ลองออนไลน์!
— Xcali
@Xcali แต่การเปลี่ยนแปลงของคุณต้องเป็นตัวเลือกที่ไม่เป็นมาตรฐาน-M5.010ซึ่งยังนับ
— MIK
— Xcali
2

Python 2 , 62 * 4 = 248

ขอบคุณ @ovs และ @Giuseppe!

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

ลองออนไลน์!

Python 2 , 51 * 6 = 306

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

ลองออนไลน์!

Python 2 , 70 * 5 = 350

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

ลองออนไลน์!

ขอบคุณ @Mr Xcoder สำหรับบันทึกไบต์จากทั้งสองรุ่น!

— Steadybox
แหล่งที่มา
คุณสามารถลบช่องว่างระหว่างและ6 for
— Mr. Xcoder
@ Mr.Xcoder ขอบคุณ!
— Steadybox
— ovs
@ovs ที่ไม่ถูกต้องฉันคิดว่าคุณต้องการสอง \x6f s ซึ่งยังคงดีสำหรับ 244
— Giuseppe
2

05AB1E , คะแนน: 22 (22 ไบต์ * 1)

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

ลองออนไลน์

คำอธิบาย:

หมายเหตุ 1: wrap stack เข้าในรายการบิวด์อิน)ถูกใช้แทนคู่ บิว‚ด์เนื่องจาก‚เป็นส่วนหนึ่งของคำในพจนานุกรมgoodอยู่แล้ว
หมายเหตุ 2: สองจุลภาคในรหัส‚และ,อาจมีลักษณะเดียวกันแต่จะมีตัวอักษร Unicode ที่แตกต่างกัน คนแรกที่มักจะใช้สำหรับ builtin คู่และที่สองสำหรับ builtin พิมพ์เพื่อ STDOUT กับท้ายบรรทัดใหม่ ในกรณีนี้พวกเขาจะใช้สำหรับคำในพจนานุกรมgoodและคอมม่าที่คาดว่าจะอยู่ในเอาท์พุท

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

ดู 05AB1E เคล็ดลับของฉัน (ส่วนวิธีใช้พจนานุกรมได้อย่างไร )เพื่อทำความเข้าใจว่าเพราะ…‚¿•´,อะไร"good morning,"และ„ˆ¨èãเป็น"green orbit"อย่างไร

— Kevin Cruijssen
แหล่งที่มา
2

PowerShell , 46 ไบต์ * 4 = 184 คะแนน

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

ลองออนไลน์!

— Mazzy
แหล่งที่มา
1
นั่นฉลาด ฉันลืมไปโดยสิ้นเชิง$0
— Veskah
: | รอฉันลอง แต่หลังจากทำรูปแบบดังนั้นมันจึงไม่ทำงานเช่นนี้
— ASCII- เท่านั้น
¯ \ _ (ツ) _ / ¯ลิงค์ TIO เกี่ยวกับอะไร?
— mazzy
2

PowerShell , 49 * 5 58 ไบต์ * 4 = 232 pts

-13 pts ขอบคุณ ASCII-only 

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

ลองออนไลน์!

ใช้การจัดรูปแบบจาก 5 oวินาทีเป็น 4 เพื่อตัดตัวเลขบางส่วนออก

— Veskah
แหล่งที่มา
2
— ASCII เท่านั้นเท่านั้น
— ASCII เท่านั้นเท่านั้น
1

เยลลี่ , 31 ไบต์× 2 = 62 คะแนน

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

ลองออนไลน์!

คำอธิบาย

“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)
— dylnan
แหล่งที่มา
1

JavaScript (ES6), 61 ไบต์ * 3 = 183

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

แสดงตัวอย่างโค้ด

JavaScript (ES6), 51 ไบต์ * 4 = 204

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

คำตอบที่แนะนำโดย @ETHproductions

แสดงตัวอย่างโค้ด

JavaScript (ES6), 73 ไบต์ * 4 = 292

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

แสดงตัวอย่างโค้ด

JavaScript (ES6), 58 ไบต์ * 6 = 348

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

แสดงตัวอย่างโค้ด

— darrylyeo
แหล่งที่มา
หรือเปลี่ยน_=>_เป็น'$&'
— ETHproductions
1
อีกทางหนึ่งฉันคิดว่าคุณสามารถทำ'$&$&$&$&$&$&'เพื่อทดแทนซึ่งฉันคิดว่าช่วยให้คุณลบสองกรณีและลงไปที่มีตัวละครหลายตัวผูกที่ 4 ลดคะแนนลงอย่างมาก ...
— ETHproductions
@ ETHproductions ขอบคุณไม่ทราบเกี่ยวกับรูปแบบการเปลี่ยน!
— darrylyeo
1

Ruby, 55x4 = 220 คะแนน

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

ค่อนข้างรำคาญที่การใช้ each_char ทำให้จำนวนของ r คือ 5 ..

— HåvardNygård
แหล่งที่มา
1

Pushy , 36 * 2 = 72

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

ลองออนไลน์!

หลักการสำคัญของคำตอบนี้คือตัวละครแต่ละตัวnถูกเก็บไว้n + index - 29เพื่อหลีกเลี่ยงการซ้ำซ้อนในสายอักขระดั้งเดิม การแมปนี้สร้างสตริงใน backticks ส่วนที่เหลือของโปรแกรมจะถอดรหัสและพิมพ์อักขระแต่ละตัวสองครั้ง:

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

ไบต์ที่ใช้สองครั้ง: `'W

การเปลี่ยนแปลง

  • ความยาว Golfed จาก 41 เป็น 38 โดยเปลี่ยนวิธีการถอดรหัส
  • เพิ่มความยาวจาก 38 ถึง 37 โดยลบ 29 จากอักขระที่เข้ารหัสแต่ละตัวเพื่อป้องกันไม่ให้อักขระหลายไบต์
  • ความยาวของลูกกอล์ฟจาก 37 เป็น 36 โดยใช้ 'end loop'
— FlipTack
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.