21

Masz siatkę 3x3. Każda komórka może być w kolorze czarnym lub białym. Wyświetl wszystkie 512 z tych kolorów. Wygrywa najmniej bajtów.

Siatki można wyświetlać w dowolnej formacji, o ile są one wizualnie oddzielone, a odstępy wyglądają regularnie. Możesz użyć grafiki lub obrazów ASCII. W przypadku czerni i bieli można użyć dowolnych dwóch wyraźnych widocznych symboli lub kolorów. Wszelkie białe znaki są poprawne, o ile wynik jest poprawny wizualnie.

Przykładowe dane wyjściowe:

...
...
...

...
...
..X

...
...
.X.

...
...
.XX

...
...
X..

...
...
X.X

...
...
XX.

...
...
XXX

...
..X
...

...
..X
..X

...
..X
.X.

...
..X
.XX

...
..X
X..

...
..X
X.X

...
..X
XX.

...
..X
XXX

...
.X.
...

...
.X.
..X

...
.X.
.X.

...
.X.
.XX

...
.X.
X..

...
.X.
X.X

...
.X.
XX.

...
.X.
XXX

...
.XX
...

...
.XX
..X

...
.XX
.X.

...
.XX
.XX

...
.XX
X..

...
.XX
X.X

...
.XX
XX.

...
.XX
XXX

...
X..
...

...
X..
..X

...
X..
.X.

...
X..
.XX

...
X..
X..

...
X..
X.X

...
X..
XX.

...
X..
XXX

...
X.X
...

...
X.X
..X

...
X.X
.X.

...
X.X
.XX

...
X.X
X..

...
X.X
X.X

...
X.X
XX.

...
X.X
XXX

...
XX.
...

...
XX.
..X

...
XX.
.X.

...
XX.
.XX

...
XX.
X..

...
XX.
X.X

...
XX.
XX.

...
XX.
XXX

...
XXX
...

...
XXX
..X

...
XXX
.X.

...
XXX
.XX

...
XXX
X..

...
XXX
X.X

...
XXX
XX.

...
XXX
XXX

..X
...
...

..X
...
..X

..X
...
.X.

..X
...
.XX

..X
...
X..

..X
...
X.X

..X
...
XX.

..X
...
XXX

..X
..X
...

..X
..X
..X

..X
..X
.X.

..X
..X
.XX

..X
..X
X..

..X
..X
X.X

..X
..X
XX.

..X
..X
XXX

..X
.X.
...

..X
.X.
..X

..X
.X.
.X.

..X
.X.
.XX

..X
.X.
X..

..X
.X.
X.X

..X
.X.
XX.

..X
.X.
XXX

..X
.XX
...

..X
.XX
..X

..X
.XX
.X.

..X
.XX
.XX

..X
.XX
X..

..X
.XX
X.X

..X
.XX
XX.

..X
.XX
XXX

..X
X..
...

..X
X..
..X

..X
X..
.X.

..X
X..
.XX

..X
X..
X..

..X
X..
X.X

..X
X..
XX.

..X
X..
XXX

..X
X.X
...

..X
X.X
..X

..X
X.X
.X.

..X
X.X
.XX

..X
X.X
X..

..X
X.X
X.X

..X
X.X
XX.

..X
X.X
XXX

..X
XX.
...

..X
XX.
..X

..X
XX.
.X.

..X
XX.
.XX

..X
XX.
X..

..X
XX.
X.X

..X
XX.
XX.

..X
XX.
XXX

..X
XXX
...

..X
XXX
..X

..X
XXX
.X.

..X
XXX
.XX

..X
XXX
X..

..X
XXX
X.X

..X
XXX
XX.

..X
XXX
XXX

.X.
...
...

.X.
...
..X

.X.
...
.X.

.X.
...
.XX

.X.
...
X..

.X.
...
X.X

.X.
...
XX.

.X.
...
XXX

.X.
..X
...

.X.
..X
..X

.X.
..X
.X.

.X.
..X
.XX

.X.
..X
X..

.X.
..X
X.X

.X.
..X
XX.

.X.
..X
XXX

.X.
.X.
...

.X.
.X.
..X

.X.
.X.
.X.

.X.
.X.
.XX

.X.
.X.
X..

.X.
.X.
X.X

.X.
.X.
XX.

.X.
.X.
XXX

.X.
.XX
...

.X.
.XX
..X

.X.
.XX
.X.

.X.
.XX
.XX

.X.
.XX
X..

.X.
.XX
X.X

.X.
.XX
XX.

.X.
.XX
XXX

.X.
X..
...

.X.
X..
..X

.X.
X..
.X.

.X.
X..
.XX

.X.
X..
X..

.X.
X..
X.X

.X.
X..
XX.

.X.
X..
XXX

.X.
X.X
...

.X.
X.X
..X

.X.
X.X
.X.

.X.
X.X
.XX

.X.
X.X
X..

.X.
X.X
X.X

.X.
X.X
XX.

.X.
X.X
XXX

.X.
XX.
...

.X.
XX.
..X

.X.
XX.
.X.

.X.
XX.
.XX

.X.
XX.
X..

.X.
XX.
X.X

.X.
XX.
XX.

.X.
XX.
XXX

.X.
XXX
...

.X.
XXX
..X

.X.
XXX
.X.

.X.
XXX
.XX

.X.
XXX
X..

.X.
XXX
X.X

.X.
XXX
XX.

.X.
XXX
XXX

.XX
...
...

.XX
...
..X

.XX
...
.X.

.XX
...
.XX

.XX
...
X..

.XX
...
X.X

.XX
...
XX.

.XX
...
XXX

.XX
..X
...

.XX
..X
..X

.XX
..X
.X.

.XX
..X
.XX

.XX
..X
X..

.XX
..X
X.X

.XX
..X
XX.

.XX
..X
XXX

.XX
.X.
...

.XX
.X.
..X

.XX
.X.
.X.

.XX
.X.
.XX

.XX
.X.
X..

.XX
.X.
X.X

.XX
.X.
XX.

.XX
.X.
XXX

.XX
.XX
...

.XX
.XX
..X

.XX
.XX
.X.

.XX
.XX
.XX

.XX
.XX
X..

.XX
.XX
X.X

.XX
.XX
XX.

.XX
.XX
XXX

.XX
X..
...

.XX
X..
..X

.XX
X..
.X.

.XX
X..
.XX

.XX
X..
X..

.XX
X..
X.X

.XX
X..
XX.

.XX
X..
XXX

.XX
X.X
...

.XX
X.X
..X

.XX
X.X
.X.

.XX
X.X
.XX

.XX
X.X
X..

.XX
X.X
X.X

.XX
X.X
XX.

.XX
X.X
XXX

.XX
XX.
...

.XX
XX.
..X

.XX
XX.
.X.

.XX
XX.
.XX

.XX
XX.
X..

.XX
XX.
X.X

.XX
XX.
XX.

.XX
XX.
XXX

.XX
XXX
...

.XX
XXX
..X

.XX
XXX
.X.

.XX
XXX
.XX

.XX
XXX
X..

.XX
XXX
X.X

.XX
XXX
XX.

.XX
XXX
XXX

X..
...
...

X..
...
..X

X..
...
.X.

X..
...
.XX

X..
...
X..

X..
...
X.X

X..
...
XX.

X..
...
XXX

X..
..X
...

X..
..X
..X

X..
..X
.X.

X..
..X
.XX

X..
..X
X..

X..
..X
X.X

X..
..X
XX.

X..
..X
XXX

X..
.X.
...

X..
.X.
..X

X..
.X.
.X.

X..
.X.
.XX

X..
.X.
X..

X..
.X.
X.X

X..
.X.
XX.

X..
.X.
XXX

X..
.XX
...

X..
.XX
..X

X..
.XX
.X.

X..
.XX
.XX

X..
.XX
X..

X..
.XX
X.X

X..
.XX
XX.

X..
.XX
XXX

X..
X..
...

X..
X..
..X

X..
X..
.X.

X..
X..
.XX

X..
X..
X..

X..
X..
X.X

X..
X..
XX.

X..
X..
XXX

X..
X.X
...

X..
X.X
..X

X..
X.X
.X.

X..
X.X
.XX

X..
X.X
X..

X..
X.X
X.X

X..
X.X
XX.

X..
X.X
XXX

X..
XX.
...

X..
XX.
..X

X..
XX.
.X.

X..
XX.
.XX

X..
XX.
X..

X..
XX.
X.X

X..
XX.
XX.

X..
XX.
XXX

