도전

무지개를 7 개의 색상으로 간주하고 문자열을로 표현하십시오 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

자바 스크립트, 68 바이트

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

input "Red"의 경우이 함수는 먼저 /Red(.[a-z]*)/문자열 'RedOrangeYellowGreenBlueIndigoVioletRed'과 일치 하도록 RegExp 를 구성한 다음 첫 번째 캡처 결과를 반환합니다.

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;
}

펄 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]

온라인으로 사용해보십시오!

펄 6 , 56 바이트

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

온라인으로 사용해보십시오!

각 색상의 첫 문자의 ASCII 코드 중 2-4 비트가 0-6에 매핑된다는 사실을 악용합니다.

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

다음은 "indigo"및 "violet"대신 "purple"을 사용하는 멋진 비경쟁 솔루션입니다 (38 자, 59 바이트).

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

온라인으로 사용해보십시오!

루비 -n , 62 60 바이트

Asone Tuhid의 -2.

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

온라인으로 사용해보십시오!

정규식 접근 방식은 Ruby에도 유망합니다. 그러나 나는 캡쳐 그룹을 사용하는 대신 미리보기를 사용하여 경기를 직접 인쇄하는 더 짧은 솔루션에 도달했습니다. lookahead가 lookbehind보다 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

엑셀, 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")

하스켈 , 80 71 75 바이트

^{9 바이트를 줄인 Laikoni에게 감사드립니다!}

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

이제 :스테이지의 입력을 자체 정규식으로 바꿉니다. 따라서 이전 결과는 정규식이되고 색상 목록과 일치합니다. (단일) 일치는 첫 번째 캡처 그룹 (예 :주기의 다음 색상)으로 바뀌고 반환됩니다. 프로그램 종료시 출력이 자동으로 발생합니다.

Vim, 59 56 53 52 바이트

tsh 덕분에 -1 바이트

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

자바 (JDK 10) , 77 바이트

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

온라인으로 사용해보십시오!

크레딧

• Kevin Cruijssen 덕분에 -10 바이트
• Okx 덕분에 -1 바이트

Coconut, 79 bytes

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

Try it online!

Husk, 28 bytes

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

Try it online!

Maybe there are better options for managing the arguments, but this is the best I could find

Explanation

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

Run and debug it

This uses the ring translation instruction. It replaces each element in an array with the following one from the "decoder ring". Usually, it's used to do character replacement in a string, but it can be used on an entire string too, if it's wrapped in a singleton array.

Here's the unpacked, ungolfed, commented ascii representation of the same program.

]   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

Run this one

J, 67 64 62 bytes

-2 bytes thank to FrownyFrog

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

Try it 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