Ваша задача - напечатать текст Good morning, Green orb!, каждый символ которого будет повторяться столько раз, сколько самый частый байт в вашем источнике (режиме). Завершающий перевод строки разрешен и не нуждается в повторении.

Например, если ваш источник

print p

Так как pпоявляется дважды, и каждый второй байт появляется, как только вам нужно будет напечатать

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Ответы будут оцениваться по произведению их количества байтов и количества повторений вывода. Например, приведенный выше код (если бы он работал) получил бы 7 * 2 = 14 . Цель должна состоять в том, чтобы минимизировать счет.

Ваш код должен содержать как минимум 1 байт.

Используйте эту программу, чтобы убедиться, что ваш код и выходные данные совпадают

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

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

Попробуйте онлайн!

объяснение

Первое, что я делаю, это нажимаю на строку

!bro neerG ,gninrom dooG

к стеку, используя довольно стандартную тактику мозговых ударов колмогоровской сложности.

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

Затем мы помещаем счетчик в стек выключения, чтобы сообщить нам, сколько раз дублировать каждый символ. Однако я не смог определить, что это за счетчик, пока не закончу писать программу.

Затем мы одновременно переворачиваем строку и дублируем каждый символ на нужное количество раз. Конкретно счетчик + 1.

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

Эти две части программы имеют режим из 99 открытых скобок. Однако, поскольку нам наверняка понадобится хотя бы одна скобка. Здесь я заметил, что последний символ, который мы нажимали, !имеет код символа 33, что означает, что мы можем использовать его для создания 99, точного числа, которое мы хотим, используя только одну дополнительную скобку. Это совпадение, но оно работает.

Haskell , 37 байт × 3 = 111

-20 спасибо H.PWiz. -25 благодаря Ними.

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

Попробуйте онлайн!

Операторы Хаскелла FTW.

_{Само-напоминание никогда не играть в гольф на мобильном телефоне. Я продолжаю делать глупые ошибки. Я могу выдвинуть по крайней мере половину вины на мобильном телефоне. :П}

брейкфук , 235 х 77 = 18,095 балла

Редактировать: -2 байта благодаря @Dennis

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

Попробуйте онлайн!

Тест TIO

Подожди, это не боулинг? \ s

Brainfuck - один из худших языков для решения этого вопроса. Я должен был начать с минимизируя , какой характер будет неизбежно появляться больше всего, как правило , либо +или -. После написания первой итерации кода я обнаружил, что он ужасно несбалансирован в пользу +s. Я переставил части кода, такие как генерация больших чисел, чтобы использовать больше -. Наконец, я закончил в качестве равного количества двух символов на 77 единицу меньше , -чем +. Конечно, это можно уменьшить еще больше, что я и сделаю завтра.

Но эй, по крайней мере, я победил ответ Brainflak

Желе , 13 байт * 1 = 13

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

Попробуйте онлайн!

Алиса , 49 байтов * 2 = 98 144

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

Попробуйте онлайн!

объяснение

/...@
\.../

Это обычная структура для линейных программ, которые работают полностью в обычном режиме. Развернув зигзагообразный поток управления, мы получим:

"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"

Таким образом, мы получаем четыре различных символов для представления oс, и три для 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.

Питон 2 , 62 × 3 = 186

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

Попробуйте онлайн!

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

Попробуйте онлайн!

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

Попробуйте онлайн!

APL (Dyalog Unicode) , 46 байт × 2 = 92

(Содержит непечатные материалы)

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

Попробуйте онлайн!

+ Большое количество байтов благодаря кодовой странице Dyalog, спасибо @ Adám за указание на это.

Vim, 42 41 нажатие клавиш × 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. Как побочный эффект, утроьте текущий o.
4. X0
   Удалить один oи перейти к началу.
5. @s
   Запустите макрос s, который повторяет каждый символ дважды.

С 78 × 4 = 312

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

Попробуйте онлайн!

356 332

Japt , 24 байта * 2 = 48

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

Содержит непечатный. Проверьте это онлайн!

Большая часть программы представляет собой просто сжатую строку, которая распаковывается в

Good morning,
Green orb!

и m²затем mAps каждый символ, повторяя это ²WICE ^{хорошо, что было немного растянуть} . Пробел - единственный символ, который появляется 3 раза в сжатой строке; чтобы сохранить один экземпляр, мы заменяем его новой строкой, затем используем ·¸для разделения на новые строки и сразу присоединяемся к пробелам. Хотя на 2 байта длиннее, это существенно снижает оценку (с 66 до 48).

Если бы только был короткий путь сделать это без использования символа дважды ...

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 ' ', поэтому любые улучшения потребуют довольно значительных изменений в подходе.

R , 65 байтов * 5 = 325 59 байтов * 5 = 295 62 байта * 4 = 248

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

Попробуйте онлайн!

Есть 4 (or,')символа.

Рубин , 52 байта × 3 = 156

puts"Good morning, Green \x6frb!".gsub(/(.)/,'\1'*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 (несколько изменений назад). Для всех оптимизаций посмотрите на изменения.

V , 35 байтов * 2 = 70

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

Попробуйте онлайн!

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 байтов * 1 = 16

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

Попробуй здесь!

Сжатие!

Хотя, если Greenне использовать заглавные буквы, это может быть на 3 байта короче: /

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 для сохранения байта из обеих версий!

Ом v2 , 20 байтов * 1 = 20

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

Попробуйте онлайн!

Должен любить компрессию, хотя, к сожалению, она не так хороша, как SOGL.

Чисто , 77 байт * 3 = 231

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

Попробуйте онлайн!

CJam , 32 байта × 2 = 64

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

Попробуйте онлайн!

Вставляет строку, затем выполняет XOR для первых 20 символов [0, 1, …, 19], а затем дублирует каждый символ.

05AB1E , оценка: 22 (22 байта * 1)

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

Попробуйте онлайн.

Объяснение:

Примечание 1: стек обертывание в список встроенных команд )используются вместо встроено пары ‚ , потому что ‚это уже часть словаря слова good.
ПРИМЕЧАНИЕ 2: две запятые в коде ‚и ,могут выглядеть одинаково, но это разные символы юникода . Первый обычно используется для встроенной пары , а второй - для встроенной печати в 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".

PowerShell , 46 байт * 4 = 184 балла

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

Попробуйте онлайн!

PowerShell , 49 * 5 58 байт * 4 = 232 балла

^{-13 баллов благодаря ASCII-только}

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

Попробуйте онлайн!

Использует форматирование, чтобы перейти от 5 oс до 4, чтобы вырезать некоторые числа

Желе , 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)

JavaScript (ES6), 61 байт * 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 байт * 4 = 204

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

Ответ, предложенный @ETHproductions .

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

JavaScript (ES6), 73 байта * 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 байт * 6 = 348

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

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

Сетчатка , 36 × 4 = 144

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

Попробуйте онлайн! Есть три новых строки и четыре oс, так что больше ничего не поделаешь.

Рубин, 55х4 = 220 баллов

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

Я очень раздражен тем, что использование each_char делает счетчик R 5 ..

Напористый , 36 * 2 = 72

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

Попробуйте онлайн!

Основной принцип этого ответа заключается в том, что каждый символ nхранится так n + index - 29, чтобы избежать повторения в исходной строке. Это отображение создало строку в обратных чертах. Остальная часть программы просто декодирует это и печатает каждый символ дважды:

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

Изменения

• Длина гольфа от 41 до 38, путем изменения метода декодирования.
• Гольф длина от 38 до 37 путем вычитания 29 из каждого закодированного символа для предотвращения многобайтовых символов.
• Гольф длина от 37 до 36 с использованием неявной «концевой петли»