Herausforderung

Betrachten Sie den Regenbogen als sieben Farben, dargestellt durch Zeichenfolgen als Red Orange Yellow Green Blue Indigo Violet.
Ihre Aufgabe ist es, ein Programm zu erstellen, das eine dieser Farben als Ein- und Ausgabe in der Reihenfolge der Regenbogenfarben erhält. Dies schließt Überlappungen einViolet -> Red

Eingang

Eine Zeichenfolge, die eine der Regenbogenfarben enthält.

Ausgabe

Die nächste in der Bestellfarbe des Regenbogens.

Regeln

• Farbnamen unterscheiden zwischen Groß- und Kleinschreibung. Sie müssen mit dem in diesem Beitrag enthaltenen Fall übereinstimmen.
• Die Eingabe ist immer gültig. Jedes Verhalten ist für ungültige Eingaben zulässig.
• Dies ist Codegolf, also gewinnt die kürzeste Anzahl von Bytes!

Beispiel für Ein- und Ausgabe

Input -> Output
Red -> Orange
Orange -> Yellow
Yellow -> Green
Green -> Blue
Blue -> Indigo
Indigo -> Violet
Violet -> Red

SOGL V0.12 , 23 Bytes

k‰³d∆|ΝμHō↑≥░δ÷f‘θ⁽,WIw

Probieren Sie es hier aus!

Erläuterung:

...‘θ⁽,WIw  
...‘        push "red orange yellow green blue indigo violet"
    θ       split on spaces
     ⁽      uppercase the 1st letter of every item (SOGLs dictionary only has lowercase words)
      ,W    get the inputs index in the array
        I   increment
         w  and get that item in the array, wrapping if necessary

JavaScript, 68 Bytes

s=>'RedOrangeYellowGreenBlueIndigoVioletRed'.match(s+'(.[a-z]*)')[1]

Für die Eingabe erstellt "Red"diese Funktion zuerst ein RegExp /Red(.[a-z]*)/, das mit der Zeichenfolge übereinstimmt, 'RedOrangeYellowGreenBlueIndigoVioletRed'und gibt dann das erste Erfassungsergebnis zurück.

f=
s=>'RedOrangeYellowGreenBlueIndigoVioletRed'.match(s+'(.[a-z]*)')[1]

document.write('<table><tr><th>Input<th>Output')
for(i='Red';;){
document.write(`<tr><td>${i}<td>${i=f(i)}`);
if(i=='Red')break;
}

Perl 5 -p , 58 57 Bytes

#!/usr/bin/perl -p
$_={(Red,Orange,Yellow,Green,Blue,Indigo,Violet)x2}->{$_}

Probieren Sie es online!

Jetzt, da die Herausforderung geändert wurde, um zyklisch zu sein, ist die Regex-Lösung

say RedOrangeYellowGreenBlueIndigoVioletRed=~/$_(.[a-z]+)/

ist nicht mehr optimal (wegen des doppelten Red)

Auch 57 Bytes:

#!/usr/bin/perl -p
$_=(Indigo,Blue,Violet,Yellow,Orange,Red,Green)[ord>>2&7]

Probieren Sie es online!

Python , 79 Bytes

z="Red Orange Yellow Green Blue Indigo Violet".split()*2
dict(zip(z,z[1:])).get

Probieren Sie es online!

Griffe Violet -> Red. Die gewünschte Funktion wird anonym in der zweiten Zeile angegeben.

80 Bytes

lambda x:"Red Orange Yellow Green Blue Indigo Violet Red".split(x)[1].split()[0]

Probieren Sie es online!

Perl 6 , 56 Bytes

{<Indigo Blue Violet Yellow Orange Red Green>[.ord/4%8]}

Probieren Sie es online!

Nutzt die Tatsache aus, dass Bits 2-4 der ASCII-Codes des ersten Buchstabens jeder Farbe zufällig auf 0-6 abgebildet werden.

say map (*.ord +> 2) % 8, <R O Y G B I V>
# (4 3 6 1 0 2 5)

Hier ist eine nette, nicht konkurrierende Lösung, die "lila" anstelle von "indigo" und "violett" verwendet (38 Zeichen, 59 Bytes):

{'🍎🧡💛💚💙💜🍎'.uninames~~m/$^a.\S+.<(\S+/}

Probieren Sie es online!

Rubin -n , 62 60 Bytes

-2 von Asone Tuhid.

p"RedVioletIndigoBlueGreenYellowOrangeRed"[/.[a-z]+(?=#$_)/]

Probieren Sie es online!

Der Regex-Ansatz sieht auch für Ruby vielversprechend aus. Ich bin jedoch zu einer kürzeren Lösung gekommen, indem ich einen Lookahead verwendet und das Match direkt gedruckt habe, anstatt mit Erfassungsgruppen zu spielen. Die Liste der Farben ist in umgekehrter Richtung, da lookahead 1 Byte billiger ist als lookbehind.

Rot , 87 Bytes

func[c][print first find/tail[Red Orange Yellow Green Blue Indigo Violet Red]to-word c]

Probieren Sie es online!

05AB1E , 30 Bytes

“†¾›ÈŠÛˆ¨‡—ëßigo°Íolet“#™DIk>è

Probieren Sie es online!

Erläuterung

“†¾›ÈŠÛˆ¨‡—ëßigo°Íolet“          # push a string of colours
                       #         # split on spaces
                        ™        # title-case each
                         D       # duplicate
                          Ik     # get the index of the input
                            >    # increment
                             è   # get the element at that index

Excel, 85 Bytes

=CHOOSE(MOD(CODE(A1),12),"green","indigo","yellow",,,"orange","blue",,"violet","red")

Verwendet Kleinbuchstaben.

Gleicher Ansatz mit 86 Bytes in Großbuchstaben:

=CHOOSE(MOD(CODE(A1),12),"Violet","Red",,,"Green","Indigo","Yellow",,,"Orange","Blue")

Haskell , 80 71 75 Bytes

^{Danke an Laikoni für die Kürzung von 9 Bytes!}

g x=snd(span(/=x)$words"Red Orange Yellow Green Blue Indigo Violet Red")!!1

Probieren Sie es online!

Eine andere Lösung, etwas idiomatischer, aber ich könnte es nicht kürzer machen:

data R=Red|Orange|Yellow|Green|Blue|Indigo|Violet deriving(Enum,Read,Eq)
succ.read

Es muss abgeleitet werden, Readweil die Eingabe eine Zeichenfolge ist und mindestens Eqoder Showum entweder auf Gleichheit zu testen oder das Ergebnis anzuzeigen.

Retina , 65 58 Bytes

$
(.[a-z]+)
L$:`RedOrangeYellowGreenBlueIndigoVioletRed
$1

Probieren Sie es online!

Erläuterung

$
(.[a-z]+)

Wir beginnen mit dem Anhängen (.[a-z]+)an die Eingabe und verwandeln sie in eine Regex, die der Eingabefarbe entspricht, unmittelbar gefolgt von genau einer weiteren Farbe (Erfassung der letzteren).

L$:`RedOrangeYellowGreenBlueIndigoVioletRed
$1

Jetzt wird der :Bühneneingang durch einen eigenen regulären Ausdruck ersetzt. Das vorherige Ergebnis wird zum regulären Ausdruck und mit der Liste der Farben abgeglichen. Die (einzelne) Übereinstimmung wird durch die erste Erfassungsgruppe (dh die nächste Farbe im Zyklus) ersetzt und zurückgegeben. Die Ausgabe am Programmende erfolgt automatisch.

Vim, 59 56 53 52 Bytes

-1 Byte dank tsh

2IYellow Green Blue Indigo Violet Red Orange <Esc>*wywVp

Java (JDK 10) , 77 Byte

s->"Red Orange Yellow Green Blue Indigo Violet Red".split(s)[1].split(" ")[1]

Probieren Sie es online!

Credits

• -10 Bytes dank Kevin Cruijssen
• -1 Byte dank Okx

Kokosnuss , 79 Bytes

s->"# Violet Red # # Green Indigo Yellow # # Orange Blue".split()[ord(s[0])%12]

Probieren Sie es online!

Schale , 28 Bytes

S!o→€⁰w¨ṙ}ΘΞĠ«ẇ₇G²€ḃλBżḃIÿö⌉

Probieren Sie es online!

Vielleicht gibt es bessere Optionen für die Verwaltung der Argumente, aber dies ist das Beste, was ich finden konnte

Erläuterung

S!o→€⁰w¨ṙ}ΘΞĠ«ẇ₇G²€ḃλBżḃIÿö⌉
       ¨ṙ}ΘΞĠ«ẇ₇G²€ḃλBżḃIÿö⌉    Compressed string with all the colors
                                "Red Orange Yellow Green Blue Indigo Violet"
      w                         Split on spaces
S                               Pass the list to both the following functions:
    €⁰                          1) Find the index of the input in the list
  o→                                  and increase it by one
 !                              2) Get the element of the list at the
                                   resulting position (indexing is cyclical)

Stax , 31 30 29 Bytes

ÇôF┘≡▓ƒ◄╙>┘☼░⌂╪B<U[ÇQ╒eöΣQ╔÷n

Führen Sie es aus und debuggen Sie es

Dies verwendet den Ringübersetzungsbefehl. Es ersetzt jedes Element in einem Array durch das folgende Element aus dem "Decoder-Ring". Normalerweise wird die Zeichenersetzung in einer Zeichenfolge verwendet, sie kann jedoch auch für eine gesamte Zeichenfolge verwendet werden, wenn sie in ein Singleton-Array eingeschlossen ist.

Hier ist die entpackte, ungolfierte, kommentierte ASCII-Darstellung desselben Programms.

]   wrap input in singleton array
`5^bZ_9G*h]h%oM~X9e-0ZQJkb2`    compressed string literal with color names
:.j title case and split on spaces
:t  do ring translation

Führen Sie dieses aus

J , 67 64 62 Bytes

-2 Bytes danke an FrownyFrog

>:&.((cut'Red Orange Yellow Green Blue Indigo Violet Red')i.<)

Probieren Sie es online!

R , 109 93 Bytes

function(x){y=c("Red","Orange","Yellow","Green","Blue","Indigo","Violet");y[match(x,y)%%7+1]}

Probieren Sie es online!

-16 Dank an Giuseppe für die Verwendung von matchRatschlägen

Batch, 97 Bytes

@set s=Red Orange Yellow Green Blue Indigo Violet Red
@call set s=%%s:*%1 =%%
@echo %s: =&rem %

Erläuterung: In callder zweiten Zeile wird der Parameter durch den Befehl ersetzt und ausgewertet. set s=%s:Red =%Dadurch wird beispielsweise das Präfix der Zeichenfolge gelöscht, die den Parameter enthält. Die Ersetzung in der dritten Zeile ersetzt dann alle Leerzeichen durch Anweisungstrennzeichen und Kommentare. Dies funktioniert, weil die Zeichenfolge vor dem Parsen ersetzt wird.

Ruby -n , 75 69 Bytes

a=%w{Red Orange Yellow Green Blue Indigo Violet};p a[-~(a.index$_)%7]

Probieren Sie es online!

Julia 0,6 , 76 Bytes

f(s)=match(Regex("$s(.[a-z]*)"),"RedOrangeYellowGreenBlueIndigoViolet"^2)[1]

Probieren Sie es online!

Dies behandelt das Violett-> Rot, indem die Saite mit Strom versorgt wird ^ Netzbetreiber .

Hier ist eine etwas längere Lösung ohne reguläre Ausdrücke:

g(s,l=split("Red Orange Yellow Green Blue Indigo Violet"," "))=l[(findin(l,[s])[1])%7+1]

PowerShell , 74 Byte

(-split("Red Orange Yellow Green Blue Indigo Violet "*2-split$args)[1])[0]

Probieren Sie es online!

Nimmt den String "Red ... Violet "und multipliziert ihn mit zwei, um den Violet -> RedTestfall richtig zu behandeln . Wir haben dann -splitdiese Zeichenfolge bei der Eingabe$args , um uns ein Array von zwei Zeichenfolgen zu geben. Wir nehmen die zweite Zeichenkette [1], dann -splitdie Whitespace- Zeichenkette , um uns eine Reihe von Zeichenketten zu geben und die erste zu nehmen[0] .

Bei der Eingabe "Yellow"führt der erste Schritt beispielsweise zu @("Red Orange ", " Green Blue Indigo ... Indigo Violet "). Wir nehmen die zweite davon, teilen sie in Leerzeichen auf (wodurch das Leerzeichen entfernt wird), was dazu führt @("Green", "Blue", ... "Violet"), dass die [0]nächste richtige Zeichenfolge entsteht.

IBM / Lotus Notes Formula Language, 79 74 Byte

@Left(@Right("Red Orange Yellow Green Blue Indigo Violet Red ";a+" ");" ")

Vorgängerversion für 79:

R:=@Explode("Red,Orange,Yellow,Green,Blue,Indigo,Violet,Red");R[@Member(a;R)+1]

Übernimmt Eingaben aus einem bearbeitbaren Textfeld namens a.

Es gibt kein TIO für die Formelsprache. Hier sind ein paar Screenshots.

PHP, 92 Bytes

$a=" Red   OrangeYellowGreen Blue  IndigoVioletRed";echo substr($a,strpos($a,$argv[1])+6,6)

Probieren Sie es online!

Kotlin , 73 Bytes

x->"RedOrangeYellow Green  BlueIndigoVioletRed".substringAfter(x).take(6)

Probieren Sie es online!

Unter Ausnutzung der Tatsache, dass viele Farben aus 6 Zeichen bestehen, wird den Farben, denen keine Leerzeichen vorangestellt sind, eine Länge von 6 Zeichen vorangestellt. Es ist hoffentlich akzeptabel, dass einige der Farben mit Leerzeichen vor ihnen ausgegeben werden.
zB ist Rot, ist " Red"Blau" Blue"

SmileBASIC, 94 84 Bytes

C$="Red   OrangeYellowGreen Blue  IndigoViolet
INPUT I$?MID$(C$*2,INSTR(C$,I$)+6,6)

Gema , 67 Zeichen

*=@subst{*\?<J>=\?\$2\;\?=;RedOrangeYellowGreenBlueIndigoVioletRed}

Probelauf:

bash-4.4$ echo -n Yellow | gema '*=@subst{*\?<J>=\?\$2\;\?=;RedOrangeYellowGreenBlueIndigoVioletRed}'
Green

bash-4.4$ echo -n Violet | gema '*=@subst{*\?<J>=\?\$2\;\?=;RedOrangeYellowGreenBlueIndigoVioletRed}'
Red

Gema , 59 Zeichen

R=Orange
O=Yellow
Y=Green
G=Blue
B=Indigo
I=Violet
V=Red
*=

Langweilig. Dümmster Ansatz aller Zeiten, aber ziemlich kurz.

Probelauf:

bash-4.4$ gema 'R=Orange;O=Yellow;Y=Green;G=Blue;B=Indigo;I=Violet;V=Red;*=' <<< 'Yellow'
Green

bash-4.4$ gema 'R=Orange;O=Yellow;Y=Green;G=Blue;B=Indigo;I=Violet;V=Red;*=' <<< 'Violet'
Red

q / kdb + , 59 55 Bytes

Lösung:

.[!;2 8#($)`Red`Violet`Indigo`Blue`Green`Yellow`Orange]

Beispiele:

q).[!;2 8#($)`Red`Violet`Indigo`Blue`Green`Yellow`Orange]"Red"
"Violet"
q).[!;2 8#($)`Red`Violet`Indigo`Blue`Green`Yellow`Orange]"Orange"
"Red"
q).[!;2 8#($)`Red`Violet`Indigo`Blue`Green`Yellow`Orange]"Blue"
"Green"

Erläuterung:

Erstellen Sie ein Wörterbuch der Farbe => nächste Farbe, die Eingabe ist der Schlüssel zum Wörterbuch:

.[!;2 8#($)`Red`Violet`Indigo`Blue`Green`Yellow`Orange] / the solution
.[ ;                                                  ] / apply multiple args to function
           `Red`Violet`Indigo`Blue`Green`Yellow`Orange  / list of colours
         ($)                                            / convert to strings
    2 8#                                                / reshape into 2x8 grid
  !                                                     / create dictionary

Bonus:

Es ist 53 Bytes in K4:

.[!;2 8#$`Red`Violet`Indigo`Blue`Green`Yellow`Orange]

Japt , 45 43 Bytes

-2 Bytes dank Shaggy

`R‚sOÎÁƒYÁMwsGÎ9sBluƒI˜igosVio¤t`qs
g1+UbNg

Probieren Sie es online!

sed, 72 bytes

s/$/%RedOrangeYellowGreenBlueIndigoVioletRed/;s/(.+)%.*\1(.[a-z]+).*/\2/

Probieren Sie es online

Beispiel 1:

Eingang:

Red
Orange
Yellow
Green
Blue
Indigo
Violet

Ausgabe:

Orange
Yellow
Green
Blue
Indigo
Violet
Red

Beispiel 2:

Eingang:

Indigo
Yellow
Red
Red
Blue
Green
Orange
Violet
Green
Green
Green
Blue
Blue
Violet

Ausgabe:

Violet
Green
Orange
Orange
Indigo
Blue
Yellow
Red
Blue
Blue
Blue
Indigo
Indigo
Red