Ihre Aufgabe ist es, den Text zu drucken Good morning, Green orb!, wobei jedes Zeichen so oft an der richtigen Stelle wiederholt wird, wie das häufigste Byte in Ihrer Quelle (der Modus). Ein abschließender Zeilenumbruch ist zulässig und muss nicht wiederholt werden.

Zum Beispiel, wenn Ihre Quelle war

print p

Da perscheint zweimal und jedes zweite Byte erscheint einmal, wenn Sie drucken müssten

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Die Antworten werden nach dem Produkt ihrer Byteanzahl und der Häufigkeit bewertet, mit der die Ausgabe wiederholt wird. Zum Beispiel würde der obige Code (wenn er funktioniert) 7 * 2 = 14 ergeben . Das Ziel sollte sein, die Punktzahl zu minimieren.

Ihr Code muss mindestens 1 Byte enthalten.

Verwenden Sie dieses Programm, um zu überprüfen, ob Ihr Code und Ihre Ausgabe übereinstimmen

Brain-Flak , 384 · 10 & sup6 ; 366 · 100 = 36.600

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

Probieren Sie es online!

Erläuterung

Das erste, was ich tue, ist die Saite zu drücken

!bro neerG ,gninrom dooG

auf den Stapel mit ziemlich Standard-Brain-Flak-Kolmogorov-Komplexitätstaktik.

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

Dann legen wir einen Zähler auf den Stapel ab und teilen uns mit, wie oft jedes Zeichen dupliziert werden soll. Allerdings konnte ich nicht feststellen, was dieser Zähler war, bis ich mit dem Schreiben des Programms fertig war.

Als nächstes kehren wir gleichzeitig die Zeichenfolge um und duplizieren jedes Zeichen an der richtigen Stelle so oft wie nötig. Insbesondere der Zähler + 1.

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

Diese beiden Teile des Programms haben einen Modus von 99 offenen Klammern. Da wir jedoch höchstwahrscheinlich mindestens 1 Klammer benötigen werden. Hier ist mir aufgefallen, dass das letzte Zeichen, das wir gepusht !haben, den Zeichencode 33 hat, was bedeutet, dass wir damit 99 erstellen können, die exakte Zahl, die wir möchten, indem wir nur eine zusätzliche Klammer verwenden. Das ist ein ziemlicher Zufall, aber es funktioniert.

Haskell , 37 Bytes × 3 = 111

-20 danke an H.PWiz. -25 danke an nimi.

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

Probieren Sie es online!

Haskells Betreiber FTW.

_{Selbstanzeige, zum auf Mobile nie zu golfen. Ich mache immer wieder blöde Fehler. Ich kann mindestens die Hälfte der Schuld auf das Handy schieben. : P}

Brainfuck , 235 x 77 = 18.095 Punkte

Edit: -2 Bytes dank @Dennis

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

Probieren Sie es online!

TIO-Test

Warten Sie, das ist kein Code-Bowling? \ s

Mit nur 8 verwendbaren Zeichen ist Brainfuck eine der schlechtesten Sprachen, um diese Frage zu beantworten. Ich musste damit beginnen, zu minimieren, welcher Charakter zwangsläufig am häufigsten auftaucht, typischerweise entweder +oder -. Nachdem ich die erste Iteration des Codes geschrieben hatte, fand ich ihn fürchterlich unausgewogen zugunsten von +s. Ich habe Teile des Codes neu angeordnet, z. B. die Generierung größerer Zahlen, um mehr zu verwenden -. Schließlich beenden I mit bis einer gleich bei 77 Menge der zwei Zeichen um eins kleiner ist -als +. Es ist sicherlich möglich, dies weiter zu reduzieren, was ich morgen ausprobieren werde.

Aber hey, zumindest habe ich die Antwort von Brainflak geschlagen

Jelly , 13 Bytes * 1 = 13

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

Probieren Sie es online!

Alice , 49 Bytes * 2 = 98 144

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

Probieren Sie es online!

Erläuterung

/...@
\.../

Dies ist der übliche Rahmen für lineare Programme, die vollständig im Ordinalmodus arbeiten. Wenn wir den Zick-Zack-Kontrollfluss entfalten, erhalten wir:

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

Die Grundidee ist, Zeichen zu vermeiden, die sich mit Hilfe einer Transliteration mehr als zweimal wiederholen. Die Transliteration, die wir machen werden, ist die folgende:

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

Die Art fromund Weise, wie die Transliteration in Alice funktioniert, besteht darin, dass die und to-Zeichenfolgen zunächst im LCM ihrer Länge wiederholt werden. In diesem Fall ist jedoch die Länge der fromZeichenfolge ausschlaggebend.

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

Auf diese Weise erhalten wir vier verschiedene Charaktere , die vertreten os und drei jeweils n, rund der Raum. Wir können die fromZeichenfolge mithilfe der Bereichserweiterung wie folgt generieren :

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

Das einzige Problem ist jetzt, dass wir vier "sowohl für die inputals auch für die toZeichenfolge benötigen würden . Um dies zu vermeiden, setzen wir beide in eine einzelne Zeichenfolge und teilen sie an einem =als Trennzeichen verwendeten Punkt auf.

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

Der Rest ist nur:

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

Probieren Sie es online!

C (gcc) , ^{74 × 6 =} 444 ^{_{durchgestrichen 444 ist immer noch regulär 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]);}

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

Vielen Dank an @MDXF für das Speichern von 9 Punkten und für weitere 6 Punkte!

Probieren Sie es online!

Alternative Version, druckbares ASCII, 69 × 3 = 207

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

Probieren Sie es online!

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

(Enthält nicht druckbare)

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

Probieren Sie es online!

+ Viele Bytes dank Dyalogs Codepage, danke an @ Adám für den Hinweis.

Vim, 42 41 Tastenanschläge × 3 = 123

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

Erläuterung:

1. iGod morning, Green orb!<Esc>
   Schreiben Sie die Zeichenfolge God morning, Green orb!(eine ofehlt).
2. 2|
   Springe zum ersten o.
3. qsyl2pl@sq
   Erstellen Sie ein rekursives Makro s. Verdreifachen Sie als Nebeneffekt den Strom o.
4. X0
   Entfernen Sie eine ound springen Sie zum Anfang.
5. @s
   Führen Sie den Makro aus s, der jedes Zeichen zweimal wiederholt.

C 78 × 4 = 312

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

Probieren Sie es online!

356 332

Japt , 24 Bytes * 2 = 48

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

Enthält eine nicht druckbare. Online testen!

Der größte Teil des Programms ist nur eine komprimierte Zeichenfolge, die nach dekomprimiert wird

Good morning,
Green orb!

und m²dann maps jedes Zeichen durch Wiederholen es ²wice ^{Ordnung, das ein wenig strecken war} . Leerzeichen ist das einzige Zeichen, das in der komprimierten Zeichenfolge dreimal vorkommt. Um eine Instanz zu speichern, ersetzen wir sie durch eine neue Zeile. Dann ·¸teilen wir sie in neue Zeilen und fügen sie sofort in Leerzeichen ein. Es ist zwar 2 Byte länger, verringert aber die Punktzahl erheblich (von 66 auf 48).

Wenn es nur einen kurzen Weg gäbe, dies ohne Zeichen zweimal zu tun ...

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

Probieren Sie es online!

yeah ........ SNOBOL verlangt, dass die Operatoren durch Leerzeichen getrennt sind, und es gibt Leerzeichenanforderungen, die ziemlich umständlich sind. Der Code enthält 9 '\t'und 10 ' ', sodass für Verbesserungen eine erhebliche Änderung des Ansatzes erforderlich ist.

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

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

Probieren Sie es online!

Es gibt 4 (or,')Zeichen.

Ruby , 52 Bytes × 3 = 156

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

Probieren Sie es online!

Perl 5 , 59 × 2 = 118 Punkte

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

Probieren Sie es online!

Perl 5 , 51 × 3 = 153156 Punkte

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

Probieren Sie es online!

Perl 5 , 43 × 4 = 172 Punkte

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

Probieren Sie es online!

Dank @Xcali wurden in jeder Lösung 2 Byte gespeichert (vor einigen Änderungen). Für alle Optimierungen schauen Sie sich die Bearbeitungen an.

V , 35 Bytes * 2 = 70

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

Probieren Sie es 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 Bytes * 1 = 16

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

Probieren Sie es hier aus!

Kompression!

Wenn Greennicht so groß geschrieben, könnte dies 3 Bytes kürzer sein: /

Python 2 , 62 * 4 = 248

Vielen Dank an @ovs und @Giuseppe!

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

Probieren Sie es online!

Python 2 , 51 * 6 = 306

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

Probieren Sie es online!

Python 2 , 70 * 5 = 350

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

Probieren Sie es online!

Vielen Dank an @Mr. Xcoder zum Speichern eines Bytes aus beiden Versionen!

Ohm v2 , 20 Bytes * 1 = 20

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

Probieren Sie es online!

Ich muss die Komprimierung lieben, obwohl sie leider nicht so gut ist wie die von SOGL.

Sauber , 77 Bytes * 3 = 231

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

Probieren Sie es online!

CJam , 32 Bytes × 2 = 64

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

Probieren Sie es online!

Drückt eine Zeichenfolge, verknüpft die ersten 20 Zeichen mit XOR [0, 1, …, 19]und dupliziert dann jedes Zeichen.

05AB1E , Score: 22 (22 Byte * 1)

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

Probieren Sie es online aus.

Erläuterung:

HINWEIS 1: Der eingebaute Wrap-Stack in Liste) wird anstelle des eingebauten Paars verwendet ‚ , da das ‚bereits Teil des Wörterbuchworts ist good.
Hinweis 2: Die beiden Kommas im Code ‚und ,kann gleich aussehen, aber verschiedene Unicode - Zeichen . Das erste wird normalerweise für das eingebaute Paar verwendet , und das zweite für den eingebauten Ausdruck an STDOUT mit nachfolgendem Zeilenumbruch . In diesem Fall werden sie jedoch für das Wörterbuchwort goodund das erwartete Komma in der Ausgabe verwendet.

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

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie verwende ich das Wörterbuch? ) An, um zu verstehen, warum es …‚¿•´,ist "good morning,"und „ˆ¨èãist "green orbit".

PowerShell , 46 Byte * 4 = 184 Punkte

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

Probieren Sie es online!

PowerShell , 49 * 5 58 Byte * 4 = 232 Punkte

^{-13 Punkte dank nur ASCII}

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

Probieren Sie es online!

Verwendet die Formatierung von 5 os bis 4 s, um einige Zahlen auszublenden

Gelee , 31 Bytes × 2 = 62 Punkte

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

Probieren Sie es online!

Erläuterung

“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,'$&$&$&$&')

Antwort vorgeschlagen von @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!
.
$&$&$&$&

Probieren Sie es online! Es gibt drei Zeilenumbrüche und vier Sekunden o, es ist also nichts mehr zu tun.

Ruby, 55 x 4 = 220 Punkte

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

Ich bin ziemlich genervt, dass mit each_char die Anzahl von rs 5 macht.

Aufdringlich , 36 × 2 = 72

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

Probieren Sie es online!

Das Hauptprinzip dieser Antwort ist, dass jedes Zeichen wie nfolgt gespeichert n + index - 29wird, um die Wiederholung in der Originalzeichenfolge zu vermeiden. Durch diese Zuordnung wurde die Zeichenfolge in den Backticks erstellt. Der Rest des Programms dekodiert dies einfach und druckt jedes Zeichen zweimal aus:

` ... `              \ 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, die zweimal verwendet werden: `'W

Änderungsprotokoll

• Golf Länge von 41 bis 38, durch Ändern der Decodierungsmethode.
• Länge von 38 bis 37 durch Subtrahieren von 29 von jedem codierten Zeichen, um Multibyte-Zeichen zu vermeiden.
• Golflänge von 37 bis 36 durch implizite "Endschleife"