Desafio

Considere o arco-íris como sete cores, representadas por seqüências de caracteres como Red Orange Yellow Green Blue Indigo Violet.
Sua tarefa é criar um programa que receba uma dessas cores como entrada e saída a seguir na ordem da cor do arco-íris. Isso inclui sobreposiçãoViolet -> Red

Entrada

Uma sequência contendo uma das cores do arco-íris.

Saída

O próximo em ordem cor do arco-íris.

Regras

• Os nomes de cores diferenciam maiúsculas de minúsculas. Eles devem corresponder ao caso incluído nesta postagem.
• A entrada sempre será válida. Qualquer comportamento é permitido para entrada inválida.
• Isso é código de golfe, então a menor quantidade de bytes vence!

Exemplo de entrada e saída

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

Experimente aqui!

Explicação:

...‘θ⁽,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 entrada "Red", essa função primeiro constrói um RegExp /Red(.[a-z]*)/para corresponder à sequência 'RedOrangeYellowGreenBlueIndigoVioletRed'e, em seguida, retorna o primeiro resultado da 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}->{$_}

Experimente online!

Agora que o desafio foi alterado para ser cíclico, a solução regex

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

não é mais ideal (devido ao dobro Red)

Também 57 bytes:

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

Experimente online!

Python , 79 bytes

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

Experimente online!

Alças Violet -> Red. A função desejada é dada anonimamente na segunda linha.

80 bytes

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

Experimente online!

Perl 6 , 56 bytes

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

Experimente online!

Explora o fato de que os bits 2-4 dos códigos ASCII da primeira letra de cada cor são mapeados para 0-6.

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

Aqui está uma boa solução não concorrente que usa "roxo" em vez de "índigo" e "violeta" (38 caracteres, 59 bytes):

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

Experimente online!

Ruby -n , 62 60 bytes

-2 por Asone Tuhid.

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

Experimente online!

A abordagem Regex também parece promissora para Ruby. No entanto, cheguei a uma solução mais curta usando um lookahead e imprimindo diretamente a partida, em vez de jogar com grupos de captura. A lista de cores está na direção inversa, já que a aparência da cabeça é 1 byte mais barata que a aparência.

Vermelho , 87 bytes

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

Experimente online!

05AB1E , 30 bytes

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

Experimente online!

Explicação

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

Usa nomes em minúsculas.

Mesma abordagem, com letras maiúsculas 86 bytes:

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

Haskell , 80 71 75 bytes

^{Obrigado a Laikoni por reduzir 9 bytes!}

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

Experimente online!

Outra solução, um pouco mais idiomática, mas não consegui reduzi-la:

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

Ele precisa derivar Readdevido ao requisito de que a entrada seja uma sequência e, pelo menos Eqou Showpara testar a igualdade ou mostrar o resultado.

Retina , 65 58 bytes

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

Experimente online!

Explicação

$
(.[a-z]+)

Começamos anexando (.[a-z]+)à entrada, transformando-a em um regex que corresponde à cor da entrada, imediatamente seguido por exatamente mais uma cor (capturando a última).

L$:`RedOrangeYellowGreenBlueIndigoVioletRed
$1

Agora, a :entrada do palco é trocada com seu próprio regex. Portanto, o resultado anterior se torna o regex e é comparado com a lista de cores. A partida (única) é substituída por seu primeiro grupo de captura (ou seja, a próxima cor do ciclo) e retornada. A saída no final do programa acontece automaticamente.

Vim, 59 56 53 52 Bytes

-1 byte graças 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]

Experimente online!

Créditos

• -10 bytes graças a Kevin Cruijssen
• -1 byte graças a Okx

Coco , 79 bytes

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

Experimente online!

Casca , 28 bytes

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

Experimente online!

Talvez haja melhores opções para gerenciar os argumentos, mas isso é o melhor que pude encontrar

Explicação

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

Execute e depure

Isso usa a instrução de conversão de toque. Ele substitui cada elemento em uma matriz pelo seguinte do "anel decodificador". Geralmente, é usado para fazer a substituição de caracteres em uma string, mas também pode ser usado em uma string inteira, se estiver envolvido em uma matriz singleton.

Aqui está a representação ASCII descompactada, não destruída e comentada do mesmo 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

Execute este

J , 67 64 62 bytes

-2 bytes obrigado a FrownyFrog

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

Experimente online!

R , 109 93 bytes

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

Experimente online!

-16 agradecimentos a Giuseppe pelo uso de matchconselhos

Lote, 97 bytes

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

Explicação: A callsegunda linha tem o efeito de substituir o parâmetro no comando e avaliá-lo, transformando-o em set s=%s:Red =%, por exemplo , que exclui o prefixo da sequência que inclui o parâmetro. A substituição na terceira linha substitui todos os espaços por separadores de instrução e comentários. Isso funciona porque a substituição de string ocorre antes da análise.

Ruby -n , 75 69 bytes

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

Experimente online!

Julia 0.6 , 76 bytes

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

Experimente online!

Isso lida com o violeta-> vermelho reciclando a corda com o ^operador de energia .

Aqui está uma solução um pouco mais longa sem 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]

Experimente online!

Pega a string "Red ... Violet "e multiplica-a por dois para lidar adequadamente com o Violet -> Redcaso de teste. Em seguida, colocamos -splita string na entrada $argspara fornecer uma matriz de duas strings. Tomamos a segunda corda do mesmo [1], em seguida, -splitque no espaço em branco para nos dar uma matriz de strings e tomar a primeira [0].

Por exemplo, para entrada "Yellow", o primeiro passo resultará em @("Red Orange ", " Green Blue Indigo ... Indigo Violet "). Nós pegamos o segundo, dividimos no espaço em branco (o que remove o espaço em branco), resultando em @("Green", "Blue", ... "Violet"), portanto, pegar [0]um deles resulta na próxima sequência correta.

IBM / Lotus Notes Formula Language, 79 74 bytes

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

Versão anterior para 79:

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

Recebe entrada de um campo de texto editável chamado a.

Não há TIO para o idioma das fórmulas, então aqui estão algumas capturas de tela.

PHP, 92 bytes

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

Experimente online!

Kotlin , 73 bytes

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

Experimente online!

Aproveitando o fato de que muitas cores têm 6 caracteres, as que não são são prefixadas com espaços para torná-las 6 caracteres. Espero que seja aceitável que algumas cores sejam produzidas com espaços à sua frente.
por exemplo, vermelho é " Red", azul é" Blue"

SmileBASIC, 94 84 bytes

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

Gema , 67 caracteres

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

Exemplo de execução:

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
*=

Chato. A abordagem mais burra de todos os tempos, mas bastante curta.

Exemplo de execução:

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

Solução:

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

Exemplos:

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"

Explicação:

Crie um dicionário de cor => próxima cor, a entrada é a chave do dicionário:

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

Bônus:

São 53 bytes no K4:

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

Japonês , 45 43 bytes

-2 bytes graças a Shaggy

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

Experimente online!

sed, 72 bytes

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

Experimente Online

Exemplo 1:

Entrada:

Red
Orange
Yellow
Green
Blue
Indigo
Violet

Saída:

Orange
Yellow
Green
Blue
Indigo
Violet
Red

Exemplo 2:

Entrada:

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

Saída:

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