Laci pola yang indah

Selamat pagi PPCG!

Suatu hari, ketika saya mencoba untuk membantu seseorang di Stack Overflow, sebagian dari masalahnya memberi saya ide untuk tantangan ini.

Pertama-tama, periksa bentuk berikut:

Di mana semua angka hitam adalah indeks dari titik-titik dalam bentuk dan semua angka biru tua adalah indeks dari hubungan antara titik-titik.

Sekarang, mengingat angka heksadesimal untuk 0x00000 hingga 0xFFFFF, Anda perlu menggambar bentuk di konsol menggunakan hanya ruang karakter dan "■" (menggunakan karakter "o" juga oke).

Berikut adalah beberapa contoh di mana angka heksadesimal adalah input dan bentuk adalah output:

0xE0C25 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■               ■ 
■               ■ 
■               ■ 
■ ■ ■ ■ ■       ■ 
        ■       ■ 
        ■       ■ 
        ■       ■ 
        ■ ■ ■ ■ ■
0xC1043 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
              ■   
            ■     
          ■       
        ■         
      ■           
    ■             
  ■               
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xE4F27 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■       ■ 
■       ■       ■ 
■       ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■       ■ 
■       ■       ■ 
■       ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xF1957 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■           ■ ■ 
■   ■       ■   ■ 
■     ■   ■     ■ 
■       ■       ■ 
■     ■   ■     ■ 
■   ■       ■   ■ 
■ ■           ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xD0C67 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
  ■             ■ 
    ■           ■ 
      ■         ■ 
■ ■ ■ ■ ■       ■ 
      ■ ■       ■ 
    ■   ■       ■ 
  ■     ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0x95E30 :
■ ■ ■ ■ ■       ■ 
  ■     ■     ■ ■ 
    ■   ■   ■   ■ 
      ■ ■ ■     ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■ ■       
        ■   ■     
        ■     ■   
        ■       ■ 
0x95622 :
■ ■ ■ ■ ■       ■ 
  ■     ■     ■   
    ■   ■   ■     
      ■ ■ ■       
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■         
        ■         
        ■         
■ ■ ■ ■ ■         
0xC5463 : 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■     ■   
        ■   ■     
        ■ ■       
■ ■ ■ ■ ■         
      ■ ■         
    ■   ■         
  ■     ■         
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xE5975 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■     ■ ■ 
■       ■   ■   ■ 
■       ■ ■     ■ 
■       ■       ■ 
■     ■ ■ ■     ■ 
■   ■   ■   ■   ■ 
■ ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 
0xB5E75 :
■ ■ ■ ■ ■       ■ 
■ ■     ■     ■ ■ 
■   ■   ■   ■   ■ 
■     ■ ■ ■     ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
      ■ ■ ■     ■ 
    ■   ■   ■   ■ 
  ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 
0xF4C75 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■     ■       ■ 
■   ■   ■       ■ 
■     ■ ■       ■ 
■ ■ ■ ■ ■       ■ 
      ■ ■ ■     ■ 
    ■   ■   ■   ■ 
  ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■
0xF5D75 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■     ■     ■ ■ 
■   ■   ■   ■   ■ 
■     ■ ■ ■     ■ 
■ ■ ■ ■ ■       ■ 
■     ■ ■ ■     ■ 
■   ■   ■   ■   ■ 
■ ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 

Berikut ini beberapa penjelasan tentang cara kerjanya:

0xFFFFF(16) = 1111 1111 1111 1111 1111(2)

Anda di sini memiliki 20 bit, setiap bit mengatakan apakah ada tautan atau tidak.

Indeks Bit Paling Signifikan (MSB) adalah 0 (referensi gambar) atau Bit Paling Signifikan (LSB) adalah 19 (referensi gambar lagi).

Inilah cara kerjanya untuk bentuk pertama yang diberikan sebagai contoh:

0xE0C25(16) = 1110 0000 1100 0010 0101(2)

Berarti Anda akan memiliki tautan yang ada berikut ini: 0,1,2,8,9,14,17,19.

Jika Anda menyorot garis pada gambar referensi dengan angka-angka itu, itu akan memberi Anda bentuk ini:

■ ■ ■ ■ ■ ■ ■ ■ ■ 
■               ■ 
■               ■ 
■               ■ 
■ ■ ■ ■ ■       ■ 
        ■       ■ 
        ■       ■ 
        ■       ■ 
        ■ ■ ■ ■ ■

Berikut ini adalah implementasi Python yang sederhana dan tidak ungolfed jika Anda membutuhkan bantuan lebih lanjut:

