Ein Programmierpuzzle von Mode Golf

43

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

code-challenge  kolmogorov-complexity  hello-world  self-referential 
— Weizen-Assistent
quelle
Funktionen sind erlaubt, oder?
— Totalhuman
1
@totallyhuman Ja, solange sie keine Eingaben machen.
— Wheat Wizard
1
Sollte dies nicht quine markiert werden ?
— FantaC
Morgen kann nicht groß geschrieben werden, haha?
— Magic Octopus Urn
@magicoctopusurn Nein, der Text sollte der gleiche sein.
— Weizen-Zauberer

Antworten:

18

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.

— Weizen-Assistent
quelle
9
Ah ja, nur ziemlich normale Kolmogorov-Komplexitätstaktik. Das sind die Dinge.
— John Keates
Du, mein guter Kerl, musst verrückt sein, es überhaupt zu versuchen. Ich werde nur +1 geben und weggehen, bevor mein Gehirn explodiert und versucht, alle Klammern zu verstehen.
— Caird Coinheringaahing
15

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

— total menschlich
quelle
5
Verwenden <*, um Bytes zu speichern (Beachten Sie, dass ich seine Gültigkeit nicht überprüft habe)
— H.PWiz
... Verdammt, Haskell hat fast zu viele Bediener. Vielen Dank!
— Totalhuman
15

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

— Scherzen
quelle
Hey, Glückwunsch! Ich kann nicht glauben, dass es überhaupt möglich ist, dies in BF zu tun ... ;#Schön, wenn es in der Sprache gemacht werden kann (͡ ° ͜ʖ ͡ °)
— RedClover
13

Jelly , 13 Bytes * 1 = 13

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

Probieren Sie es online!

— Mr. Xcoder
quelle
3
Endlich schafft jemand die schwer fassbare * 1 Antwort. Ich hatte das Gefühl, dass Jelly die Sprache dafür sein würde ...
— ETHproductions
@ETHproductions Haha, habe gerade meinen Code halbiert und dabei * 1
— Mr. Xcoder
Haha, verdammt, ich habe das gerade gefunden, nachdem du es bearbeitet hast
— dylnan
Was genau ist der Unterschied aus Neugier? Wie ist die neue komprimierte Saite halb so lang wie die alte?
— ETHproductions
@ETHproductions Ich habe im Grunde genommen zuerst eine nicht optimale komprimierte Zeichenfolge verwendet, dann den optimierten Jelly-Kompressor, der die Übereinstimmungen im Wörterbuch gefunden hat.
— Mr. Xcoder
10

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.
— Martin Ender
quelle
5

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!

— Dennis
quelle
— Dennis
5

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.
— user285259
quelle
4

C 78 × 4 = 312

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

Probieren Sie es online!

356 332

— MD XF
quelle
Kommentieren, weil ich es leid bin, es jedes Mal in meinem Browserverlauf zu finden, wenn ich Golf spielen möchte: Ich habe dies verwendet , um die Anzahl der Zeichenwiederholungen zu ermitteln.
— MD XF
Und das , um die Zeichenfolge zu codieren.
— MD XF
3

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

— ETHproductions
quelle
Weil ich es nicht sehen kann: Welcher Charakter ist dreimal in der Quelle? Ich sehe mehrere Dinge, die 2 zählen, aber nicht 3.
— Draco18s
1
@ Draco18s Keine, die Punktzahl beträgt 24 * 2.
— ETHproductions
Dann ist die Ausgabe falsch. Sie drucken jedes Zeichen dreimal statt zweimal.
— Draco18s
@ Draco18s Dangit, hat den falschen Link gepostet ... Danke, dass du darauf hingewiesen hast.
— ETHproductions
*salute*Und jetzt, wo ich mir Ihre Antwort
— ansehe,
3

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.

— Giuseppe
quelle
3

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.

— Giuseppe
quelle
2
Ich habe noch nie strrepzuvor gesehen , dass sollte sich als nützlich erweisen.
— BLT
3

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.

— mik
quelle
Wenn Sie dies zu einem Programm anstelle einer Funktion machen, sparen Sie 2 Byte (4 Punkte): Probieren Sie es online aus!
— Xcali
@Xcali, aber Ihre Änderung benötigt eine nicht standardmäßige Option -M5.010, die auch zählt
— mik
— Xcali
2

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                                  /..
— DJMcMayhem
quelle
2

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!

— Steadybox
quelle
Sie können das Leerzeichen zwischen 6und entfernen for.
— Mr. Xcoder
@ Mr.Xcoder Danke!
— Steadybox
— Ovs
@ovs das ist nicht ganz richtig, ich denke, Sie brauchen zwei \x6fs, die immer noch gut für 244 ist
— Giuseppe
2

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.

— Lynn
quelle
2

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

— Kevin Cruijssen
quelle
2

PowerShell , 46 Byte * 4 = 184 Punkte

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

Probieren Sie es online!

— mazzy
quelle
1
Das ist schlau. Ich habe völlig vergessen$0
— Veskah
: | Warten Sie, ich habe es versucht, aber erst nachdem ich das Format ausgeführt habe, hat es nicht so gut funktioniert wie dieses
— ASCII-
¯ \ _ (ツ) _ / ¯ was ist mit TIO Link?
— mazzy
1

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)
— dylnan
quelle
1

JavaScript (ES6), 61 Byte * 3 = 183

_=>'Good morning, Gr\145en \x6f\x72b!'.replace(/./g,"$&$&$&")

Code-Snippet anzeigen

JavaScript (ES6), 51 Byte * 4 = 204

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

Antwort vorgeschlagen von @ETHproductions .

Code-Snippet anzeigen

JavaScript (ES6), 73 Byte * 4 = 292

_=>`G00d mo1ning, G244n orb!`.replace(/./g,_=>(('o'+!0)[_]||_).repeat(4))

Code-Snippet anzeigen

JavaScript (ES6), 58 Byte * 6 = 348

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

Code-Snippet anzeigen

— darrylyeo
quelle
Alternativ können Sie um _=>_'$&'
— Uhr
1
Alternativ, denke ich, können Sie einfach '$&$&$&$&$&$&'für den Ersatz
— sorgen
@ETHproductions Danke, wusste nichts über dieses Ersatzmuster!
— darrylyeo
1

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.

— Håvard Nygård
quelle
1

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"
— FlipTack
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.