Su tarea es imprimir el texto Good morning, Green orb!, con cada carácter repetido en su lugar tantas veces como el byte más frecuente en su fuente (el modo). Se permite una nueva línea final y no es necesario repetirla.

Por ejemplo, si su fuente era

print p

Dado que paparece dos veces y cada dos bytes aparece una vez, necesitaría imprimir

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Las respuestas se puntuarán por el producto de su recuento de bytes y la cantidad de veces que se repite la salida. Por ejemplo, el código anterior (si funcionó) obtendría una puntuación de 7 * 2 = 14 . El objetivo debe ser minimizar el puntaje.

Su código debe contener al menos 1 byte.

Use este programa para verificar que su código y salida coincidan

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

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

Pruébalo en línea!

Explicación

Lo primero que hago es empujar la cuerda

!bro neerG ,gninrom dooG

a la pila usando tácticas de complejidad de Kolmogorov bastante complicadas.

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

Luego empujamos un contador hacia la pila de fichas para decirnos cuántas veces duplicar cada personaje. Sin embargo, no iba a poder determinar qué era este contador hasta que terminara de escribir el programa.

A continuación, invertimos simultáneamente la cadena y duplicamos cada carácter en su lugar la cantidad correcta de veces. Específicamente el contador + 1.

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

Estas dos partes del programa tienen un modo de 99 paréntesis abiertos. Sin embargo, dado que sin duda vamos a necesitar al menos 1 paréntesis. Aquí es donde noté que el último carácter que empujamos !convenientemente tiene el código de caracteres 33, lo que significa que podemos usarlo para crear 99, el número exacto que queremos usando solo un paréntesis adicional. Esta es una coincidencia pero funciona.

Haskell , 37 bytes × 3 = 111

-20 gracias a H.PWiz. -25 gracias a nimi.

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

Pruébalo en línea!

Los operadores de Haskell FTW.

_{Recordatorio para nunca jugar golf en el móvil. Sigo cometiendo errores tontos. Puedo llevar al menos la mitad de la culpa al móvil. :PAGS}

brainfuck , 235 x 77 = 18,095 puntos

Editar: -2 bytes gracias a @Dennis

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

Pruébalo en línea!

Prueba de TIO

Espera, ¿esto no es código de bolos? \ s

Con solo 8 caracteres utilizables, Brainfuck es uno de los peores idiomas para hacer esta pregunta. Tuve que comenzar minimizando qué personaje inevitablemente aparecería más, típicamente uno +o -. Después de escribir la primera iteración del código, lo encontré terriblemente desequilibrado a favor de +s. Reorganicé partes del código, como la generación de números más grandes, para usar más -. Finalmente, terminé en una cantidad igual de los dos personajes en 77 uno menos -que +. Ciertamente es posible reducir esto aún más, lo que intentaré mañana.

Pero bueno, al menos superé la respuesta de Brainflak

Jalea , 13 bytes * 1 = 13

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

Pruébalo en línea!

Alicia , 49 bytes * 2 = 98144

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

Pruébalo en línea!

Explicación

/...@
\.../

Este es el marco habitual para programas lineales que operan completamente en modo ordinal. Al desplegar el flujo de control en zigzag, obtenemos:

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

La idea básica es evitar los caracteres que se repiten más de dos veces con la ayuda de una transliteración. La transliteración que vamos a hacer es la siguiente:

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

La forma en que funciona la transliteración en Alice es que las cadenas fromy tose repiten primero al LCM de sus longitudes, aunque en este caso, todo lo que importa es la longitud de la fromcadena, por lo que obtenemos:

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

De esta forma, obtenemos cuatro caracteres diferentes para representar la os, y tres para cada uno n, ry el espacio. Podemos generar la fromcadena usando la expansión de rango de la siguiente manera:

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

El único problema ahora es que necesitaríamos cuatro "tanto para inputla tocadena como para la cadena. Para evitar eso, los colocamos en una sola cadena y la dividimos en =un separador.

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

El resto es solo:

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

Pitón 2 , 62 × 3 = 186

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

Pruébalo en línea!

C (gcc) , ^{74 × 6 =} 444 ^{_{tachado 444 sigue siendo regular 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]);}

Pruébalo en línea!

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

¡Gracias a @MDXF por ahorrar 9 puntos y allanar el camino para 6 más!

Pruébalo en línea!

Versión alternativa, ASCII imprimible, 69 × 3 = 207

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

Pruébalo en línea!

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

(Contiene no imprimibles)

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

Pruébalo en línea!

+ Muchos bytes gracias a la página de códigos de Dyalog, gracias a @ Adám por señalarlo.

Vim, 42 41 pulsaciones de teclas × 3 = 123

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

Explicación:

1. iGod morning, Green orb!<Esc>
   Escribe la cadena God morning, Green orb!( ofalta una ).
2. 2|
   Salta al primero o.
3. qsyl2pl@sq
   Crea una macro recursiva s. Como efecto secundario, triplique la corriente o.
4. X0
   Elimina uno oy salta al principio.
