64 Bit ASCII Weben

18

Eingang

Zwei ganze Zahlen:

  • Eine nicht negative ganze Zahl W im Bereich von 0 bis 2 ^ 64-1, die die Bindung angibt.
  • Eine positive ganze Zahl S im Bereich von 1 bis 255, die die Seitenlänge angibt.

Diese können in der von Ihnen gewünschten Reihenfolge eingenommen werden.

Ausgabe

Ein S durch S ASCII - Darstellung der angeforderten Webart ( S Newline getrennt Saiten S - Zeichen mit einem optionalen Newline). Die Bindung wird durch die Bindungsnummer W wie folgt definiert:

Wandle W in Binär um und teile es in 8 Bytes auf. Das erste (höchstwertige) Byte definiert die oberste Zeile von links (höchstwertiges Bit) nach rechts. Das nächste Byte definiert die nächste Zeile usw. für 8 Zeilen. Die Bindungsnummer definiert ein 8 x 8-Quadrat, das von links oben über den erforderlichen Bereich gekachelt werden sollte. Das heißt, seine linke obere Ecke sollte der linken oberen Ecke des zu bedeckenden Bereichs entsprechen.

Jeder 0sollte als angezeigt werden |und jeder 1sollte als angezeigt werden-

Beispiele

Eingang: 0 8

Ausgang:

||||||||
||||||||
||||||||
||||||||
||||||||
||||||||
||||||||
||||||||

Eingang: 3703872701923249305 8

Ausgabe:

||--||--
|--||--|
--||--||
-||--||-
||--||--
|--||--|
--||--||
-||--||-

Eingang: 3732582711467756595 10

Ausgabe:

||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--

Eingang: 16141147355100479488 3

Ausgabe:

---
|||
---

Leaderboard-Snippet

(mit Martins Vorlage )

Code-Snippet anzeigen

code-golf ascii-art base-conversion tiling Trichoplax
quelle

Antworten:

10

K, 20

{y#y#'"|-"8 8#0b\:x}

.

             0b\:x    // convert to binary
         8 8#         // reshape into an 8x8 boolean matrix
     "|-"             // index into this char vector using the booleans as indices  
  y#'                 // extend horizontally
y#                    // extend vertically

.

k){y#y#'"|-"8 8#0b\:x}[3703872701923249305j;10]
"||--||--||"
"|--||--||-"
"--||--||--"
"-||--||--|"
"||--||--||"
"|--||--||-"
"--||--||--"
"-||--||--|"
"||--||--||"
"|--||--||-"

k){y#y#'"|-"8 8#0b\:x}[3703872701923249305j;8]
"||--||--"
"|--||--|"
"--||--||"
"-||--||-"
"||--||--"
"|--||--|"
"--||--||"
"-||--||-"
tmartin
quelle
Einfacher und unkomplizierter geht es nicht!
JohnE
1
@ JohnE Das gilt nur für Menschen, die K. verstehen;)
Alex A.
14

CJam, 33 31 Bytes

