Göreviniz Good morning, Green orb!, her karakter kaynağınızda (mod) en sık kullanılan bayt kadar yerinde tekrarlanan şekilde basmaktır. Takip eden bir yeni satıra izin verilir ve tekrarlanması gerekmez.

Örneğin, kaynağınız

print p

Yana pyazdırmak gerekir kez iki kez görünür ve diğer her bayt görünür

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Cevaplar, bayt sayımlarının çarpımı ve çıktının tekrarlanma sayısı tarafından puanlanacaktır. Örneğin, yukarıdaki kod (işe yaradıysa) 7 * 2 = 14 olur . Amaç, kişinin puanını en aza indirgemek olmalıdır.

Kodunuz en az 1 bayt içermelidir.

Kodunuzun ve çıktınızın eşleştiğini doğrulamak için bu programı kullanın

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

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

Çevrimiçi deneyin!

açıklama

İlk yaptığım ipi itmek

!bro neerG ,gninrom dooG

oldukça standart beyin-flak Kolmogorov-karmaşıklık taktikleri kullanarak yığına.

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

Daha sonra, her bir karakteri kaç kez kopyalayacağımızı söylemek için bir sayacı kapalı yığına iteriz. Bununla birlikte, programı yazmayı bitirinceye kadar bu sayacın ne olduğunu belirleyemedim.

Daha sonra dizgiyi eşzamanlı olarak tersine çeviririz ve her karakteri doğru sayıda yerine kopyalarız. Spesifik olarak sayaç + 1.

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

Programın bu iki kısmı 99 açık parantez moduna sahiptir. Ancak, kesinlikle en azından 1 paranteze ihtiyacımız olacak. İşte !rahatça ittiğimiz son karakterin , 33 karakter koduna sahip olduğunu fark ettim; bu, yalnızca bir tane daha parantez kullanmak istediğimiz tam sayı olan 99'u oluşturmak için kullanabileceğimiz anlamına gelir. Bu tamamen tesadüf ama işe yarıyor.

Haskell , 37 bayt × 3 = 111

-20 H.PWiz'e teşekkürler. -25 nimi için teşekkürler.

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

Çevrimiçi deneyin!

Haskell operatörleri FTW.

_{Cep hatırlatma asla kendini hatırlatma. Aptal hatalar yapmaya devam ediyorum. En azından yarısını cep telefonuna itebilirim. : P}

brainfuck , 235 x 77 = 18,095 puan

Düzenleme: @Dennis sayesinde -2 bayt

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

Çevrimiçi deneyin!

TIO testi

Bekle, bu kod bowlingi değil mi ?? \ s

Yalnızca 8 kullanılabilir karakterle beyin fırtınası bu soruyu yapmak için en kötü dillerden biridir. Hangi karakterin kaçınılmaz olarak en fazla, tipik olarak ya +da görüneceğini en aza indirmeye başlamak zorunda kaldım -. Kodun ilk yinelemesini yazdıktan sonra, onu lehine çok dengesiz buldum +. Daha fazla kullanabilmek için kodun daha büyük sayıların üretilmesi gibi kısımlarını yeniden düzenledim -. Son olarak, bitti bir eşit 77'de iki karakter miktarı bir eksik -daha +. Bunu daha da azaltmak kesinlikle mümkün, ki bu da yarın gideceğim.

Ama hey, en azından Brainflak'ın cevabını yendim

Jöle , 13 bayt * 1 = 13

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

Çevrimiçi deneyin!

Alice , 49 bayt * 2 = 98 144

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

Çevrimiçi deneyin!

açıklama

/...@
\.../

Bu, tamamen Ordinal modda çalışan lineer programlar için normal çerçevedir. Zikzak kontrol akışını açarak şunları elde ederiz:

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

Temel fikir, harf çevirisi ile ikiden fazla tekrar eden karakterlerden kaçınmaktır. Yapacağımız harf çevirisi şöyle:

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

Harcemenin Alice'de çevrilme şekli, fromve karakter todizilerinin ilk önce uzunluklarının LCM değerine tekrarlanmasıdır, ancak bu durumda tüm hususlar fromdizgenin uzunluğudur;

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

Bu şekilde, temsil etmek dört farklı karakterler olsun os ve üç her n, rve boşluk. Biz üretebilir fromşöyle aralık genişletme kullanarak dizeyi:

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

Şimdi tek sorun, "hem hem hem inputde tostring için dörde ihtiyacımız olacak . Bundan kaçınmak için, ikisini de tek bir dizgeye yerleştirdik ve =ayırıcı olarak kullanılana böldük.

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

Gerisi sadece:

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

Çevrimiçi deneyin!

C (gcc) , ^{74 × 6 =} 444 ^{_{çarpı 444 hala normaldir 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]);}

Çevrimiçi deneyin!

C (gcc) , 68x3 = 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                                      ]);}

9 puandan tasarruf ve 6 daha fazla yer açmak için @ MDXF'e teşekkürler!

Çevrimiçi deneyin!

Alternatif sürüm, yazdırılabilir ASCII, 69 × 3 = 207

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

Çevrimiçi deneyin!

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

(Yazdırılamaz içerir)

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

Çevrimiçi deneyin!

+ Dyalog kod sayfası sayesinde çok fazla bayt, bunu işaret ettiği için @ Adám sayesinde.

Vim, 42 41 tuş vuruşlarını × 3 = 123

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

Açıklama:

1. iGod morning, Green orb!<Esc>
   Dize yazın God morning, Green orb!(bir tane oeksik).
2. 2|
   İlkine atla o.
3. qsyl2pl@sq
   Özyinelemeli bir makro oluşturun s. Yan etki olarak akımı üçe katlayın o.
4. X0
   Birini çıkarın ove başlangıcına atlayın.
5. @s
sHer karakteri iki kez tekrarlayan makroyu çalıştırın .

C, 78 × 4 = 312

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

Çevrimiçi deneyin!

356 332

Japt , 24 bayt * 2 = 48

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

Yazdırılamaz. Çevrimiçi test edin!

Programın çoğunluğu sadece sıkıştırılmış bir dizgedir;

Good morning,
Green orb!

ve m²sonra mher karakteri aps tekrar ederek ²tamamıyla aps ^{, bu biraz} gergindi . Boşluk, sıkıştırılmış dizede 3 kez görünen tek karakterdir; Bir örneği kurtarmak için onu yeni bir satırla değiştiririz, sonra ·¸yeni satırlara bölmek ve hemen boşluklara katılmak için kullanırız. 2 bayt daha uzun olsa da, skoru önemli ölçüde azaltır (66'dan 48'e).

Şimdi, iki kez karakter kullanmadan bunu yapmanın kısa bir yolu olsaydı ...

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

Çevrimiçi deneyin!

evet ........ SNOBOL, operatörlerin boşluklarla ayrılmasını gerektirir ve oldukça garip olan boşluk gereksinimleri vardır. Kodda 9 '\t've 10 var ' ', bu yüzden herhangi bir iyileştirme yaklaşımda oldukça önemli bir değişiklik gerektirecektir.

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

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

Çevrimiçi deneyin!

4 (or,')karakter var.

Ruby , 52 bayt × 3 = 156

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

Çevrimiçi deneyin!

Perl 5 , 59 × 2 = 118 puan

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

Çevrimiçi deneyin!

Perl 5 , 51 × 3 = 153156 makas

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

Çevrimiçi deneyin!

Perl 5 , 43 × 4 = 172 puan

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

Çevrimiçi deneyin!

@Ccali sayesinde her bir çözümde 2 byte kaydedildi (birkaç değişiklik önce). Tüm optimizasyonlar için düzenlemelere bakın.

V , 35 bayt * 2 = 70

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

Çevrimiçi deneyin!

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 bayt * 1 = 16

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

Burada dene!

Sıkıştırma!

Buna rağmen, eğer Greenbüyük harf olmasaydı , 3 bayt daha kısa olabilirdi:

Python 2 , 62 * 4 = 248

@Ovs ve @Giuseppe'ye teşekkürler!

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

Çevrimiçi deneyin!

Python 2 , 51 * 6 = 306

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

Çevrimiçi deneyin!

Python 2,70 * 5 = 350

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

Çevrimiçi deneyin!

@ Mr'a teşekkürler. Her iki sürümden de bir bayt kaydetmek için Xcoder!

Ohm v2 , 20 bayt * 1 = 20

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

Çevrimiçi deneyin!

Sıkıştırmayı sevmeliyim, fakat ne yazık ki SOGL'ler kadar iyi değil.

Temiz , 77 bayt * 3 = 231

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

Çevrimiçi deneyin!

CJam , 32 bayt × 2 = 64

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

Çevrimiçi deneyin!

Bir dizge iter, ardından XOR ile ilk 20 karakteri girer [0, 1, …, 19], sonra her karakteri çoğaltır.

05AB1E , Puan: 22 (22 bayt * 1)

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

Çevrimiçi deneyin.

Açıklama:

Not 1: Yerleşik çiftin yerine listenin içine yerleştirme dizisi )kullanılır , çünkü bu zaten sözlük kelimesinin bir parçasıdır . NOT 2: Koddaki iki virgül ve aynı görünebilir, ancak farklı unicode karakterlerdir . Birincisi genellikle yerleşik çift ​​için , ikincisi ise yerleşik newline ile STDOUT'a yazdırmak için kullanılır . Bu durumda sözlük kelimesi ve çıktıdaki beklenen virgül için kullanılırlar . ‚‚good
‚,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)

Benim bu 05AB1E ucu bakın (bölüm nasıl sözlüğü kullanılır? ) Anlamak için …‚¿•´,ise "good morning,"ve „ˆ¨èãolup "green orbit".

PowerShell , 46 bayt * 4 = 184 puan

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

Çevrimiçi deneyin!

PowerShell , 49 * 5 58 bayt * 4 = 232 puan

^{-Sadece ASCII-teşekkürler}

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

Çevrimiçi deneyin!

oBazı sayıları çıkarmak için 5 s'den 4'e gitmek için biçimlendirme kullanır

Jöle , 31 bayt × 2 = 62 puan

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

Çevrimiçi deneyin!

açıklama

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

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

Cevap @ETHproductions tarafından önerildi .

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

JavaScript (ES6), 73 bayt * 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 bayt * 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!
.
$&$&$&$&

Çevrimiçi deneyin! Üç yeni satır ve dört osaniye var, bu yüzden daha yapılacak bir şey yok.

Ruby, 55x4 = 220 puan

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

Her birimi kullanmanın r 'nin 5 sayısını sayması beni çok rahatsız etti.

Pushy , 36 * 2 = 72

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

Çevrimiçi deneyin!

Bu cevabın ana ilkesi, her karakterin orijinal dizgede tekrarlanmasını önlemek için nolduğu gibi saklanmasıdır n + index - 29. Bu haritalama dizgiyi backticks'te yarattı. Programın geri kalanı basitçe bunu çözer ve her karakteri iki kez basar:

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

İki kez kullanılan bayt: `'W

Değişiklikler

• Kod çözme yöntemini değiştirerek 41 ile 38 arasında golf uzunluğu.
• Çok baytlı karakterleri önlemek için kodlanan her karakterden 29'u çıkartarak 38'den 37'ye kadar olan golf uzunluğu.
• Kapalı 'bitiş halkası' kullanılarak 37'den 36'ya kadar golf uzunluğu