Piękna szuflada z wzorem

Dzień dobry PPCG!

Pewnego dnia, gdy próbowałem pomóc komuś z Stack Overflow, część jego problemu dała mi pomysł na to wyzwanie.

Przede wszystkim sprawdź następujący kształt:

Gdzie wszystkie czarne liczby są indeksem punktów w kształcie, a wszystkie ciemnoniebieskie liczby są indeksem połączeń między punktami.

Teraz, biorąc pod uwagę liczbę szesnastkową od 0x00000 do 0xFFFFF, musisz narysować kształt w konsoli, używając tylko przestrzeni znaków i „■” (użycie znaku „o” jest również w porządku).

Oto kilka przykładów, w których wprowadzana jest liczba szesnastkowa, a kształt jest generowany:

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

Oto kilka wyjaśnień na temat tego, jak to działa:

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

Masz tutaj 20 bitów, każdy bit mówi, czy istnieje link, czy nie.

Indeks najbardziej znaczącego bitu (MSB) wynosi 0 (odniesienie do obrazka) lub mniej znaczący bit (LSB) wynosi 19 (ponownie odniesienie do obrazka).

Oto jak to działa dla pierwszego kształtu podanego jako przykład:

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

Oznacza to, że będziesz mieć następujące istniejące linki: 0,1,2,8,9,9,14,17,19.

Jeśli podświetlisz linie na obrazie referencyjnym tymi liczbami, uzyskasz następujący kształt:

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

Oto prosta i niestosowana implementacja Pythona, jeśli potrzebujesz dodatkowej pomocy:

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)

Oczywiście nie jest idealny i dość długo czeka na to, co powinien zrobić, i właśnie dlatego tu jesteś!

Co sprawia, że ​​ten program jest absurdalnie krótki :)

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź!

JavaScript (ES6), 202 188 187 bajtów

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

Jak to działa

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

Pracujemy na siatce g9 rzędów po 10 znaków. Siatka jest początkowo wypełniona spacjami, a LineFeed co 10 znak.

Każdy segment jest określony przez pozycję początkową i kierunek.

Wskazówki są kodowane w następujący sposób:

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

Każdy segment jest zakodowany jako liczba całkowita:

• kierunek jest zapisywany w bitach # 0 i # 1
• pozycja początkowa jest zapisywana w bitach # 2 do # 8

Na przykład segment # 3 zaczyna się w pozycji 55 i używa trzeciego kierunku. Dlatego jest zakodowany jako (55 << 2) | 3 == 223.

Poniżej znajduje się wynikowa lista liczb całkowitych, od segmentu 19 do segmentu 0:

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

Po zakodowaniu w delcie, począwszy od 356, staje się:

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

Który jest ostatecznie zakodowany jako:

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

Python 3, 289 bajtów

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

Nic mądrego, tylko twarde kodowanie.

Rubin, 116 bajtów

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

Opiera się to na kilku wzorach, które zaobserwowałem. Po pierwsze, wzór powtarza się co 9 linii. Po drugie, jeśli punkty początkowe linii poziomych są odpowiednio wybrane, kierunki x zmieniają się w sposób ciągły przez prawą, lewą i prostą.

Niegolfowany w programie testowym

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],'---------'}

Wydaje mi się, że istnieje rozwiązanie 112-bajtowe wykorzystujące ciąg 20 znaków i dekodowanie w celu zdefiniowania parametrów 20 linii. Spróbuję później, jeśli będę miał czas.

PHP, 142 150 149 bajtów

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

drukuje kształt w miarę potrzeby; tzn. jeśli dolna część jest pusta, zostanie wycięta.
Uruchom z php -nr '<code>' <input>. Nie wpisuj prefiksu

Przetestuj online

Dodaj 11 bajtów, aby nie ciąć: wstaw ,$r[80]=" "po $r="".

wyjaśnienie kodowania

Każda linia może być opisana punktem początkowym i jednym z czterech kierunków.
Rysując na siatce 9x9, pozycja początkowa waha się od 0,0do 8,4; lub łącznie, od 0do 8*9+4=76. Na szczęście wszystkie punkty początkowe [0,4,8,36,40,44,72,76]są podzielne przez 4; więc kod kierunku[0..3] można wycisnąć na bity 0 i 1 -> nie trzeba w ogóle przesuwać.

