Виклик

Розглянемо веселку як сім кольорів, представлених рядками як Red Orange Yellow Green Blue Indigo Violet.
Ваше завдання - створити програму, яка отримує один із цих кольорів у якості вхідних та вихідних даних наступного порядку для кольору веселки. Це включає перекриттяViolet -> Red

Вхідні дані

Рядок, що містить один з кольорів веселки.

Вихідні дані

Наступний по порядку колір веселки.

Правила

• Назви кольорів залежать від регістру. Вони повинні відповідати випадку, включеному в цю посаду.
• Вхід завжди буде дійсним. Будь-яка поведінка дозволена для недійсного введення.
• Це кодовий гольф, тому найменша кількість байтів виграє!

Приклад введення та виведення

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

SOGL V0.12 , 23 байти

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

Спробуйте тут!

Пояснення:

...‘θ⁽,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 байт

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

Для введення "Red"ця функція спочатку побудує RegExp /Red(.[a-z]*)/для відповідності рядку, 'RedOrangeYellowGreenBlueIndigoVioletRed'а потім поверне перший результат захоплення.

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 байт

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

Спробуйте в Інтернеті!

Тепер, коли завдання було змінено на циклічне рішення регулярного виразка

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

вже не є оптимальним (через подвійне Red)

Також 57 байт:

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

Спробуйте в Інтернеті!

Пітон , 79 байт

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

Спробуйте в Інтернеті!

Ручки Violet -> Red. Бажана функція задається анонімно у другому рядку.

80 байт

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

Спробуйте в Інтернеті!

Perl 6 , 56 байт

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

Спробуйте в Інтернеті!

Експлуатує той факт, що біти 2-4 коду ASCII першої літери кожного кольору трапляються на 0-6.

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

Ось приємне неконкурентне рішення, яке використовує "фіолетове" замість "індиго" та "фіолетове" (38 символів, 59 байт):

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

Спробуйте в Інтернеті!

Рубі -n , 62 60 байт

-2 Асоне Тухід.

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

Спробуйте в Інтернеті!

Підхід Regex виглядає перспективним і для Ruby. Однак я прийшов до більш короткого рішення, використовуючи підказку і безпосередньо друкуючи матч, а не граючи із захопленням груп. Список кольорів знаходиться в зворотному напрямку, оскільки lookahead на 1 байт дешевший, ніж позаду.

Червоний , 87 байт

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

Спробуйте в Інтернеті!

05AB1E , 30 байт

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

Спробуйте в Інтернеті!

Пояснення

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

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

Використовує малі імена.

Аналогічний підхід із великими літерами 86 байт:

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

Haskell , 80 71 75 байт

^{Дякуємо Лайконі за скорочення 9 байт!}

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

Спробуйте в Інтернеті!

Ще одне рішення, трохи більш ідіоматичне, але я не міг його коротше:

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

Це потрібно отримати Readчерез вимогу, що вхід є рядком і хоча б Eqабо Showдля того, щоб або перевірити рівність, або показати результат.

Сітківка , 65 58 байт

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

Спробуйте в Інтернеті!

Пояснення

$
(.[a-z]+)

Почнемо з додавання (.[a-z]+)до вводу, тим самим перетворивши його на регулярний вираз, який відповідає вхідному кольорові, одразу після цього точно ще один колір (захоплюючи останній).

L$:`RedOrangeYellowGreenBlueIndigoVioletRed
$1

Тепер :поміняє вхід сцени власним регулярним виразом. Таким чином, попередній результат стає регулярним виразом і відповідає зі списком кольорів. (Одиничний) збіг замінюється його першою групою захоплення (тобто наступним кольором у циклі) та повертається. Вихід у кінці програми відбувається автоматично.

Вим, 59 56 53 52 байт

-1 байт завдяки tsh

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

Java (JDK 10) , 77 байт

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

Спробуйте в Інтернеті!

Кредити

• -10 байт завдяки Кевіну Крейсейну
• -1 байт завдяки Okx

Кокосовий горіх , 79 байт

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

Спробуйте в Інтернеті!

Лушпиння , 28 байт

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

Спробуйте в Інтернеті!

Можливо, є кращі варіанти управління аргументами, але це найкраще, що я міг знайти

Пояснення

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)

Стакс , 31 30 29 байт

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

Запустіть і налагоджуйте його

Для цього використовується інструкція з перекладу кільця. Він замінює кожен елемент у масиві наступним із "кільця декодера". Зазвичай він використовується для заміни символів у рядку, але він може бути використаний і для цілого рядка, якщо він загорнутий у однотонний масив.

Ось розпаковане, нерозроблене, прокоментуване представлення ascii тієї самої програми.

]   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

Виконати цей

J , 67 64 62 байт

-2 байти дякую FrownyFrog

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

Спробуйте в Інтернеті!

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