Los niños y las niñas están emocionados de ver Fifty Shades of Grey en la pantalla plateada, solo queremos codificar sin ser molestados, así que aquí hay un desafío para elegir nuestro cerebro.

Tienes que:

• Imprima en la pantalla cincuenta cuadrados llenos cada uno con un tono diferente de gris
• Si su idioma de elección carece de capacidades de procesamiento de imágenes , puede generar un archivo de imagen
• Los cuadrados deben ser visibles, al menos 20 x 20 píxeles
• No puede usar números aleatorios a menos que se asegure de que cada tono sea único.
• No puede conectarse a ningún servicio a través de ninguna red.
• No puede leer ningún archivo en su programa.
• No puede utilizar ninguna biblioteca fuera de las bibliotecas estándar de su idioma de elección.

Este es el código de golf, por lo que el código más corto gana.

MATLAB, 24 bytes

Segundo intento, ahora en realidad conforme a las reglas.

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

La 'I' significa 'InitialMagnification', pero aparentemente Matlab completará automáticamente los nombres en pares de nombre / valor. ¡Seguro que es un buen truco de golf!

Mathematica, 30 bytes

Aquí hay otro enfoque de Mathematica:

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

o

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

El primero simplemente crea una matriz

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

y el segundo

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

Luego, los ArrayPlottraza como una cuadrícula y, de forma predeterminada, usa escala de grises para visualizar los valores.

CJam - 23 (sin salida gráfica real)

Como CJam no puede dibujar en la pantalla (¿todavía?), Escribí un programa que genera una imagen en formato pgm simple .
Guarde la salida en un archivo llamado 50.pgm y ábralo con un visor / editor de imágenes.

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

Pruébalo en línea

El resultado se ve así:

Explicación:

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

Versión actual (34 bytes)

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

Versión anterior (59 bytes), gracias a Martin Büttner.

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

Se agregaron bordes azules para resaltar la posición de los cuadrados.

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

Numero de cuadrados:

    Length[%[[1]]]

50

Primer intento (72 bytes)

Si los cuadrados pueden superponerse. Como señala Zgarb, existe una remota posibilidad de que un cuadrado oculte a otro.

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

Sabio - 26 24 35 29 caracteres

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

Se parece a esto:

Intentos anteriores : primero tuve Matrix([range(50)]).plot(), luego matrix_plot([range(50)]). Estos se veían así:

El usuario @flawr señaló que los cuadrados producidos con la configuración predeterminada son demasiado pequeños. Agregar una figsizeopción lo corrige, pero es 6 caracteres más largo que la versión 5x10 en la parte superior de esta respuesta:

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

R, 47 42 39 38 37 36 35 bytes

Suponiendo que se les permita superponerse, esto funciona. Symbolsrequiere un vector que contenga el tamaño de cada cuadrado, y estoy ahorrando espacio reutilizando el mismo vector para todos los parámetros de la función. El cuadrado más grande siempre tiene 1 pulgada de ancho. Con 50:99 como rango de enteros, el cuadrado más pequeño tendrá alrededor de media pulgada de ancho, por lo que 36 píxeles a 72 ppp.

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

Gracias a todos por los comentarios y sugerencias, soy bastante nuevo en R, por lo que todo esto es muy educativo.

Versión anterior:

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

Imagen anterior:

Java - 180

Bastante sencillo, solo dibujando cajas.

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 saltos de línea:

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

Los cuadrados deben tener al menos 20 píxeles, pero no hay nada que decir que tengan el mismo tamaño, así que supongo que esto califica.

Es posible acortar esto usando más códigos VDU de bajo nivel. Pero cambiar de este patrón a uno menos interesante es poco probable que lo acorte.

ipython 2, 54 bytes

Lo mejor que pude hacer fue con un programa ipython. Al iniciar ipython ipython -pylaby ejecutar este programa, se mostrará un gráfico con 50 tonos de gris en 50 cuadrados:

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

Salida:

Solución 2:

Aquí hay otro programa (61 bytes):

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

que muestra la siguiente ventana:

JavaScript ( 72 , 70 , 67 bytes)

72: original (tomando prestado el ■uso inteligente de la respuesta de Sphinxxx ):

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

70: robar descaradamente a Ismael Miguel (quien merece los votos), un bucle más corto y que permite al navegador corregir por falta de # proceder con el código de color ...

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

67 bytes (65 caracteres): intercambiando la entidad por el carácter unicode:

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

C ++, 98 83 caracteres

Bien, entonces necesitarás un emulador de terminal que admita colores verdaderos. Para mac os existen las versiones nocturnas de iTerm2, por ejemplo. Para Unix, creo que Konsole lo admite. Aquí hay una lista, por si acaso: https://gist.github.com/XVilka/8346728#now-supporting-truecolor

Compilar con g ++ (\ e depende del compilador).

Para que los cuadrados tengan suficiente área, deberá cambiar el tamaño de fuente de su terminal.

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

El uso de bibliotecas C en lugar de C ++ permite afeitar algunos caracteres.

C, 61 58 caracteres

Este es el mismo programa pero en C, que supone que las declaraciones de función sin tipo devuelven int, y que no necesita incluir algunas de las funciones estándar de la biblioteca, como en este caso, printf. Sugerido por @cartographer. Tres caracteres menos gracias a @ user3601420

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

Se compila con un par de advertencias (para asumir que el tipo de retorno de main es int y para incluir implícitamente la declaración de printf).

Python 2, 125 115 104 bytes

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

Salida de muestra:

Buena tortuga vieja. Este fue el único método que se me ocurrió en Python que imprime imágenes en una pantalla utilizando solo las bibliotecas estándar.

La forma cuadrada de la tortuga es de 21 por 21, lo cual es muy conveniente. Esto se puede ver cavando a través de turtle.py:

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

Si tiene un monitor de alta resolución o no le importa que algunos cuadrados estén fuera de la pantalla, entonces estos son 93 bytes:

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

Manifestación

(Esta demostración utiliza Skulpt adaptando el fragmento que se encuentra aquí . Solo se incluye para dar una idea de lo que hace el código; tuve que modificar algunos bits para que funcione).

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

Después de las sugerencias de randomra .

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

Esta solución no muestra nada ya que la biblioteca estándar de J no contiene rutinas GUI. En cambio, genero una imagen y la escribo en la salida estándar. La salida es aleatoria, asegura que todos los tonos sean distintos. Aquí hay algunos resultados de muestra y la imagen convertida a png y rotada 90 ° para facilitar la visualización:

Excel vba, 81

En la ventana inmediata:

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

en la hoja activa:

^{{81 sombras es tanto código como 50}}

R ,3732 caracteres ¹ :

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

Sin embargo, la pantalla para esto se ve ... meh (la imagen gira 90 ° para ajustarse mejor al texto; comprimido, longitud del lado cuadrado original> 20px):

Aquí hay una versión más bonita que traza los cuadrados en orden aleatorio dentro de una matriz (50 caracteres):

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

(Y sí, los tres cuadrados adyacentes de colores aparentemente idénticos son en realidad tres tonos de gris diferentes).

¹ Sí, otra respuesta R,y ni siquiera el más corto(ahora el más corto para R) - disculpas. Me faltaba una bonita representación en R.

Matlab 35 gracias a sanchises

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

Matlab 36

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

Muestra 50 cuadrados rellenos con valores grises 1 a 50 y 2 rectángulos adicionales rellenos con valores grises 0 y 51:

Matlab, 45

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

JavaScript, 87 90 bytes

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

Esto genera cuadrados al HTML, porque es realmente el único método de JavaScript de salida gráfica. Gracias a edc65 por reducir 3 bytes.

PHP, 96 88 74 bytes

¡Gracias a Ismael Miguel por guardar 22 bytes!

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

Escribe 50 <p>s con 9 mm de alto y ancho (que debería ser mayor que 20px en la mayoría de las pantallas), apilados unos sobre otros, todos con una pequeña diferencia de tono.

Resultado generado (la imagen se aleja y se gira 90 °):

Matlab - 33 bytes

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

A pesar de los comandos detallados, el resultado sigue siendo bastante compacto. Se ve un poco mejor si reemplaza surfcon surfacepero eso cuesta 3 caracteres.

¡Si no notas el cuadrado gris número 50, es porque es un poco más grande que los demás!

Javascript (77 71 bytes):

Esta respuesta ya no está basada en IE11. Funciona porque el navegador convierte los códigos de color incorrectos en códigos utilizables (agregando #al número).

Aquí está el código:

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

Firefox todavía tiene la peculiaridad de hacer círculos.

(Edición pequeña: cambiado for(i=61;i-->9;)a for(i=59;i-->9;)porque estaba produciendo 52 cuadrados)

Vieja respuesta:

Esto se basa en mi respuesta PHP y usa casi las mismas formas para hacer los cuadrados:

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

No es la respuesta más corta, pero vale la pena agregarla aquí.

Esta solución no es compatible con Chrome (produce múltiples colores verdes) y Firefox (mismo resultado, pero produce círculos? OO WTH?)

Como se trata de código de golf, es aceptable una solución que funcione con una versión específica o un software específico.

Piet- 2 * 103 = 206

Esto es único porque el código fuente y la salida cumplen el desafío:

La mayor parte es decorativa, así que solo conté las dos filas superiores, que están solas bien. Produce una escala de grises ppm como lo han hecho otros.

JavaScript: 70 bytes

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

Procesamiento, 66 caracteres:

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

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

Hice lo más corto que pude encontrar:

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

Este es exactamente el mismo código que mi respuesta de Javascript (con 71 bytes) .

¡Pero MUCHO más corto!

Esto tiene una peculiaridad en Firefox: ¡en lugar de cuadrados, Firefox hace círculos ! (¡Vaya locura!)
Aparte de eso, todos los navegadores producen el color correcto (incluso con los que faltan #en el coloratributo).

Envíos no válidos y registro de cambios :

Antigua respuesta, con 62 bytes.

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

Todos los tonos están perfectamente alineados.

Esta solución no funcionará para Chrome (producirá cuadrados con varios colores) y Firefox (que hace círculos oO ¡Sí, círculos con <hr>! ¡La regla horizontal es un círculo en Firefox!).
Puede probarlo en IE11 y debería estar bien.

(simplemente eliminado de arriba)

He notado algo horrible: estaba emitiendo en #111lugar de #010101algunos colores.

Esto significaba que algunos colores se repetían.

Por lo tanto, tuve que sacrificar algunos bytes:

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

Emite los 50 tonos en perfecto orden, de más claro a más oscuro.

Debido a un punto correcto hecho por @ edc65 , tuve que agregar width=20, para producir cuadrados perfectos .

Reducido un byte más al reemplazar f!=$ccon f>$c, que funciona perfectamente.

Versión final, sin width=20:

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

Esto no es válido porque se requiere para generar cuadrados.
Esto genera los tonos de más claro a más oscuro.

Se redujo 1 byte al cambiar a un whilebucle, así:

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

Primera solución

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

Esto no tiene los tonos perfectamente ordenados, pero hay 50 diferentes.

No hay nada que indique que deben ordenarse, pero hay un requisito de tamaño.

Espero poder reducirlo mucho más.

Puede probarlo en http://writecodeonline.com/php/ (haga clic en "Mostrar como HTML").

CSS (87 caracteres)

Utiliza animación;)

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

La versión ejecutable es más larga ya que Webkit todavía necesita el prefijo del proveedor. :(

: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 se nos permite un <a>elemento aleatorio y vacío , podemos reducirlo a solo 72 caracteres:

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

¿Ver? ¡CSS es un lenguaje de programación legítimo!

R, 36 bytes

Puedo acortar trivialmente la respuesta de freekvd.

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

(Perdón por no hacer un comentario bajo su solución. Stackexchange todavía no me permite hacer comentarios, votar, etc.).

PostScript, 34 bytes

En codificación ISO-Latin-1:

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

Este es el binario equivalente a:

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

(Esto supone que lo está utilizando en un dispositivo que tiene al menos 1000 puntos [= 10 pulgadas = 25.4 cm] de ancho).

DrRacket - 83

Solo por el hecho de activar DrRacket 1 año después de "Introducción al diseño sistemático de programas".

EDITAR :

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

C # - 173

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

Ampliado :

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

Salida :

JavaScript, 152 bytes.

Bien, quizás esta no sea la mejor solución, pero aquí está la mía.

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)

Aquí está la salida con flotador css a la izquierda (solo para que sea más fácil contar los cuadrados) y sin: