Le défi est simple: dessiner un arc-en-ciel en aussi peu d'octets que possible

Les spécifications de l'arc-en-ciel sont les suivantes:

• Le chiffre doit être exactement 400 pixels de large et 200 pixels de haut (éventuellement 401x201 si vous voulez un seul pixel central)
• L'anneau rouge doit toucher toutes les bordures de la figure (rayon extérieur = 200 pixels)
• Tous les anneaux doivent avoir la même largeur (10 pixels)
  • L'anneau violet doit avoir un rayon intérieur de 130 pixels
• L'arc doit être la moitié supérieure d'un cercle parfait
• Le fond doit être blanc (transparent est également accepté)
• La figure ne doit pas avoir de bordures (exception est faite si la bordure ne peut pas être supprimée)
• Les fonctions intégrées de création d'arc-en-ciel ne sont pas autorisées!

Les couleurs suivantes doivent être utilisées dans l'arc-en-ciel:

C'est le golf de code, donc le code le plus court en octets gagne!

Exemple:

Liés, mais différents!

MATL , 107 95 92 87 84 83 octets

-200:200 0:200!PYyq10/k12-t8<*t0>*Q7B.561FTh.295Oh.51h4BPFTF6Bl.5hOh4B8$v255*k5M/YG

Cela fonctionne dans la version actuelle (14.0.0) du langage / compilateur.

EDIT (6 juillet 2017) : Vous pouvez l'essayer sur MATL Online! .

Pour vérifier que les couleurs sont correctes, supprimez les cinq derniers caractères (vous devez attendre quelques secondes et faire défiler jusqu'à la fin de la sortie).

Explication

Le code comporte trois étapes principales:

Étape 1 : Générez une matrice 201x401 avec des nombres de 1à 8. Les pixels avec valeur 1sont le fond (blanc), les pixels avec valeurs 2, ...,8 représentent chaque bande de l'arc-en-ciel.

Les coordonnées horizontales varient entre -200de 200gauche à droite, et les coordonnées verticales vont de 0de200 bas en haut. Ainsi, l'origine (0,0) est en bas au centre, le coin supérieur gauche est (-200,200), etc.

Les différentes bandes de l'arc-en-ciel sont générées en calculant la distance de chaque pixel à l'origine et en les quantifiant par pas de 10 pixels.

Étape 2 : Générez une matrice 8x3 définissant la palette de couleurs. Chaque rangée est l'une des couleurs nécessaires (blanc et les sept couleurs de l'arc-en-ciel). Chaque valeur de la matrice 201x401 précédente sera interprétée comme un index d'une ligne de cette palette de couleurs.

Nous générons la matrice de palette de couleurs en utilisant des valeurs comprises entre 0 et 1 pour chaque composante de couleur, puis en multipliant par 255 et en arrondissant. De cette façon, la plupart des valeurs sont initialement 0 et 1, qui deviendront plus tard 0 et 255. Les valeurs intermédiaires sont codées comme des valeurs comprises entre 0 et 1 avec 2 ou 3 décimales, choisies de sorte que lorsqu'elles sont multipliées et arrondies, elles donnent la valeur exacte souhaitée.

Étape 3 : Affichez l'image avec cette palette de couleurs.

               % STEP 1: CREATE MATRIX DEFINING THE RAINBOW BANDS
-200:200       % row vector [-200, -199, ..., 200]
0:200          % row vector [0, 1, ..., 200]
!P             % transpose and flip: convert into column vector [200; 199; ...; 0]
Yy             % hypotenuse function with broadcast: distance from each point to (0,0)
q10/k          % subtract 1, divide by 10, floor (round down). Gives 20 circular bands
               % 10 pixels wide, with values from 0 to 19
12-            % subtract 12
t8<*           % values larger than 7 are set to 0
t0>*           % values less than 0 are set to 0. We now have 7 bands with values
               % 1, ..., 7, and the white background with value 0
Q              % add 1: white becomes 1, bands become 2, ..., 8

               % STEP 2: CREATE MATRIX DEFINING THE COLORMAP
