Il tuo compito è stampare il testo Good morning, Green orb!, con ogni carattere ripetuto sul posto tutte le volte che il byte più frequente nella tua sorgente (la modalità). Una nuova riga finale è consentita e non deve essere ripetuta.

Ad esempio se la tua fonte era

print p

Poiché pappare due volte e ogni altro byte appare una volta che dovresti stampare

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Le risposte verranno assegnate in base al prodotto del loro conteggio dei byte e al numero di volte in cui l'output viene ripetuto. Ad esempio il codice sopra (se funzionava) avrebbe ottenuto 7 * 2 = 14 . L'obiettivo dovrebbe essere quello di ridurre al minimo il proprio punteggio.

Il codice deve contenere almeno 1 byte.

Utilizzare questo programma per verificare che il codice e l'output corrispondano

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

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

Provalo online!

Spiegazione

La prima cosa che faccio è spingere la corda

!bro neerG ,gninrom dooG

nello stack usando tattiche piuttosto standard di complessità di Kolmogorov.

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

Quindi spingiamo un segnalino fuori dallo stack per dirci quante volte duplicare ogni personaggio. Tuttavia non sarei stato in grado di determinare cosa fosse questo contatore fino a quando non avessi finito di scrivere il programma.

Successivamente, invertiamo simultaneamente la stringa e dupliciamo ogni carattere in posizione il numero corretto di volte. In particolare il contatore + 1.

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

Queste due parti del programma hanno una modalità di 99 parentesi aperte. Tuttavia, poiché avremo sicuramente bisogno di almeno 1 parentesi. Qui è dove ho notato che l'ultimo carattere che abbiamo premuto !ha convenientemente il codice carattere 33, il che significa che possiamo usarlo per creare 99, il numero esatto che vogliamo usando solo una parentesi aggiuntiva. Questa è una coincidenza, ma funziona.

Haskell , 37 byte × 3 = 111

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

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

Provalo online!

Gli operatori di Haskell FTW.

_{Promemoria per non giocare mai a golf sul cellulare. Continuo a fare errori stupidi. Posso spingere almeno la metà della colpa sul cellulare. : P}

brainfuck , 235 x 77 = 18.095 punti

Modifica: -2 byte grazie a @Dennis

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

Provalo online!

Test TIO

Aspetta, questo non è il bowling di codice ?? \S

Con solo 8 caratteri utilizzabili, brainfuck è una delle peggiori lingue per fare questa domanda. Ho dovuto iniziare a minimizzare quale personaggio appariva inevitabilmente di più, in genere o +o -. Dopo aver scritto la prima iterazione del codice, l'ho trovato terribilmente sbilanciato a favore di +s. Ho riorganizzato parti del codice, come la generazione di numeri più grandi, per usarne di più -. Infine, sono finito in una uguale quantità dei due caratteri a 77 uno meno -di +. È certamente possibile ridurlo ulteriormente, che proverò domani.

Ma hey, almeno ho battuto la risposta Brainflak

Gelatina , 13 byte * 1 = 13

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

Provalo online!

Alice , 49 byte * 2 = 98 144

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

Provalo online!

Spiegazione

/...@
\.../

Questo è il solito framework per programmi lineari che funzionano interamente in modalità Ordinale. Spiegando il flusso di controllo a zigzag, otteniamo:

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

L'idea di base è evitare personaggi che si ripetono più di due volte con l'aiuto di una traslitterazione. La traslitterazione che faremo è la seguente:

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

Il modo in cui la traslitterazione funziona in Alice è che le stringhe frome tovengono prima ripetute sull'LCM delle loro lunghezze, anche se in questo caso, tutto ciò che conta è la lunghezza della fromstringa, quindi otteniamo:

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

In questo modo, si ottiene quattro personaggi diversi per rappresentare le os, e tre ciascuno per n, re lo spazio. Possiamo generare la fromstringa usando l'espansione dell'intervallo come segue:

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

L'unico problema ora è che ne avremmo bisogno di quattro "sia per inputla tostringa che per la stringa. Per evitarlo, li inseriamo entrambi in una singola stringa e li dividiamo in un =usato come separatore.

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

Il resto è solo:

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

Provalo online!

C (cc) , ^{74 × 6 =} 444 ^{_{barrato 444 è ancora regolare 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]);}

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

Grazie a @MDXF per aver salvato 9 punti e spianato la strada per altri 6!

Provalo online!

Versione alternativa, ASCII stampabile, 69 × 3 = 207

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

Provalo online!

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

(Contiene non stampabili)

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

Provalo online!

+ Molti byte grazie alla codepage di Dyalog, grazie a @ Adám per averlo segnalato.

Vim, 42 41 sequenze di tasti × 3 = 123

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

Spiegazione:

1. iGod morning, Green orb!<Esc>
   Scrivi la stringa God morning, Green orb!(una omancante).
2. 2|
   Vai al primo o.
3. qsyl2pl@sq
   Crea una macro ricorsiva s. Come effetto collaterale, triplica la corrente o.