q~:X;2b64Te["|-"f=8/{X*X<z}2*N*

Teste es hier.

Erläuterung

q~      e# Read and eval input.
:X;     e# Store the side length in X and discard it.
2b      e# Convert to base 2.
64Te[   e# Left-pad to length 64 with zeroes.
"|-"f=  e# Select '|' for 0 and '=' for 1.
8/      e# Split into chunks of 8 bits.
{       e# Do the following twice:
  X*    e#   Repeat lines X times (to ensure we have enough of them).
  X<    e#   Truncate them to exactly X lines.
  z     e#   Transpose the grid.
        e#   The transpose ensures that the second pass tiles the columns, and that the
        e#   grid is oriented correctly again after both passes are done.
}2*
N*      e# Join lines by newline characters.
Martin Ender
quelle
2
Ich applaudiere dir :). Dies ist wahrscheinlich die schnellste Antwort in der Geschichte von PPCG
Beta Decay
7
@BetaDecay Der Vorteil von Golfsprachen ist, dass Sie weniger tippen müssen, sodass Sie schneller programmieren können. : P
Martin Ender
1
Meine Güte, machte sich sogar die Mühe, die Tags zu bearbeiten, bevor ich antwortete! Jemand verbringt zu viel Zeit mit Golfen. P
Sabre
Ist dies beabsichtigte Ausgabe: Link
Octavia Togami
@Kenzie, die eingegebene Nummer ist größer als 2^64-1.
Martin Ender
5

Java, 110 109 107 Bytes

Mein Code hat die Form einer anonymen Lambda-Funktion, die a annimmt longund intdann a zurückgibt String.

(w,s)->{String b="";for(int j,i=s--;i-->0;b+='\n')for(j=s;j>=0;)b+=(w>>8*(i%8)+j--%8)%2<1?'|':45;return b;}

Komplette prüfbare Klasse

import java.util.function.BiFunction;
public class AsciiWeave {   
    public static void main(String[] args){
        BiFunction<Long,Integer,String> weave = 
            (w,s)->{String b="";for(int j,i=s--;i-->0;b+='\n')for(j=s;j>=0;)b+=(w>>8*(i%8)+j--%8)%2<1?'|':45;return b;}}
        ;
        System.out.println(weave.apply(Long.valueOf(args[0]),Integer.valueOf(args[1])));
    }
}
Ankh-Morpork
quelle
3
Ich muss sagen, ich bin es nicht gewohnt, von Java geschlagen zu werden. : P Gute Arbeit.
Alex A.
Vielen Dank @AlexA.! Lambdas machen Java wirklich benutzerfreundlicher für das Golfen: (w,s)->Stattdessen String w(long w,int s)ist es eine große Ersparnis auf Anhieb.
Ankh-Morpork
@Ypnypn das sollte auf jeden Fall funktionieren
Ankh-Morpork
Wow, das ist beeindruckend. Gut gemacht.
TheNumberOne
4

Matlab, 86 80 Bytes

function f(W,S)
a='|-';x=de2bi(typecast(W,'uint8'))+1;s=8-mod(0:S-1,8);a(x(s,s))

Vielen Dank an Hoki für seinen Vorschlag, der mich veranlasste, 6 Bytes zu sparen.

Beispiel:

>> W = uint64(3732582711467756595)
W =
  3732582711467756595
>> S = uint8(10)
S =
   10
>> f(W,S)
ans =
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
Luis Mendo
quelle
de2biwerden Sie ein paar weitere Zeichen speichern ;-)
Hoki
@Hoki! Vielen Dank! Ich habe darüber nachgedacht ... aber es gibt eine andere Reihenfolge des Ergebnisses
Luis Mendo
yep, Sie müssen umkehren a='|-'zu a='-|'. Und verwenden Siex=de2bi(typecast(W,'uint8'))+1;
Hoki
@Hoki Ich habe es geschafft, de2binur den 9-Begriff zu verschieben (für die Umkehrung verwendet). Danke noch einmal!
Luis Mendo
3

Julia, 145 Bytes

