Die schöne Musterlade

Guten Morgen PPCG!

Als ich neulich versuchte, jemandem bei Stack Overflow zu helfen, gab mir ein Teil seines Problems eine Idee für diese Herausforderung.

Überprüfen Sie zunächst die folgende Form:

Dabei sind alle schwarzen Zahlen der Index der Punkte in der Form und alle dunkelblauen Zahlen der Index der Verknüpfungen zwischen den Punkten.

Wenn Sie nun eine Hexadezimalzahl für 0x00000 bis 0xFFFFF angeben, müssen Sie in der Konsole eine Form zeichnen, bei der nur Zeichen und "■" verwendet werden (die Verwendung des Zeichens "o" ist ebenfalls in Ordnung).

Hier sind einige Beispiele, in denen eine hexadezimale Zahl eingegeben und eine Form ausgegeben wird:

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

Hier einige Erklärungen zur Funktionsweise:

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

Sie haben hier 20 Bits, jedes Bit gibt an, ob eine Verknüpfung besteht oder nicht.

Der Index des höchstwertigen Bits (MSB) ist 0 (Bildreferenz) oder das niedrigwertigste Bit (LSB) ist 19 (wieder Bildreferenz).

So funktioniert es für die erste als Beispiel angegebene Form:

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

Das heißt, Sie haben die folgenden vorhandenen Links: 0,1,2,8,9,14,17,19.

Wenn Sie die Linien auf dem Referenzbild mit diesen Zahlen markieren, erhalten Sie diese Form:

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

Hier ist eine einfache und unkomplizierte Python-Implementierung, wenn Sie weitere Hilfe benötigen:

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)

Natürlich ist es nicht perfekt und es ist ziemlich lang für das, was es tun sollte, und genau das ist der Grund, warum du hier bist!

Das Programm lächerlich kurz zu machen :)

Das ist Code-Golf, also gewinnt die kürzeste Antwort!

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

Wie es funktioniert

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

Wir arbeiten in einem Raster gvon 9 Zeilen mit 10 Zeichen. Das Raster wird anfänglich mit Leerzeichen gefüllt, wobei jedes 10. Zeichen einen Zeilenvorschub enthält.

Jedes Segment wird durch eine Startposition und eine Richtung definiert.

Anweisungen sind wie folgt codiert:

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

Jedes Segment ist als Ganzzahl codiert:

• Die Richtung wird in den Bits # 0 und # 1 gespeichert
• Die Startposition wird in den Bits 2 bis 8 gespeichert

Beispielsweise beginnt das Segment Nr. 3 an Position 55 und verwendet die 3. Richtung. Daher ist es codiert als (55 << 2) | 3 == 223.

Unten ist die resultierende Liste von ganzen Zahlen von Segment # 19 bis Segment # 0:

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

Sobald die Delta-Codierung bei 356 beginnt, wird sie:

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

Welches ist schließlich codiert als:

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

Python 3, 289 Bytes

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

Nichts Schlaues, nur Hardcoding.

Ruby, 116 Bytes

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

Dies beruht auf ein paar Mustern, die ich beobachtet habe. Erstens wiederholt sich das Muster alle 9 Zeilen. Zweitens, wenn die Startpunkte der horizontalen Linien richtig gewählt sind, wechseln die x-Richtungen kontinuierlich durch rechts, links und gerade.

Ungolfed im Testprogramm

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

Ich glaube, es gibt eine 112-Byte-Lösung mit einer 20-Zeichen-Zeichenfolge und etwas Dekodierung, um die Parameter der 20 Zeilen zu definieren. Ich werde es später versuchen, wenn ich Zeit habe.

PHP, 142 150 149 Bytes

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

druckt die Form so weit wie nötig; dh wenn der untere Teil leer ist, wird er abgeschnitten.
Laufen Sie mit php -nr '<code>' <input>. Keine Eingabe voranstellen

Testen Sie es online

Fügen Sie 11 Bytes für kein Schneiden hinzu: Fügen Sie ,$r[80]=" "danach ein $r="".

Kodierung erklärt

Jede Linie kann mit einem Startpunkt und einer von vier Richtungen beschrieben werden.
In einem 9x9-Raster reicht die Startposition von 0,0bis 8,4; oder kombiniert von 0bis 8*9+4=76. Zum Glück sind alle Startpunkte [0,4,8,36,40,44,72,76]durch 4 teilbar; So kann der Richtungscode [0..3]in die Bits 0 und 1 eingeklemmt werden -> es ist überhaupt keine Verschiebung erforderlich.

