Défi

Considérez l'arc-en-ciel comme sept couleurs, représentées par des chaînes comme Red Orange Yellow Green Blue Indigo Violet.
Votre tâche consiste à créer un programme qui reçoit l'une de ces couleurs en entrée et qui sort ensuite dans l'ordre couleur arc-en-ciel. Cela inclut le chevauchementViolet -> Red

Contribution

Une chaîne contenant l'une des couleurs de l'arc-en-ciel.

Production

Le suivant dans l'ordre couleur de l'arc-en-ciel.

Règles

• Les noms de couleur sont sensibles à la casse. Ils doivent correspondre à l'étui inclus dans cet article.
• L'entrée sera toujours valide. Tout comportement est autorisé pour une entrée non valide.
• C'est le golf de code, donc le plus petit nombre d'octets gagne!

Exemple d'entrée et de sortie

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

SOGL V0.12 , 23 octets

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

Essayez-le ici!

Explication:

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

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

Pour l'entrée "Red", cette fonction construit d'abord un RegExp /Red(.[a-z]*)/pour correspondre à la chaîne 'RedOrangeYellowGreenBlueIndigoVioletRed', puis renvoie le premier résultat de capture.

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 octets

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

Essayez-le en ligne!

Maintenant que le défi a été changé pour être cyclique, la solution d'expression régulière

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

n'est plus optimal (en raison du double Red)

Aussi 57 octets:

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

Essayez-le en ligne!

Python , 79 octets

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

Essayez-le en ligne!

Poignées Violet -> Red. La fonction souhaitée est donnée de manière anonyme dans la deuxième ligne.

80 octets

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

Essayez-le en ligne!

Perl 6 , 56 octets

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

Essayez-le en ligne!

Exploite le fait que les bits 2-4 des codes ASCII de la première lettre de chaque couleur correspondent à 0-6.

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

Voici une belle solution non concurrente qui utilise "violet" au lieu de "indigo" et "violet" (38 caractères, 59 octets):

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

Essayez-le en ligne!

Rubis -n , 62 60 octets

-2 par Asone Tuhid.

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

Essayez-le en ligne!

L'approche Regex semble également prometteuse pour Ruby. Cependant, je suis arrivé à une solution plus courte en utilisant une anticipation et en imprimant directement le match, plutôt que de jouer avec des groupes de capture. La liste des couleurs est en sens inverse car l'anticipation est 1 octet moins chère que l'anticipation.

rouge , 87 octets

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

Essayez-le en ligne!

05AB1E , 30 octets

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

Essayez-le en ligne!

Explication

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

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

Utilise des noms en minuscules.

Même approche, avec des lettres majuscules 86 octets:

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

Haskell , 80 71 75 octets

