Tecelagem ASCII de 64 bits

18

Entrada

Dois inteiros:

  • Um número inteiro não negativo W no intervalo de 0 a 2 ^ 64-1, especificando a trama.
  • Um número inteiro positivo S no intervalo de 1 a 255, especificando o comprimento do lado.

Elas podem ser obtidas na ordem que melhor lhe convier.

Resultado

Uma representação S por S ASCII do weave solicitado ( S newline separou sequências de caracteres S com uma nova linha à direita opcional). O tecido é definido pelo número W do tecido da seguinte forma:

Converta W em binário e divida em 8 bytes. O primeiro byte (mais significativo) define a linha superior, da esquerda (bit mais significativo) para a direita. O próximo byte define a próxima linha e assim por diante para 8 linhas. O número do tecido define um quadrado de 8 por 8, que deve ser colocado lado a lado sobre a área desejada, começando no canto superior esquerdo. Ou seja, seu canto superior esquerdo deve corresponder ao canto superior esquerdo da área a ser coberta.

Todos 0devem ser exibidos como um |e todos 1devem ser exibidos como um-

Exemplos

Entrada: 0 8

Ouput:

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

Entrada: 3703872701923249305 8

Resultado:

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

Entrada: 3732582711467756595 10

Resultado:

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

Entrada: 16141147355100479488 3

Resultado:

---
|||
---

Snippet de cabeçalho

(usando o modelo de Martin )

Mostrar snippet de código

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

Respostas:

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
Realmente não fica mais simples ou mais direto do que isso!
Johne
1
@JohnE Isso é verdade apenas para pessoas que entendem K.;)
Alex A.
14

CJam, 33 31 bytes

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

Teste aqui.

Explicação

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
Aplaudo :). Esta é provavelmente a resposta mais rápida da história do PPCG
Decay Beta
7
@BetaDecay O benefício das linguagens de golfe é que você tem menos para digitar, para poder codificar mais rapidamente. : P
Martin Ender
1
Nossa, até se deu ao trabalho de editar as tags antes de responder! Alguém passa muito tempo jogando golfe; P
Saber
É este o resultado pretendido: ligação
Octavia Togami
@Kenzie esse número de entrada é maior que 2^64-1.
Martin Ender
5

Java, 110 109 107 Bytes

Meu código é na forma de uma função lambda anônimo que leva um longe um int, em seguida, retorna um 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 testável 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 dizer que não estou acostumado a ser derrotado pelo Java. : P Bom trabalho.
Alex A.
Obrigado @AlexA.! As lambdas realmente tornam o java mais útil para o golfe: em (w,s)->vez de String w(long w,int s)economizar muito, o jogo é imediato.
Ankh-morpork 31/07/2015
@Ypnypn que deve definitivamente trabalho
Ankh-Morpork
Uau, isso é impressionante. Bom trabalho.
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))

Agradeço a Hoki por sua sugestão, que me levou a economizar 6 bytes.

Exemplo:

>> W = uint64(3732582711467756595)
W =
  3732582711467756595
>> S = uint8(10)
S =
   10
>> f(W,S)
ans =
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
Luis Mendo
fonte
de2bivocê vai economizar mais alguns caracteres ;-)
Hoki
@Hoki! Obrigado! Eu pensei sobre isso ... mas dá uma ordem diferente do resultado
Luis Mendo
sim, você tem que reverter a='|-'para a='-|'. E usex=de2bi(typecast(W,'uint8'))+1;
Hoki
@Hoki eu consegui encaixar de2biapenas movendo o 9-termo (usado para reversão). Obrigado novamente!
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)

Isso cria uma função que aceita dois números inteiros e imprime no stdout.

Ungolfed + explicação:

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

Isso é muito longo e tenho certeza de que pode ser muito mais curto. Trabalhando nisso.

Alex A.
fonte
3

J, 28 bytes

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

Uso:

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

Explicação (da direita para a esquerda):

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

Experimente online aqui.

randomra
fonte
3

CJam, 30 28 27 bytes

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

Experimente on-line no intérprete 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))

Para cada um dos s*svalores de n:

  • Calcular as coordenadas via divmod (i,j)=(n/s,n%s)
  • Calcule o local no ladrilho como (i%8,j%8)
  • Calcule a posição de bit apropriada como 8*(i%8)+(j%8)
  • Extraia essa parte wdeslocando wmuitos espaços com a direita e leve a última parte com &1.
  • Junte-se a um dos | | - nessa posição
  • Adicione a nova linha no final de cada linha sempre que n%s==0

Na verdade, tudo isso acaba recebendo o ladrilho para trás, pois ele lê wdo final. Corrigimos isso usando ~nno lugar de n. Tentei uma abordagem recursiva, mas acabou um pouco mais.

A expressão w>>~n/s%8*8+~n%s%8&1é um milagre de precedência do operador.

xnor
fonte
1

Python 2, 132 bytes

Certamente não é a solução mais elegante, e é pouco mais curta que C, mas é um começo. As entradas são separadas por vírgula.

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

Um pouco mais de golfe pode ser feito aqui e preciso de uma explicação, mas não tenho tempo no momento :)

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
Você poderia formatar o título como "C, 100 bytes"? Dessa forma, ele aparecerá melhor na tabela de classificação.
Anubian Noob
Sim, desculpe por isso.
Cole Cameron
1
Estou tendo problemas para que seu código seja executado corretamente no meu ambiente. Você está compilando com alguma opção específica?
Ankh-morpork 31/07/2015
@ dohaqatar7 Parece que alguns ambientes Linux precisam stdlib.hser incluídos explicitamente. Não fui obrigado a incluí-lo mais cedo quando testei no CentOS (acredito que era nisso que eu estava). Agora no Ubuntu, eu não posso começar a correr sem compilar assim:gcc -include stdlib.h w.c
Cole Cameron
Faz sentido que eu testei no Ubuntu
Ankh-Morpork
1

Pitão, 31 30 bytes

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

A entrada devem ser em duas linhas, W , em seguida, S .

Experimente aqui

Explicação

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