Für eine einfache Berechnung der Cursorbewegung 0wird für Ost (nur Richtung ohne vertikale Bewegung) und [1,2,3]für Südwest, Süd, Südost, wobei der Versatz 9(für vertikale Bewegung) plus [-1,0,1]-> [8,9,10]-> ist delta=code?code+7:1.

Die Richtung für die erste und letzte Zeile ist nach Osten, was zu Codes zwischen 0 und 76 führt [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]. und bitweises x oder 96 für jeden Wert führt zu druckbaren und unproblematischen ASCII-Codes [96,100,98,99,101,102,103,105,106,68, 72,70,71,73,74,75,77,78,40,44]-> `dbcefgijDHFGIJKMN(,. Der Code verwendet das LSB für Bit 0, während Zeile 0 dem MSB entspricht, sodass die Zeichenfolge umgekehrt werden muss. Finito.

Nervenzusammenbruch

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

etwas Golf erklärt

• Da ^96sich dies nicht auf die unteren beiden Bits auswirkt, kann es beim Extrahieren der Richtung ignoriert werden. Es ist also nicht erforderlich, den Wert in einer Variablen zu speichern, wodurch 5 Bytes auf dem Cursor-Init gespeichert werden.
• Verwenden ~3statt 124spart ein Byte und ermöglicht das nächste Golfen:
• Das Initialisieren des Schleifenzählers $k=3innerhalb der $pZuweisung spart zwei Bytes
  und schadet der Vorbedingung nicht (da der obere Wert noch eine Ziffer hat).
• Die Verwendung eines Strings für das Ergebnis hat die kürzestmögliche Initialisierung und Darstellung: Wenn ein Zeichen über das Ende eines Strings hinaus gesetzt wird, setzt PHP die fehlenden Zeichen implizit auf Leerzeichen. Und chunk_splitist der kürzeste Weg, um die Zeilenumbrüche einzufügen.
  Ich möchte nicht einmal wissen, wie viel mehr alles andere dauern würde.
• 7+($c&3?:-6)ist ein Byte kürzer als $c&3?$c%4+7:1.
• Hinzugefügt hexdec()(8 Byte), um die Eingabebeschränkung zu erfüllen.

JavaScript, 184 183 178 168 167 Bytes

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>

War ursprünglich 206 Bytes, aber die Antwort von @ Arnauld hat mich dazu inspiriert, eine eindimensionale Array-Lösung zu untersuchen. Bearbeiten: 1 Byte dank @ edc65 gespeichert. Gespeichert 5 15 Bytes dank @Arnauld. Ein weiteres Byte durch Ändern der Zeichenauswahl gespeichert.

Stapel, 491 Bytes

@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 

Hinweis: Die letzte Zeile endet mit einem Leerzeichen. Das Versetzen einer ifBedingung mit einer Variablen in eine forSchleife geht über den Stapel hinaus, sodass eine eigene Unterroutine erforderlich ist. Da es nichts sichtbares macht, falle ich hinein, um auszusteigen. Die ~unquotes die Saiten in der äußeren Schleife so dass die innere Schleife eine Schleife über die Zahlen. Die Zahlen sind einfach die Bitmasken für alle Stellen, an denen os gezeichnet werden soll.

C 267 262 260 256 Zeichen

Das Zählen entgeht als 1 Zeichen

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 ist ein Verweis auf die Felder, in die ein 'o' eingefügt werden soll.

Probieren Sie es online!

Befunge, 468 Bytes

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

Probieren Sie es online!

In der ersten Zeile wird eine Zeichenfolge aus stdin gelesen und als Hexadezimalzahl ausgewertet. Der Rest des Codes ist im Wesentlichen nur eine Doppelschleife über den x / y-Koordinaten des Gitters, wobei eine massive Boolesche Berechnung festlegt, ob ofür jede Position eine ausgegeben werden soll.

Grundsätzlich gibt es für jeden der 20 Gitterpunkte eine eigene Bedingung (die ersten vier):

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

Und wenn wir alle 20 berechnet haben, ODER das Los zusammen, und wenn das Ergebnis wahr ist, geben wir ein aus o, sonst geben wir ein Leerzeichen aus.

Befunge hat keine Möglichkeit, Bits zu manipulieren. Um also die Bits aus der Eingabe zu extrahieren, werden wir nur wiederholt evaluieren n%2und dann n/=2die 20 Bedingungsberechnungen durchlaufen.