Twoim zadaniem jest wydrukowanie tekstu Good morning, Green orb!, przy czym każdy znak powtarza się w miejscu tyle razy, ile najczęściej występuje bajt w twoim źródle (tryb). Końcowy znak nowej linii jest dozwolony i nie trzeba go powtarzać.

Na przykład jeśli źródłem było

print p

Ponieważ ppojawia się dwa razy i co drugi bajt pojawia się raz, gdy trzeba będzie wydrukować

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Odpowiedzi zostaną ocenione według iloczynu liczby bajtów i liczby powtórzeń wyniku. Na przykład powyższy kod (jeśli zadziałał) uzyska 7 * 2 = 14 . Celem powinno być zminimalizowanie własnego wyniku.

Twój kod musi zawierać co najmniej 1 bajt.

Użyj tego programu, aby sprawdzić, czy kod i dane wyjściowe są zgodne

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

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

Wypróbuj online!

Wyjaśnienie

Pierwszą rzeczą, którą robię, jest pchanie sznurka

!bro neerG ,gninrom dooG

do stosu przy użyciu dość standardowych taktyk złożoności Kołmogorowa.

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

Następnie przesuwamy licznik do stosu off, aby powiedzieć nam, ile razy powielamy każdą postać. Jednak nie mogłem ustalić, co to był licznik, dopóki nie skończyłem pisać programu.

Następnie w górę jednocześnie odwracamy ciąg znaków i duplikujemy każdy znak w odpowiedniej liczbie razy. W szczególności licznik + 1.

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

Te dwie części programu mają tryb 99 otwartych nawiasów. Ponieważ jednak z pewnością będziemy potrzebować co najmniej 1 nawiasu. Tutaj zauważyłem, że ostatni znak, który wypchnęliśmy, !ma kod 33, co oznacza, że ​​możemy go użyć do utworzenia 99, dokładnie takiej liczby, jakiej chcemy, używając tylko jednego dodatkowego nawiasu. To całkiem zbieg okoliczności, ale działa.

Haskell , 37 bajtów × 3 = 111

-20 dzięki H.PWiz. -25 dzięki nim.

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

Wypróbuj online!

Operatorzy Haskell FTW.

_{Samo przypomnienie, aby nigdy nie grać w golfa na telefonie komórkowym. Popełniam głupie błędy. Mogę zrzucić co najmniej połowę winy na telefony komórkowe. : P}

brainfuck , 235 x 77 = 18,095 punktów

Edycja: -2 bajty dzięki @Dennis

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

Wypróbuj online!

Test TIO

Czekaj, to nie jest kręgle kodu? \ s

Tylko 8 użytecznych znaków sprawia, że ​​pieprzenie mózgu jest jednym z najgorszych języków, w którym można zadać to pytanie. Musiałem zacząć minimalizując która charakter nieuchronnie pojawiają się najczęściej, zwykle albo +albo -. Po napisaniu pierwszej iteracji kodu okazało się, że jest okropnie niezrównoważona na korzyść +s. Przestawiłem części kodu, takie jak generowanie większych liczb, aby użyć więcej -. Wreszcie, skończyło się na w równej ilości z dwóch znaków na 77 jeden mniej -niż +. Z pewnością można to jeszcze bardziej zmniejszyć, o czym jutro pójdę.

Ale hej, przynajmniej pokonałem odpowiedź Brainflak

Galaretka , 13 bajtów * 1 = 13

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

Wypróbuj online!

Alice , 49 bajtów * 2 = 98 144

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

Wypróbuj online!

Wyjaśnienie

/...@
\.../

Jest to zwykła struktura dla programów liniowych, które działają całkowicie w trybie porządkowym. Po rozwinięciu zygzakowatego przepływu sterowania otrzymujemy:

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

Podstawową ideą jest unikanie znaków, które powtarzają się więcej niż dwa razy za pomocą transliteracji. Transliteracja, którą będziemy wykonywać, jest następująca:

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

Sposób transliteracji w Alicji polega na tym, że ciągi fromi tosą najpierw powtarzane do LCM ich długości, chociaż w tym przypadku wszystkie sprawy są długością fromciągu, więc otrzymujemy:

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

W ten sposób otrzymujemy cztery różne znaki do reprezentowania os, a trzy dla każdego n, ra przestrzeń. Możemy wygenerować fromciąg za pomocą rozszerzenia zakresu w następujący sposób:

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

Jedynym problemem jest to, że teraz będziemy potrzebowali czterech "zarówno dla inputi na tosznurku. Aby tego uniknąć, umieściliśmy je w jednym ciągu i podzielimy na =używany jako separator.

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

Reszta to po prostu:

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

Wypróbuj online!

C (gcc) , ^{74 × 6 =} 444 ^{_{przekreślony 444 jest nadal regularny 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]);}

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

Dzięki @MDXF za uratowanie 9 punktów i utorowanie drogi dla 6 kolejnych!

Wypróbuj online!

Alternatywna wersja, do wydruku ASCII, 69 × 3 = 207

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

Wypróbuj online!

APL (Dyalog Unicode) , 46 bajtów × 2 = 92

(Zawiera niedrukowalne)

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

Wypróbuj online!

+ Dużo bajtów dzięki stronie kodowej Dyalog, dzięki @ Adám za zwrócenie na to uwagi.

Vim, 42 41 naciśnięć klawiszy × 3 = 123

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

Wyjaśnienie:

1. iGod morning, Green orb!<Esc>
   Napisz ciąg God morning, Green orb!( obrak jednego ).
2. 2|
   Przejdź do pierwszego o.
3. qsyl2pl@sq
   Utwórz makro rekurencyjne s. Jako efekt uboczny potrójny prąd o.
4. X0
   Usuń jeden oi przeskocz na początek.