7B             % first row: [1 1 1] (7 converted to binary: color white)
.561FTh        % second row (light purple)
.295Oh.51h     % third row (dark purple)
4BP            % fourth row: [0 0 1] (4 converted to binary and flipped: blue)
FTF            % fifth row (green)
6B             % sixth row: [1 1 0] (6 converted to binary: yellow)
l.5hOh         % seventh row: orange
4B             % eigth row: [1 0 0] (4 converted to binary: red)
8$v            % vertically concatenate the 8 eight rows
255*k          % multiply by 255 and round down. Gives exact color values 
5M/            % push 255 again and divide. This is needed because colors in MATL are
               % defined between 0 and 1, not between 0 and 255

               % STEP 3: DISPLAY
YG             % display image with that colormap

Piet , 838 codels, plusieurs milliers de pixels

Quelqu'un devait le faire:

Si vous enregistrez cette image, vous pouvez l' essayer en ligne !

Le programme Piet réel n'est que les 125 premiers pixels, que j'ai créés à l'aide d'un programme Python que j'ai écrit.

Modifier cela a vraiment blessé ma vision, je trébucherai pendant des jours!

Cela génère l'image au format SVG, car SVG est vraiment (à mon avis) le moyen le plus simple de le faire. J'ai volé sans vergogne le code SVG de Doorknob. Les sorties:

eh bien, c'est vraiment:

<svg viewBox='0 0 400 200'><circle cx='200' cy='200' r='200' fill='red'/><circle cx='200' cy='200' r='190' fill='#ff7f00'/><circle cx='200' cy='200' r='180' fill='yellow'/><circle cx='200' cy='200' r='170' fill='lime'/><circle cx='200' cy='200' r='160' fill='blue'/><circle cx='200' cy='200' r='150' fill='indigo'/><circle cx='200' cy='200' r='140' fill='#8f00ff'/><circle cx='200' cy='200' r='130' fill='white'/></svg>

Bonne chance en battant cette réponse, non-utilisateurs d'Esolang!

Pyth, 150 149 128 octets

"<svg viewBox=0,0,400,200>"V8s["<circle cx=200 cy=200 r="-200*TN" fill="@c"red #ff7f00 #ff0 #0f0 #00f indigo #8f00ff #fff"dN" />

Sorties en SVG:

<svg viewBox=0,0,400,200>
<circle cx=200 cy=200 r=200 fill=red />
<circle cx=200 cy=200 r=190 fill=#ff7f00 />
<circle cx=200 cy=200 r=180 fill=#ff0 />
<circle cx=200 cy=200 r=170 fill=#0f0 />
<circle cx=200 cy=200 r=160 fill=#00f />
<circle cx=200 cy=200 r=150 fill=indigo />
<circle cx=200 cy=200 r=140 fill=#8f00ff />
<circle cx=200 cy=200 r=130 fill=#fff />

Merci à @MamaFunRoll pour 16 octets et @PatrickRoberts pour 6 de plus!

Minecraft 1.10 (presque), 2677 caractères à commande unique , 868 blytes

Eh bien, j'ai choisi une langue verbeuse.

summon FallingSand ~ ~1 ~ {Block:log,Time:1,Passengers:[{id:FallingSand,Block:redstone_block,Time:1,Passengers:[{id:FallingSand,Block:activator_rail,Time:1,Passengers:[{id:MinecartCommandBlock,Command:"summon ArmorStand ~ ~ ~ {Tags:[\"b\"]}"},{id:MinecartCommandBlock,Command:"summon Pig ~ ~ ~ {NoAI:1b}"},{id:MinecartCommandBlock,Command:setblock ~-1 ~-2 ~6 chain_command_block 3 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=200] ~ ~ ~ tp @e[c=1] ~ -99 ~"}},{id:MinecartCommandBlock,Command:setblock ~-1 ~-2 ~5 chain_command_block 3 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=190,r=200] ~ ~ ~ setblock ~ ~ ~ wool 14"}},{id:MinecartCommandBlock,Command:setblock ~-1 ~-2 ~4 chain_command_block 3 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=180,r=190] ~ ~ ~ setblock ~ ~ ~ wool 1"}},{id:MinecartCommandBlock,Command:setblock ~ ~-2 ~4 chain_command_block 4 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=170,r=180] ~ ~ ~ setblock ~ ~ ~ wool 4"}},{id:MinecartCommandBlock,Command:setblock ~ ~-2 ~5 chain_command_block 2 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=160,r=170] ~ ~ ~ setblock ~ ~ ~ wool 13"}},{id:MinecartCommandBlock,Command:setblock ~ ~-2 ~6 chain_command_block 2 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=150,r=160] ~ ~ ~ setblock ~ ~ ~ wool 11"}},{id:MinecartCommandBlock,Command:setblock ~ ~-2 ~7 chain_command_block 2 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=140,r=150] ~ ~ ~ setblock ~ ~ ~ wool 10"}},{id:MinecartCommandBlock,Command:setblock ~ ~-2 ~8 chain_command_block 2 replace {auto:1,Command:"execute @e[tag=b] ~ ~ ~ execute @e[rm=130,r=140] ~ ~ ~ setblock ~ ~ ~ wool 2"}},{id:MinecartCommandBlock,Command:setblock ~1 ~-2 ~8 chain_command_block 4 replace {auto:1,Command:"tp @e[type=Cow] ~1 ~ ~"}},{id:MinecartCommandBlock,Command:setblock ~1 ~-2 ~7 chain_command_block 3 replace {auto:1,Command:"tp @e[type=Bat] ~-1 ~ ~"}},{id:MinecartCommandBlock,Command:setblock ~1 ~-2 ~6 chain_command_block 3 replace {auto:1,Command:"execute @e[type=Pig] ~ ~ ~ summon Bat ~ ~ ~ {NoAI:1b}"}},{id:MinecartCommandBlock,Command:setblock ~1 ~-2 ~5 chain_command_block 3 replace {auto:1,Command:"execute @e[type=Pig] ~ ~ ~ summon Cow ~ ~ ~ {NoAI:1b}"}},{id:MinecartCommandBlock,Command:setblock ~1 ~-2 ~4 repeating_command_block 3 replace {auto:1,Command:"tp @e[type=Pig] ~ ~1 ~"}},{id:MinecartCommandBlock,Command:setblock ~ ~ ~1 command_block 0 replace {Command:fill ~ ~-3 ~-1 ~ ~ ~ air}},{id:MinecartCommandBlock,Command:setblock ~ ~-1 ~1 redstone_block},{id:MinecartCommandBlock,Command:kill @e[type=MinecartCommandBlock,r=1]}]}]}]}

Créez un nouveau monde Superflat, collez ce désordre dans un bloc de commandes Impulse, définissez votre distance de rendu assez élevée et exécutez-le. Brisez le support d'armure lorsque votre ordinateur cesse de prendre du retard.

Le résultat est de 400 blocs de diamètre et 200 blocs de hauteur, comme demandé.

J'ai utilisé l'un des générateurs de commandes de MrGarretto pour tout emballer ensemble, puis j'ai modifié le résultat un peu pour économiser quelques octets supplémentaires. Voici l'apport:

INIT:summon ArmorStand ~ ~ ~ {Tags:["b"]}
INIT:summon Pig ~ ~ ~ {NoAI:1b}
tp @e[type=Pig] ~ ~1 ~
execute @e[type=Pig] ~ ~ ~ summon Cow ~ ~ ~ {NoAI:1b}
execute @e[type=Pig] ~ ~ ~ summon Bat ~ ~ ~ {NoAI:1b}
tp @e[type=Bat] ~-1 ~ ~
tp @e[type=Cow] ~1 ~ ~
execute @e[tag=b] ~ ~ ~ execute @e[rm=130,r=140] ~ ~ ~ setblock ~ ~ ~ wool 2
execute @e[tag=b] ~ ~ ~ execute @e[rm=140,r=150] ~ ~ ~ setblock ~ ~ ~ wool 10
execute @e[tag=b] ~ ~ ~ execute @e[rm=150,r=160] ~ ~ ~ setblock ~ ~ ~ wool 11
execute @e[tag=b] ~ ~ ~ execute @e[rm=160,r=170] ~ ~ ~ setblock ~ ~ ~ wool 13
execute @e[tag=b] ~ ~ ~ execute @e[rm=170,r=180] ~ ~ ~ setblock ~ ~ ~ wool 4
execute @e[tag=b] ~ ~ ~ execute @e[rm=180,r=190] ~ ~ ~ setblock ~ ~ ~ wool 1
execute @e[tag=b] ~ ~ ~ execute @e[rm=190,r=200] ~ ~ ~ setblock ~ ~ ~ wool 14
execute @e[tag=b] ~ ~ ~ execute @e[rm=200] ~ ~ ~ tp @e[c=1] ~ -99 ~

C'est un total de 15 1,9+ blocs de commandes et 838 octets, donc 15 * 2 + 838 = 868 blytes .

Voici la (presque) partie, il manque un coin et un bord. Logiquement, cela ne devrait pas - Bug Minecraft? Ce serait exactement 400x200 blocs sans ça. Je ne peux pas faire grand chose.

Mathematica 152 144 126 octets

Graphics@MapIndexed[{#,Disk[{0,0},4-#/5&@@#2,{Pi,0}]}&,RGBColor/@TextWords@"#f00 #ff7f00 #ff0 #0f0 #00f #4b0082 #8f00ff #fff"]

Merci @CatsAreFluffy d'avoir rasé 8 octets et @njpipeorgan pour 18 autres :)

vim, 165 142 139

i<svg viewBox=0,0,400,200><cr><circle cx=2<C-n> cy=2<C-n> r=2<C-n> fill=red<cr>#ff7f00<cr>#ff0<cr>#0f0<cr>#00f<cr>indigo<cr>#8f00ff<cr>#fff<esc>2Gqq0y4f=jPBB10<C-x>@qq@qV2G:norm A /><cr>

Yeesh, c'est maladroit. Il doit y avoir des améliorations qui peuvent être apportées.

Sorties en SVG, comme ma réponse Pyth .

Merci à @MyHamDJ d' avoir rasé 3 octets!

HTML + SVG + ES6, 169

<svg width=400 viewBox=0,0,40,20 onload="this.innerHTML=`f00
ff7f00
ff0
0f0
00f
4b0082
8f00ff
fff`.replace(/.+/g,c=>`<circle cx=20 cy=20 r=${--r} fill=#${c} />`,r=21)"/>

Rubis avec chaussures, 155 octets

Shoes.app(width:400,height:200){background'fff'
8.times{|i|stroke fill %w{f00 ff7f00 ff0 0f0 00f 4b0082 8f00ff fff}[i]
oval left:i*=10,top:i,radius:200-i}}

Exemple de sortie:

JavaScript (ES6), 171 158 octets

document.write`<svg width=400 height=200>${`f00
ff7f00
ff0
0f0
00f
4b0082
8f00ff
fff`.replace(/.+/g,c=>`<circle cx=200 cy=200 r=${i--}0 fill=#${c} />`,i=20)}`

Crédit à @ edc65 pour l'idée de convertir

`[...].map((c,i)=>...)`

à

`...`.replace(/.+/g,c=>...,i=20)

Cela peut sembler plus long, mais la quantité d'octets enregistrés lors de la compression du tableau en une chaîne vaut bien la conversion. (Il enregistre 13 octets dans ce cas)

Démo

document.write`<svg width=400 height=200>${`f00
ff7f00
ff0
0f0
00f
4b0082
8f00ff
fff`.replace(/.+/g,c=>`<circle cx=200 cy=200 r=${i--}0 fill=#${c} />`,i=20)}`

HTML (162) + CSS (146)

body{height:200px;width:400px}div{height:100%;box-sizing:border-box;border-radius:50% 50% 0 0/100% 100% 0 0;border:solid;border-width:10px 10px 0}

<div style=color:red><div style=color:#FF7F00><div style=color:#FF0><div style=color:#0F0><div style=color:#00F><div style=color:#4B0082><div style=color:#8F00FF>

HTML (224) + CSS (128)

body{height:200px;width:400px}div{height:100%;box-sizing:border-box;border-radius:50% 50% 0 0/100% 100% 0 0;padding:10px 10px 0}

<div style=background:red><div style=background:#FF7F00><div style=background:#FF0><div style=background:#0F0><div style=background:#00F><div style=background:#4B0082><div style=background:#8F00FF><div style=background:#FFF>

SpecBAS - 318 254 octets

Si nous dessinons des arcs-en-ciel, cela semble être un bon endroit pour utiliser le successeur de ZX Spectrum BASIC.

1 p,k=20,x1=0,x2=400,y=200
2 FOR EACH s IN [16711680,16744192,16776960,65280,255,4915330,9371903]: PALETTE p,s: INC p: NEXT s
3 CLS 15: DRAW 0,200 TO 70,200: DRAW 330,200 TO 400,200
4 FOR i=1 TO 7
5 INK k: DRAW x1,y TO x2,y,-PI: DRAW x1+10,y TO x2-10,y,-PI: FILL x1+5,190
6 x1+=10,x2-=10,k+=1
7 NEXT i

La ligne 2 configure la palette pour les valeurs RVB spécifiques nécessaires (et n'aide probablement pas le nombre d'octets) car les couleurs Spectrum standard ne correspondent pas.

La DRAWcommande peut prendre un paramètre supplémentaire qui lui fait tourner d'un certain nombre de degrés radians entre x1, y1 et x2, y2. Enfin, il trouve un espace dans les demi-cercles qui viennent d'être dessinés et l'inondation se remplit de la couleur actuelle.

Tcl / Tk , 263 octets

canvas .c -bg #FFF -bo 0 -highlightt 0;pack .c -e 1 -f both;wm ge . 400x200;foreach {r c} {200 #FF0000 190 #FF7F00 180 #FFFF00 170 #00FF00 160 #0000FF 150 #4B0082 140 #8F00FF 130 #FFF} {.c cr o -$r -$r $r $r -outline $c -f $c};after 100 {.c x s -5 u;.c y s -10 u}

Hélas, ce genre de question favorise toujours certains langages ésotériques ... Cela dit, Tcl / Tk rend vraiment toutes les opérations graphiques faciles, courtes et lisibles .

Cela dit, j'ai sacrifié la lisibilité pour réduire les options à aussi peu de caractères que possible. Je n'imagine pas que croquer la liste des couleurs aidera beaucoup par rapport au code pour le déballer ...

A titre de comparaison, voici le code non croqué (380 octets):

canvas .c -bg #FFF -borderwidth 0 -highlightthickness 0
pack .c -expand yes -fill both
wm geometry . 400x200
foreach {r c} {
  200 #FF0000 
  190 #FF7F00 
  180 #FFFF00 
  170 #00FF00 
  160 #0000FF 
  150 #4B0082 
  140 #8F00FF 
  130 #FFFFFF
} {
  .c create arc -$r -$r $r $r -extent 180 -outline $c -fill $c
}
after 100 {
  .c xview scroll -5 units
  .c yview scroll -10 units
}

le after commande était malheureusement nécessaire car aucun défilement (de l'origine des coordonnées du canevas) ne peut être effectué avant que la fenêtre ne soit mappée à l'écran.

En outre, le code croqué dessine en fait un plein arc-en-ciel (en utilisant un cercle au lieu d'un arc) et repose uniquement sur l'écrêtage de fenêtre ...

Quoi qu'il en soit, j'espère que vous apprécierez tous. : O)

LaTeX, 290 octets

\documentclass{proc}\input tikz\begin{document}\def\z#1!#2!#3!#4!{\definecolor{t}{rgb}{#1,#2,#3}\fill[color=t](200pt,0)circle(#4pt);}\tikz{\clip(0,0)rectangle(400pt,200pt);\z1!0!0!200!\z1!.5!0!190!\z1!1!0!180!\z0!1!0!170!\z0!0!1!160!\z.29!0!.51!150!\z.56!0!1!140!\z1!1!1!130!}\end{document}

Essayez-le ici .

Explications

\documentclass{proc}
\input tikz
\begin{document}

    %Define macro "\z" with 4 arguments.         
    % The first 3 arguments are rgb values for the color
    % Last argument is the radius in pt that we draw a full circle with

    \def\z#1!#2!#3!#4!
        {\definecolor{t}{rgb}{#1,#2,#3}
         \fill[color=t](200pt,0)circle(#4pt);}

    % Start a Tikz figure

    \tikz{

        % We only draw the top half of the circle

        \clip(0,0)rectangle(400pt,200pt);

        % Draw each circle from biggest to smallest

        \z1!0!0!200!
        \z1!.5!0!190!
        \z1!1!0!180!
        \z0!1!0!170!
        \z0!0!1!160!
        \z.29!0!.51!150!
        \z.56!0!1!140!

        % Draw a white circle last

        \z1!1!1!130!
    }
\end{document}

Java, 354 octets

public void r() throws IOException{BufferedImage i=new BufferedImage(400,200,2);Graphics2D g=i.createGraphics();g.setStroke(new BasicStroke(10));int[]c={0xFF0000,0xFF7F00,0xFFFF00,0xFF00,255,0x4B0082,0x8F00FF};for(int v=0;v<7;v ++){g.setColor(new Color(c[v]));g.drawArc(v*10+5,v*10+5,390-v*20,390-v*20,0,360);}ImageIO.write(i,"PNG",new File("a.png"));}}

Utilise simplement la Graphics2Dclasse pour dessiner 7 arcs, avec un tableau pour stocker les couleurs. Je suis sûr qu'il peut encore être amélioré.

Code non golfé:

public void ungolfed() throws IOException {
        BufferedImage i = new BufferedImage(400, 200, 2); // 2 is TYPE_INT_ARGB
        Graphics2D g = i.createGraphics();
        g.setStroke(new BasicStroke(10));
        int[] c = {0xFF0000, 0xFF7F00, 0xFFFF00, 0x00FF00, 0x0000FF, 0x4B0082, 0x8F00FF};
        for(int v = 0; v < 7; v ++) {
            g.setColor(new Color(c[v]));
            g.drawArc(v * 10 + 5, v * 10 + 5, 390 - v * 20, 390 - v * 20, 0, 360);
        }
        ImageIO.write(i, "PNG", new File("a.png"));
    }

Bubblegum , 139 octets

Hexdump:

00000000: b329 2e4b 5728 cb4c 2d77 caaf b035 d031  .).KW(.L-w...5.1
00000010: d031 3130 d031 3230 b0e3 b249 ce2c 4ace  .110.120...I.,J.
00000020: 4955 48ae b005 f215 922b c154 1198 4ccb  IUH......+.T..L.
00000030: ccc9 b12d 4a4d 51d0 c7ad ced0 12aa 4e39  ...-JMQ.......N9
00000040: 2dcd 3c0d 2884 4fad 0542 2d7e 85e6 3085  -.<.(.O..B-~..0.
00000050: 0604 149a c115 1aa4 e155 680a 5598 9997  .........Uh.U...
00000060: 9299 9e8f 57a9 09cc 4c0b a07f d2f0 1b6b  ....W...L......k
00000070: 8cf0 1148 2100 0a                        ...H!..

Malheureusement, c'est plus court que ma réponse Pyth . :(

Génère le même fichier SVG.

CSS, 244 242 240 octets

body{width:400px;height:200px;background-image:radial-gradient(500px at bottom,#FFF 26%,#8F00FF 26%,#8F00FF 28%,#4B0082 28%,#4B0082 30%,#00F 30%,#00F 32%,#0F0 32%,#0F0 34%,#FF0 34%,#FF0 36%,#FF7F00 36%,#FF7F00 38%,red 38%,red 40%,#FFF 40%)}

Edit: enregistré 2 octets en contournant un bug dans Chrome. Sauvegardé 2 octets supplémentaires grâce à @TrangOul.

Remarque: l'extrait utilise un en <div>raison des limitations des extraits de pile.

div {
    width: 400px;
    height: 200px;
    background-image: radial-gradient(500px at bottom,
        #FFF 26%,
        #8F00FF 26%, #8F00FF 28%,
        #4B0082 28%, #4B0082 30%,
        #00F 30%, #00F 32%,
        #0F0 32%, #0F0 34%,
        #FF0 34%, #FF0 36%,
        #FF7F00 36%, #FF7F00 38%,
        red 38%, red 40%,
        #FFF 40%);
}

<div>

Javascript 271 251

c=document.body.appendChild(document.createElement('canvas'))
x=c.getContext('2d')
c.width=400
r=c.height=200
for(i=0;i<8;x.beginPath(),x.arc(r,r,r-i*10,0,7),x.fillStyle="#"+"FF0000FF7F00FFFF0000FF000000FF4B00828F00FFFFFFFF".substr(i++*6,6),x.fill());

C, 220 217 213 octets

#define X printf("%c",s<169|s/401?y:s
i=8e4,t,y=255;main(s){for(puts("P6 400 200 255");i--;X/288?y:s<195?143:s<225?75:0),X<256|s/360?0:s/323?127:y),X<225&s/195?130:s<256?y:0))s=i/400,t=i%400-200,s=(s*s+t*t)/100;}

La sortie est PPM (le type binaire).

Edit: économisé quelques octets grâce à @tucuxi.

Edit 2: Code réarrangé pour économiser encore plus.

Google Blockly , 48 blocs, 75 octets

Cliquez sur le gif ci-dessous pour naviguer vers la solution, où vous pouvez voir de plus près comment cela fonctionne.
Quant à l'explication, je pense qu'une image vaut mille mots, et donc un gif vaut mille images.

lien vers un grand gif lisible

Remarque: je ne sais pas comment compter dans Blockly, j'ai donc compté chaque bloc comme 1 octet et chaque variable de manière régulière, de sorte que 0== 1 octet, 530== 3 octets, Arial== 5 octets et bold== 4 octets.
J'ai compté le caractère spécial que j'ai utilisé pour couper l'arc-en-ciel comme 2 octets. Veuillez signaler toute erreur ou suggestion du nombre d'octets dans les commentaires

Postscript (87 octets)

Vidage hexadécimal:

00000000: 3188 0131 2030 2e35 3631 8800 3120 302e  1..1 0.561..1 0.
00000010: 3237 3888 0030 2e35 3188 0030 8801 3088  278..0.51..0..0.
00000020: 0130 8801 3188 0031 2030 2e35 8800 3188  .0..1..1 0.5..1.
00000030: 0030 87c8 0038 7b34 2031 9287 929d 87c8  .0...8{4 1......
00000040: 0030 2032 9258 3087 b400 9205 9216 9242  .0 2.X0........B
00000050: 880a 92a9 7d92 83                        ....}..

Sortie:

HTML + CSS, 310 307 octets

<b style=background:red><b style=background:#ff7f00><b style=background:#ff0><b style=background:lime><b style=background:blue><b style=background:indigo><b style=background:#8f00ff><b style=background:#fff;width:260px;height:130px><style>b{float:left;padding:10px 10px 0 10px;border-radius:300px 300px 0 0}

Balisage invalide super-duper (peut ou peut ne pas sembler correct dans votre navigateur). Je voulais juste voir si c'était même possible.

PHP, 285 octets

<?php $a=imagecreate(400,200);define("b",255);$c=array(b,b,b,b,0,0,b,127,0,b,b,0,0,b,0,0,0,b,75,0,130,143,0,b,b,b,b);for($i=0;$i<9;$i++){imagefilledellipse($a,200,200,420-$i*20,420-$i*20,imagecolorallocate($a,$c[$i*3],$c[$i*3+1],$c[$i*3+2]));}header("Content-type:png");imagepng($a);?>

Les sorties:

Bash + ImageMagick, 159 125 caractères

eval convert -size 401x201 xc: '-fill \#'{f00,ff7f00,ff0,0f0,00f,4b0082,8f00ff,fff}' -draw "circle 200,200 200,$[i++*10]"' x:

Exemple de sortie:

Traitement, 196 186 181 179 169 163 octets

int d=400,i=0;size(d,d/2);background(-1);int[]c={-65536,-33024,-256,#00ff00,#0000ff,#4b0082,#8f00ff,-1};for(noStroke();i<8;ellipse(200,200,d,d),d-=20)fill(c[i++]);

10 octets enregistrés grâce à Kritixi Lithos
... et 6 octets supplémentaires grâce à dzaima

R, 184 170 octets

Faire une image avec des dimensions de pixels fixes s'avère étonnamment délicat avec R, dont les fonctions de traçage sont principalement destinées aux statisticiens. En particulier, R laisse un espace supplémentaire pour les étiquettes et les axes de coordonnées, sauf si vous définissez explicitement des marges de largeur nulle en appelantpar .

D'un autre côté, certaines des couleurs requises (spécifiquement le rouge, le jaune et le bleu) se trouvent dans la palette par défaut et peuvent être référencées simplement par des indices entiers.

png(,400,200)
par(mar=0*1:4)
plot(as.raster(outer(199:0,-199.5:200,function(y,x)c(rep("white",13),"#8F00FF","#4B0082",4,"green",7,"#FF7F00",2)[1+(x^2+y^2)^.5%%200/10])))

Forth Salon Haiku (184 octets)

Je ne peux pas satisfaire les contraintes de dimension avec ce format, mais j'ai pensé qu'il valait quand même la peine d'être partagé.

: ^ 2 ** ;
: b 0.9 * dup x .5 - ^ y 2.01 / ^
+ sqrt dup rot > swap rot .045
+ < * * + ;
0 .56 .2 b .29 .25 b 1 .4 b
1 .45 b 1 .5 b 0 1 .35 b 1 .4 b
0.5 .45 b 0 1 .2 b .51 .25 b
1 .3 b

Excel VBA, _{213 202 196 192} 172 octets

Code

Fonction de fenêtre immédiate VBE anonyme qui ne prend aucune entrée et génère un arc-en-ciel, sous forme d'image vectorielle, vers l'objet feuilles (1)

For i=0To 7:j=400-20*i:Set s=Sheet1.Shapes.AddShape(20,10*i,10*i,j,j):s.Fill.ForeColor.RGB=Array(255,32767,65535,65280,-31*4^8,8519755,&HE1008F,-1)(i):s.Line.Visible=0:Next

Version du sous-programme

Sub a
For i=0To 7
j=400-20*i
set s=Sheet1.Shapes.AddShape(20,10*i,10*i,j,j)
s.Fill.ForeColor.RGB=Array(255,32767,65535,65280,-31*4^8,8519755,&HE1008F,-1)(i)
s.Line.Visible=0
Next
End Sub

-11 octets pour supprimer l' .Adjustments(3)=3/80appel et ajouter un 8ème arc blanc

-6 octets pour utiliser -1plus&HFFFFFF

-3 octets pour utiliser Sheet1plusSheets(1)

-6 octets pour convertir une withinstruction en setinstruction

-14 octets pour la conversion de la Subfonction VBE anonyme

Sortie

DIV Games Studio (184 octets)

Pas le plus court mais assez simple. Utilise la palette par défaut DIV

PROGRAM r;
local
c[]=22,26,235,41,54,82,249,15,15;
BEGIN
set_mode(400200);
for(x=-80;x<80;x+=10)
y=399-x;
draw(5,c[abs(x)/10],15,0,x,x,y,y);
x+=70*(x<0);END
LOOP;FRAME;END
END

Explication

Définir le démarrage du programme (nommé "r" pour économiser de l'espace)

PROGRAM r;

configuration de la recherche de palette

local
c[]=22,26,235,41,54,82,249,15,15;

Code de programme BEGIN

BEGIN

Réglez le mode vidéo sur 400 200

set_mode(400200);

boucle x (variable prédéfinie) de -80 (dont bg hack) à 80 (7 couleurs + centre blanc)

for(x=-80;x<80;x+=10)

définir les contraintes d'élipse

y=399-x;

draw elipse - à la première itération, cela dessine un cercle plus grand que l'écran en blanc complet (index -8)

dessin (type (5 = élipse remplie), couleur, opacité, x0, y0, x1, y1)

draw(5,c[abs(x)/10],15,0,x,x,y,y);

une fois que le premier est terminé, augmentez x jusqu'à zéro pour commencer à dessiner une bande rouge

x+=70*(x<0);

fin pour boucle

END

boucle infinie, écran de dessin.

LOOP;FRAME;END

fin (correspond à COMMENCER en haut du programme)

END

Perl, 175 + 1 = 176 octets

perl -MSVG -E '$z=SVG->new(width=>4e2,height=>2e2);@x=qw/#fff #8f00ff indigo #00f #0f0 #ff0 #ff7f00 red/;$z->circle(cx=>200,cy=>200,r=>200-10*$a++,style=>{fill=>pop@x})for 1..8;say$z->xmlify'

PHP, 190 octets

imagefill($a=imagecreatetruecolor($r=400,200),0,0,$w=0xffffff);foreach([255<<16,0xff7f00,$w-255,65280,255,4915330,9371903,$w]as$i)imagefilledellipse($a,200,200,$r,20+$r-=20,$i);imagepng($a);

Exécutez-le comme ceci:

php -r 'imagefill($a=imagecreatetruecolor($r=400,200),0,0,$w=0xffffff);foreach([255<<16,0xff7f00,$w-255,65280,255,4915330,9371903,$w]as$i)imagefilledellipse($a,200,200,$r,20+$r-=20,$i);imagepng($a);' | display

Fonctionne également en théorie à 179 octets (mais l'image semble un peu foirée, mauvais GD):

php -r '$r=410;imagesetthickness($a=imagecreatetruecolor(400,200),10);foreach([255<<16,0xff7f00,0xffff00,65280,255,4915330,9371903]as$i)imagearc($a,200,200,$r-=20,$r,1,0,$i);imagepng($a);' | display

Ce n'est pas non plus une image parfaite, mais bien meilleure que la précédente (et @ 166 octets):

php -d error_reporting=30709 -r '$a=imagecreatetruecolor($r=400,200);foreach([255<<16,0xff7f00,0xffff00,65280,255,4915330,9371903]as$i)for(;++$$i<21;)imageellipse($a,200,200,$r,$r--,$i);imagepng($a);' | display