Les garçons et les filles sont enthousiastes à l'idée de voir Fifty Shades of Grey sur leur grand écran. Nous voulons simplement coder sans être dérangés, alors voici un défi: choisir notre cerveau.

Vous devez:

• Imprimez sur l'écran cinquante carrés remplis chacun d'une nuance de gris différente
• Si votre langue de choix manque de capacités de traitement d'image , vous pouvez générer un fichier image.
• Les carrés doivent être visibles, au moins 20 x 20 pixels
• Vous ne pouvez pas utiliser de nombres aléatoires à moins de vous assurer que chaque nuance est unique.
• Vous ne pouvez vous connecter à aucun service sur aucun réseau
• Vous ne pouvez lire aucun fichier dans votre programme.
• Vous ne pouvez utiliser aucune bibliothèque en dehors des bibliothèques standard de la langue de votre choix.

C'est le code de golf si le code le plus court gagne.

MATLAB, 24 octets

Deuxième tentative, maintenant conforme aux règles.

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

Le 'I' signifie 'InitialMagnification', mais apparemment, Matlab complétera automatiquement les noms en paires nom / valeur. Bien sûr, c'est un bon tour de golf!

Mathematica, 30 octets

Voici une autre approche de Mathematica:

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

ou

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

Le premier crée simplement un tableau

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

et le second

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

Ensuite, ArrayPlottracez-les sous forme de grille et, par défaut, utilise l'échelle de gris pour visualiser les valeurs.

CJam - 23 (pas de sortie graphique réelle)

Comme CJam ne peut pas (encore?) Dessiner à l'écran, j'ai écrit un programme qui affiche une image au format .pg .
Enregistrez la sortie dans un fichier nommé 50.pgm et ouvrez-la avec un visualiseur / éditeur d'images.

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

Essayez-le en ligne

Le résultat ressemble à ceci:

Explication:

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

Version actuelle (34 octets)

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

Version antérieure (59 octets), merci à Martin Büttner.

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

Des bordures bleues ont été ajoutées pour mettre en évidence la position des carrés.

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

Nombre de carrés:

    Length[%[[1]]]

50

Première tentative (72 octets)

Si les carrés peuvent se chevaucher. Comme le note Zgarb, il existe une faible possibilité qu’une case en cache une autre.

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

Sage - 26 24 35 29 caractères

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

Cela ressemble à ceci:

Les tentatives précédentes : Tout d' abord j'ai eu Matrix([range(50)]).plot(), alors matrix_plot([range(50)]). Ils ressemblaient à ceci:

L'utilisateur @flawr a fait remarquer que les carrés produits avec les paramètres par défaut sont trop petits. L'ajout d'une figsizeoption le corrige, mais il comporte 6 caractères de plus que la version 5x10 en haut de cette réponse:

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

R, 47 42 39 38 37 36 35 octets

En supposant qu'ils soient autorisés à se chevaucher, cela fonctionne. Symbolsnécessite un vecteur contenant la taille de chaque carré, et je gagne de la place en réutilisant le même vecteur pour tous les paramètres de fonction. Le plus grand carré fait toujours 1 pouce de large. Avec 50:99 comme plage d’entiers, le plus petit carré aura environ un demi-pouce de large, soit 36 ​​pixels à 72 dpi.

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

Merci à tous pour les commentaires et les suggestions, je suis un nouveau venu dans R, donc tout cela est très instructif.

Versions précédentes:

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

Image précédente:

Java - 180

Assez simple, il suffit de dessiner des boîtes.

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

Avec des sauts de ligne:

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

Les carrés doivent avoir au moins 20 pixels, mais rien ne dit qu'ils doivent avoir la même taille, alors je suppose que cela suffit.

Il peut être possible de raccourcir ce processus en utilisant davantage de codes VDU de bas niveau. Mais passer de ce modèle à un modèle moins intéressant ne le rendra probablement pas plus court.

ipython 2, 54 octets

Le mieux que je pouvais faire était avec un programme ipython. Lancer ipython avec ipython -pylabet exécuter ce programme affichera un graphique avec 50 nuances de gris sur 50 carrés:

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

Sortie:

Solution 2:

Voici un autre programme (61 octets):

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

qui affiche la fenêtre suivante:

JavaScript ( 72 , 70 , 67 octets)

72: original (empruntant l' ■utilisation intelligente de la réponse de Sphinxxx ):

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

70: voler sans vergogne à Ismael Miguel (qui mérite les votes), une boucle plus courte et permettant au navigateur de corriger l'absence de # procédant au code de couleur ...

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

67 octets (65 caractères): permutation de l'entité contre le caractère unicode:

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

C ++, 98 83 caractères

D'accord, vous aurez besoin d'un émulateur de terminal prenant en charge les couleurs vraies. Pour mac os, il existe par exemple les versions nocturnes de iTerm2. Pour Unix, je pense que konsole le soutient. Voici une liste, juste au cas où: https://gist.github.com/XVilka/8346728#now-supporting-truecolor

Compiler avec g ++ (\ e dépend du compilateur).

Pour que les carrés aient une surface suffisante, vous devrez modifier la taille de la police du terminal.

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

L'utilisation de bibliothèques C au lieu de C ++ permet de raser certains caractères.

C, 61 58 caractères

Il s’agit du même programme, mais en C, qui suppose que les déclarations de fonctions non typées renvoient int, et qui n’a pas besoin d’inclusions pour certaines des fonctions de bibliothèque standard, comme dans ce cas printf. Proposé par @cartographer. Trois caractères en moins grâce à @ user3601420

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

Compile avec quelques avertissements (pour supposer que le type de retour de main est int et pour inclure implicitement la déclaration de printf).

Python 2, 125 115 104 octets

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

Exemple de sortie:

Bonne vieille tortue C’était la seule méthode à laquelle je pouvais penser en Python qui imprimait des images sur un écran en utilisant uniquement les bibliothèques standard.

La forme de la tortue carrée se trouve être 21 x 21, ce qui est très pratique. Ceci peut être vu en fouillant dans turtle.py:

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

Si vous avez un moniteur haute résolution ou si quelques cases ne sont pas gênantes, ceci correspond à 93 octets:

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

Démo

(Cette démonstration utilise Skulpt en adaptant l'extrait de code trouvé ici . Il est uniquement inclus pour donner une idée de ce que le code fait - j'ai dû modifier quelques bits pour le faire fonctionner.)

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 caractères)

Après les suggestions de randomra .

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

Cette solution n'affiche rien car la bibliothèque standard de J ne contient pas de routines d'interface graphique. Au lieu de cela, je génère une image et l'écris sur la sortie standard. La sortie est aléatoire, il s’assure que toutes les nuances sont distinctes. Voici un exemple de sortie et l'image convertie en png et tournée de 90 ° pour faciliter la visualisation:

Excel vba, 81

Dans la fenêtre immédiate:

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

sur la feuille active:

^{{81 nuances correspondent à autant de code que 50}}

R ,3732 caractères ¹ :

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

Cependant, l'affichage de cette image ressemble à… meh (image pivotée à 90 ° pour un meilleur ajustement au texte; longueur du côté carré compressé d'origine> 20 px):

Voici une version plus agréable qui trace les carrés dans un ordre aléatoire dans une matrice (50 caractères):

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

(Et oui, les trois carrés adjacents de couleurs apparemment identiques sont en réalité trois nuances de gris différentes.)

¹ Oui, une autre réponse R,et même pas le plus court(maintenant le plus court pour R) - excuses. Il me manquait un joli rendu en R.

Matlab 35 grâce aux franchises

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

Matlab 36

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

Affiche 50 carrés remplis avec les valeurs de gris 1 à 50 et 2 rectangles supplémentaires remplis avec les valeurs de gris 0 et 51:

Matlab, 45 ans

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

JavaScript, 87 90 octets

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

Cela génère des carrés au format HTML, car il s'agit en réalité de la seule méthode de sortie graphique de JavaScript. Merci à edc65 pour avoir supprimé 3 octets.

PHP, 96 88 74 octets

Merci à Ismael Miguel pour avoir économisé 22 octets!

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

Écrit 50 <p>secondes avec une hauteur et une largeur de 9 mm (qui doivent être supérieures à 20 px sur la majorité des écrans), empilés les uns sur les autres, le tout avec une légère différence de nuance.

Résultat généré (l’image est zoomée et tournée à 90 °):

Matlab - 33 octets

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

Malgré les commandes verbeuses, le résultat est encore assez compact. Cela semble un peu mieux si vous remplacez surfpar surfacemais cela coûte 3 caractères.

Si vous ne remarquez pas le 50ème carré gris, c'est qu'il est un peu plus grand que les autres!

Javascript (77 71 octets):

Cette réponse n'est plus basée sur IE11. Cela fonctionne parce que le navigateur convertit les codes de couleur défectueux en codes utilisables (en ajoutant #le numéro).

Voici le code:

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

Firefox a toujours le côté bizarre de faire des cercles.

(Petite édition: Changé for(i=61;i-->9;)pour for(i=59;i-->9;)parce qu'il produisait 52 places)

Ancienne réponse:

Ceci est basé sur ma réponse PHP , et utilise presque les mêmes méthodes pour faire les carrés:

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

Ce n'est pas la réponse la plus courte, mais ça vaut la peine d'ajouter ici.

Cette solution n'est pas compatible avec Chrome (produit plusieurs couleurs vertes) et Firefox (même résultat, mais produit des cercles? OO WTH?)

Puisqu'il s'agit de code-golf, une solution fonctionnant avec une version spécifique ou un logiciel spécifique est acceptable.

Piet- 2 * 103 = 206

Ceci est unique en ce que le code source et la sortie répondent au défi:

La plupart de ces éléments sont décoratifs. Je n'ai donc compté que les deux premiers rangs, qui sont très bien isolés. Émet un niveau de gris en ppm comme certains l’ont fait.

JavaScript - 70 octets

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

Traitement, 66 caractères:

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 octets):

J'ai fait le plus court possible

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

C'est exactement le même code que ma réponse Javascript (avec 71 octets) .

Mais BEAUCOUP plus court!

Cela a une bizarrerie dans Firefox: au lieu de carrés, Firefox fait des cercles ! (Allez la folie!)
Sinon, tous les navigateurs produisent la bonne couleur (même avec les manquants #sur l' colorattribut).

Soumissions non valides et journal des modifications :

Ancienne réponse, avec 62 octets.

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

Toutes les nuances sont parfaitement alignées.

Cette solution ne fonctionnera pas pour Chrome (produira des carrés de plusieurs couleurs) et pour Firefox (qui fait des cercles oO Oui, les cercles avec <hr>! La règle horizontale est un cercle sur Firefox!).
Vous pouvez le tester sur IE11 et ça devrait aller.

(simplement enlevé d'en haut)

J'ai remarqué quelque chose de terrible: il s'agissait de produire #111au lieu de #010101pour certaines couleurs.

Cela signifiait que certaines couleurs se répètent.

Par conséquent, j'ai dû sacrifier quelques octets:

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

Reproduit les 50 nuances dans un ordre parfait, du plus clair au plus foncé.

En raison d’un argument correct de @ edc65 , j’ai dû ajouter width=20pour produire des carrés parfaits .

Réduction d'un octet supplémentaire en remplaçant f!=$cpar f>$c, ce qui fonctionne parfaitement.

Version finale, sans width=20:

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

Ceci est invalide car il est nécessaire de générer des carrés.
Cela sort les nuances de clair à foncé.

Réduit de 1 octet en passant à une whileboucle, comme ceci:

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

Première solution:

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

Cela n'a pas ordonné les nuances, mais il y en a 50 différentes.

Rien n'indique qu'ils doivent être commandés, mais leur taille est requise.

J'espère pouvoir le réduire beaucoup plus.

Vous pouvez le tester sur http://writecodeonline.com/php/ (cliquez sur "Afficher en HTML").

CSS (87 caractères)

Utilise l'animation;)

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

La version exécutable est plus longue car Webkit a toujours besoin du préfixe du fournisseur. :(

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

Si un <a>élément vide et aléatoire est autorisé , nous pouvons le réduire à 72 caractères:

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

Voir? CSS est un langage de programmation légitime!

R, 36 octets

Je peux faire la réponse de freekvd plus courte trivialement.

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

(Désolé de ne pas avoir commenté sa solution. Stackexchange ne me permet pas de commenter, de voter, etc.).

PostScript, 34 octets

En codage ISO-Latin-1:

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

C'est l'équivalent binaire de:

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

(Cela suppose que vous l'utilisez sur un périphérique d'au moins 1 000 points [= 10 pouces = 25,4 cm] de large.)

DrRacket - 83

Juste pour alléger DrRacket un an après "Introduction à la conception systématique de programmes".

EDIT :

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

C # - 173

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

Élargi :

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

Sortie :

JavaScript, 152 octets.

Ok, alors peut-être que ce n'est pas la meilleure solution mais voici la mienne.

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)

Voici la sortie avec css float left (juste pour faciliter le comptage des carrés) et sans: