Meninos e meninas estão animados para ver Fifty Shades of Grey na tela prateada, nós apenas queremos codificar sem nos incomodar, então aqui está um desafio para escolher nosso cérebro.

Voce tem que:

• Imprima na tela cinquenta quadrados preenchidos com um tom diferente de cinza
• Se o seu idioma de escolha não possuir recursos de processamento de imagem , você poderá gerar um arquivo de imagem
• Os quadrados devem estar visíveis, pelo menos 20 x 20 pixels
• Você não pode usar números aleatórios, a menos que tenha certeza de que cada tom é único.
• Você não pode se conectar a nenhum serviço em nenhuma rede
• Você não pode ler nenhum arquivo no seu programa.
• Você não pode usar nenhuma biblioteca fora das bibliotecas padrão do seu idioma preferido.

Este é o código de golfe, então o código mais curto vence.

MATLAB, 24 bytes

Segunda tentativa, agora realmente em conformidade com as regras.

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

O 'I' significa 'InitialMagnification', mas aparentemente o Matlab completará automaticamente os nomes nos pares nome / valor. Claro que é um bom truque de golfe!

Mathematica, 30 bytes

Aqui está outra abordagem do Mathematica:

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

ou

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

O primeiro simplesmente cria uma 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}}

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

Em seguida, ArrayPlotplota-os como uma grade e, por padrão, usa a escala de cinza para visualizar os valores.

CJam - 23 (sem saída gráfica real)

Como o CJam não pode desenhar na tela (ainda?), Escrevi um programa que gera uma imagem no formato pgm simples .
Salve a saída em um arquivo chamado 50.pgm e abra com um visualizador / editor de imagens.

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

Experimente online

O resultado fica assim:

Explicação:

"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

Versão atual (34 bytes)

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

Versão anterior (59 bytes), graças a Martin Büttner.

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

Bordas azuis adicionadas para destacar a posição dos quadrados.

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

Número de quadrados:

    Length[%[[1]]]

50.

Primeira tentativa (72 bytes)

Se os quadrados puderem se sobrepor. Como observa Zgarb, existe uma possibilidade remota de que um quadrado oculte outro.

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

Sábio - 26 24 35 29 caracteres

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

Se parece com isso:

Tentativas anteriores : Primeiro eu tive Matrix([range(50)]).plot(), então matrix_plot([range(50)]). Eles se pareciam com isso:

O usuário @flawr apontou que os quadrados produzidos com as configurações padrão são muito pequenos. A adição de uma figsizeopção o corrige, mas são 6 caracteres a mais que a versão 5x10 na parte superior desta resposta:

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

R, 47 42 39 38 37 36 35 bytes

Supondo que eles possam se sobrepor, isso funciona. Symbolsrequer um vetor que contém o tamanho de cada quadrado e estou economizando espaço reutilizando o mesmo vetor para todos os parâmetros de função. A maior praça é sempre 1 polegada de largura. Com 50:99 como o intervalo de números inteiros, o menor quadrado terá cerca de meia polegada de largura, portanto, 36 pixels a 72 dpi.

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

Obrigado a todos pelos comentários e sugestões, sou muito novo no R, então tudo isso é muito educativo.

Versões prévias:

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

Imagem anterior:

Java - 180

Bem simples, apenas desenhando caixas.

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

Com quebras de linha:

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

Os quadrados devem ter pelo menos 20 pixels, mas não há nada a dizer que eles devem ter o mesmo tamanho, então acho que isso se qualifica.

Pode ser possível reduzi-lo usando mais códigos VDU de baixo nível. Mas a mudança desse padrão para um menos interessante provavelmente não o tornará mais curto.

ipython 2, 54 bytes

O melhor que pude fazer foi com um programa ipython. Iniciar o ipython ipython -pylabe executar este programa mostrará um gráfico com 50 tons de cinza em 50 quadrados:

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

Resultado:

Solução 2:

Aqui está outro programa (61 bytes):

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

que exibe a seguinte janela:

JavaScript ( 72 , 70 , 67 bytes)

72: original (emprestando o ■uso inteligente da resposta do Sphinxxx ):

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

70: roubando descaradamente Ismael Miguel (que merece os votos), um loop for mais curto e permitindo que o navegador corrija a falta de # continuar o código de cores ...

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

67 bytes (65 caracteres): trocando a entidade pelo caractere unicode:

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

C ++, 98 83 caracteres

Ok, então você precisará de um emulador de terminal que suporte cores verdadeiras. Para mac os, há as construções noturnas do iTerm2, por exemplo. Para o unix, acredito que o konsole o suporta. Aqui está uma lista, apenas no caso: https://gist.github.com/XVilka/8346728#now-supporting-truecolor

Compile com g ++ (\ e depende do compilador).

Para que os quadrados tenham área suficiente, você precisará alterar o tamanho da fonte do terminal.

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

O uso de bibliotecas C em vez de C ++ permite raspar alguns caracteres.

C, 61 58 caracteres

Este é o mesmo programa, mas em C, que assume declarações de funções não tipadas para retornar int e que não precisa incluir inclusões para algumas das funções padrão da biblioteca, como neste caso, printf. Sugerida por @cartographer. Três caracteres a menos graças a @ user3601420

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

Compila com alguns avisos (por assumir o tipo de retorno do main como int e incluir implicitamente a declaração 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

Saída de amostra:

Boa e velha tartaruga. Este foi o único método que eu consegui pensar no Python que imprime imagens em uma tela usando apenas as bibliotecas padrão.

O formato quadrado da tartaruga é de 21 por 21, o que é muito conveniente. Isso pode ser visto pesquisando turtle.py:

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

Se você tem um monitor de alta resolução ou não se importa de alguns quadrados fora da tela, são 93 bytes:

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

Demo

(Esta demonstração usa o Skulpt adaptando o snippet encontrado aqui . Ele está incluído apenas para ter uma idéia do que o código faz - tive que modificar alguns bits para fazê-lo funcionar.)

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)

Após sugestões de randomra .

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

Esta solução não exibe nada, pois a biblioteca padrão de J não contém rotinas da GUI. Em vez disso, giro uma imagem e a escrevo na saída padrão. A saída é aleatória, garantindo que todas as tonalidades sejam distintas. Aqui está um exemplo de saída e a imagem convertida em png e girada em 90 ° para facilitar a visualização:

Excel vba, 81

Na janela imediata:

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

na planilha ativa:

^{{81 tons é tanto código quanto 50}}

R ,37.32 caracteres ¹ :

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

No entanto, a exibição para isso parece… meh (a imagem girou 90 ° para se ajustar melhor ao texto; comprimento do lado quadrado original compactado> 20px):

Aqui está uma versão melhor que plota os quadrados em ordem aleatória dentro de uma matriz (50 caracteres):

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

(E sim, os três quadrados adjacentes de cores aparentemente idênticas são na verdade três tons diferentes de cinza.)

¹ Sim, outra resposta R,e nem mesmo o mais curto(agora o mais curto para R) - desculpas. Estava faltando uma renderização bonita em R.

Matlab 35 graças a sanchises

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

Matlab 36

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

Exibe 50 quadrados preenchidos com os valores de cinza 1 a 50 e 2 retângulos adicionais preenchidos com os valores de cinza 0 e 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>')

Isso gera quadrados para o HTML, porque é realmente o único método de saída gráfica do JavaScript. Graças ao edc65 por remover 3 bytes.

PHP, 96 88 74 bytes

Obrigado a Ismael Miguel por salvar 22 bytes!

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

Grava 50 <p>s com 9 mm de altura e largura (que deve ser maior que 20 px na maioria das telas), empilhados um sobre o outro, todos com uma pequena diferença de tonalidade.

Resultado gerado (a imagem é reduzida e girada 90 °):

Matlab - 33 bytes

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

Apesar dos comandos detalhados, o resultado ainda é bastante compacto. Parece um pouco melhor se você substituir surfcom surface, mas que custa 3 caracteres.

Se você não perceber o 50º quadrado cinza, é porque ele é um pouco maior que os outros!

Javascript (77 71 bytes):

Esta resposta não é mais baseada no IE11. Funciona porque o navegador converte os códigos de cores incorretos em códigos utilizáveis ​​(adicionando #ao número).

Aqui está o código:

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

O Firefox ainda tem a peculiaridade de fazer círculos.

(Edição pequena: alterada for(i=61;i-->9;)para for(i=59;i-->9;)porque estava produzindo 52 quadrados)

Resposta antiga:

Isso é baseado na minha resposta PHP e usa quase as mesmas maneiras de fazer os quadrados:

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

Não é a resposta mais curta, mas vale a pena adicionar aqui.

Esta solução não é compatível com o Chrome (produz várias cores verdes) e Firefox (o mesmo resultado, mas produz círculos? OO WTH?)

Como se trata de código-golfe, uma solução que trabalha com uma versão específica ou um software específico é aceitável.

Piet- 2 * 103 = 206

Isso é único, pois o código fonte e a saída cumprem o desafio:

A maior parte é decorativa, então contei apenas as duas primeiras fileiras, que ficam sozinhas bem. Produz um ppm em escala de cinza como alguns outros já fizeram.

JavaScript - 70 bytes

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

Processando, 66 caracteres:

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

Eu fiz o menor que pude encontrar:

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

Este é exatamente o mesmo código da minha resposta Javascript (com 71 bytes) .

Mas MUITO mais curto!

Isso tem uma peculiaridade no Firefox: em vez de quadrados, o Firefox faz círculos ! (Entre na loucura!)
Além disso, todos os navegadores produzem a cor certa (mesmo com a falta #no coloratributo).

Envios e log de alterações inválidos :

Resposta antiga, com 62 bytes.

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

Todos os tons estão perfeitamente alinhados.

Essa solução não funcionará no Chrome (produzirá quadrados com várias cores) e no Firefox (que cria círculos OO Sim, circula com <hr>! A régua horizontal é um círculo no Firefox!).
Você pode testá-lo no IE11 e deve ficar bem.

(simplesmente removido de cima)

Eu notei algo horrível: estava produzindo em #111vez de #010101algumas cores.

Isso significava que algumas cores estavam se repetindo.

Portanto, tive que sacrificar alguns bytes:

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

Produz as 50 tonalidades em perfeita ordem, de mais clara a mais escura.

Devido a um argumento correto feito por @ edc65 , eu tive que adicionar width=20, para produzir quadrados perfeitos .

Reduzido mais um byte, substituindo f!=$cpor f>$c, que funciona perfeitamente.

Versão final, sem width=20:

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

Isso é inválido porque é necessário gerar quadrados.
Isso produz os tons de mais claro para mais escuro.

Redução de 1 byte alternando para um whileloop, assim:

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

Primeira solução:

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

Isso não tem os tons ordenadamente ordenados, mas existem 50 diferentes.

Não há nada afirmando que eles devem ser pedidos, mas há um requisito de tamanho.

Espero poder reduzir muito mais.

Você pode testá-lo em http://writecodeonline.com/php/ (clique em "Exibir como HTML").

CSS (87 caracteres)

Usa animação;)

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

A versão executável é mais longa, pois o Webkit ainda precisa do prefixo do fornecedor. :(

: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 for permitido um <a>elemento vazio e aleatório, podemos reduzi-lo para apenas 72 caracteres:

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

Vejo? CSS é uma linguagem de programação legítima!

R, 36 bytes

Eu posso diminuir a resposta do freekvd trivialmente.

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

(Desculpe por não fazer um comentário sob a solução dele. O Stackexchange ainda não me permite fazer comentários, votar etc.).

PostScript, 34 bytes

Na codificação ISO-Latin-1:

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

Este é o equivalente binário a:

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

(Isso pressupõe que você o esteja usando em um dispositivo com pelo menos 1000 pontos [= 10 polegadas = 25,4 cm] de largura.)

DrRacket - 83

Apenas para ativar o DrRacket 1 ano após "Introdução ao desenho sistemático de programas".

EDIT :

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

Expandido :

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

Saída :

JavaScript, 152 bytes.

Ok, talvez essa não seja a melhor solução, mas aqui está a minha.

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)

Aqui está a saída com o flutuador css à esquerda (para facilitar a contagem dos quadrados) e sem: