Wer ist der schläfrigste von allen?

31

Schreiben Sie ein Programm oder eine Funktion , die in einer Zeichenfolge des Zeichens nimmt , -=o.wo die -=o's und .ist immer abwechseln, Zeichen zu Zeichen. Die Zeichenfolge hat eine ungerade Länge von mehr als eins und beginnt und endet immer in einer von -=o.

Grundsätzlich sieht die Eingabe aus wie eine Reihe von Emoticon-Gesichtern, die Augen in verschiedenen Zuständen der Schläfrigkeit teilen, z

o.=.=.-.-.o.o

Ihr Ziel ist es, das Gesicht zu drucken oder zurückzugeben, das entweder das schläfrigste oder das wachste ist (es liegt an Ihnen, was Sie wählen). Wenn es mehrere Möglichkeiten gibt, wer am schläfrigsten oder am wachsten ist, kann eine davon ausgegeben werden.

Es gibt neun verschiedene Gesichter und fünf Schläfrigkeitsstufen:

-.- is 100% sleepy
-.= is 75% sleepy
-.o is 50% sleepy
=.- is 75% sleepy
=.= is 50% sleepy
=.o is 25% sleepy
o.- is 50% sleepy
o.= is 25% sleepy
o.o is 0% sleepy

Im Fall ist es nicht klar, wird der Müdigkeits Prozentsatz durch die Zuordnung berechnet , 1um -für voll schlafend, 0.5um =für halb im Schlaf, und 0zu ofür wach. Dann ist die Summe der beiden Augenwerte geteilt durch zwei der Prozentsatz.

Der kürzeste Code in Bytes gewinnt.

Testfälle

Schläfrigste

-.- GIVES -.-
=.- GIVES =.-
o.o GIVES o.o
o.-.= GIVES -.=
=.-.= GIVES =.- OR -.=
o.-.= GIVES -.=
-.-.= GIVES -.-
o.o.- GIVES o.-
=.=.=.o GIVES =.=
-.=.=.= GIVES -.=
=.o.-.= GIVES -.=
o.-.o.=.= GIVES o.- OR -.o OR =.=
-.o.-.=.= GIVES -.=
o.o.o.o.o GIVES o.o
-.-.-.-.- GIVES -.-
o.=.=.-.-.o.o GIVES -.-
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES -.= OR =.-

Die meisten wach

-.- GIVES -.-
=.- GIVES =.-
o.o GIVES o.o
o.-.= GIVES o.-
=.-.= GIVES =.- OR -.=
o.-.= GIVES o.-
-.-.= GIVES -.=
o.o.- GIVES o.o
=.=.=.o GIVES =.o
-.=.=.= GIVES =.=
=.o.-.= GIVES =.o
o.-.o.=.= GIVES o.=
-.o.-.=.= GIVES -.o OR o.- OR =.=
o.o.o.o.o GIVES o.o
-.-.-.-.- GIVES -.-
o.=.=.-.-.o.o GIVES o.o
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES o.o
code-golf  string 
— Calvins Hobbys
quelle
31
Ich fühle mich-.-
— Kritixi Lithos

Antworten:

28

Pyth, 12 10 Bytes

hoSN%2.:z3

Dies druckt das schläfrigste Emoticon. Überprüfen Sie alle Testfälle gleichzeitig im Pyth-Compiler .

Die Idee, die Sortierung zu verwenden, geht an @ Sp3000 .

Wie es funktioniert

hoSN%2.:z3
              (implicit) Save the in z.
      .:z3    Compute all substrings of length 3.
    %2        Keep every seconds substring. This discards non-emoticons.
 o            Sort the emoticons by the following key:
  SN            Sort the characters of the emoticon.
                This works since '-' < '=' < 'o'.
h             Retrieve the first, minimal element.
— Dennis
quelle
18
Was ist das für eine Zauberei?!
— AvZ
@Dennis Ich bin neu in Pyth, also könnte das falsch sein: Warum nicht hS%2.:z3?
— Helix Quar
5
@helix Weil wir =.-schläfriger sein wollen als -.o, aber sie sind andersherum sortiert. Ich hatte den gleichen Fehler gemacht.
— 20.
9

Python 2, 54 53 Bytes

f=lambda s:s and max((s+' ')[:3],f(s[2:]),key=sorted)

Dies ist eine Funktion, die das Gesicht zurückgibt, das am meisten wach ist.

Vielen Dank an xnor für die Bereitstellung vieler taktischer Tricks, um meinen ursprünglichen Algorithmus zu verkürzen.

— xsot
quelle
Nun, ich finde es albern, nicht zu erkennen, dass die Symbole nach Wachheit sortiert sind. Ich denke, Sie können das wiederverwenden, maxanstatt es zu f=lambda s:s[3:]and max(s[:3],f(s[2:]))or s
— wiederholen
Eigentlich denke ich, dass dies nicht funktioniert =.-.o, da =.-vs -.odie Ausnahme von der Sortierregel ist.
— Xnor
Eigentlich habe ich gerade gemerkt, dass ich die Operation falsch verstanden habe. Ich dachte, dass die Gesichter sortiert sind, wie sie in der Tabelle angezeigt werden. Aufgrund dieser Annahme schlägt meine Eingabe für "= .o.-" fehl. Ich glaube, ich habe ein Problem.
— Xsot
@xsot Ich glaube, es ,key=sortedwäre eine Lösung, aber das ist 11 Zeichen, also ist deins wahrscheinlich kürzer.
— xnor
Ja, das ist die Lösung, die ich mir vorgestellt hatte
— Uhr
6

CJam, 12 Bytes

q3ew2%{$}$0=

Dies druckt das schläfrigste Emoticon. Probieren Sie diese Geige oder diese Testsuite im CJam-Interpreter aus.

Die Idee, die Sortierung zu verwenden, geht an @ Sp3000 .

Wie es funktioniert

q            e# Read all input from STDIN.
 3ew         e# Push all overlapping slices of length 3.
    2%       e# Keep every seconds slice. This discards non-emoticons.
      {$}$   e# Sort the slices by their sorted characters.
             e# This works since '-' < '=' < 'o'.
          0= e# Retrieve the first, minimal slice.
— Dennis
quelle
4

Dyalog APL, 35 28 Bytes

{⊃{⍵[⍒{+/'.??o='⍳⍵}¨⍵]}3,/⍵}

Dies ist eine monadische Funktion, die die Zeichenfolge rechts nimmt und das schläfrigste Gesicht ausgibt.

    {⊃{⍵[⍒{+/'.??o='⍳⍵}¨⍵]}3,/⍵}'o.=.=.-.-.o.o'
-.-
— Lirtosiast
quelle
{(⊃⍒3+/'.??o='⍳⍵)⊃3,/⍵}
— user46915
Und angesichts der Eingabebeschränkungen ??ist dies auch nicht erforderlich .
— user46915
4

Prolog, 205 189 Bytes

Code

r([X|T],[N|B],M):-N=M,write(X);r(T,B,M).
p(X):-findall(S,sub_atom(X,_,3,_,S),L),findall(E,(nth1(I,L,E),I mod 2=\=0),R),maplist(atom_codes,R,Q),maplist(sum_list,Q,S),min_list(S,M),r(R,S,M).

Erläuterung

r([X|T],[N|B],M):-N=M,write(X);r(T,B,M).
p(X):-findall(S,sub_atom(X,_,3,_,S),L),              % L = all sublists of length 3
      findall(E,(nth1(I,L,E),I mod 2=\=0),R),        % R = every other element of L
      maplist(atom_codes,R,Q),                       % Q = list of decimal ascii codes 
                                                           created from R

      maplist(sum_list,Q,S),                         % S = list of sums of R's lists
      min_list(S,M),                                 % M = minimum sum
      r(R,S,M).                                      % Prints first element in R with sum M

Beispiel

>p('-.=.-.o.o.=.o.-.o.=.-.o.=.o.-').
-.=

Bearbeiten: 16 Bytes durch Vereinheitlichen von r-Klauseln mit OR gespeichert.

— Emigna
quelle
1

Clojure, 82 Bytes

(fn[x](println(apply str(apply min-key #(reduce +(map int %))(partition 3 2 x)))))

Bonus: Die folgende kleinere Funktion druckt das gleiche Gesicht, aber mit mehr Stil!

(fn[x](println(apply min-key #(reduce +(map int %))(partition 3 2 x))))

Hier testen.

— galdre
quelle
1

Ruby, 59 Bytes

Die Funktion gibt das schläfrigste Gesicht mit dem Sortiertrick zurück.

f=->(s){s.split(?.).each_cons(2).min_by{|e|e.sort}.join(?.)}

So genannt:

f.call("o.=.=.-.-.o.o")
# => "-.-"

Funktioniert bei unangenehmer Augenordnung aufgrund von inneren Augen:

f.call("=.-.o")
# => "=.-"
— Neil Slater
quelle
1

Minkolang 0,12 , 119 Bytes

Zuerst habe ich versucht, dies kurz und richtig golfen zu können. Ich gab auf und ging für etwas mehr "Spaß", aber immer noch relativ golfen.

>2@fv$oI2:[9[i$z3[iciz1+q=]++3=tt"^"3zpt]$x$x]IX3140w
o.o1F
o.=1$
=.o1+
=.=12
o.-1:
-.o11
=.-1+
-.=13
-.-1[
/c0i<
\qO].

Probieren Sie es hier aus!

Erläuterung

Aber wirklich, klicke auf den Link oben und klicke Slow! Sowieso...

>2@fv

Dies überspringt das fv, was später wichtig sein wird.

$o                                                  Read in whole input as characters 
  I2:                                               Half the stack length
     [                                              Open for loop (for each face)
      9[                                            Open another for loop - 9 repeats
        i$z                                         Stores loop counter in register
           3[                                       Open another for loop - 3 repeats
             ic                                     Copy char 1/2/3
               iz1+q                                Retrieve char from lookup table
                    =                               1 if equal, 0 otherwise
                     ]                              Close for loop
                      ++                            Add twice
                        3=                          1 if equal to 3, 0 otherwise
                          tt      t                 Ternary - executes first part when 0,
                                                    second part otherwise
                            "^"3zp                  Put a ^ next to the face that matched
                                   ]                Close lookup for loop
                                    $x$x            Dump first two characters
                                        ]           Close for loop
                                         IX         Dump the whole stack
                                           31       Push a 3, then a 1
                                             40w    Wormhole to (4,0) in the code

Alles, was das tat, war ^, die passenden Gesichter zu markieren. Die Codebox könnte nun so aussehen:

>2@fv$oI2:[9[i$z3[iciz1+q=]++3=tt"^"3zpt]$x$x]IX3140w
o.o1F
o.=1$
=.o1+
=.=^2   <-- caret
o.-^:   <-- caret
-.o11
=.-1+
-.=^3   <-- caret
-.-1[
/c0i<
\qO].

Natürlich ohne die Kommentare. Jetzt hat das 40wWurmloch den Befehlszeiger an gesendet v, der ihn sofort weiterleitet F. Nun Fist ein "gosub" -Befehl. Es ist wie ein Goto, aber Sie können dorthin zurückkehren, wo Sie es genannt haben. Zum Zeitpunkt F, an dem der Stack angetroffen wird [3,1], springt er auf die 1(vielleicht) zweite Zeile. Während der Programmzähler nach unten wanderte, schob er 1s auf dem Weg auf den Stapel. Das heißt ... bis es auf ein trifft ^, an welchem ​​Punkt es wieder nach oben umgeleitet wird, wo es jedesmal 1wieder drückt . Der Befehlszeiger dient dannf , wodurch seine Position und Richtung wiederhergestellt werden (als er Ffrüher angetroffen wurde). Der Einfachheit halber nehme ich den folgenden Code und ändere sein Layout. (Das</\ dienen dazu, den Anweisungszeiger nach Bedarf umzuleiten.)

$+                 Sum up the whole stack
  2:               Divide by 2 (because each 1 was pushed twice)
    1+             Add 1 (shift down one row)
      3[           Open for loop - 3 repeats
        i          Push loop counter
         0c        Copy top of stack
           q       Retrieve face character
            O      Output as character
             ].    Close for loop and stop when it's done.

Eigentlich bin ich ein bisschen stolz darauf, wie ich mehrere einzigartige Funktionen von Minkolang verwendet habe, die ich vorher noch nicht oft verwendet habe. Hauptsächlich das Ternäre und das Gosub. Wie auch immer, da hast du es!

— El'endia Starman
quelle
1

C 70 Bytes

char*f(char*s){char*p=s[3]?f(s+2):s;return*s+s[2]>*p+p[2]?s[3]=0,s:p;}

Die Funktion gibt das hellste Gesicht zurück. Es ändert die Eingabezeichenfolge an der richtigen Stelle, um eine nullterminierte Zeichenfolge zurückzugeben.

— han
quelle
1

Python 2/3, 54 56 Bytes

lambda x:".".join(max(zip(x[::2],x[2::2]),key=sorted))

Ich wollte nur eine Alternative zu xsots rekursiver Antwort suchen.

Dies nimmt das beste (oder das schlechteste?) Tupel benachbarter Augenpaare und verbindet sie miteinander.

Ersetzen Sie max durch min, um die schläfrigsten zu erhalten (da dies die wachsten Ergebnisse liefert).

Scheint mit dem folgenden Test zu funktionieren:

for line in """-.- GIVES -.-
    =.- GIVES =.-
    o.o GIVES o.o
    o.-.= GIVES o.-
    =.-.= GIVES =.- OR -.=
    o.-.= GIVES o.-
    -.-.= GIVES -.=
    o.o.- GIVES o.o
    =.=.=.o GIVES =.o
    -.=.=.= GIVES =.=
    =.o.-.= GIVES =.o
    o.-.o.=.= GIVES o.=
    -.o.-.=.= GIVES -.o OR o.- OR =.=
    o.o.o.o.o GIVES o.o
    -.-.-.-.- GIVES -.-
    o.=.=.-.-.o.o GIVES o.o
    -.=.-.o.o.=.o.-.o.=.-.o.=.o.- GIVES o.o""".splitlines():
    inp, _, opts = line.partition(" GIVES ")
    optst = opts.split(" OR ")
    act = f(inp)
    print(inp, "expected", opts, "got", act, "equal?", act in optst)

Was das folgende Ergebnis ergibt:

-.- expected -.- got -.- equal? True
=.- expected =.- got =.- equal? True
o.o expected o.o got o.o equal? True
o.-.= expected o.- got o.- equal? True
=.-.= expected =.- OR -.= got =.- equal? True
o.-.= expected o.- got o.- equal? True
-.-.= expected -.= got -.= equal? True
o.o.- expected o.o got o.o equal? True
=.=.=.o expected =.o got =.o equal? True
-.=.=.= expected =.= got =.= equal? True
=.o.-.= expected =.o got =.o equal? True
o.-.o.=.= expected o.= got o.= equal? True
-.o.-.=.= expected -.o OR o.- OR =.= got =.= equal? True
o.o.o.o.o expected o.o got o.o equal? True
-.-.-.-.- expected -.- got -.- equal? True
o.=.=.-.-.o.o expected o.o got o.o equal? True
-.=.-.o.o.=.o.-.o.=.-.o.=.o.- expected o.o got o.o equal? True
— TLW
quelle
Zwei kurze Fragen: 1) Wird die Kennzeichnung als Python 2/3 empfohlen, wenn mit beiden etwas funktioniert? 2) Ist das f=Teil als Teil der Codegröße für diese Herausforderung erforderlich? Wenn ich das nicht tun , dass es die Lambda schaffen werde und dann sofort nur um es wegzuwerfen wieder ...
— TLW
1
1) „Python 2/3“ oder einfach nur „Python“ ist in Ordnung , ich denke 2) Wenn Sie nicht brauchen , die f=dann der aktuelle Konsens darüber , dass anonyme Funktionen sind in Ordnung standardmäßig zu sein scheinen, so dass Sie die Tropfen können f=in diesem Fall ( xsot's braucht es, da es rekursiv ist)
— Sp3000
0

Mathematica, 61 Bytes

"."
Sort[Partition[#~StringSplit~%,2,1]][[1]]~StringRiffle~%&

Geht für das schläfrigste.

— LegionMammal978
quelle
Diese Funktion funktioniert nur einmal, es sei denn, Sie wiederholen den gesamten Code jedes Mal, wenn Sie ihn aufrufen möchten. Die Funktionseinreichungen müssen wiederverwendbar sein . Der Aufruf Ihrer Funktion unterbricht den Wert des Globalen, auf %das sie sich stützt.
— Martin Ender
0

F # 60

fun s->Seq.max[for n in 0..2..String.length s-2->s.[n..n+2]]

Gibt das wachste Gesicht zurück (ändern maxum minfür das schläfrigste)

— Sehnsucht
quelle
0

Perl 5, 127 Bytes

%h=qw[- 2 = 1];sub r{$b=0;$b+=$h{$_}for split'',pop;$b}($_)=<>;@a='o.o';while(/.../g){push@a,$& if(r$&)>r$a[-1];--pos}say$a[-1]

(Ich bin sicher, dass es in Kürze machbar ist.) So funktioniert es:

  1. Nimm jede dreistellige Zeichenfolge aus der Zeichenfolge, mit einer Überlappung von eins (das ist es, was der --posmacht).
  2. Hängen Sie diese dreistellige Zeichenfolge an ein Array an, wenn ihr Wert den Wert des letzten Elements des Arrays überschreitet. hier ist "Wert" nur die Summe der Werte seiner Charaktere in Schläfrigkeit.
  3. Gibt das letzte Element des Arrays aus.
— msh210
quelle
0

ES6, 81 72 Bytes

a=>"-.-,-.=,=.-,-.o,=.=,o.-,=.o,o.=,o.o".split`,`.find(b=>a.includes(b))

Benötigt wahrscheinlich Chrome 45 oder Firefox 41.

Vielen Dank an @ETHproductions für die Einsparung von 9 Bytes.

— Neil
quelle
1
Nett, "=.-"sollte aber mit getauscht werden "-.o"; das gleiche mit "=.o"und "o.-". Möglicherweise können Sie auch einige Bytes speichern, indem Sie alles in eine durch Kommas getrennte Zeichenfolge setzen und verwenden .split`,` .
— ETHproductions
Durch die Verwendung von split könnten 9 Zeichen
— gespart werden
@ETHproductions Tut mir leid, dass ich nicht bemerkt habe, dass die ursprüngliche Liste der Gesichter nicht in der Reihenfolge der Schläfrigkeit lag.
— Neil
0

> <> , 55 Bytes

versuch es hier!

<v~i:i&0"."0
 >i:@+:&:@)?v&~i0(?v
 ^?)0i:r~r&~<;ooo$r<

Gibt das meiste Wachgesicht aus.

Da die ASCII-Werte für -, = und o jeweils zunehmen, könnte ich das zu meinem Vorteil nutzen. Grundsätzlich werden die Werte des aktuellen und des vorherigen Augenteils addiert, überprüft, ob es sich um einen höheren Wert als zuvor handelt. Wenn dies der Fall ist, wird der neue Wert gespeichert und die entsprechende Fläche aktualisiert. Anschließend wird eine Schleife bis zum Ende der Eingabe ausgeführt. Gibt dann das verbleibende Gesicht aus. (Ich bin sehr erfreut darüber, wie gut der gesamte Code passt)

— Torcado
quelle
0

Perl 5 -MList::Util=max -p , 68 Bytes

s|..(?=(.))|$t=max$t,ord($&)%15%4+ord($1)%15%4 .$&.$1|eg;$_=$t;s/.//

Probieren Sie es online!

Ergreift jede Gruppe von drei Zeichen, ignoriert die .in der Mitte, ordnet die Addition der beiden anderen zu einer Ganzzahl im Bereich von 0 bis 4 zu, verkettet diese mit der Vorderseite des Emoticon-Gesichts und sortiert sie danach. Nimmt den letzten Eintrag (meistens wach), entfernt die Nummer von vorne und gibt sie aus.

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