5. @s
   Uruchom makro s, które powtórzy każdy znak dwukrotnie.

C, 78 × 4 = 312

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

Wypróbuj online!

356 332

Japt , 24 bajty * 2 = 48

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

Zawiera niedrukowalne. Przetestuj online!

Większość programu to tylko skompresowany ciąg, który dekompresuje się do

Good morning,
Green orb!

a m²następnie maps każdy znak, powtarzając to ²wice ^{porządku, to było trochę odcinku} . Spacja jest jedynym znakiem, który pojawia się 3 razy w skompresowanym ciągu; aby zapisać jedną instancję, zastępujemy ją nową linią, a następnie używamy·¸ do podziału na nowych linii i natychmiastowego łączenia w spacje. Dłuższy o 2 bajty, znacznie zmniejsza wynik (z 66 do 48).

Teraz, gdyby był na to krótki sposób bez użycia postaci dwa razy ...

SNOBOL4 (CSNOBOL4) , 97 bajtów * 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

Wypróbuj online!

tak ........ SNOBOL wymaga oddzielenia operatorów białymi spacjami, a wymagania dotyczące białych spacji są dość niezręczne. W kodzie jest 9 '\t'i 10 ' ', więc wszelkie ulepszenia będą wymagały dość znaczącej zmiany podejścia.

R , 65 bajtów * 5 = 325 59 bajtów * 5 = 295 62 bajtów * 4 = 248

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

Wypróbuj online!

Istnieją 4 (or,')znaki.

Rubin , 52 bajty × 3 = 156

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

Wypróbuj online!

Perl 5 , 59 × 2 = 118 punktów

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

Wypróbuj online!

Perl 5 , 51 × 3 = 153156 zwrotnica

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

Wypróbuj online!

Perl 5 , 43 × 4 = 172 punkty

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

Wypróbuj online!

Zaoszczędź 2 bajty w każdym rozwiązaniu dzięki @Xcali (kilka zmian temu). Dla wszystkich optymalizacji spójrz na zmiany.

V , 35 bajtów * 2 = 70

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

Wypróbuj 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 bajtów * 1 = 16

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

Wypróbuj tutaj!

Kompresja!

Chociaż, jeśli Greennie jest tak wielkie, może to być 3 bajty krótsze: /

Python 2 , 62 * 4 = 248

Dzięki @ovs i @Giuseppe!

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

Wypróbuj online!

Python 2 , 51 * 6 = 306

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

Wypróbuj online!

Python 2 , 70 * 5 = 350

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

Wypróbuj online!

Dzięki @Mr. Xcoder do zapisywania bajtu z obu wersji!

Ohm v2 , 20 bajtów * 1 = 20

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

Wypróbuj online!

Uwielbiam kompresję, chociaż niestety nie jest tak dobra jak SOGL.

Czysty , 77 bajtów * 3 = 231

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

Wypróbuj online!

CJam , 32 bajty × 2 = 64

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

Wypróbuj online!

Przesuwa ciąg, następnie XOR zapisuje pierwsze 20 znaków [0, 1, …, 19], a następnie powiela każdy znak.

05AB1E , wynik: 22 (22 bajtów * 1)

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

Wypróbuj online.

Wyjaśnienie:

UWAGA 1: Stos zawijania do wbudowanej listy) jest używany zamiast wbudowanej pary ‚ , ponieważ ‚jest już częścią słowa słownika good.
UWAGA 2: dwa przecinki w kodzie ‚i ,może wyglądać tak samo, ale mają różne znaki Unicode . Pierwszy jest zwykle używany dla wbudowanej pary , a drugi dla wbudowanego wydruku do STDOUT z końcowym znakiem nowej linii . W tym przypadku są one używane jako słowo słownikowe goodi oczekiwany przecinek na wyjściu.

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

Zobacz moją wskazówkę 05AB1E (sekcja Jak korzystać ze słownika? ), Aby zrozumieć, dlaczego …‚¿•´,jest "good morning,"i „ˆ¨èãjest "green orbit".

PowerShell , 46 bajtów * 4 = 184 punkty

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

Wypróbuj online!

PowerShell , 49 * 5 58 bajtów * 4 = 232 pkt

^{-13 pkt dzięki tylko ASCII}

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

Wypróbuj online!

Używa formatowania, aby przejść od 5 os do 4, aby wydzielić niektóre liczby

Galaretka , 31 bajtów × 2 = 62 punkty

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

Wypróbuj online!

Wyjaśnienie

“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 bajtów * 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 bajtów * 4 = 204

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

Odpowiedź sugerowana przez @ETHproductions .

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

JavaScript (ES6), 73 bajty * 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 bajtów * 6 = 348

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

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

Siatkówka , 36 × 4 = 144

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

Wypróbuj online! Istnieją trzy nowe linie i cztery os, więc nie ma nic więcej do zrobienia.

Rubinowy, 55x4 = 220 punktów

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

Jestem dość zirytowany, że użycie each_char powoduje, że liczba r's 5 ..

Pushy , 36 * 2 = 72

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

Wypróbuj online!

Główną zasadą tej odpowiedzi jest to, że każdy znak njest przechowywany tak n + index - 29, aby uniknąć powtórzenia w oryginalnym ciągu. To odwzorowanie utworzyło łańcuch w backticks. Reszta programu po prostu dekoduje to i wypisuje każdy znak dwukrotnie:

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

Użyte bajty dwukrotnie: `'W

Dziennik zmian

• Długość w golfa od 41 do 38, zmieniając metodę dekodowania.
• Długość w golfa od 38 do 37, odejmując 29 od każdego zakodowanego znaku, aby zapobiec znakom wielobajtowym.
• Długość w golfa od 37 do 36 za pomocą niejawnej „pętli końcowej”