X..
XXX
...

X..
XXX
..X

X..
XXX
.X.

X..
XXX
.XX

X..
XXX
X..

X..
XXX
X.X

X..
XXX
XX.

X..
XXX
XXX

X.X
...
...

X.X
...
..X

X.X
...
.X.

X.X
...
.XX

X.X
...
X..

X.X
...
X.X

X.X
...
XX.

X.X
...
XXX

X.X
..X
...

X.X
..X
..X

X.X
..X
.X.

X.X
..X
.XX

X.X
..X
X..

X.X
..X
X.X

X.X
..X
XX.

X.X
..X
XXX

X.X
.X.
...

X.X
.X.
..X

X.X
.X.
.X.

X.X
.X.
.XX

X.X
.X.
X..

X.X
.X.
X.X

X.X
.X.
XX.

X.X
.X.
XXX

X.X
.XX
...

X.X
.XX
..X

X.X
.XX
.X.

X.X
.XX
.XX

X.X
.XX
X..

X.X
.XX
X.X

X.X
.XX
XX.

X.X
.XX
XXX

X.X
X..
...

X.X
X..
..X

X.X
X..
.X.

X.X
X..
.XX

X.X
X..
X..

X.X
X..
X.X

X.X
X..
XX.

X.X
X..
XXX

X.X
X.X
...

X.X
X.X
..X

X.X
X.X
.X.

X.X
X.X
.XX

X.X
X.X
X..

X.X
X.X
X.X

X.X
X.X
XX.

X.X
X.X
XXX

X.X
XX.
...

X.X
XX.
..X

X.X
XX.
.X.

X.X
XX.
.XX

X.X
XX.
X..

X.X
XX.
X.X

X.X
XX.
XX.

X.X
XX.
XXX

X.X
XXX
...

X.X
XXX
..X

X.X
XXX
.X.

X.X
XXX
.XX

X.X
XXX
X..

X.X
XXX
X.X

X.X
XXX
XX.

X.X
XXX
XXX

XX.
...
...

XX.
...
..X

XX.
...
.X.

XX.
...
.XX

XX.
...
X..

XX.
...
X.X

XX.
...
XX.

XX.
...
XXX

XX.
..X
...

XX.
..X
..X

XX.
..X
.X.

XX.
..X
.XX

XX.
..X
X..

XX.
..X
X.X

XX.
..X
XX.

XX.
..X
XXX

XX.
.X.
...

XX.
.X.
..X

XX.
.X.
.X.

XX.
.X.
.XX

XX.
.X.
X..

XX.
.X.
X.X

XX.
.X.
XX.

XX.
.X.
XXX

XX.
.XX
...

XX.
.XX
..X

XX.
.XX
.X.

XX.
.XX
.XX

XX.
.XX
X..

XX.
.XX
X.X

XX.
.XX
XX.

XX.
.XX
XXX

XX.
X..
...

XX.
X..
..X

XX.
X..
.X.

XX.
X..
.XX

XX.
X..
X..

XX.
X..
X.X

XX.
X..
XX.

XX.
X..
XXX

XX.
X.X
...

XX.
X.X
..X

XX.
X.X
.X.

XX.
X.X
.XX

XX.
X.X
X..

XX.
X.X
X.X

XX.
X.X
XX.

XX.
X.X
XXX

XX.
XX.
...

XX.
XX.
..X

XX.
XX.
.X.

XX.
XX.
.XX

XX.
XX.
X..

XX.
XX.
X.X

XX.
XX.
XX.

XX.
XX.
XXX

XX.
XXX
...

XX.
XXX
..X

XX.
XXX
.X.

XX.
XXX
.XX

XX.
XXX
X..

XX.
XXX
X.X

XX.
XXX
XX.

XX.
XXX
XXX

XXX
...
...

XXX
...
..X

XXX
...
.X.

XXX
...
.XX

XXX
...
X..

XXX
...
X.X

XXX
...
XX.

XXX
...
XXX

XXX
..X
...

XXX
..X
..X

XXX
..X
.X.

XXX
..X
.XX

XXX
..X
X..

XXX
..X
X.X

XXX
..X
XX.

XXX
..X
XXX

XXX
.X.
...

XXX
.X.
..X

XXX
.X.
.X.

XXX
.X.
.XX

XXX
.X.
X..

XXX
.X.
X.X

XXX
.X.
XX.

XXX
.X.
XXX

XXX
.XX
...

XXX
.XX
..X

XXX
.XX
.X.

XXX
.XX
.XX

XXX
.XX
X..

XXX
.XX
X.X

XXX
.XX
XX.

XXX
.XX
XXX

XXX
X..
...

XXX
X..
..X

XXX
X..
.X.

XXX
X..
.XX

XXX
X..
X..

XXX
X..
X.X

XXX
X..
XX.

XXX
X..
XXX

XXX
X.X
...

XXX
X.X
..X

XXX
X.X
.X.

XXX
X.X
.XX

XXX
X.X
X..

XXX
X.X
X.X

XXX
X.X
XX.

XXX
X.X
XXX

XXX
XX.
...

XXX
XX.
..X

XXX
XX.
.X.

XXX
XX.
.XX

XXX
XX.
X..

XXX
XX.
X.X

XXX
XX.
XX.

XXX
XX.
XXX

XXX
XXX
...

XXX
XXX
..X

XXX
XXX
.X.

XXX
XXX
.XX

XXX
XXX
X..

XXX
XXX
X.X

XXX
XXX
XX.

XXX
XXX
XXX

code-golf ascii-art graphical-output combinatorics grid Filipe Teixeira
źródło

@ edc65 xnor dokonał edycji, a Filipe zatwierdził ją (po czym wyczyściłem komentarze). Właśnie dodałem tagi.

Martin Ender,

Czy możemy przenieść przykład do PasteBin? Przewijanie jest teraz anemiczne. Poza tym jest to tylko zestaw mocy kwadratu wejściowego podzielony na linie wejścia, gdzie 1s i 0s są zastąpione przez Xi.

Stan Strum

16

K, 11 bajtów

(3 3#)'!9#2

Przykład wyjściowy:

Jest to natywna, dość drukowana reprezentacja K listy macierzy, która moim zdaniem jest wystarczająca dla specyfikacji problemu. Każda matryca jest ograniczona załączonym zestawem nawiasów.

I szybkie sprawdzenie poczytalności w celu wykazania, że skonstruowano 512 matryc:

  #(3 3#)'!9#2
512

Bardzo proste. Większość pracy znajduje się w !. Najpierw generujemy 9-metrowy wektor 2s za pomocą „take” ( 9#2). Następnie wykorzystujemy monadyczną formę „licznika przebiegu” !- kilka przykładów ilustruje jej zachowanie:

Następnie po prostu wykonaj przekształcenie 3x3 ( (3 3#)) każdego ( ') z wektorów 0/1 o długości 9.

JohnE
źródło

34

Mathematica, 25 bajtów

Image/@{0,1}~Tuples~{3,3}

Daje tablicę ze wszystkimi siatkami jako obrazy, która jest również wyświetlana bezpośrednio na ekranie:

wprowadź opis zdjęcia tutaj

(Przycięte, aby niepotrzebnie wysadzić posta.)

Martin Ender
źródło

3

głosowano za to, że jest najładniejszym wyjściem

Filipe Teixeira,

14

JavaScript, 77 80

Zmienione po aktualizacji PO. Teraz mamy pytanie, więc oto odpowiedź.

Uruchom fragment w dowolnej przeglądarce, aby go przetestować.

// Test: redefine console to have output inside the snippet

console = { log: function(x) { O.textContent+=x+'\n\n';} }

// Solution: 77 chars (note, distinct outputs to console are automatically separed)
  
for(i=511;++i<1024;)console.log(i.toString(2).slice(1).match(/.../g).join`
`)

<pre id=O></pre>

Rozwiń fragment kodu

Stary post: wyświetlanie graficzne w przeglądarce, z javascript i płótnem. ~ 300 bajtów kodu (może być skrócony).

Uruchom fragment kodu poniżej.

d=8, // Min block size
C.width=d*64,C.height=d*128,
T=C.getContext('2d')

for(i=0;i<512;i++)
{
  bx=4*(i/32|0)
  by=4*(i%32)
  for(b=1,j=0;j<9;j++,b+=b)    
  {
    if(b&i) 
      x=j/3|0, y=j%3, T.fillRect((bx+x)*d,(by+y)*d,d,d);
  }
  T.strokeRect(bx*d,by*d,d*3,d*3);
}

<canvas id=C></canvas>

Rozwiń fragment kodu

edc65
źródło

Jeśli podasz (ES6), możesz zamienić na .join('\n').join '' (dosłowna nowa linia, nie spacja ... głupie formatowanie komentarzy), aby zaoszczędzić 3 bajty

Patrick Roberts

@PatrickRoberts tak, ciąg szablonu został już zaimplementowany w przeglądarce Firefox 14 miesięcy temu, ale nie wiedziałem o tym. Edycja kodu po tak długim czasie jest trochę nekropolią

edc65

6

Matlab, 33

reshape(dec2bin(0:511,9)',3,3,[])

To trochę dziwne, aby uzyskać prawidłowe wymiary, ale jestem bardzo zadowolony z wyniku!

Oebele
źródło

6

POWERSHELL - 65

0..511|%{[convert]::ToString($_,2).padleft(9,'0')-split"(.{3})"}

wynik

potwierdzenie

(0..511|%{[convert]::ToString($_,2).padleft(9,'0')-split"(.{3})"} | measure -Line).lines/3

512

edycja zainspirowana wyświetlaniem wyników odpowiedzi matematycznej-617

Add-Type -AssemblyName System.Drawing
$a=new-object System.Drawing.Bitmap 992,496
$g=[Drawing.Graphics]::FromImage($a)
$b=@{};$y=@{};$i=$c=$d=$z=$k=$l=$m=0;
0..511|%{$y[$d++]=[convert]::ToString($_,2).padleft(9,'0')}
while($m-lt480){while($l-lt496){for($z=($m+0);$z-lt($m+32);$z++){
      $y[$z].tochararray()|%{if($_-eq"0"){$b[$i++]=[Drawing.Brushes]::Black}
        else{$b[$i++]=[Drawing.Brushes]::White}
      }
      for($j=($l+0);$j-lt($l+30);$j+=10){
        ($k+0),($k+10),($k+20)|%{$g.FillRectangle($b[$c++],$_,$j,10,10)}
      }$k+=31
    }$k=0;$l+=31;$m+=32
  }
}$a.save("$HOME/3X3_Grid.png")

blabb
źródło

6

Python 2, 49 bajtów

i=2048;exec"print bin(i/4)[i%4*3+3:][:3];i+=1;"*i

Podziel binarne rozszerzenie i. Używane są wartości binarne o długości -10 od 512 do 1023, odcinające początkową wartość 1 (i prefiks 0b). Są one podzielone na kawałki 3, jak okna [3:6], [6:9], [9:12], i [12:15], z ostatnim jednego wykroju do pustego wiersza. Iteracja po czterech odcinkach jest zwinięta z zewnętrzną pętlą liczącą 512 liczb za pomocą sztuczki divmod.

xnor
źródło

4

CJam, 12 bajtów

2,9m*3f/N*N*

Sprawdź to tutaj.

Używa 0i 1jako odrębne znaki.

Wyjaśnienie

2,  e# Push [0 1].
9m* e# Generate all 9-tuples of 0s and 1s.
3f/ e# Split each 9-tuple into 3 subarrays of length 3.
N*  e# Join all those grids with newlines.
N*  e# Put newlines between all the length-3 arrays.

Alternatywnym (wciąż 12-bajtowym) rozwiązaniem jest

2,3m*3m*N*N*

Martin Ender
źródło

4

Rubinowy, 86 bajtów

0.upto(511).map{|i|i.to_s(2).rjust(9,'0')}.each{|j|p j[0..2];p j[3..5];p j[6..8];puts}

Wydruki drukuj z cudzysłowami, ponieważ psą one krótsze niż puts, ale nadal pasują do reguł.

Pikolo
źródło

4

Haskell, 57 54 bajtów

r x=sequence[x,x,x]
u=unlines
f=putStr$u$map u$r$r".X"

f daje taki sam wynik jak w opisie wyzwania, tzn. zaczyna się od

...
...
...

...
...
..X

...
...
.X.

Edycja: @ Mauris znalazł 3 bajty do zapisania. Dzięki!

nimi
źródło

Myślę, że r x=sequence[x,x,x]robi to samo i jest krótszy.

Lynn,

@Mauris: masz rację. Edytowałem mój post. Dzięki!

nimi

3

C # - 111

for(int i=0;i<512;i++)Console.WriteLine(Regex.Replace(Convert.ToString(i,2).PadLeft(9,'0'),"(.{3})","$1\r\n"));

Konwertuje każdą liczbę całkowitą na jej reprezentację binarną i dzieli co 3 znaki.

Stephan Schinkel
źródło

2

Python 2, 95 bajtów

Odrębnymi znakami są 0i 1, każdy blok jest oddzielony \n\n.

n='\n';print(n+n).join(y[:3]+n+y[3:6]+n+y[-3:]for y in[bin(x)[2:].zfill(9)for x in range(512)])

Kade
źródło

2

Python 2, 81

import re
for i in range(512):print re.sub('(.{3})','\\1\n',bin(i)[2:].zfill(9))

dieter
źródło

2

Rubin, 92 bajty

0.upto(511){|i|("%09d"%i.to_s(2)).scan(/.{3}/).map{|j|j.scan(/./)}.map{|j|puts j.join};puts}

Liczy się 0 si 1si, a każdy blok jest oddzielony pustą linią ( \n\n)

klaskać
źródło

2

Rubinowy, 68 bajtów

Drukuje dokładnie taki sam wynik jak w przykładzie podanym w pytaniu

puts (0..511).map{|i|("%09b"%i).tr("01",".X").gsub(/.../){$&+$/}}*$/

daniero
źródło

Nie ma potrzeby tr, produkcja 0i 1jest w porządku. Jeszcze kilka sugestii 512.times{|i|$><<("%09b"%i).gsub(/.../){$&+$/}+$/}50 bajtów.

Level River St

2

Python 3, 80 bajtów

for i in range(512):print("\n".join(format(i,'09b')[j:j+3]for j in(0,3,6)),"\n")

Udało mi się kogoś ogłuszyć :)

Zniszczalna cytryna
źródło

Zapisz bajt za pomocą pętli while: i=512newlinewhile i:print("\n".join(format(i,'09b')[j:j+3]for j in(0,3,6)),"\n");i-=1

FlipTack

2

PHP, 55 bajtów

for(;$c<512;)echo chunk_split(sprintf("%09b ",$c++),3);

wykorzystuje 0i 1. Uruchom z -r.

Tytus
źródło

Po prostu uwielbiam sposób, w jaki wprowadziłem separującą linię :)

Tytus

2

Pyth, 11 bajtów

V^`T9jbc3Nk

Wypróbuj tutaj!

Dzięki @Jakube :)

Rozpad beta
źródło

2

Python 2 , 56 bajtów

from itertools import*
print set(combinations('X.'*9,9))

Wypróbuj online!

Zwraca 512 konfiguracji jako obiekt ustawiony w pythonie. Odwołaj się do wersji bez golfa, aby zwiększyć czytelność danych wyjściowych.

Wersja bez golfa, aby dane wyjściowe były bardziej czytelne:

Python 2 , 121 bajtów

from itertools import*
for i in set(combinations('X.'*9,9)):
	for j in range(3):print''.join(list(i))[j*3:(j*3)+3]
	print

Wypróbuj online!

Koishore Roy
źródło

1

C - 97 bajtów

i;main(j){for(;i++<512;)for(j=0;j++<13;)putchar(j%4&&j<13?i%(1<<j-j/4)>(1<<j-j/4-1)-1?88:46:10);}

Zasadniczo drukuje przykładowe dane wyjściowe z pierwotnego pytania.

Cole Cameron
źródło

1

Swift 2, 92 bajty

Int do ciągu binarnego w Swift zajmuje zbyt wiele znaków, więc używam tylko dwóch zagnieżdżonych pętli ...

var s="";for x in 0..<512{(0..<9).map{s+=($0%3==0 ?"\n":"")+"\(x>>$0&1)"};s+="\n-"};print(s)

GoatInTheMachine
źródło

1

Prolog (SWI), 98 bajtów

Wyjście to lista macierzy 3x3 zawierających elementy 0 i 1.

r([]).
r([H|T]):-between(0,1,H),r(T).
p(Y):-Z=[[_,_,_],[_,_,_],[_,_,_]],findall(Z,maplist(r,Z),Y).

Tłumacz online

Wydaje mi się, że generowanie macierzy może być krótsze.
Powinno być możliwe zmieszczenie między nimi w forallu lub czymś podobnym, ale nie mogę zrozumieć, jak to zrobić.

Docenione wskazówki golfowe.

Emigna
źródło

1

Perl, 56 55 bajtów

print$_/9&1<<$_%9?1:0,$/x(!(++$_%3)+!($_%9))for+0..4607

Wydajność:

Denis Ibaev
źródło

1

Python 3, 123 121 109 103 bajtów

Oto mój stary:

import itertools
[print(a+b+c,d+e+f,g+h+i,'\n',sep='\n') for a,b,c,d,e,f,g,h,i in itertools.product(['X','.'],repeat=9)]

A oto mój nowy:

import itertools as i
[print(a[:3],a[3:6],a[6:],'\n',sep='\n') for a in i.product(['X','.'],repeat=9)]

To drukuje dodatkowe znaki, ale OP powiedział, że grafika ASCII jest dozwolona, co oznacza, że wiele znaków jest w porządku.

Lord Ratte
źródło

1

Python 3, 74 bajty

i=512;b="\n"
while i:i-=1;a=format(i,'09b');print(a[:3]+b+a[3:6]+b+a[6:],b)

Tylko trochę krótszy niż odpowiedź Destructible Lemon

Pancernik
źródło

0

Perl, 52 bajty

printf+("%03b
"x3).$/,$_&7,$_/8&7,$_>>6&7 for 0..511

lub 54 bajty:

print map$_.$/,sprintf('%09b',$_)=~/.../g,''for 0..511

lub Perl 5.14+, 48 bajtów:

say sprintf('%09b',$_)=~s/.../$&\n/gr for 0..511

Denis Ibaev
źródło

0

Galaretka , 17 bajtów (niekonkurencyjna)

512+ḶBḊ€s€3Y€j“¶¶

Wypróbuj online!

Zastosowania 01. Z powodu błędu ⁾musiałem użyć “¶¶zamiast⁾¶¶ , ponieważ w przeciwnym razie zamiast dwóch nowych linii, dwa pilcrows pojawiłyby się na wyjściu. Jak widać, nie kosztowało mnie to wcale bajtów.

K bije to, więc to trzeba jeszcze pograć w golfa.

Erik the Outgolfer
źródło

0

05AB1E , 15 bajtów (niekonkurujące)

žAFNžA+b¦3ô»,¶?

Wypróbuj online!

Erik the Outgolfer
źródło

0

J , 27 bajtów

echo@<"2'.X'{~_3]\"1#:i.512

Wypróbuj online!

FrownyFrog
źródło

Problem nie ogranicza formatu wyjściowego, więc możesz użyć echo _3]\"1#:i.512.

Bolce Bussiere

0

Tcl , 72 bajty

time {puts [regsub -all (...) [format %09b [expr [incr i]-1]] \&\n]} 512

Wypróbuj online!

sergiol
źródło

Nieudany outgolf: tio.run/…

sergiol

0

Python 2 , 114 bajtów

from itertools import *
for i in product(".X",repeat=9):
    i="".join(i);print i[0:3]+"\n"+i[3:6]+"\n"+i[6:]+"\n"

Wypróbuj online!

Husnain Raza
źródło

Wydrukuj wszystkie kolory siatki 3x3

Odpowiedzi:

K, 11 bajtów

Mathematica, 25 bajtów

JavaScript, 77 80

Matlab, 33

POWERSHELL - 65

Python 2, 49 bajtów

CJam, 12 bajtów

Wyjaśnienie

Rubinowy, 86 bajtów

Haskell, 57 54 bajtów

C # - 111

Python 2, 95 bajtów

Python 2, 81

Rubin, 92 bajty

Rubinowy, 68 bajtów

Python 3, 80 bajtów

PHP, 55 bajtów

Pyth, 11 bajtów

Python 2 , 56 bajtów

Python 2 , 121 bajtów

C - 97 bajtów

Swift 2, 92 bajty

Prolog (SWI), 98 bajtów

Perl, 56 55 bajtów

Python 3, 123 121 109 103 bajtów

Python 3, 74 bajty

Perl, 52 bajty

Galaretka , 17 bajtów (niekonkurencyjna)

05AB1E , 15 bajtów (niekonkurujące)

J , 27 bajtów

Tcl , 72 bajty

Python 2 , 114 bajtów