4. X0
   Rimuovine uno oe salta all'inizio.
5. @s
   Esegui la macro s, che ripete ogni personaggio due volte.

C, 78 × 4 = 312

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

Provalo online!

356 332

Japt , 24 byte * 2 = 48

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

Contiene un non stampabile. Provalo online!

La maggior parte del programma è solo una stringa compressa, che si decomprime a

Good morning,
Green orb!

e m²poi maps ciascun carattere ripetendola ²Wice ^{bene, che era un po 'un tratto} . Lo spazio è l'unico carattere che appare 3 volte nella stringa compressa; per salvare un'istanza la sostituiamo con una nuova riga, quindi usiamo ·¸per dividere su nuove righe e unire immediatamente gli spazi. Mentre 2 byte più a lungo, riduce sostanzialmente il punteggio (da 66 a 48).

Se solo ci fosse un modo breve per farlo senza usare due volte nessun personaggio ...

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

Provalo online!

sì ........ SNOBOL richiede che gli operatori siano separati da spazi bianchi, e ci sono requisiti di spazi bianchi piuttosto imbarazzanti. Ci sono 9 '\t'e 10 ' 'nel codice, quindi qualsiasi miglioramento richiederà un cambiamento abbastanza significativo nell'approccio.

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

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

Provalo online!

Ci sono 4 (or,')personaggi

Rubino , 52 byte × 3 = 156

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

Provalo online!

Perl 5 , 59 × 2 = 118 punti

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

Provalo online!

Perl 5 , 51 × 3 = 153156 punti

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

Provalo online!

Perl 5 , 43 × 4 = 172 punti

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

Provalo online!

Salvato 2 byte in ciascuna soluzione grazie a @Xcali (alcune modifiche fa). Per tutte le ottimizzazioni, guarda le modifiche.

V , 35 byte * 2 = 70

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

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

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

Provalo qui!

Compressione!

Tuttavia, se Greennon fosse maiuscolo in questo modo, questo potrebbe essere più corto di 3 byte: /

Python 2 , 62 * 4 = 248

Grazie a @ovs e @Giuseppe!

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

Provalo online!

Python 2 , 51 * 6 = 306

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

Provalo online!

Python 2 , 70 * 5 = 350

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

Provalo online!

Grazie a @Mr. Xcoder per salvare un byte da entrambe le versioni!

Ohm v2 , 20 byte * 1 = 20

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

Provalo online!

Devo amare la compressione, anche se purtroppo non è buona come quella di SOGL.

Pulito , 77 byte * 3 = 231

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

Provalo online!

CJam , 32 byte × 2 = 64

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

Provalo online!

Spinge una stringa, quindi XOR inserisce i primi 20 caratteri [0, 1, …, 19], quindi duplica ogni carattere.

05AB1E , Punteggio: 22 (22 byte * 1)

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

Provalo online.

Spiegazione:

NOTA 1: al posto della coppia incorporata viene utilizzato lo stack di avvolgimento nell'elenco incorporato , poiché fa già parte della parola del dizionario . NOTA 2: Le due virgole nel codice e può sembrare lo stesso, ma sono diversi i caratteri Unicode . Il primo viene solitamente utilizzato per la coppia incorporata e il secondo per la stampa incorporata su STDOUT con newline finale . In questo caso vengono utilizzati per la parola del dizionario e la virgola prevista nell'output.) ‚‚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)

Vedi questo mio suggerimento 05AB1E (sezione Come usare il dizionario? ) Per capire perché …‚¿•´,è "good morning,"ed „ˆ¨èãè "green orbit".

PowerShell , 46 byte * 4 = 184 punti

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

Provalo online!

PowerShell , 49 * 5 58 byte * 4 = 232 punti

^{-13 punti grazie solo a ASCII}

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

Provalo online!

Utilizza la formattazione per passare da 5 osecondi a 4 per eliminare alcuni numeri

Gelatina , 31 byte × 2 = 62 punti

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

Provalo online!

Spiegazione

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

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

Risposta suggerita da @ETHproductions .

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

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

Provalo online! Ci sono tre newline e quattro os, quindi non c'è altro da fare.

Rubino, 55x4 = 220 punti

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

Sono abbastanza seccato che l'uso di each_char fa il conteggio di r's 5 ..

troppo intraprendente , 36 * 2 = 72

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

Provalo online!

Il principio principale di questa risposta è che ogni personaggio nè memorizzato comen + index - 29 per evitare la ripetizione nella stringa originale. Questa mappatura ha creato la stringa nei backtick. Il resto del programma semplicemente decodifica questo e stampa ogni personaggio due volte:

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

Byte utilizzati due volte: `'W

changelog

• Lunghezza del golf da 41 a 38, modificando il metodo di decodifica.
• Lunghezza del golf da 38 a 37 sottraendo 29 da ciascun carattere codificato per evitare caratteri multibyte.
• Lunghezza golfata da 37 a 36 usando 'end loop' implicito