La sfida è semplice: disegna un arcobaleno nel minor numero di byte possibile

Le specifiche per l'arcobaleno sono le seguenti:

• La figura deve essere esattamente larga 400 pixel e alta 200 pixel (facoltativamente 401x201 se si desidera un singolo pixel centrale)
• L'anello rosso dovrebbe toccare tutti i bordi della figura (raggio esterno = 200 pixel)
• Tutti gli anelli devono avere la stessa larghezza (10 pixel)
  • L'anello viola deve avere un raggio interno di 130 pixel
• L'arco dovrebbe essere la metà superiore di un cerchio perfetto
• Lo sfondo deve essere bianco (è accettato anche il trasparente)
• La figura non deve avere bordi (viene fatta eccezione se il confine non può essere soppresso)
• Le funzioni di creazione arcobaleno integrate non sono consentite!

I seguenti colori devono essere utilizzati nell'arcobaleno:

Questo è il codice golf, quindi vince il codice più breve in byte!

Esempio:

Correlati, ma diversi!

MATL , 107 95 92 87 84 83 byte

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

Funziona con la versione corrente (14.0.0) del linguaggio / compilatore.

EDIT (6 luglio 2017) : puoi provarlo su MATL Online! .

Per verificare che i colori siano corretti, rimuovere gli ultimi cinque caratteri (è necessario attendere alcuni secondi e scorrere fino alla fine dell'output).

Spiegazione

Il codice ha tre passaggi principali:

Passaggio 1 : generare una matrice 201x401 con numeri da 1a 8. I pixel con valore 1sono di sfondo (bianco), i pixel con valori 2, ..., 8rappresentano ciascuna banda dell'arcobaleno.

Coordinate orizzontali vanno da -200a 200sinistra a destra, e coordinate verticali vanno da 0a 200basso verso l'alto. Quindi l'origine (0,0) è al centro in basso, l'angolo in alto a sinistra è (-200.200), ecc.

Le diverse bande dell'arcobaleno vengono generate calcolando la distanza da ciascun pixel all'origine e quantificando in passi di 10 pixel.

Passaggio 2 : generare una matrice 8x3 che definisce la mappa colori. Ogni riga è uno dei colori necessari (bianco e i sette colori dell'arcobaleno). Ogni valore della precedente matrice 201x401 verrà interpretato come un indice di una riga di questa mappa colori.

Generiamo la matrice mappa colori usando valori compresi tra 0 e 1 per ciascun componente colore, quindi moltiplicando per 255 e arrotondando per difetto. In questo modo la maggior parte dei valori sono inizialmente 0 e 1, che diventeranno in seguito 0 e 255. I valori intermedi vengono codificati come valori compresi tra 0 e 1 con 2 o 3 decimali, scelti in modo che quando moltiplicati e arrotondati forniscano esattamente il valore desiderato.

Passaggio 3 : visualizza l'immagine con quella mappa colori.

               % 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 codici, diverse migliaia di pixel

Qualcuno lo doveva fare:

Se salvi questa immagine puoi provarla online !

L'attuale programma Piet è solo i primi ~ 125 pixel, che ho creato usando un programma Python che ho scritto.

La modifica di questo in seguito ha davvero danneggiato la mia visione, inciamperò per giorni!

Questo genera l'immagine in un formato SVG, perché SVG è davvero (secondo me) il modo più semplice per farlo. Ho spudoratamente rubato il codice SVG di Doorknob. Uscite:

bene, questo davvero:

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

Buona fortuna a battere questa risposta, utenti non Esolang!

Pyth, 150 149 128 byte

"<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" />

Uscite in 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 />

Grazie a @MamaFunRoll per 16 byte e @PatrickRoberts per altri 6!

Minecraft 1.10 (quasi), 2677 caratteri a comando singolo , 868 blytes

Beh, ho sicuramente scelto una lingua verbosa.

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

Crea un nuovo mondo Superflat, incolla quel casino in un blocco di comando Impulse, imposta la distanza di rendering abbastanza alta ed eseguilo. Rompere il supporto per armature quando il computer smette di rallentare.

Il risultato è di 400 blocchi attraverso e 200 blocchi di altezza, come richiesto.

Ho usato l'unico generatore di comandi di MrGarretto per raggruppare tutto insieme, quindi ho modificato un po 'il risultato per salvare un altro paio di byte. Ecco l'input ad esso:

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 ~

Sono in totale 15 blocchi di comando 1.9+ e 838 byte, quindi 15 * 2 + 838 = 868 blytes .

Ecco la (quasi) parte, manca un angolo e un bordo. Logicamente non dovrebbe - Minecraft bug? Sarebbe esattamente 400x200 blocchi se non fosse per quello. Non posso fare molto.

Mathematica 152 144 126 byte

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

Grazie @CatsAreFluffy per aver rasato 8 byte e @njpipeorgan per altri 18 :)

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>

Sì, questo è goffo. Devono essere apportati miglioramenti.

Emette come SVG, come la mia risposta Pyth .

Grazie a @MyHamDJ per aver rasato 3 byte!

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)"/>

Rubino con scarpe, 155 byte

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

Uscita campione:

JavaScript (ES6), 171 158 byte

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)}`

Ringraziamo @ edc65 per l'idea di conversione

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

a

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

Potrebbe sembrare più lungo, ma la quantità di byte salvati nel comprimere l'array in una stringa merita la conversione. (Salva 13 byte in questo caso)

dimostrazione

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 byte

Se stiamo disegnando arcobaleni, allora sembra un buon posto per usare il successore di 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 riga 2 imposta la tavolozza per i valori RGB specifici necessari (e probabilmente non aiuta il conteggio dei byte) poiché i colori dello spettro standard non corrispondevano.

Il DRAWcomando può prendere un parametro aggiuntivo che lo fa girare attraverso un numero di gradi radianti tra x1, y1 e x2, y2. Alla fine trova uno spazio vuoto nei semicerchi appena disegnati e l'inondazione si riempie del colore attuale.

Tcl / Tk , 263 byte

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}

Purtroppo, questo tipo di domanda favorisce sempre alcuni linguaggi esoterici ... Detto questo, Tcl / Tk rende davvero tutte le operazioni grafiche: facili, brevi e leggibili .

Detto questo, ho sacrificato la leggibilità per ridurre le opzioni al minor numero di caratteri possibile. Non immagino che la compressione dell'elenco dei colori sia di grande aiuto rispetto al codice per decomprimerlo ...

Per un confronto, ecco il codice non crunch (380 byte):

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
}

Il after comando è stato purtroppo necessario, dal momento che nessun scorrimento (di origine di coordinate del tela) può essere fatto prima che la finestra è mappato allo schermo.

Inoltre, il codice crunch in realtà disegna un intero arcobaleno (usando un cerchio invece di un arco) e si basa solo sul ritaglio della finestra ...

Ad ogni modo, spero che vi divertirete. : O)

LaTeX, 290 byte

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

Provalo qui .

spiegazioni

\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 byte

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

Usa solo la Graphics2Dclasse per disegnare 7 archi, con un array per memorizzare i colori. Sono sicuro che può essere ulteriormente migliorato.

Codice non golfato:

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 119 byte

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

Purtroppo, questo è più breve della mia risposta Pyth . :(

Genera lo stesso file SVG.

CSS, 244 242 240 byte

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%)}

Modifica: salvato 2 byte aggirando un bug in Chrome. Salvati altri 2 byte grazie a @TrangOul.

Nota: lo snippet utilizza a <div> causa delle limitazioni degli Stack Snippet.

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 byte

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

L'output è PPM (il tipo binario).

Modifica: salvato un paio di byte grazie a @tucuxi.

Modifica 2: codice riorganizzato per risparmiare ancora di più.

Google Blockly , 48 blocchi, 75 byte

Fai clic sull'immagine in basso per navigare alla soluzione, dove puoi vedere da vicino come funziona.
Per quanto riguarda una spiegazione, penso che un'immagine valga più di mille parole, e quindi una gif vale più di mille immagini.

collegamento a grandi gif leggibili

Nota: non sono sicuro di come contare in Blockly, quindi ho contato ogni blocco come 1 byte e ogni variabile in modo regolare, in modo che 0== 1 byte, 530== 3 byte, Arial== 5 byte e bold== 4 byte.
Ho contato il carattere speciale che ho usato per tagliare l'arcobaleno come 2 byte. Si prega di segnalare eventuali errori o suggerimenti del conteggio dei byte nei commenti

Postscript (87 byte)

Discarica esadecimale:

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

Produzione:

HTML + CSS, 310 307 byte

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

Markup non valido per Super Duper (potrebbe non essere corretto nel tuo browser). Volevo solo vedere se fosse possibile.

PHP, 285 byte

<?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);?>

Uscite:

Bash + ImageMagick, 159 125 caratteri

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

Uscita campione:

Elaborazione, 196 186 181 179 169 163 byte

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++]);

Salvato 10 byte grazie a Kritixi Lithos
... e altri 6 byte grazie a dzaima

R, 184 170 byte

Realizzare un'immagine con dimensioni fisse dei pixel risulta sorprendentemente complicato con R, le cui funzioni di disegno sono principalmente destinate agli statistici. In particolare, R lascia spazio extra per etichette e assi di coordinate a meno che non si imposti esplicitamente i margini come larghezza zero chiamando par.

D'altra parte, alcuni dei colori richiesti (in particolare rosso, giallo e blu) si trovano nella tavolozza predefinita e possono essere referenziati semplicemente da indici interi.

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 byte)

Non posso soddisfare i vincoli di dimensione con questo formato, ma ho pensato che valesse comunque la pena condividerli.

: ^ 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 byte

Codice

Funzione di finestra immediata VBE anonima che non accetta input e genera un arcobaleno, come immagine vettoriale, sull'oggetto fogli (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

Versione subroutine

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 byte per rimuovere la .Adjustments(3)=3/80chiamata e aggiungere un ottavo arco bianco

-6 byte per l'utilizzo di -1over&HFFFFFF

-3 byte per l'utilizzo di Sheet1overSheets(1)

-6 byte per convertire withun'istruzione in setun'istruzione

-14 byte per la conversione da Subin funzione VBE anonima

Produzione

DIV Games Studio (184 byte)

Non il più breve ma abbastanza semplice. Utilizza la tavolozza predefinita 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

Spiegazione

Definire l'avvio del programma (denominato "r" per risparmiare spazio)

PROGRAM r;

ricerca nella palette delle impostazioni

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

INIZIA codice programma

BEGIN

Impostare la modalità video su 400.200

set_mode(400200);

loop x (variabile predefinita) da -80 (che bg hack) a 80 (7 colori + centro bianco)

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

definire i vincoli elipse

y=399-x;

disegnare elipse: alla prima iterazione disegna un cerchio più grande dello schermo in bianco completo (indice -8)

disegnare (tipo (5 = ellisse riempita), colore, opacità, x0, y0, x1, y1)

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

una volta fatto per primo, bump x fino a zero per iniziare a disegnare la banda rossa

x+=70*(x<0);

fine per loop

END

ciclo infinito, schermo di disegno.

LOOP;FRAME;END

fine (corrisponde a INIZIO all'inizio del programma)

END

Perl, 175 + 1 = 176 byte

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 byte

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

Eseguilo in questo modo:

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

Funzionando anche in teoria a 179 byte (ma l'immagine sembra un po 'incasinata, cattivo 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

Inoltre, non un'immagine perfetta, ma molto meglio di quanto sopra (e @ 166 byte):

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