patterns = [
  0xE0C25, 0xC1043, 0xE4F27, 0xF1957, 
  0xD0C67, 0x95E30, 0x95622, 0xC5463, 
  0xE5975, 0xB5E75, 0xF4C75, 0xF5D75
]

def printIfTrue(condition, text = "■ "):
  if condition:
    print(text, end="")
  else:
    print(" "*len(text), end="")

def orOnList(cube, indexes):
  return (sum([cube[i] for i in indexes]) > 0)

def printPattern(pattern):
  cube = [True if n == "1" else False for n in str(bin(pattern))[2::]]
  for y in range(9):
    if y == 0: printIfTrue(orOnList(cube, [0, 2, 3]))
    if y == 4: printIfTrue(orOnList(cube, [2, 4, 9, 11, 12]))
    if y == 8: printIfTrue(orOnList(cube, [11, 13, 18]))
    if y in [0, 4, 8]:
      printIfTrue(cube[int((y / 4) + (y * 2))], "■ ■ ■ ")
      if y == 0: printIfTrue(orOnList(cube, [0, 1, 4, 5, 6]))
      if y == 4: printIfTrue(orOnList(cube, [3, 5, 7, 9, 10, 13, 14, 15]))
      if y == 8: printIfTrue(orOnList(cube, [12, 14, 16, 18, 19]))
      printIfTrue(cube[int((y / 4) + (y * 2)) + 1], "■ ■ ■ ")
    elif y in [1, 5]:
      for i in range(7):
        if i in [2, 5]:
          print(" ", end=" ")
        printIfTrue(cube[y * 2 + (1 - (y % 5)) + i])
    elif y in [2, 6]:
      for i in range(5):
        if i in [1, 2, 3, 4]:
          print(" ", end=" ")
        if i in [1, 3]:
          if i == 1 and y == 2:
            printIfTrue(orOnList(cube, [3, 4]))
          elif i == 3 and y == 2:
            printIfTrue(orOnList(cube, [6, 7]))
          if i == 1 and y == 6:
            printIfTrue(orOnList(cube, [12, 13]))
          elif i == 3 and y == 6:
            printIfTrue(orOnList(cube, [15, 16]))
        else:
          printIfTrue(cube[(y * 2 - (1 if y == 6 else 2)) + i + int(i / 4 * 2)])
    elif y in [3, 7]:
      for i in range(7):
        if i in [2, 5]:
          print("  ", end="")
        ri, swap = (y * 2 - 2) + (1 - (y % 5)) + i, [[3, 6, 12, 15], [4, 7, 13, 16]]
        if ri in swap[0]: ri = swap[1][swap[0].index(ri)]
        elif ri in swap[1]: ri = swap[0][swap[1].index(ri)]
        printIfTrue(cube[ri])
    if y == 0: printIfTrue(orOnList(cube, [1, 7, 8]))
    if y == 4: printIfTrue(orOnList(cube, [6, 8, 10, 16, 17]))
    if y == 8: printIfTrue(orOnList(cube, [15, 17, 19]))
    print()

for pattern in patterns:
  printPattern(pattern)

Tentu saja itu tidak sempurna dan cukup lama untuk apa yang harus dilakukan, dan itulah alasan mengapa Anda ada di sini!

Membuat program ini sangat singkat :)

Ini kode-golf, jadi jawaban tersingkat menang!

JavaScript (ES6), 202 188 187 byte

let f =

n=>`0${x=',16,-54,21,-26,21,21,-26,21,166'}${x},16`.split`,`.map((d,i)=>(k-=d,n)>>i&1&&[..."ooooo"].map(c=>g[p-=(k&3||9)^8]=c,p=k>>2),g=[...(' '.repeat(9)+`
`).repeat(9)],k=356)&&g.join``

console.log(f(0xE0C25))
console.log(f(0xC1043))
console.log(f(0xE4F27))
console.log(f(0xF1957))

Bagaimana itu bekerja

n =>                                                 // given 'n':
  `0${x = ',16,-54,21,-26,21,21,-26,21,166'}${x},16` // build the list of delta values
  .split`,`.map((d, i) =>                            // split the list and iterate
    (k -= d, n) >> i & 1 &&                          // update 'k', test the i-th bit of 'n'
    [..."ooooo"].map(c =>                            // if the bit is set, iterate 5 times:
      g[                                             // 
        p -= (k & 3 || 9) ^ 8                        // compute the direction and update 'p'
      ] = c,                                         // write a 'o' at this position
      p = k >> 2                                     // initial value of 'p'
    ),                                               //
    g = [...(' '.repeat(9) + `\n`).repeat(9)],       // initialization of the 'g' array
    k = 356                                          // initial value of 'k'
  )                                                  //
  && g.join``                                        // yield the final string