^{Merci à Laikoni d'avoir raccourci 9 octets!}

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

Essayez-le en ligne!

Une autre solution, un peu plus idiomatique, mais je n'ai pas pu la raccourcir:

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

Il doit dériver en Readraison de l'exigence que l'entrée soit une chaîne et au moins Eqou Showafin de tester l'égalité ou d'afficher le résultat.

Rétine , 65 58 octets

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

Essayez-le en ligne!

Explication

$
(.[a-z]+)

Nous commençons par ajouter (.[a-z]+)à l'entrée, la transformant ainsi en une expression régulière qui correspond à la couleur d'entrée, immédiatement suivie par exactement une autre couleur (capturant cette dernière).

L$:`RedOrangeYellowGreenBlueIndigoVioletRed
$1

Maintenant, les :échanges de l'entrée de la scène avec son propre regex. Ainsi, le résultat précédent devient l'expression régulière et il est comparé à la liste des couleurs. La correspondance (unique) est remplacée par son premier groupe de capture (c'est-à-dire la couleur suivante du cycle) et renvoyée. La sortie à la fin du programme se produit automatiquement.

Vim, 59 56 53 52 octets

-1 octet grâce à tsh

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

Java (JDK 10) , 77 octets

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

Essayez-le en ligne!

Crédits

• -10 octets grâce à Kevin Cruijssen
• -1 octet grâce à Okx

Noix de coco , 79 octets

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

Essayez-le en ligne!

Husk , 28 octets

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

Essayez-le en ligne!

Il y a peut-être de meilleures options pour gérer les arguments, mais c'est la meilleure que j'ai pu trouver

Explication

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 octets

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

Exécuter et déboguer

Cela utilise l'instruction de traduction en anneau. Il remplace chaque élément d'un tableau par le suivant de "l'anneau du décodeur". Habituellement, il est utilisé pour remplacer les caractères dans une chaîne, mais il peut également être utilisé sur une chaîne entière, s'il est enveloppé dans un tableau singleton.

Voici la représentation ascii non emballée, non golfée et commentée du même programme.

]   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

Exécutez celui-ci

J , 67 64 62 octets

-2 octets merci à FrownyFrog

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

Essayez-le en ligne!

R , 109 93 octets

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

Essayez-le en ligne!

-16 merci à Giuseppe pour l'utilisation des matchconseils

Lot, 97 octets

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

Explication: Le callsur la deuxième ligne a pour effet de remplacer le paramètre dans la commande et de l'évaluer, en le transformant par exemple set s=%s:Red =%en ce qui supprime le préfixe de la chaîne qui inclut le paramètre. La substitution sur la troisième ligne remplace alors tous les espaces par des séparateurs d'instructions et des commentaires. Cela fonctionne car la substitution de chaîne se produit avant l'analyse.

Rubis -n , 75 69 octets

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

Essayez-le en ligne!

Julia 0,6 , 76 octets

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

Essayez-le en ligne!

Cela gère le Violet-> Rouge en recyclant la chaîne avec l' ^opérateur de puissance .

Voici une solution légèrement plus longue sans regex:

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

PowerShell , 74 octets

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

Essayez-le en ligne!

Prend la chaîne "Red ... Violet "et la multiplie par deux pour gérer correctement le Violet -> Redcas de test. Nous avons ensuite -splitcette chaîne en entrée $argspour nous donner un tableau de deux chaînes. Nous prenons la deuxième chaîne de celui [1]- ci , puis -splitcelle sur les espaces blancs pour nous donner un tableau de chaînes et prendre la première[0] .

Par exemple, pour la saisie "Yellow", la première étape se traduira par @("Red Orange ", " Green Blue Indigo ... Indigo Violet "). Nous prenons le second de celui-ci, le divisons sur un espace blanc (qui supprime l'espace blanc), ce qui entraîne @("Green", "Blue", ... "Violet"), donc la prise de [0]celui-ci entraîne la chaîne suivante appropriée.

Langage de formule IBM / Lotus Notes, 79 74 octets

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

Version précédente pour 79:

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

Prend la saisie d'un champ de texte modifiable appelé a .

Il n'y a pas de TIO pour le langage des formules, voici donc quelques captures d'écran.

PHP, 92 octets

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

Essayez-le en ligne!

Kotlin , 73 octets

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

Essayez-le en ligne!

Profitant du fait que de nombreuses couleurs sont à 6 caractères, celles qui ne le sont pas sont préfixées par des espaces pour leur faire 6 caractères. J'espère qu'il est acceptable que certaines des couleurs soient sorties avec des espaces devant elles.
Par exemple, le rouge est " Red", le bleu est" Blue"

SmileBASIC, 94 84 octets

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

Gema , 67 caractères

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

Exemple d'exécution:

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 personnages

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

Un ennuyeux. Approche la plus stupide jamais, mais assez courte.

Exemple d'exécution:

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 octets

Solution:

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

Exemples:

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"

Explication:

Créez un dictionnaire de couleur => couleur suivante, l'entrée est la clé du dictionnaire:

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

Prime:

C'est 53 octets en K4:

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

Japt , 45 43 octets

-2 octets grâce à Shaggy

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

Essayez-le en ligne!

sed, 72 octets

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

Essayez-le en ligne

Exemple 1:

Contribution:

Red
Orange
Yellow
Green
Blue
Indigo
Violet

Production:

Orange
Yellow
Green
Blue
Indigo
Violet
Red

Exemple 2:

Contribution:

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

Production:

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