Ragazzi e ragazze sono entusiasti di vedere Cinquanta sfumature di grigio sul grande schermo, vogliamo solo programmare senza essere disturbati, quindi ecco una sfida per scegliere il nostro cervello.

Devi:

• Stampa sullo schermo cinquanta quadrati riempiti ciascuno con una diversa tonalità di grigio
• Se la tua lingua preferita manca di capacità di elaborazione delle immagini , potresti generare un file di immagine
• I quadrati devono essere visibili, almeno 20 x 20 pixel
• Non puoi usare numeri casuali a meno che non ti assicuri che ogni sfumatura sia unica.
• Non è possibile connettersi a nessun servizio su alcuna rete
• Non puoi leggere alcun file nel tuo programma.
• Non è possibile utilizzare alcuna libreria al di fuori delle librerie standard della propria lingua preferita.

Questo è il codice golf, quindi vince il codice più breve.

MATLAB, 24 byte

Secondo tentativo, ora effettivamente conforme alle regole.

imshow(0:1/49:1,'I',2e3)

L'io sta per "InitialMagnification", ma apparentemente Matlab completerà automaticamente i nomi nelle coppie nome / valore. Certo è un buon trucco per il golf!

Mathematica, 30 byte

Ecco un altro approccio Mathematica:

ArrayPlot[#+5#2&~Array~{5,10}]

o

ArrayPlot[5#+#2&~Array~{10,5}]

Il primo crea semplicemente un array

{{6, 11, 16, 21, 26, 31, 36, 41, 46, 51}, 
 {7, 12, 17, 22, 27, 32, 37, 42, 47, 52}, 
 {8, 13, 18, 23, 28, 33, 38, 43, 48, 53}, 
 {9, 14, 19, 24, 29, 34, 39, 44, 49, 54}, 
 {10, 15, 20, 25, 30, 35, 40, 45, 50, 55}}

e il secondo

{{6, 7, 8, 9, 10},
 {11, 12, 13, 14, 15},
 {16, 17, 18, 19, 20},
 {21, 22, 23, 24, 25},
 {26, 27, 28, 29, 30},
 {31, 32, 33, 34, 35},
 {36, 37, 38, 39, 40},
 {41, 42, 43, 44, 45},
 {46, 47, 48, 49, 50},
 {51, 52, 53, 54, 55}}

Quindi, ArrayPlotli traccia come una griglia e, per impostazione predefinita, utilizza la scala di grigi per visualizzare i valori.

CJam - 23 (nessun output grafico effettivo)

Dato che CJam non è in grado di disegnare sullo schermo (ancora?), Ho scritto un programma che produce un'immagine in formato pgm semplice .
Salvare l'output in un file chiamato 50.pgm e aprirlo con un visualizzatore / editor di immagini.

"P2"1e3K51_,1>K*$K*~]N*

Provalo online

Il risultato è simile al seguente:

Spiegazione:

"P2"     push "P2" (netpbm magic number)
1e3K     push 1000 and K=20 (image size)
51       push 51 (value of white)
_,       duplicate 51 and convert to an array [0 1 2 ... 50]
1>       remove 0 (slice from 1)
K*       repeat the array 20 times
$        sort, to get [(20 1's) (20 2's) ... (20 50's)]
K*       repeat the array 20 times
~        dump the elements on the stack
]        put everything from the stack in an array
N*       join with newlines

Mathematica 72 61 59 43 35 34 byte

Versione corrente (34 byte)

GrayLevel[#/50]~Style~50 &~Array~50    

Versione precedente (59 byte), grazie a Martin Büttner.

Graphics[{GrayLevel[#/50],Cuboid@{#~Mod~9,#/9}}&/@Range@50]

Bordi blu aggiunti per evidenziare la posizione dei quadrati.

Graphics[{EdgeForm[Blue], GrayLevel[#/50], Cuboid@{#~Mod~9, #/9}} & /@Range@50]

Numero di quadrati:

    Length[%[[1]]]

50

Primo tentativo (72 byte)

Se i quadrati possono sovrapporsi. Come osserva Zgarb, esiste una remota possibilità che un quadrato ne nasconda un altro.

  Graphics@Table[{GrayLevel@k,Cuboid[{0,15}~RandomReal~2]},{k,.4,.89,.01}]

Salvia - 26 24 35 29 caratteri

matrix(5,10,range(50)).plot()

Sembra così:

Tentativi precedenti : prima ho avuto Matrix([range(50)]).plot(), quindi matrix_plot([range(50)]). Questi sembravano così:

L'utente @flawr ha sottolineato che i quadrati prodotti con le impostazioni predefinite sono troppo piccoli. L'aggiunta di figsizeun'opzione lo risolve, ma è più lunga di 6 caratteri rispetto alla versione 5x10 all'inizio di questa risposta:

matrix_plot([range(50)],figsize=20)

R, 47 42 39 38 37 36 35 byte

Supponendo che possano sovrapporsi, questo funziona. Symbolsrichiede un vettore che contenga le dimensioni di ciascun quadrato e sto risparmiando spazio riutilizzando lo stesso vettore per tutti i parametri della funzione. Il quadrato più grande è sempre largo 1 pollice. Con 50:99 come intervallo di numeri interi, il quadrato più piccolo sarà largo circa mezzo pollice, quindi 36 pixel a 72 dpi.

symbols(x,,,x<-50:99,bg=gray(x/99))

Grazie a tutti per i commenti e i suggerimenti, sono abbastanza nuovo su R, quindi è tutto molto educativo.

Versione precedente:

symbols(x,sq=x<-50:99,bg=gray(x/99))            #36
x=50:99;symbols(x,sq=x,bg=gray(x/99))           #37
x<-50:99;symbols(x,sq=x,bg=gray(x/99))          #38
x<-1:50;symbols(x,sq=x/x,bg=gray(x/50))         #39
x<-1:50/50;symbols(x,sq=x/x,bg=rgb(x,x,x))      #42
x<-1:50/50;symbols(x,squares=x/x,bg=rgb(x,x,x)) #47

Immagine precedente:

Java - 180

Abbastanza semplice, solo disegnando caselle.

import java.awt.*;void f(){new Frame(){public void paint(Graphics g){for(int i=1;i<51;g.setColor(new Color(328965*i)),g.fillRect(i%8*20,i++/8*20,20,20))setSize(600,600);}}.show();}

Con interruzioni di riga:

import java.awt.*;
    void f(){
        new Frame(){
            public void paint(Graphics g){
                for(int i=1;
                    i<51;
                    g.setColor(new Color(328965*i)),
                    g.fillRect(i%8*20,i++/8*20,20,20))
                    setSize(600,600);
            }
        }.show();
    }

BBC BASIC, 57

FORn=51TO2STEP-1VDU19;-1,n,n,n:RECTANGLEFILL0,0,n*20NEXT

I quadrati devono essere di almeno 20 pixel, ma non c'è nulla da dire che devono avere le stesse dimensioni, quindi immagino che questo sia valido.

Potrebbe essere possibile abbreviarlo utilizzando più codici VDU di basso livello. Ma è improbabile che il passaggio da questo modello a uno meno interessante lo accorcia.

ipython 2, 54 byte

Il meglio che potevo fare era con un programma ipython. Avviare ipython con ipython -pylabed eseguire questo programma mostrerà un grafico con 50 sfumature di grigio in 50 quadrati:

t=arange(50);c=t/50.;scatter(t%5,t,500,zip(c,c,c),'s')

Produzione:

Soluzione 2:

Ecco un altro programma (61 byte):

imshow(arange(50).reshape(5,10)*.02,'Greys',None,1,'nearest')

che visualizza la seguente finestra:

JavaScript ( 72 , 70 , 67 byte)

72: originale (prendendo in prestito l' ■uso intelligente dalla risposta di Sphinxxx ):

for(i=90;i>40;)document.write('<font color=#'+i+i+i--+' size=7>&#9632;')

70: rubare spudoratamente da Ismael Miguel (che merita i voti), un ciclo più breve per consentire al browser di correggere per mancanza di # procedere con il codice colore ...

for(i=60;--i>9;)document.write('<font color='+i+i+i+' size=7>&#9632;')

67 byte (65 caratteri): scambio dell'entità con il carattere unicode:

for(i=60;--i>9;)document.write('<font color='+i+i+i+' size=7>■')

C ++, 98 83 caratteri

Va bene, avrai bisogno di un emulatore di terminale che supporti i colori reali. Per mac os ci sono le build notturne di iTerm2, ad esempio. Per unix credo che Konsole lo supporti. Ecco un elenco, per ogni evenienza: https://gist.github.com/XVilka/8346728#now-supporting-truecolor

Compilare con g ++ (\ e dipende dal compilatore).

Affinché i quadrati abbiano un'area sufficiente, dovrai cambiare la dimensione del carattere del terminale.

#include <cstdio>
int main(){for(int i=51;i--;)printf("\e[48;2;%i;%i;%im ",i,i,i);}

L'uso delle librerie C anziché C ++ consente di radere alcuni caratteri.

C, 61 58 caratteri

Questo è lo stesso programma ma in C, che assume dichiarazioni di funzioni non tipizzate per restituire int, e che non ha bisogno di includere per alcune delle funzioni di libreria standard, come in questo caso, printf. Suggerito da @cartographer. Tre caratteri in meno grazie a @ user3601420

main(i){for(i=51;i--;)printf("\e[48;2;%i;%i;%im ",i,i,i);}

Compila un paio di avvertenze (per assumere il tipo di ritorno di main come int e per includere implicitamente la dichiarazione di printf).

Python 2, 125 115 104 byte

from turtle import*
shape("square")
bk(500)
ht()
pu()
exec'color((xcor()/2e3+.5,)*3);stamp();fd(21);'*50

Uscita campione:

Buona vecchia tartaruga. Questo era l'unico metodo che mi veniva in mente in Python che stampa le immagini su uno schermo usando solo le librerie standard.

La forma della tartaruga quadrata sembra essere 21 per 21, il che è molto conveniente. Questo può essere visto scavando attraverso turtle.py:

"square" : Shape("polygon", ((10,-10), (10,10), (-10,10), (-10,-10)))

Se hai un monitor ad alta risoluzione o non ti dispiace che alcuni quadrati siano fuori dallo schermo, allora questo è 93 byte:

from turtle import*
shape("square")
ht()
pu()
exec'color((xcor()/2e3,)*3);stamp();fd(21);'*50

dimostrazione

(Questa demo usa Skulpt adattando lo snippet trovato qui . È incluso solo per dare un'idea di ciò che fa il codice - ho dovuto modificare alcuni bit per farlo funzionare.)

function out(a){var b=document.getElementById("output");b.innerHTML+=a}function builtinRead(a){if(void 0===Sk.builtinFiles||void 0===Sk.builtinFiles.files[a])throw"File not found: '"+a+"'";return Sk.builtinFiles.files[a]}
$(document).ready(function run(){Sk.canvas="canvas";Sk.configure({output:out,read:builtinRead});try{Sk.importMainWithBody("<stdin>",!1,'import turtle\nt=turtle.Turtle()\nt.speed(9)\nt.shape("square")\n\nt.bk(500)\nt.ht()\nt.pu()\nfor i in range(50):t.color(64+2*i,64+2*i,64+2*i);t.stamp();t.fd(21)')}catch(a){throw Error(a.toString());}})

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"></script><script src="http://www.skulpt.org/static/skulpt.min.js" type="text/javascript"></script><script src="http://www.skulpt.org/static/skulpt-stdlib.js" type="text/javascript"></script>
<canvas height="100" width="1200" id="canvas" style="border:1px solid gray">Your browser does not support HTML5 Canvas!</canvas>

J ( 43 41 40 38 33 29 caratteri)

Dopo i suggerimenti di randomra .

1!:2&4'P2 ',":(,*:,],*:#?~)50

Questa soluzione non visualizza nulla in quanto la libreria standard di J non contiene routine GUI. Invece, generi un'immagine e la scrivo sull'output standard. L'output è randomizzato, ha assicurato che tutte le sfumature siano distinte. Ecco un esempio di output e l'immagine convertita in png e ruotata di 90 ° per una visualizzazione più semplice:

Excel vba, 81

Nella finestra immediata:

for i=1 to 9:for j=1 to 9:k=i+j*10:cells(i,j).interior.color=rgb(k,k,k):next:next

sul foglio attivo:

^{{81 sfumature ha lo stesso codice di 50}}

R ,3732 caratteri ¹ :

image(t(1:50),c=gray.colors(50))

Tuttavia, il display per questo sembra ... meh (immagine ruotata di 90 ° per adattarsi meglio al testo; compressa, lunghezza del lato quadrato originale> 20px):

Ecco una versione più bella che traccia i quadrati in ordine casuale all'interno di una matrice (50 caratteri):

image(matrix(sample(1:50),10),c=gray.colors(50))

(E sì, i tre quadrati adiacenti di colori apparentemente identici sono in realtà tre diverse tonalità di grigio.)

¹ Sì, un'altra risposta R,e nemmeno il più corto(ora il più breve per R) - scuse. Mi mancava un bel rendering in R.

Matlab 35 grazie a sanchise

imshow(int8(ones(20,1)*(0:.05:51)))

Matlab 36

imshow(uint8(ones(20,1)*(0:.05:51)))

Visualizza 50 quadrati riempiti con i valori grigi da 1 a 50 e 2 rettangoli aggiuntivi riempiti con i valori grigi 0 e 51:

Matlab, 45

imshow(uint8(ones(20,1)*floor(1:0.05:50.95)))

JavaScript, 87 90 byte

for(i=90;i>40;)document.write('<p style=background:#'+i+i+i--+';height:9ex;width:9ex>')

Questo genera quadrati per l'HTML, perché è davvero l'unico metodo di output grafico di JavaScript. Grazie a edc65 per la rasatura di 3 byte.

PHP, 96 88 74 byte

Grazie a Ismael Miguel per aver salvato 22 byte!

for($i=60;--$i>9;)echo"<p style=background:#$i$i$i;height:9mm;width:9mm>";

Scrive 50 <p>s con 9 mm di altezza e larghezza (che dovrebbe essere maggiore di 20 px sulla maggior parte degli schermi), sovrapposti l'uno all'altro, tutti con una leggera differenza di tonalità.

Risultato generato (l'immagine viene ingrandita e ruotata di 90 °):

Matlab - 33 byte

surf(meshgrid(1:7)),colormap gray

Nonostante i comandi dettagliati, il risultato è ancora abbastanza compatto. Sembra un po 'meglio se si sostituiscesurf con surfacema costa 3 caratteri.

Se non noti il ​​50 ° quadrato grigio, è perché è un po 'più grande degli altri!

Javascript (77 71 byte):

Questa risposta non è più basata su IE11. Funziona perché il browser converte i codici colore errati in codici utilizzabili (aggiungendo #al numero).

Ecco il codice:

for(i=59;i-->9;)document.write("<hr color="+i+i+i+" size=20 width=20>")

Firefox ha ancora la stranezza di creare cerchie.

(Modifica piccola: modificata for(i=61;i-->9;)in for(i=59;i-->9;)perché produceva 52 quadrati)

Vecchia risposta:

Questo si basa sulla mia risposta PHP e utilizza quasi gli stessi modi per creare i quadrati:

for(i=51;i--;)document.write("<hr color=rgb("+[i,i,i]+") size=20 width=20>");

Non è la risposta più breve, ma vale la pena aggiungerla qui.

Questa soluzione non è compatibile con Chrome (produce più colori verdi) e Firefox (stesso risultato, ma produce cerchi? O O WTH?)

Dato che si tratta di code-golf, una soluzione che funziona con una versione specifica o un software specifico è accettabile.

Piet- 2 * 103 = 206

Questo è unico in quanto il codice sorgente e l'output soddisfano la sfida:

La maggior parte è decorativa, quindi ho contato solo le prime due file, che stanno da sole. Emette un ppm in scala di grigi come altri hanno fatto.

JavaScript - 70 byte

for(i=51;i-=1;)document.write('<a style=opacity:'+i/50+'>&#9632;</a>')

Elaborazione, 66 caratteri:

size(1000,20);for(int i=0;i<981;i+=20){fill(i/4);rect(i,0,20,20);}

PHP (62 60 63 72 71 62 59 byte):

Ho reso il più breve che potessi trovare:

for($i=59;$i-->9;)echo"<hr color=$i$i$i size=20 width=20>";

Questo è esattamente lo stesso codice della mia risposta Javascript (con 71 byte) .

Ma MOLTO più breve!

Questo ha una stranezza in Firefox: invece di quadrati, Firefox crea cerchi ! (Fatti folle!) Al di
là di ciò, tutti i browser producono il colore giusto (anche se manca #l' colorattributo).

Invio e log delle modifiche non validi :

Vecchia risposta, con 62 byte.

while($i++<51)echo"<hr color=rgb($i,$i,$i) size=20 width=20>";

Tutte le tonalità sono perfettamente allineate.

Questa soluzione non funzionerà per Chrome (produrrà quadrati con più colori) e Firefox (che rende cerchi oO Sì, cerchi con <hr>! Il righello orizzontale è un cerchio su Firefox!).
Puoi testarlo su IE11 e dovrebbe andare bene.

(semplicemente rimosso dall'alto)

Ho notato qualcosa di terribile: era in uscita #111invece che #010101per alcuni colori.

Ciò significava che alcuni colori si ripetevano.

Pertanto, ho dovuto sacrificare alcuni byte:

<?while(f>$c=dechex(65-$i++))echo"<hr color=#$c$c$c size=20 width=20>";

Produce le 50 tonalità in perfetto ordine, da più chiaro a più scuro.

A causa di un punto corretto fatto da @ edc65 , ho dovuto aggiungere width=20, per produrre quadrati perfetti .

Ridotto un altro byte sostituendolo f!=$ccon f>$c, che funziona perfettamente.

Versione finale, senza width=20:

<?while(f!=$c=dechex(65-$i++))echo"<hr color=#$c$c$c size=20>";

Questo non è valido perché è necessario per l'output dei quadrati.
Questo emette le tonalità da più chiaro a più scuro.

Ridotto 1 byte passando a un whileloop, in questo modo:

<?while($c=dechex(50-$i++))echo"<hr color=#$c$c$c size=20>";

Prima soluzione:

<?for($i=50;$c=dechex($i--);)echo"<hr color=#$c$c$c size=20>";

Questo non ha le tonalità ordinatamente ordinate, ma ce ne sono 50 diverse.

Non c'è nulla che affermi che devono essere ordinati, ma c'è un requisito sulla dimensione.

Spero di poterlo ridurre molto di più.

Puoi provarlo su http://writecodeonline.com/php/ (fai clic su "Visualizza come HTML").

CSS (87 caratteri)

Usa l'animazione;)

:after{content:'\25A0';font:9em z;animation:g 8s steps(50)}@keyframes g{to{color:#fff}}

La versione eseguibile è più lunga poiché Webkit necessita ancora del prefisso del fornitore. :(

:after{content:'\25A0';font:9em z;-webkit-animation:g 8s steps(50);animation:g 8s steps(50)}@-webkit-keyframes g{to{color:#fff}}@keyframes g{to{color:#fff}}

Se ci viene concesso un <a>elemento casuale e vuoto , possiamo ridurlo a soli 72 caratteri:

a{padding:3em;animation:g 8s steps(50)}@keyframes g{to{background:#000}}

Vedere? CSS è un linguaggio di programmazione legittimo!

R, 36 byte

Posso rendere la risposta di freekvd più brevemente banale.

x=9:59/59;symbols(x,sq=x,bg=gray(x))

(Ci scusiamo per non aver commentato la sua soluzione. Stackexchange non mi permette di fare commenti, votare, ecc.).

PostScript, 34 byte

Nella codifica ISO-Latin-1:

20’›‡üˆì0{’81e3’6’–10’k0ˆ                   (note, this is a Line Feed)
’c’§}’H

Questo è l'equivalente binario di:

20 setlinewidth 1020 -20 0 { dup 1e3 div setgray 10 moveto 0 10 lineto stroke } for

(Ciò presuppone che lo si stia utilizzando su un dispositivo largo almeno 1000 punti [= 10 pollici = 25,4 cm]).

DrRacket - 83

Solo per il gusto di avviare DrRacket 1 anno dopo "Introduzione alla progettazione sistematica di programmi".

MODIFICA :

(require htdp/image)(map(λ(i)(rectangle 50 50'solid(make-color i i i)))(range 50))

C # - 173

Utilizzando LINQPAD

var b=new Bitmap(1000,20);var g=Graphics.FromImage(b);for(int i=0;i<50;i++)g.FillRectangle(new SolidBrush(Color.FromArgb(i*5,i*5,i*5)),new Rectangle(i*20,0,20,20));b.Dump();

allargato :

var b = new Bitmap(1000, 20);
var g = Graphics.FromImage(b);
for (int i = 0; i < 50; i++)
    g.FillRectangle(new SolidBrush(Color.FromArgb(i * 5, i * 5, i * 5)), new Rectangle(i * 20, 0, 20, 20));
b.Dump();

Uscita :

JavaScript, 152 byte.

Okay, quindi forse questa non è la soluzione migliore, ma qui è la mia.

function b(a){c=document
e=c.createElement('p')
with(e.style){background="rgb("+[a,a,a]+")"
width=height="20px"}c.body.appendChild(e)
a<245&&b(a+5)}b(0)

Ecco l'output con css float a sinistra (solo così è più facile contare i quadrati) e senza: