Tissage ASCII 64 bits

18

Contribution

Deux entiers:

  • Un entier non négatif W compris entre 0 et 2 ^ 64-1, spécifiant le tissage.
  • Un entier positif S compris entre 1 et 255, spécifiant la longueur du côté.

Ceux-ci peuvent être pris dans l'ordre qui vous convient.

Production

Une représentation ASCII S par S de l'armure demandée ( S nouvelles lignes séparées par des caractères S avec une nouvelle ligne facultative). L'armure est définie par le numéro d'armure W comme suit:

Convertissez W en binaire et divisez-le en 8 octets. Le premier octet (le plus significatif) définit la ligne supérieure, de gauche (bit le plus significatif) à droite. L'octet suivant définit la ligne suivante, et ainsi de suite pour 8 lignes. Le numéro d'armure définit un carré de 8 x 8 qui doit être carrelé sur la zone requise à partir du coin supérieur gauche. Autrement dit, son coin supérieur gauche doit correspondre au coin supérieur gauche de la zone à couvrir.

Tout 0doit être affiché comme un |et tout 1doit être affiché comme un-

Exemples

Contribution: 0 8

Sortie:

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

Contribution: 3703872701923249305 8

Production:

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

Contribution: 3732582711467756595 10

Production:

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

Contribution: 16141147355100479488 3

Production:

---
|||
---

Extrait de classement

(en utilisant le modèle de Martin )

Afficher l'extrait de code

code-golf ascii-art base-conversion tiling trichoplax
la source

Réponses:

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
la source
Cela ne devient vraiment pas plus simple ou plus simple que cela!
JohnE
1
@JohnE Cela n'est vrai que pour les personnes qui comprennent K.;)
Alex A.
14

CJAM, 33 31 octets

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

Testez-le ici.

Explication

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
la source
2
Je vous applaudis :). C'est probablement la réponse la plus rapide de l'histoire de PPCG
Beta Decay
7
@BetaDecay L'avantage des langues de golf est que vous avez moins à taper, donc vous pouvez coder plus rapidement. : P
Martin Ender
1
Décidément, même pris la peine de modifier les balises avant de répondre! Quelqu'un passe trop de temps à jouer au golf; P
Sabre
Est-ce la sortie prévue: lien
Octavia Togami
@Kenzie ce nombre d'entrée est plus grand que 2^64-1.
Martin Ender
5

Java, 110 109 107 Octets

Mon code se présente sous la forme d'une fonction lambda anonyme qui prend a longet an intrenvoie ensuite 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 testable complète

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
la source
3
Je dois dire que je n'ai pas l'habitude d'être battu par Java. : P Beau travail.
Alex A.
Merci @AlexA.! Les Lambdas rendent vraiment Java plus utilisable pour le golf: (w,s)->au lieu de cela, String w(long w,int s)c'est une grosse économie dès le départ.
ankh-morpork
@Ypnypn qui devrait définitivement fonctionner
ankh-morpork
Wow, c'est impressionnant. Bon travail.
TheNumberOne
4

Matlab, 86 80 octets

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

Merci à Hoki pour sa suggestion, qui m'a conduit à me faire économiser 6 octets.

Exemple:

>> W = uint64(3732582711467756595)
W =
  3732582711467756595
>> S = uint8(10)
S =
   10
>> f(W,S)
ans =
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
Luis Mendo
la source
de2bivous fera économiser quelques caractères de plus ;-)
Hoki
@Hoki! Merci! J'y ai pensé ... mais ça donne un ordre de résultat différent
Luis Mendo
Eh oui, vous devez inverser a='|-'à a='-|'. Et utilisezx=de2bi(typecast(W,'uint8'))+1;
Hoki
@Hoki j'ai réussi à adapter de2bisimplement le déplacement du 9-terme (utilisé pour l'inversion). Merci encore!
Luis Mendo
3

Julia, 145 octets

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)

Cela crée une fonction qui accepte deux entiers et s'imprime sur stdout.

Non golfé + explication:

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

C'est assez long et je suis sûr qu'il peut être beaucoup plus court. J'y travaille.

Alex A.
la source
3

J, 28 octets

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

Usage:

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

Explication (de droite à gauche):

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

Essayez-le en ligne ici.

randomra
la source
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))

Pour chacune des s*svaleurs de n:

  • Calculer les coordonnées via divmod (i,j)=(n/s,n%s)
  • Calculez l'emplacement dans le pavage comme (i%8,j%8)
  • Calculez la position de bit appropriée comme 8*(i%8)+(j%8)
  • Extrayez ce bit de wen décalant wautant d'espaces avec la droite et prenez le dernier bit avec &1.
  • Rejoignez l'un des «| -» à cette position
  • Ajoutez la nouvelle ligne à la fin de chaque ligne chaque fois n%s==0

En fait, tout cela finit par faire reculer le carrelage, car il lit wde la fin. Nous corrigeons cela en utilisant ~nà la place de n. J'ai plutôt essayé une approche récursive, mais elle s'est avérée un peu plus longue.

L'expression w>>~n/s%8*8+~n%s%8&1est un miracle de priorité des opérateurs.

xnor
la source
1

Python 2, 132 octets

Ce n'est certainement pas la solution la plus élégante, et elle est à peine plus courte que C, mais c'est un début. L'entrée est prise séparée par des virgules.

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
la source
1

C, 160 135 octets

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 peu plus de golf peut être fait ici et a besoin d'une explication, mais je n'ai pas le temps pour le moment :)

Non golfé:

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
la source
Pourriez-vous formater le titre comme "C, 100 octets"? De cette façon, cela apparaîtra mieux dans le classement.
Anubian Noob
Oui, désolé.
Cole Cameron
1
J'ai du mal à faire fonctionner correctement votre code sur mon environnement. Compilez-vous avec des options spécifiques?
ankh-morpork
@ dohaqatar7 Il semble que certains environnements Linux nécessitent stdlib.hune inclusion explicite. Je n'ai pas été obligé de l'inclure plus tôt lorsque j'ai testé sur CentOS (je crois que c'est ce que je faisais). Maintenant sur Ubuntu, je ne peux pas le faire fonctionner sans compiler comme ça:gcc -include stdlib.h w.c
Cole Cameron
C'est logique que j'ai testé sur Ubuntu
ankh-morpork
1

Pyth, 31 30 octets

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

L'entrée doit être sur deux lignes, W alors S .

Essayez-le ici

Explication

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
la source