Desafío

Considere el arco iris como siete colores, representados por cadenas como Red Orange Yellow Green Blue Indigo Violet.
Su tarea es crear un programa que reciba uno de estos colores como entradas y salidas a continuación en el orden del color del arco iris. Esto incluye la superposiciónViolet -> Red

Entrada

Una cadena que contiene uno de los colores del arco iris.

Salida

El siguiente en orden color del arcoiris.

Reglas

• Los nombres de los colores distinguen entre mayúsculas y minúsculas. Deben coincidir con el caso incluido en esta publicación.
• La entrada siempre será válida. Cualquier comportamiento está permitido para entradas no válidas.
• Este es el código de golf, por lo que gana la menor cantidad de bytes.

Ejemplo de entrada y salida

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

Pruébalo aquí!

Explicación:

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

Para la entrada "Red", esta función primero construye un RegExp /Red(.[a-z]*)/para que coincida con la cadena 'RedOrangeYellowGreenBlueIndigoVioletRed'y luego devuelve el primer resultado de captura.

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}->{$_}

Pruébalo en línea!

Ahora que el desafío ha cambiado para ser cíclico, la solución regex

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

ya no es óptimo (debido al doble Red)

También 57 bytes:

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

Pruébalo en línea!

Python , 79 bytes

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

Pruébalo en línea!

Manijas Violet -> Red. La función deseada se proporciona de forma anónima en la segunda línea.

80 bytes

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

Pruébalo en línea!

Perl 6 , 56 bytes

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

Pruébalo en línea!

Explota el hecho de que los bits 2-4 de los códigos ASCII de la primera letra de cada color se asignan a 0-6.

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

Aquí hay una buena solución no competitiva que usa "púrpura" en lugar de "índigo" y "violeta" (38 caracteres, 59 bytes):

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

Pruébalo en línea!

Ruby -n , 62 60 bytes

-2 por Asone Tuhid.

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

Pruébalo en línea!

El enfoque de Regex también parece prometedor para Ruby. Sin embargo, llegué a una solución más corta usando una búsqueda anticipada e imprimiendo directamente el partido, en lugar de jugar con grupos de captura. La lista de colores está en dirección inversa, ya que la búsqueda anticipada es 1 byte más barata que la búsqueda anticipada.

Rojo , 87 bytes

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

Pruébalo en línea!

05AB1E , 30 bytes

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

Pruébalo en línea!

Explicación

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

Utiliza nombres en minúsculas.

Mismo enfoque, con letras mayúsculas 86 bytes:

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

Haskell , 80 71 75 bytes

^{¡Gracias a Laikoni por acortar 9 bytes!}

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

Pruébalo en línea!

Otra solución, un poco más idiomática, pero no pude acortarla:

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

Debe derivar Readdebido al requisito de que la entrada es una cadena y al menos Eqo Showpara probar la igualdad o mostrar el resultado.

Retina , 65 58 bytes

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

Pruébalo en línea!

Explicación

$
(.[a-z]+)

Comenzamos agregando (.[a-z]+)a la entrada, convirtiéndola en una expresión regular que coincida con el color de entrada, seguido inmediatamente por un color más (capturando el último).

L$:`RedOrangeYellowGreenBlueIndigoVioletRed
$1

Ahora :intercambia la entrada del escenario con su propia expresión regular. Entonces, el resultado anterior se convierte en la expresión regular y se compara con la lista de colores. La coincidencia (única) se reemplaza con su primer grupo de captura (es decir, el siguiente color en el ciclo) y se devuelve. La salida al final del programa ocurre automáticamente.

Vim, 59 56 53 52 Bytes

-1 byte gracias a tsh

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

Java (JDK 10) , 77 bytes

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

Pruébalo en línea!

Créditos

• -10 bytes gracias a Kevin Cruijssen
• -1 byte gracias a Okx

Coco , 79 bytes

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

Pruébalo en línea!

Casco , 28 bytes

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

Pruébalo en línea!

Quizás haya mejores opciones para manejar los argumentos, pero esto es lo mejor que pude encontrar

Explicación

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

Ejecutar y depurarlo

Esto usa la instrucción de traducción de anillo. Reemplaza cada elemento en una matriz con el siguiente del "anillo decodificador". Por lo general, se usa para reemplazar caracteres en una cadena, pero también se puede usar en una cadena completa, si está envuelta en una matriz singleton.

Aquí está la representación ascii desempaquetada, sin golf y comentada del mismo programa.

]   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

Ejecute este

J , 67 64 62 bytes

-2 bytes gracias a FrownyFrog

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

Pruébalo en línea!

R , 109 93 bytes

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

Pruébalo en línea!

-16 gracias a Giuseppe por el uso de matchconsejos

Lote, 97 bytes

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

Explicación: El callen la segunda línea tiene el efecto de sustituir el parámetro en el comando y evaluarlo, convirtiéndolo en set s=%s:Red =%, por ejemplo , lo que elimina el prefijo de la cadena que incluye el parámetro. La sustitución en la tercera línea reemplaza todos los espacios con separadores de declaraciones y comentarios. Esto funciona porque la sustitución de cadenas ocurre antes del análisis.

Ruby -n , 75 69 bytes

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

Pruébalo en línea!

Julia 0.6 , 76 bytes

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

Pruébalo en línea!

Esto maneja el Violet-> Red reciclando la cadena con el poder ^ operador de .

Aquí hay una solución un poco más larga sin expresiones regulares:

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]

Pruébalo en línea!

Toma la cuerda "Red ... Violet "y la cadena la multiplica por dos para manejar adecuadamente el Violet -> Redcaso de prueba. Luego -splitcolocamos esa cadena en la entrada $argspara darnos una matriz de dos cadenas. Tomamos la segunda cuerda del mismo[1] , luego -spliten el espacio en blanco para darnos una serie de cadenas y tomar la primera [0].

Por ejemplo, para la entrada "Yellow", el primer paso dará como resultado @("Red Orange ", " Green Blue Indigo ... Indigo Violet "). Tomamos el segundo de eso, lo dividimos en espacios en blanco (que elimina el espacio en blanco), lo que da como resultado @("Green", "Blue", ... "Violet"), por lo que tomar [0]uno de los mismos da como resultado la siguiente cadena adecuada.

Lenguaje de fórmulas IBM / Lotus Notes, 79 74 bytes

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

Versión anterior para 79:

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

Toma datos de un campo de texto editable llamado a .

No hay TIO para el lenguaje de fórmulas, así que aquí hay un par de capturas de pantalla.

PHP, 92 bytes

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

Pruébalo en línea!

Kotlin , 73 bytes

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

Pruébalo en línea!

Aprovechando el hecho de que muchos colores son de 6 caracteres, los que no lo son tienen prefijos de espacios para que tengan 6 caracteres de longitud. Con suerte, es aceptable que algunos de los colores se emitan con espacios antes de ellos.
por ejemplo, rojo es " Red", azul es" Blue"

SmileBASIC, 94 84 bytes

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

Gema , 67 personajes

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

Ejecución de muestra:

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 caracteres

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

Aburrido uno. El enfoque más tonto de todos los tiempos, pero bastante corto.

Ejecución de muestra:

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

Solución:

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

Ejemplos:

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"

Explicación:

Cree un diccionario de color => siguiente color, la entrada es la clave del diccionario:

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

Prima:

Son 53 bytes en K4:

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

Japt , 45 43 bytes

-2 bytes gracias a Shaggy

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

Pruébalo en línea!

sed, 72 bytes

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

Pruébalo en línea

Ejemplo 1:

Entrada:

Red
Orange
Yellow
Green
Blue
Indigo
Violet

Salida:

Orange
Yellow
Green
Blue
Indigo
Violet
Red

Ejemplo 2

Entrada:

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

Salida:

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