5. @s
   Ejecuta la macro s, que repite cada personaje dos veces.

C, 78 × 4 = 312

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

Pruébalo en línea!

356 332

Japt , 24 bytes * 2 = 48

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

Contiene un no imprimible. ¡Pruébalo en línea!

La mayoría del programa es solo una cadena comprimida, que se descomprime a

Good morning,
Green orb!

y m²luego maps cada personaje repitiéndolo ^{bien, eso fue un poco}² exagerado . El espacio es el único carácter que aparece 3 veces en la cadena comprimida; para guardar una instancia, la reemplazamos con una nueva línea, luego la usamos ·¸para dividir en nuevas líneas e inmediatamente unir en espacios. Si bien 2 bytes más, reduce sustancialmente la puntuación (de 66 a 48).

Ahora, si solo hubiera una forma corta de hacerlo sin usar dos veces el personaje ...

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

Pruébalo en línea!

sí ........ SNOBOL requiere que los operadores estén separados por espacios en blanco, y hay requisitos de espacios en blanco que son bastante incómodos. Hay 9 '\t'y 10 ' 'en el código, por lo que cualquier mejora requerirá un cambio de enfoque bastante significativo.

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

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

Pruébalo en línea!

Hay 4 (or,')personajes.

Rubí , 52 bytes × 3 = 156

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

Pruébalo en línea!

Perl 5 , 59 × 2 = 118 puntos

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

Pruébalo en línea!

Perl 5 , 51 × 3 = 153156 puntos

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

Pruébalo en línea!

Perl 5 , 43 × 4 = 172 puntos

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

Pruébalo en línea!

Se guardaron 2 bytes en cada solución gracias a @Xcali (hace algunos cambios). Para todas las optimizaciones mira las ediciones.

V , 35 bytes * 2 = 70

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

Pruébalo en línea!

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

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

Pruébalo aquí!

¡Compresión!

Sin embargo, si Greenno se capitaliza así, esto podría ser 3 bytes más corto: /

Pitón 2 , 62 * 4 = 248

Gracias a @ovs y @Giuseppe!

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

Pruébalo en línea!

Pitón 2 , 51 * 6 = 306

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

Pruébalo en línea!

Pitón 2 , 70 * 5 = 350

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

Pruébalo en línea!

Gracias a @Mr. ¡Xcoder para guardar un byte de ambas versiones!

Ohm v2 , 20 bytes * 1 = 20

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

Pruébalo en línea!

Me encanta la compresión, aunque desafortunadamente no es tan buena como la de SOGL.

Limpio , 77 bytes * 3 = 231

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

Pruébalo en línea!

CJam , 32 bytes × 2 = 64

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

Pruébalo en línea!

Empuja una cadena, luego XOR con los primeros 20 caracteres [0, 1, …, 19]y luego duplica cada carácter.

05AB1E , Puntuación: 22 (22 bytes * 1)

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

Pruébalo en línea.

Explicación:

NOTA 1: La pila de ajuste en la lista integrada )se usa en lugar del par integrado ‚, porque ‚ya es parte de la palabra del diccionario good.
NOTA 2: Los dos comas en el código ‚y ,pueden tener el mismo aspecto, pero son diferentes caracteres Unicode . El primero se usa generalmente para el par integrado , y el segundo para la impresión integrada en STDOUT con nueva línea final . En este caso, se utilizan para la palabra del diccionario goody, sin embargo, la coma esperada en la salida.

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

Vea esta sugerencia mía 05AB1E (sección ¿Cómo usar el diccionario? ) Para comprender por qué …‚¿•´,es "good morning,"y „ˆ¨èães "green orbit".

PowerShell , 46 bytes * 4 = 184 puntos

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

Pruébalo en línea!

PowerShell , 49 * 5 58 bytes * 4 = 232 pts

^{-13 pts gracias solo a ASCII}

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

Pruébalo en línea!

Utiliza el formateo para ir de 5 osa 4 para obtener algunos números.

Gelatina , 31 bytes × 2 = 62 puntos

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

Pruébalo en línea!

Explicación

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

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

Respuesta sugerida por @ETHproductions .

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

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

Pruébalo en línea! Hay tres líneas nuevas y cuatro os, por lo que no hay nada más que hacer.

Rubí, 55x4 = 220 puntos

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

Estoy bastante molesto porque usar each_char hace el recuento de r's 5 ..

Insistente , 36 * 2 = 72

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

Pruébalo en línea!

El principio principal de esta respuesta es que cada carácter nse almacena como n + index - 29para evitar la repetición en la cadena original. Esta asignación creó la cadena en los backticks. El resto del programa simplemente decodifica esto e imprime cada personaje dos veces:

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

Bytes usados ​​dos veces: `'W

Registro de cambios

• Longitud de golf de 41 a 38, cambiando el método de decodificación.
• Golfed longitud de 38 a 37 restando 29 de cada carácter codificado para evitar caracteres multibyte.
• Longitud de golf de 37 a 36 mediante el uso de 'final loop' implícito