Kami mengerjakan kisi g9 baris 10 karakter. Grid awalnya diisi dengan spasi, dengan LineFeed setiap karakter ke-10.

Setiap segmen ditentukan oleh posisi awal dan arah.

Arah disandikan sebagai berikut:

ID | Dir.| Offset
---|-----|-------
 0 |  W  |  -1        Offset encoding formula:
 1 | NE  |  -9        -((ID || 9) ^ 8)
 2 |  N  |  -10
 3 | NW  |  -11

Setiap segmen dikodekan sebagai integer:

• arah disimpan dalam bit # 0 dan # 1
• posisi awal disimpan dalam bit # 2 hingga # 8

Misalnya, segmen # 3 dimulai pada posisi 55 dan menggunakan arah ke-3. Oleh karena itu, ini dikodekan sebagai (55 << 2) | 3 == 223.

Di bawah ini adalah daftar bilangan bulat yang dihasilkan, dari segmen # 19 ke segmen # 0:

356,340,394,373,399,378,357,383,362,196,180,234,213,239,218,197,223,202,36,20

Setelah dikodekan delta, mulai dari 356, itu menjadi:

0,16,-54,21,-26,21,21,-26,21,166,16,-54,21,-26,21,21,-26,21,166,16

Yang akhirnya dikodekan sebagai:

`0${x=',16,-54,21,-26,21,21,-26,21,166'}${x},16`

Python 3, 289 byte

def f(n):
 for r in range(9):print(*(" o"[any(n&1<<ord(c)-97for c in"trq|t|t|t|tspon|s|s|s|sml|r|q||p|o|n||m|l|r||qp||o||nm||l|r|p||q|o|m||n|l|rpkih|k|k|k|qomkjgfe|j|j|j|nljdc|i|h||g|f|e||d|c|i||hg||f||ed||c|i|g||h|f|d||e|c|igb|b|b|b|hfdba|a|a|a|eca".split("|")[r*9+c])]for c in range(9)))

Tidak ada yang pintar, hanya hardcoding.

Ruby, 116 byte

->n{s=[' '*17]*9*$/
20.times{|i|j=i%9
n>>19-i&1>0&&5.times{|k|s[i/9*72+(j>1?~-j/3*8+k*18:j*16)+k*(2--j%3*2)]=?O}}
s}

Ini bergantung pada beberapa pola yang saya amati. Pertama, polanya berulang setiap 9 baris. Kedua, jika titik awal dari garis horizontal dipilih dengan tepat, siklus arah x terus menerus melalui kanan, kiri, lurus.

Tidak digabungkan dalam program uji

f=->n{
   s=[' '*17]*9*$/                    #Setup a string of 9 newline separated lines of 17 spaces.
   20.times{|i|                       #For each of the 20 bits..
     j=i%9                            #The pattern repeats every 9 bits.
     n>>19-i&1>0&&                    #If the relevant bit is set,
     5.times{|k|                      #draw each of the 5 points on the relevant line.
       s[i/9*72+                      #There are 9 lines starting on each row. Row y=0 starts at 0 in the string, row y=1 at 72, etc.
       (j>1?~-j/3*8+k*18:j*16)+       #~-j=j-1. For j=2..8, the starting x coordinates are (0,0,1,1,1,2,2)*8. For j=0 and 1 starting x coordinates are 0 and 16. 
       k*(2--j%3*2)                   #From the starting points, draw the lines right,left,straight. Down movement if applicable is given by conditional k*18 above.
       ]=?O                           #Having described the correct index to modify, overwrite it with a O character.
     }
   }
s}                                    #Return the string.


[0xE0C25, 0xC1043, 0xE4F27, 0xF1957, 
  0xD0C67, 0x95E30, 0x95622, 0xC5463, 
  0xE5975, 0xB5E75, 0xF4C75, 0xF5D75].map{|m|puts f[m],'---------'}

Saya percaya ada solusi 112 byte menggunakan string 20-karakter dan beberapa decoding untuk menentukan parameter dari 20 baris. Saya akan mencoba ini nanti jika saya punya waktu.

PHP, 142 150 149 byte

for($r="";$c=ord(",(NMKJIGFHDjigfecbd`"[$i]);)if(hexdec($argv[1])>>$i++&1)for($p=96^$c&~$k=3;$k++<8;$p+=7+($c&3?:-6))$r[$p]=o;echo chunk_split($r,9);

mencetak bentuk sejauh yang diperlukan; yaitu jika bagian bawah kosong, itu akan dipotong.
Jalankan dengan php -nr '<code>' <input>. Jangan awali input

Uji secara online

Tambahkan 11 byte tanpa pemotongan: Sisipkan ,$r[80]=" "setelah $r="".

pengkodean dijelaskan

Setiap baris dapat dijelaskan dengan titik awal dan satu dari empat arah.
Menggambar pada kisi 9x9, posisi awal berkisar dari 0,0hingga 8,4; atau, digabungkan, dari 0ke 8*9+4=76. Untungnya, semua poin awal[0,4,8,36,40,44,72,76] dapat dibagi 4; jadi kode arahnya[0..3] dapat dipadatkan menjadi bit 0 dan 1 -> tidak perlu bergeser sama sekali.

Untuk perhitungan gerakan kursor yang mudah, 0diambil untuk timur (hanya arah tanpa gerakan vertikal) dan [1,2,3]untuk barat daya, selatan, tenggara, di mana offset adalah 9(untuk gerakan vertikal) plus [-1,0,1]-> [8,9,10]->delta=code?code+7:1 .

Arah untuk baris pertama dan terakhir adalah timur, yang menghasilkan kode mulai dari 0 hingga 76 [0+0,4+0,0+2,0+3,4+1,4+2,4+3,8+1,8+2,...,44+1,44+2,72+0,76+0]; dan bitwise xor 96 pada setiap nilai menghasilkan kode ascii yang dapat dicetak dan tidak bermasalah [96,100,98,99,101,102,103,105,106,68, 72,70,71,73,74,75,77,78,40,44]-> `dbcefgijDHFGIJKMN(,. Kode menggunakan LSB untuk bit 0, sedangkan baris 0 sesuai dengan MSB, jadi string harus dibalik. Finito.

kerusakan

for($r="";                  // init result string, loop through line codes
    $c=ord(",(NMKJIGFHDjigfecbd`"[$i]);)
    if(hexdec($argv[1])>>$i++&1)// if bit $i is set, draw line 19-$i:
        for($p=96^$c&~$k=3          // init $k to 3, init cursor to value&~3
            ;$k++<8;                // loop 5 times
            $p+=7+($c&3?:-6)            // 2. map [0,1,2,3] to [1,8,9,10], move cursor
        )
            $r[$p]=o;                   // 1. plot
echo chunk_split($r,9);     // insert a linebreak every 9 characters, print

beberapa golf menjelaskan

• Karena ^96tidak berpengaruh pada dua bit yang lebih rendah, dapat diabaikan ketika mengekstraksi arah; jadi tidak perlu menyimpan nilai dalam variabel, yang menyimpan 5 byte pada kursor init.
• Menggunakan ~3alih-alih 124menyimpan satu byte dan memungkinkan bermain golf berikutnya:
• Menginisialisasi penghitung perulangan $k=3 di dalam $ptugas menyimpan dua byte
  dan tidak merusak kondisi awal (karena nilai atas masih memiliki satu digit).
• Menggunakan string untuk hasil memiliki inisialisasi dan ploting sesingkat mungkin: Ketika karakter diatur di luar akhir string, PHP secara implisit menetapkan karakter yang hilang ke ruang. Danchunk_split merupakan cara terpendek untuk memasukkan linebreak.
  Saya bahkan tidak ingin tahu berapa banyak lagi yang akan diambil.
• 7+($c&3?:-6)lebih pendek satu byte dari $c&3?$c%4+7:1.
• Ditambahkan hexdec()(8 byte) untuk memenuhi batasan input.

JavaScript, 184 183 178 168 167 byte

f=
n=>[...`<>K[LM]NO\\^k{lm}no|~`].map((e,i)=>n>>i&1&&[0,2,4,6,8].map(i=>a[(e&102)*4+(e&17||15)*i]=`o`,e=~e.charCodeAt()),a=[...(` `.repeat(31)+`
`).repeat(9)])&&a.join``

<input oninput=o.textContent=f(+this.value)><pre id=o>

Awalnya 206 byte tetapi jawaban @ Arnauld menginspirasi saya untuk menyelidiki solusi array satu dimensi. Sunting: Disimpan 1 byte berkat @ edc65. Disimpan 5 15 byte berkat @Arnauld. Menyimpan byte lebih lanjut dengan mengubah pilihan karakter.

Batch, 491 byte