W celu łatwego obliczenia ruchu kursora 0przyjmuje się dla wschodu (tylko kierunek bez ruchu pionowego) i [1,2,3]dla południowo-zachodniej, południowej, południowo-wschodniej, gdzie przesunięcie wynosi 9(dla ruchu pionowego) plus [-1,0,1]-> [8,9,10]-> delta=code?code+7:1.

Kierunek dla pierwszej i ostatniej linii jest wschodni, co skutkuje kodami w zakresie od 0 do 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]; i bitowa xor 96 dla każdej wartości powoduje wydrukowanie i bezproblemowych kodów ascii [96,100,98,99,101,102,103,105,106,68, 72,70,71,73,74,75,77,78,40,44]-> `dbcefgijDHFGIJKMN(,. Kod używa LSB dla bitu 0, podczas gdy linia 0 odpowiada MSB, więc ciąg musi zostać odwrócony. Finito.

awaria

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

wyjaśniono niektóre gry w golfa

• Ponieważ ^96nie ma wpływu na dolne dwa bity, można go zignorować podczas wydobywania kierunku; więc nie ma potrzeby przechowywania wartości w zmiennej, która zapisuje 5 bajtów na init kursora.
• Używanie ~3zamiast 124oszczędza jeden bajt i pozwala na następne granie w golfa:
• Zainicjowanie licznika zapętlenia $k=3wewnątrz $pprzydziału pozwala zaoszczędzić dwa bajty
  i nie zaszkodzi warunkowi wstępnemu (ponieważ górna wartość nadal ma jedną cyfrę).
• Użycie ciągu jako wyniku ma najkrótszą możliwą inicjalizację i wykreślenie: Gdy znak jest ustawiony poza końcem ciągu, PHP domyślnie ustawia brakujące znaki na spację. I chunk_splitjest najkrótszym sposobem wstawienia podziałów linii.
  Nie chcę nawet wiedzieć, o ile więcej by coś zabrało.
• 7+($c&3?:-6)jest o jeden bajt krótszy niż $c&3?$c%4+7:1.
• Dodano hexdec()(8 bajtów), aby spełnić ograniczenie wejściowe.

JavaScript, 184 183 178 168 167 bajtów

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>

Początkowo miał 206 bajtów, ale odpowiedź @ Arnaulda zainspirowała mnie do zbadania jednowymiarowego rozwiązania tablicowego. Edycja: Zapisano 1 bajt dzięki @ edc65. Zaoszczędź 5 15 bajtów dzięki @Arnauld. Zapisano kolejny bajt, modyfikując wybór znaków.

Partia, 491 bajtów

@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 

Uwaga: ostatni wiersz kończy się spacją. Umieszczenie ifwarunku ze zmienną w forpętli jest poza partią, więc wymaga własnego podprogramu. Ponieważ nic nie robi, wpadam do środka, by wyjść. Bez ~cudzysłowu ciągi w zewnętrznej pętli pozwalają pętli wewnętrznej na zapętlanie liczb. Liczby są po prostu maskami bitowymi dla wszystkich miejsc, w których onależy narysować s.

C, 267 262 260 256 znaków

Liczenie ucieka jako 1 znak

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 to odnośnik, do których pól należy wstawić „o”.

Wypróbuj online!

Befunge, 468 bajtów

~: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%

Wypróbuj online!

Pierwszy wiersz odczytuje ciąg ze standardowego wejścia, oceniając go jako liczbę szesnastkową. Reszta kodu to w zasadzie podwójna pętla nad współrzędnymi x / y siatki, z masywnym obliczeniem logicznym określającym, czy onależy wyprowadzić dla każdej lokalizacji.

Zasadniczo istnieje osobny warunek dla każdego z 20 punktów siatki, na przykład (pierwsze cztery):

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

A potem, kiedy obliczyliśmy wszystkie 20, razem LUB dużo razem, i jeśli ten wynik jest prawdziwy, wyprowadzamy a o, w przeciwnym razie wyprowadzamy spację.

Befunge nie ma żadnych przeszkód w operacjach na bitach, więc aby wydobyć bity z danych wejściowych, po prostu ciągle ewaluujemy, n%2a następnie n/=2przechodzimy przez 20 obliczeń warunków.