f(w,s)=(A=map(i->i=="1"?"-":"|",reshape(split(lpad(bin(w),64,0),""),8,8))';for i=1:s A=hcat(A,A)end;for i=1:s println(join(A[i>8?i%8:i,1:s]))end)

Dadurch wird eine Funktion erstellt, die zwei Ganzzahlen akzeptiert und auf stdout druckt.

Ungolfed + Erklärung:

function f(w,s)
    # Convert w to binary, left-padded with zeros to length 64
    b = lpad(bin(w), 64, 0)

    # Create an 8x8 array of | and -
    A = transpose(map(i -> i == "1" ? "-" : "|", reshape(split(b, ""), 8, 8)))

    # Horizontally concatenate A to itself s times
    for i = 1:s
        A = hcat(A, A)
    end

    # Print the rows of A, recycling as necessary
    for i = 1:s
        println(join(A[i > 8 ? i % 8 : i, 1:s]))
    end
end

Das ist ziemlich lang und ich bin sicher, dass es viel kürzer gemacht werden kann. Daran zu arbeiten.

Alex A.
quelle
3

J, 28 Bytes

'|-'{~]$"1]$8 8$_64{.#.inv@[

Verwendung:

   3732582711467756595 ('|-'{~]$"1]$8 8$_64{.#.inv@[) 10
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--

Erklärung (von rechts nach links):

#.inv@[   binary representation vector of S
_64{.     padded with 0-s from the right to length 64
8 8$      reshaped in an 8 by 8 matrix
]$"1]$    tiled to a W by W size
'|-'{~    select | or - based on matrix element values

Probieren Sie es hier online aus.

randomra
quelle
2

Python, 77

lambda w,s:''.join('|-'[w>>~n/s%8*8+~n%s%8&1]+'\n'[~n%s:]for n in range(s*s))

Für jeden der s*sWerte von n:

  • Berechnen Sie die Koordinaten mit divmod (i,j)=(n/s,n%s)
  • Berechnen Sie die Position in der Kachel als (i%8,j%8)
  • Berechnen Sie die entsprechende Bitposition als 8*(i%8)+(j%8)
  • Extrahieren Sie dieses Bit, windem Sie wso viele Leerzeichen nach rechts verschieben, und nehmen Sie das letzte Bit mit &1.
  • Treten Sie an dieser Position einem der '| -' bei
  • Fügen Sie die neue Zeile immer am Ende jeder Zeile ein n%s==0

Eigentlich bekommt alles, was endet, die Kacheln rückwärts, da es wvom Ende liest . Wir beheben dies, indem wir ~nanstelle von verwenden n. Ich habe stattdessen einen rekursiven Ansatz gewählt, der sich jedoch etwas länger entwickelt hat.

Der Ausdruck w>>~n/s%8*8+~n%s%8&1ist ein Wunder der Operatorpriorität.

xnor
quelle
1

Python 2, 132 Bytes

Sicherlich nicht die eleganteste Lösung, und sie ist kaum kürzer als C, aber es ist ein Anfang. Die Eingabe erfolgt durch Kommas getrennt.

k,n=input()
k=[`['|-'[int(x)]for x in'{0:064b}'.format(k)]`[2::5][i*8:i*8+8]*n for i in range(8)]*n
for j in range(n):print k[j][:n]
Kade
quelle
1

C, 160 135 Bytes

i;main(s,v)char**v;{s=atoi(v[2]);for(;i++<s*s+s;)putchar(i%(s+1)?strtoull(v[1],0,10)&1ull<<63-(i/(s+1)*8+(i%(s+1)-1)%8)%64?45:'|':10);}

Hier kann man noch ein bisschen Golf spielen und braucht eine Erklärung, aber ich habe im Moment keine Zeit :)

Ungolfed:

i;

main(s,v)
char**v;
{
    s=atoi(v[2]);
    for(;i++<s*s+s;)
        putchar(i%(s+1) ? /* print dash or pipe, unless at end of row, then print newline */
            /* Calculating which bit to check based on the position is the tough part */
            strtoull(v[1],0,10) & 1ull << 63-(i/(s+1)*8+(i%(s+1)-1)%8)%64 ? /* If bit at correct index is set, print dash, otherwise pipe */
                45 /* dash */
                : '|' /* pipe */
            : 10); /* newline */
}
Cole Cameron
quelle
Könnten Sie den Titel wie "C, 100 Bytes" formatieren? Auf diese Weise wird es in der Bestenliste besser angezeigt.
Anubian Noob
Ja, tut mir leid.
Cole Cameron
1
Ich habe Probleme damit, Ihren Code in meiner Umgebung korrekt auszuführen. Kompilieren Sie mit bestimmten Optionen?
Ankh-Morpork
@ dohaqatar7 Es sieht so aus stdlib.h, als müssten einige Linux-Umgebungen explizit eingebunden werden. Ich war nicht gezwungen, es früher einzuschließen, als ich es auf CentOS getestet habe (ich glaube, das war es, was ich gemacht habe). Jetzt auf Ubuntu kann ich es nicht zum Laufen bringen, ohne wie folgt zu kompilieren:gcc -include stdlib.h w.c
Cole Cameron
Sinnvollerweise habe ich
1

Pyth, 31 30 Bytes

L<*QbQjbyyMcs@L"|-".[Z64jvz2 8

Der Eingang sollte auf zwei Linien, W dann S .

Probieren Sie es hier aus

Erläuterung

L                              # define y(b):
  *Qb                          #   b, repeated Q (the second input) times
 <   Q                         #   cut to length Q

                        jvz2   # convert the first input to binary
                   .[Z64       # pad with 0's to length 64
             @L"|-"            # map the digits to the appropriate character
            s                  # convert the list of characters to a string
           c                 8 # chop into 8 strings
         yM                    # extend each string to the correct size
        y                      # extend the list of strings to the correct size
      jb                       # join with newlines
Ypnypn
quelle