@set n=%1
@for %%i in ("720896 524288 524288 524288 843776 262144 262144 262144 268288" "131072 65536 0 32768 16384 8192 0 4096 2048" "131072 0 98304 0 16384 0 12288 0 2048" "131072 32768 0 65536 16384 4096 0 8192 2048" "165248 1024 1024 1024 89312 512 512 512 10764" "256 128 0 64 32 16 0 8 4" "256 0 192 0 32 0 24 0 4" "256 64 0 128 32 8 0 16 4" "322 2 2 2 171 1 1 1 17")do @set s=&(for %%j in (%%~i)do @set/am=%1^&%%j&call:c)&call echo(%%s%%
:c
@if %m%==0 (set s=%s%  )else set s=%s%o 

Catatan: Baris terakhir berakhir dengan spasi. Menempatkan ifbersyarat dengan variabel di dalam afor loop adalah di luar batch sehingga membutuhkan subrutin sendiri. Karena tidak terlihat apa-apa, saya jatuh ke dalamnya untuk keluar. Tanda ~kutip string dalam loop luar memungkinkan loop dalam untuk mengulangi angka-angka. Angka-angka hanyalah bitmask untuk semua tempat di mana os harus ditarik.

C, 267 262 260 256 karakter

Menghitung lolos sebagai 1 karakter

void f(int i){char*k="\0\x1\x2\x3\x4\x4\x5\x6\x7\x8\0\x9\x12\x1b\x24\0\xa\x14\x1e\x28\x4\xc\x14\x1c\x2d\x4\xd\x16\x1f\x28\x4\xe\x18\x22\x2c\x8\x10\x18\x20\x28\x8\x11\x1a\x23\x2c\x24\x25\x26\x27\x28\x28\x29\x2a\x2b\x2c\x24\x2d\x36\x3f\x48\x24\x2e\x38\x42\x4c\x28\x30\x38\x40\x48\x28\x31\x3a\x43\x4c\x28\x31\x3a\x43\x4c\x28\x32\x3c\x46\x50\x2c\x35\x3e\x47\x50\x48\x49\x4a\x4b\x4c\x4c\x4d\x4e\x4f\x50";for(int n=0,s,l;n<81;!(++n%9)&&putchar(10))for(s=l=0;s<20;!(++l%5||++s^20)&&putchar(32))if(i<<s&1<<19&&k[l]==n&&putchar(111))break;}

k adalah sebuah pencarian yang merujuk ke kotak mana untuk menempatkan 'o'.

Cobalah online!

Befunge, 468 byte

~:85+`!#v_86*-:9`7*-48*%\82**+
3%2:/2\<$v0%2:/2\*g02*!g03%2:/2\*!+4g07%2:/2\*g02*!-8g06%2:/2\*g02*!-4g0
g!*20g*^00>50g*\2/:2%00g8-!*40g*\2/:2%30g8-!*20g*\2/:2%60g66+-!*\2/:2%70
`\5:p00:<g^*!-8g00%2:\-10:\p07-g00:p06+g00:p05`3:p04`\5:p03:<0\p02`3:p01
#o 8`#@_^4>*50g*\2/2%00g!*40g*0\>:#<1#\+_$!1+4g,48*,\1+:8`!#^_55+,$\1+:
g03%2:/2<-^!g00%2:/2\*g01*!g03%2:/2\*g01*!g07%2:/2\*!-4g06%2:/2\*g01*!-4
70g4-!*\^>!*50g*\2/:2%00g4-!*40g*\2/:2%30g8-!*10g*\2/:2%60g8-!*10g*\2/:2%

Cobalah online!

Baris pertama membaca string dari stdin, mengevaluasinya sebagai angka heksadesimal. Sisa kode pada dasarnya hanyalah sebuah loop ganda di atas koordinat x / y dari grid, dengan perhitungan boolean besar yang menentukan apakah suatuo output harus untuk setiap lokasi.

Pada dasarnya ada kondisi terpisah untuk masing-masing dari 20 titik kisi, misalnya (empat yang pertama):

(y==0) * (x<5) * bit0
(y==0) * (x>3) * bit1
(x==0) * (y<5) * bit2
(x==y) * (y<5) * bit3

Dan setelah kita menghitung 20 dari semuanya, kita ATAU lot bersama-sama, dan jika hasilnya benar, kita menghasilkan a o , kalau tidak kita output spasi.

Befunge tidak memiliki apa pun yang menghalangi operasi manipulasi bit, jadi untuk mengekstrak bit dari input, kami hanya berulang kali melakukan evaluasi n%2dan kemudian n/=2saat kami melakukan perhitungan 20 kondisi.