Chłopcy i dziewczęta są podekscytowani widząc Pięćdziesiąt twarzy Greya na srebrnym ekranie, chcemy po prostu kodować bez kłopotów, więc oto wyzwanie, aby wybrać nasz mózg.

Musisz:

• Wydruk na ekranie pięćdziesiąt kwadratów wypełnionych każdym innym odcieniem szarości
• Jeśli wybrany język nie ma możliwości przetwarzania obrazu , możesz wydrukować plik obrazu
• Kwadraty muszą być widoczne, co najmniej 20 x 20 pikseli
• Nie możesz używać liczb losowych, chyba że upewnisz się, że każdy odcień jest unikalny.
• Nie można połączyć się z żadną usługą przez żadną sieć
• Nie możesz odczytać żadnych plików w swoim programie.
• Nie możesz używać żadnych bibliotek ze standardowych bibliotek wybranego języka.

To jest golf golfowy, więc wygrywa najkrótszy kod.

MATLAB, 24 bajty

Druga próba, teraz faktycznie zgodna z zasadami.

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

„I” oznacza „InitialMagnification”, ale najwyraźniej Matlab będzie automatycznie uzupełniał nazwy w parach nazwa / wartość. Pewnie to dobra sztuczka golfowa!

Mathematica, 30 bajtów

Oto inne podejście Mathematica:

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

lub

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

Pierwszy tworzy po prostu tablicę

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

i drugi

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

Następnie ArrayPlotdrukuje je jako siatkę i domyślnie używa skali szarości do wizualizacji wartości.

CJam - 23 (brak rzeczywistej wydajności graficznej)

Ponieważ CJam nie potrafi (jeszcze?) Rysować na ekranie, napisałem program, który wyświetla obraz w zwykłym formacie pgm .
Zapisz dane wyjściowe w pliku o nazwie 50.pgm i otwórz za pomocą przeglądarki / edytora obrazów.

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

Wypróbuj online

Wynik wygląda następująco:

Wyjaśnienie:

"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 bajtów

Aktualna wersja (34 bajty)

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

Wcześniejsza wersja (59 bajtów), dzięki Martin Büttner.

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

Dodano niebieskie obramowania, aby podświetlić pozycję kwadratów.

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

Ilość kwadratów:

    Length[%[[1]]]

50

Pierwsza próba (72 bajty)

Jeśli kwadraty mogą się nakładać. Jak zauważa Zgarb, istnieje niewielkie prawdopodobieństwo, że jeden kwadrat ukryje inny.

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

Sage - 26 24 35 29 znaków

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

To wygląda tak:

Poprzednie próby : Najpierw miałem Matrix([range(50)]).plot(), potem matrix_plot([range(50)]). Te wyglądały tak:

Użytkownik @flawr wskazał, że kwadraty utworzone przy ustawieniach domyślnych są zbyt małe. Dodanie figsizeopcji to naprawia, ale jest o 6 znaków dłuższe niż wersja 5x10 u góry tej odpowiedzi:

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

R, 47 42 39 38 37 36 35 bajtów

Zakładając, że mogą się nakładać, to działa. Symbolswymaga wektora, który utrzymuje rozmiar każdego kwadratu, a ja oszczędzam miejsce, ponownie wykorzystując ten sam wektor dla wszystkich parametrów funkcji. Największy kwadrat ma zawsze szerokość 1 cala. Przy 50:99 jako zakresie liczb całkowitych najmniejszy kwadrat będzie miał około pół cala szerokości, czyli 36 pikseli przy 72 dpi.

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

Dzięki wszystkim za komentarze i sugestie, jestem całkiem nowy w R, więc to wszystko jest bardzo pouczające.

Poprzednie wersje:

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

Poprzednie zdjęcie:

Java - 180

Całkiem proste, po prostu rysowanie pól.

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

Z podziałami linii:

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

Kwadraty muszą mieć co najmniej 20 pikseli, ale nie ma nic do powiedzenia, że ​​muszą być tego samego rozmiaru, więc myślę, że to się kwalifikuje.

Można to skrócić, stosując więcej kodów VDU niskiego poziomu. Ale zmiana z tego wzoru na mniej interesujący raczej nie spowoduje skrócenia.

ipython 2, 54 bajty

Najlepsze, co mogłem zrobić, to program ipython. Uruchomienie ipython ipython -pylabi uruchomienie tego programu pokaże wykres z 50 odcieniami szarości w 50 kwadratach:

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

Wynik:

Rozwiązanie 2:

Oto inny program (61 bajtów):

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

wyświetla następujące okno:

JavaScript ( 72 , 70 , 67 bajtów)

72: oryginał (pożyczenie sprytnego ■użycia od odpowiedzi Sphinxxx ):

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

70: kradzież bezwstydna przed Ismaelem Miguelem (który zasługuje na głosy), krótsza pętla i pozwalająca przeglądarce na poprawienie braku # kontynuowania kodu koloru ...

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

67 bajtów (65 znaków): zamiana encji na znak Unicode:

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

C ++, 98 83 znaków

Ok, więc potrzebujesz emulatora terminalu, który obsługuje prawdziwe kolory. Na przykład dla Mac OS dostępne są nocne wersje iTerm2. W przypadku Uniksa konsola go obsługuje. Oto lista, na wszelki wypadek: https://gist.github.com/XVilka/8346728#now-supporting-truecolor

Kompiluj za pomocą g ++ (\ e zależy od kompilatora).

Aby kwadraty miały wystarczającą powierzchnię, musisz zmienić rozmiar czcionki terminala.

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

Korzystanie z bibliotek C zamiast C ++ pozwala na golenie niektórych znaków.

C, 61 58 znaków

Jest to ten sam program, ale w C, który zakłada, że ​​deklaracje typu bez typu zwracają int, i który nie wymaga uwzględnienia niektórych standardowych funkcji bibliotecznych, takich jak w tym przypadku printf. Sugerowany przez @cartographer. Trzy znaki mniej dzięki @ user3601420

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

Kompiluje z kilkoma ostrzeżeniami (dla założenia, że ​​typ zwracany przez main ma być int i domyślnie obejmuje deklarację printf).

Python 2, 125 115 104 bajtów

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

Przykładowe dane wyjściowe:

Dobry stary żółw. To była jedyna metoda, o której mogłem pomyśleć w Pythonie, która drukuje obrazy na ekranie przy użyciu tylko standardowych bibliotek.

Kwadratowy żółw ma po prostu 21 na 21, co jest bardzo wygodne. Można to zobaczyć, przeglądając turtle.py:

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

Jeśli masz monitor wysokiej rozdzielczości lub nie przeszkadza ci kilka kwadratów poza ekranem, to jest to 93 bajty:

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

Próbny

(To demo korzysta ze Skulpt'a , dostosowując znajdujący się tutaj fragment kodu. Jest on dołączony, aby dać wyobrażenie o tym, co robi kod - musiałem zmodyfikować kilka bitów, aby go uruchomić.)

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 znaków)

Po sugestiach od randomra .

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

To rozwiązanie nie wyświetla niczego, ponieważ standardowa biblioteka J nie zawiera procedur GUI. Zamiast tego generuję obraz i zapisuję go na standardowym wyjściu. Wyjście jest losowe, dzięki czemu wszystkie odcienie są wyraźne. Oto kilka przykładowych danych wyjściowych, a obraz przekonwertowany na png i obrócony o 90 ° dla łatwiejszego oglądania:

Excel vba, 81

W bezpośrednim oknie:

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 aktywnym arkuszu:

^{{81 odcieni to tyle samo kodu co 50}}

R ,3732 znaki ¹ :

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

Wygląda jednak na to… meh (obraz obrócony o 90 °, aby lepiej pasował do tekstu; skompresowana, oryginalna kwadratowa długość boku> 20 pikseli):

Oto ładniejsza wersja, która tworzy kwadraty w losowej kolejności w matrycy (50 znaków):

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

(I tak, trzy sąsiednie kwadraty o pozornie identycznych kolorach są w rzeczywistości trzema różnymi odcieniami szarości.)

¹ Tak, kolejna odpowiedź R,i nawet najkrótszy(teraz najkrótszy dla R) - przeprosiny. Brakowało mi ładnego renderowania w R.

Matlab 35 dzięki sanchises

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

Matlab 36

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

Wyświetla 50 kwadratów wypełnionych szarymi wartościami od 1 do 50 i 2 dodatkowe prostokąty wypełnione szarymi wartościami 0 i 51:

Matlab, 45

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

JavaScript, 87 90 bajtów

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

To generuje kwadraty do kodu HTML, ponieważ tak naprawdę jest to jedyna metoda JavaScript do wyświetlania grafiki. Dzięki edc65 do golenia 3 bajtów.

PHP, 96 88 74 bajtów

Dzięki Ismael Miguel za uratowanie 22 bajtów!

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

Zapisuje 50 <p>s przy 9 mm wysokości i szerokości (która powinna być większa niż 20 pikseli na większości ekranów), ułożonych jedna na drugiej, wszystkie z niewielką różnicą odcienia.

Wygenerowany wynik (obraz jest pomniejszony i obrócony o 90 °):

Matlab - 33 bajty

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

Pomimo pełnych poleceń wynik jest nadal dość zwarty. To wygląda nieco lepiej, jeśli zastąpi surfsię surfacejednak, że kosztuje 3 znaki.

Jeśli nie zauważysz 50. szarego kwadratu, to dlatego, że jest on nieco większy od innych!

JavaScript (77 71 bajtów):

Ta odpowiedź nie jest już oparta na IE11. Działa, ponieważ przeglądarka przekształca złe kody kolorów na użyteczne (dodając #do liczby).

Oto kod:

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

Firefox nadal ma dziwactwo tworzenia kręgów.

(Mała edycja: Zmieniono for(i=61;i-->9;)na, for(i=59;i-->9;)ponieważ produkował 52 kwadraty)

Stara odpowiedź:

Opiera się to na mojej odpowiedzi PHP i używa prawie tych samych sposobów tworzenia kwadratów:

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

Nie jest to najkrótsza odpowiedź, ale warto ją tutaj dodać.

To rozwiązanie nie jest kompatybilne z Chrome (produkuje wiele zielonych kolorów) i Firefox (ten sam wynik, ale generuje koła? OO WTH?)

Ponieważ jest to gra w golfa, dopuszczalne jest rozwiązanie działające z określoną wersją lub określonym oprogramowaniem.

Piet-2 * 103 = 206

Jest to wyjątkowe, ponieważ kod źródłowy i dane wyjściowe spełniają wyzwanie:

Większość z nich jest dekoracyjna, więc policzyłem tylko dwa górne rzędy, które same stoją w porządku. Wysyła ppm w skali szarości, tak jak niektóre inne.

JavaScript - 70 bajtów

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

Przetwarzanie, 66 znaków:

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 bajtów):

Zrobiłem najkrótszy, jaki udało mi się znaleźć:

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

Jest to dokładnie ten sam kod, co moja odpowiedź Javascript (71 bajtów) .

Ale TAK DUŻO krótszy!

To dziwactwo w Firefoksie: zamiast kwadratów Firefox tworzy koła ! (Idź obłęd!)
Othen niż wszystkie przeglądarek wytworzenia odpowiedniego koloru (nawet z zaginionych #na coloratrybutu).

Nieprawidłowe zgłoszenia i dziennik zmian :

Stara odpowiedź z 62 bajtami.

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

Wszystkie odcienie są idealnie dopasowane.

To rozwiązanie nie będzie działać w Chrome (będzie produkować kwadraty o wielu kolorach) i Firefox (co powoduje, że koła są wyłączone. Tak, koła z <hr>! Pozioma linijka to koło w Firefoksie!).
Możesz to przetestować na IE11 i powinno być w porządku.

(po prostu usunięty z góry)

Zauważyłem coś okropnego: wyświetlał #111zamiast #010101niektórych kolorów.

Oznaczało to, że niektóre kolory się powtarzały.

Dlatego musiałem poświęcić kilka bajtów:

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

Odtwarza 50 odcieni w idealnej kolejności, od jaśniejszej do ciemniejszej.

Ze względu na prawidłowy punkt @ edc65 musiałem dodać width=20, aby uzyskać idealne kwadraty .

Zmniejszono jeszcze jeden bajt, zastępując f!=$cgo f>$c, co działa idealnie.

Wersja ostateczna bez width=20:

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

Jest to nieprawidłowe, ponieważ wymagane jest wyprowadzanie kwadratów.
To powoduje, że odcienie stają się jaśniejsze lub ciemniejsze.

Zmniejszono 1 bajt, przełączając się na whilepętlę:

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

Pierwsze rozwiązanie:

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

Nie ma uporządkowanych odcieni, ale istnieje 50 różnych.

Nic nie wskazuje na to, że należy je zamówić, ale wymagana jest wielkość.

Mam nadzieję, że mogę to znacznie zmniejszyć.

Możesz to przetestować na stronie http://writecodeonline.com/php/ (kliknij „Wyświetl jako HTML”).

CSS (87 znaków)

Wykorzystuje animację;)

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

Wersja do uruchomienia jest dłuższa, ponieważ Webkit nadal potrzebuje prefiksu dostawcy. :(

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

Jeśli otrzymamy losowy, pusty <a>element, możemy ograniczyć go do 72 znaków:

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

Widzieć? CSS to prawdziwy język programowania!

R, 36 bajtów

Potrafię skrócić odpowiedź freekvd w trywialny sposób.

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

(Przepraszam, że nie skomentowałem jego rozwiązania. Stackexchange nie pozwala mi jeszcze na komentowanie, głosowanie itp.).

PostScript, 34 bajty

W kodowaniu ISO-Latin-1:

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

Jest to binarny odpowiednik:

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

(Zakłada się, że używasz go na urządzeniu o szerokości co najmniej 1000 punktów [= 10 cali = 25,4 cm]).

DrRacket - 83

Tylko w celu uruchomienia DrRacket 1 rok po „Wstępie do systematycznego projektowania programów”.

EDYCJA :

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

C # - 173

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

Rozszerzony :

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

Wyjście :

JavaScript, 152 bajty.

Okej, więc może to nie jest najlepsze rozwiązanie, ale tu jest moje.

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)

Oto wynik z css float pozostawionym (tak, aby łatwiej było policzyć kwadraty) i bez: