Sfida

Considera l'arcobaleno come sette colori, rappresentato da stringhe come Red Orange Yellow Green Blue Indigo Violet.
Il tuo compito è quello di creare un programma che riceva uno di questi colori come input e output nell'ordine del colore arcobaleno. Ciò include la sovrapposizioneViolet -> Red

Ingresso

Una stringa contenente uno dei colori dell'arcobaleno.

Produzione

Il prossimo in ordine di colore dell'arcobaleno.

Regole

• I nomi dei colori fanno distinzione tra maiuscole e minuscole. Devono corrispondere al caso incluso in questo post.
• L'input sarà sempre valido. È consentito qualsiasi comportamento per input non valido.
• Questo è il golf del codice, quindi vince il minor numero di byte!

Esempio di input e output

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

SOGL V0.12 , 23 byte

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

Provalo qui!

Spiegazione:

...‘θ⁽,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 byte

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

Per l'input "Red", questa funzione crea innanzitutto un RegExp /Red(.[a-z]*)/in modo che corrisponda alla stringa 'RedOrangeYellowGreenBlueIndigoVioletRed'e quindi restituisca il primo risultato di acquisizione.

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 byte

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

Provalo online!

Ora che la sfida è stata cambiata per diventare ciclica la soluzione regex

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

non è più ottimale (a causa del doppio Red)

Anche 57 byte:

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

Provalo online!

Python , 79 byte

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

Provalo online!

Maniglie Violet -> Red. La funzione desiderata viene data in modo anonimo nella seconda riga.

80 byte

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

Provalo online!

Perl 6 , 56 byte

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

Provalo online!

Sfrutta il fatto che i bit 2-4 dei codici ASCII della prima lettera di ciascun colore corrispondono a 0-6.

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

Ecco una bella soluzione non competitiva che utilizza "viola" invece di "indaco" e "viola" (38 caratteri, 59 byte):

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

Provalo online!

Ruby -n , 62 60 byte

-2 di Asone Tuhid.

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

Provalo online!

L'approccio Regex sembra promettente anche per Ruby. Tuttavia, sono arrivato a una soluzione più breve usando un lookahead e stampando direttamente la partita, piuttosto che giocare con i gruppi di acquisizione. L'elenco dei colori è nella direzione opposta poiché lookahead costa 1 byte in meno rispetto a lookbehind.

Rosso , 87 byte

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

Provalo online!

05AB1E , 30 byte

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

Provalo online!

Spiegazione

“†¾›ÈŠÛˆ¨‡—ëß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 byte

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

Utilizza nomi minuscoli.

Stesso approccio, con lettere maiuscole 86 byte:

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

Haskell , 80 71 75 byte

^{Grazie a Laikoni per accorciare 9 byte!}

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

Provalo online!

Un'altra soluzione, leggermente più idiomatica, ma non potrei accorciarla:

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

Deve derivare a Readcausa del requisito che l'input sia una stringa e almeno Eqo Showper verificare l'uguaglianza o mostrare il risultato.

Retina , 65 58 byte

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

Provalo online!

Spiegazione

$
(.[a-z]+)

Iniziamo aggiungendo (.[a-z]+)l'input, trasformandolo in una regex che corrisponde al colore di input, immediatamente seguito da esattamente un altro colore (catturando quest'ultimo).

L$:`RedOrangeYellowGreenBlueIndigoVioletRed
$1

Ora :scambia l'ingresso dello stage con la sua regex. Quindi il risultato precedente diventa regex ed è abbinato all'elenco dei colori. La (singola) partita viene sostituita con il suo primo gruppo di acquisizione (ovvero il colore successivo nel ciclo) e restituita. L'output alla fine del programma avviene automaticamente.

Vim, 59 56 53 52 byte

-1 byte grazie a 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]

Provalo online!

Titoli di coda

• -10 byte grazie a Kevin Cruijssen
• -1 byte grazie a Okx

Cocco , 79 byte

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

Provalo online!

Buccia , 28 byte

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

Provalo online!

Forse ci sono opzioni migliori per gestire gli argomenti, ma questa è la migliore che ho trovato

Spiegazione

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 byte

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

Esegui ed esegui il debug

Questo utilizza l'istruzione di traduzione suoneria. Sostituisce ogni elemento in un array con il seguente dal "decoder ring". Di solito, viene utilizzato per eseguire la sostituzione di caratteri in una stringa, ma può essere utilizzato anche su un'intera stringa, se è racchiuso in una matrice singleton.

Ecco la rappresentazione ascii scompattata, non golfata e commentata dello stesso programma.

]   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

Esegui questo

J , 67 64 62 byte

-2 byte grazie a FrownyFrog

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

Provalo online!

R, 109 93 bytes

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

Try it online!

-16 thanks to Giuseppe for the use of match advice

Batch, 97 bytes

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

Explanation: The call on the second line has the effect of substituting the parameter into the command and evaluating it, turning it into e.g. set s=%s:Red =%, which deletes the prefix of the string that includes the parameter. The substitution on the third line then replaces all the spaces with statement separators and comments. This works because string substitution happens before parsing.

Ruby -n, 75 69 bytes

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

Try it online!

Julia 0.6, 76 bytes

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

Try it online!

This handles the Violet->Red by recycling the string with the power ^ operator.

Here's a slightly longer solution without regexes:

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

PowerShell, 74 bytes

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

Try it online!

Takes the string "Red ... Violet " and string-multiplies it out by two to properly handle the Violet -> Red test case. We then -split that string on input $args to give us an array of two strings. We take the second string thereof [1], then -split that on whitespace to give us an array of strings and take the first [0].

For example, for input "Yellow", the first step will result in @("Red Orange ", " Green Blue Indigo ... Indigo Violet "). We take the second one of that, split it on whitespace (which removes the whitespace), resulting in @("Green", "Blue", ... "Violet"), so taking the [0] one thereof results in the proper next string.

IBM/Lotus Notes Formula Language, 79 74 bytes

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

Previous version for 79:

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

Takes input from an editable text field called a.

There is no TIO for formula language so here's a couple of screenshots.

PHP, 92 bytes

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

Try it online!

Kotlin, 73 bytes

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

Try it online!

Taking advantage of the fact that many colors are 6 characters, the ones that are not are prefixed with spaces to make them 6 characters long. Hopefully it's acceptable that some of the colors are outputted with spaces before them.
e.g. Red is " Red", Blue is " Blue"

SmileBASIC, 94 84 bytes

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

Gema, 67 characters

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

Sample run:

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 characters

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

Boring one. Dumbest approach ever, but quite short.

Sample run:

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

Solution:

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

Examples:

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"

Explanation:

Create a dictionary of colour => next colour, the input is the key to the dictionary:

.[!;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:

It's 53 bytes in K4:

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

Japt, 45 43 bytes

-2 bytes thanks to Shaggy

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

Try it online!

sed, 72 bytes

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

Try it Online

Example 1:

Input:

Red
Orange
Yellow
Green
Blue
Indigo
Violet

Output:

Orange
Yellow
Green
Blue
Indigo
Violet
Red

Example 2:

Input:

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

Output:

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