Tessitura ASCII a 64 bit

18

Ingresso

Due numeri interi:

  • Un numero intero non negativo W nell'intervallo da 0 a 2 ^ 64-1, che specifica la trama.
  • Un numero intero positivo S compreso tra 1 e 255, che specifica la lunghezza del lato.

Questi possono essere presi nell'ordine che preferisci.

Produzione

Una rappresentazione S by S ASCII della trama richiesta ( S newline ha separato le stringhe di caratteri S con una nuova riga finale facoltativa). La trama è definita dal numero di trama W come segue:

Converti W in binario e diviso in 8 byte. Il primo byte (più significativo) definisce la riga superiore, da sinistra (bit più significativo) a destra. Il byte successivo definisce la riga successiva e così via per 8 righe. Il numero di tessitura definisce un quadrato di 8 per 8 che dovrebbe essere piastrellato sull'area richiesta a partire dall'alto in alto a sinistra. Cioè, il suo angolo in alto a sinistra dovrebbe corrispondere all'angolo in alto a sinistra dell'area da coprire.

Ogni 0dovrebbe essere visualizzato come un |e ogni 1dovrebbe essere visualizzato come un-

Esempi

Ingresso: 0 8

ouput:

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

Ingresso: 3703872701923249305 8

Produzione:

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

Ingresso: 3732582711467756595 10

Produzione:

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

Ingresso: 16141147355100479488 3

Produzione:

---
|||
---

Snippet della classifica

(usando il modello di Martin )

Mostra snippet di codice

code-golf  ascii-art  base-conversion  tiling 
— trichoplax
fonte

Risposte:

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
fonte
Non diventa davvero più semplice o più semplice di così!
— JohnE
1
@JohnE Questo è vero solo per le persone che capiscono K.;)
— Alex A.
14

CJam, 33 31 byte

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

Provalo qui.

Spiegazione

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
fonte
2
Ti applaudo :). Questa è probabilmente la risposta più rapida nella storia di PPCG
— Decadimento beta
7
@BetaDecay Il vantaggio delle lingue di golf è che hai meno da scrivere, in modo da poter scrivere più velocemente. : P
— Martin Ender,
1
Accidenti, si è anche preso la briga di modificare i tag prima di rispondere! Qualcuno passa troppo tempo a giocare a golf; P
— Sabre,
È questo output previsto: link
— Octavia Togami
@Kenzie quel numero di input è maggiore di 2^64-1.
— Martin Ender,
5

Java, 110 109 107 byte

Il mio codice ha la forma di una funzione lambda anonima che accetta a longe an intrestituisce a 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;}

Classe testabile completa

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
fonte
3
Devo dire che non sono abituato a essere battuto da Java. : P Bel lavoro.
— Alex A.
Grazie @AlexA.! Le lambda rendono davvero Java più utilizzabile per il golf: (w,s)->invece di String w(long w,int s)un grande risparmio subito.
— ankh-morpork,
@Ypnypn che dovrebbe sicuramente funzionare
— ankh-morpork il
Caspita, è impressionante. Buon lavoro.
— TheNumberOne,
4

Matlab, 86 80 byte

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

Grazie a Hoki per il suo suggerimento, che mi ha portato a salvarmi 6 byte.

Esempio:

>> W = uint64(3732582711467756595)
W =
  3732582711467756595
>> S = uint8(10)
S =
   10
>> f(W,S)
ans =
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
— Luis Mendo
fonte
de2biti farà risparmiare qualche altro personaggio ;-)
— Hoki,
@Hoki! Grazie! Ci ho pensato ... ma dà un ordine diverso del risultato
— Luis Mendo,
sì, si deve invertire la a='|-'a a='-|'. E usax=de2bi(typecast(W,'uint8'))+1;
— Hoki il
@Hoki sono riuscito ad adattarmi de2bisemplicemente spostando il 9-termine (utilizzato per l'inversione). Grazie ancora!
— Luis Mendo,
3

Julia, 145 byte

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)

Questo crea una funzione che accetta due numeri interi e stampa su stdout.

Ungolfed + spiegazione:

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

Questo è piuttosto lungo e sono sicuro che può essere reso molto più breve. Lavorando su di esso.

— Alex A.
fonte
3

J, 28 byte

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

Uso:

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

Spiegazione (da destra a sinistra):

#.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

Provalo online qui.

— randomra
fonte
3

CJam, 30 28 27 byte

q~_2m*W%/ff{8f%8bm>"|-"=}N*

Provalo online nell'interprete CJam .

— Dennis
fonte
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))

Per ciascuno dei s*svalori di n:

  • Calcola le coordinate tramite divmod (i,j)=(n/s,n%s)
  • Calcola la posizione nella piastrellatura come (i%8,j%8)
  • Calcola la posizione del bit appropriata come 8*(i%8)+(j%8)
  • Estrai quel bit wspostando wtanti spazi con right e prendi l'ultimo bit con &1.
  • Unisciti a uno dei "| -" in quella posizione
  • Aggiungi la nuova riga alla fine di ogni riga ogni volta n%s==0

In realtà, tutto ciò che finisce per ottenere la piastrellatura all'indietro, poiché legge wdalla fine. Risolviamo usando ~nal posto di n. Ho provato invece un approccio ricorsivo, ma si è rivelato leggermente più lungo.

L'espressione w>>~n/s%8*8+~n%s%8&1è un miracolo della precedenza dell'operatore.

— XNOR
fonte
1

Python 2, 132 byte

Certamente non è la soluzione più elegante, ed è a malapena più breve di C, ma è un inizio .. L'input viene preso separato da virgole.

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
fonte
1

C, 160 135 byte

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

Un po 'più di golf può essere fatto qui e ha bisogno di una spiegazione, ma al momento non ho tempo :)

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
fonte
Potresti formattare il titolo come "C, 100 byte"? In questo modo verrà visualizzato meglio nella classifica.
— Anubian Noob,
Sì, mi dispiace per quello.
— Cole Cameron,
1
Ho problemi a far funzionare correttamente il tuo codice nel mio ambiente. Stai compilando con qualche opzione specifica?
— ankh-morpork,
@ dohaqatar7 Sembra che alcuni ambienti Linux debbano stdlib.hessere inclusi esplicitamente. Non ero costretto a includerlo prima quando ho provato su CentOS (credo che fosse quello su cui mi trovavo). Ora su Ubuntu, non riesco a farlo funzionare senza compilare in questo modo:gcc -include stdlib.h w.c
— Cole Cameron
Ha senso che ho provato su Ubuntu
— ankh-morpork il
1

Pyth, 31 30 byte

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

L'ingresso dovrebbe essere su due linee, W quindi S .

Provalo qui

Spiegazione

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.