Dệt ASCII 64 bit

18

Đầu vào

Hai số nguyên:

  • Một số nguyên không âm W trong phạm vi 0 đến 2 ^ 64-1, chỉ định kiểu dệt.
  • Một số nguyên dương S trong phạm vi từ 1 đến 255, chỉ định độ dài cạnh.

Đây có thể được thực hiện trong bất kỳ thứ tự phù hợp với bạn.

Đầu ra

Một đại diện S by S ASCII của kiểu dệt được yêu cầu ( S chuỗi ký tự S được phân tách bằng dòng mới với một dòng mới tùy chọn). Kiểu dệt được xác định bởi số dệt W như sau:

Chuyển đổi W thành nhị phân và chia thành 8 byte. Byte đầu tiên (quan trọng nhất) xác định hàng trên cùng, từ trái (bit quan trọng nhất) sang phải. Byte tiếp theo định nghĩa hàng tiếp theo, và cứ thế cho 8 hàng. Số dệt xác định một hình vuông 8 x 8 nên được lát trên khu vực cần thiết bắt đầu từ trên cùng bên trái. Đó là, góc trên cùng bên trái của nó phải tương ứng với góc trên cùng bên trái của khu vực được che phủ.

Mọi thứ 0nên được hiển thị dưới dạng |và mọi thứ 1sẽ được hiển thị dưới dạng-

Ví dụ

Đầu vào: 0 8

Ouput:

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

Đầu vào: 3703872701923249305 8

Đầu ra:

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

Đầu vào: 3732582711467756595 10

Đầu ra:

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

Đầu vào: 16141147355100479488 3

Đầu ra:

---
|||
---

Bảng xếp hạng

(sử dụng mẫu của Martin )

Hiển thị đoạn mã

code-golf  ascii-art  base-conversion  tiling 
— trichoplax
nguồn

Câu trả lời:

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
nguồn
Nó thực sự không đơn giản hoặc đơn giản hơn thế này!
— Johne
1
@ John Điều đó chỉ đúng với những người hiểu về K .;)
— Alex A.
14

CJam, 33 31 byte

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

Kiểm tra nó ở đây.

Giải trình

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
nguồn
2
Tôi hoan nghênh bạn :). Đây có lẽ là câu trả lời nhanh nhất trong lịch sử PPCG
— Beta Decay
7
@BetaDecay Lợi ích của ngôn ngữ chơi gôn là bạn có ít kiểu gõ hơn, do đó bạn có thể viết mã nhanh hơn. : P
— Martin Ender
1
Geez, thậm chí đã đi đến sự cố chỉnh sửa các thẻ trước khi trả lời! Ai đó dành quá nhiều thời gian để chơi gôn; P
— Saber
Đây có phải là đầu ra dự định không: link
— Octavia Togami
@Kenzie số đầu vào lớn hơn 2^64-1.
— Martin Ender
5

Java, 110 109 107 byte

Mã của tôi ở dạng hàm lambda ẩn danh nhận một longvà intsau đó trả về 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;}

Hoàn thành lớp kiểm tra

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
nguồn
3
Tôi phải nói rằng, tôi không quen bị Java đánh bại. : P Làm việc tốt.
— Alex A.
Cảm ơn @AlexA.! Lambdas thực sự làm cho java có thể sử dụng nhiều hơn để chơi gôn: (w,s)->thay vì String w(long w,int s)là một khoản tiết kiệm lớn ngay lập tức.
— ankh-morpork
@Ypnypn chắc chắn sẽ hoạt động
— ankh-morpork
Wow, điều này thật ấn tượng. Làm tốt lắm.
— 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))

Cảm ơn Hoki vì lời đề nghị của anh ấy, điều đó đã khiến tôi tiết kiệm cho tôi 6 byte.

Thí dụ:

>> W = uint64(3732582711467756595)
W =
  3732582711467756595
>> S = uint8(10)
S =
   10
>> f(W,S)
ans =
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
— Luis Mendo
nguồn
de2bisẽ giúp bạn tiết kiệm thêm một vài nhân vật ;-)
— Hoki
@Hoki! Cảm ơn! Tôi đã nghĩ về nó ... nhưng nó đưa ra một thứ tự khác về kết quả
— Luis Mendo
vâng, bạn phải đảo ngược a='|-'để a='-|'. Và sử dụngx=de2bi(typecast(W,'uint8'))+1;
— Hoki
@Hoki tôi quản lý để phù hợp de2bi di chuyển 9-thuật ngữ (được sử dụng để đảo ngược). Cảm ơn một lần nữa!
— 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)

Điều này tạo ra một hàm chấp nhận hai số nguyên và in ra thiết bị xuất chuẩn.

Ungolfed + giải thích:

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ái này khá dài và tôi chắc chắn nó có thể ngắn hơn nhiều. Làm việc trên đó.

— Alex A.
nguồn
3

J, 28 byte

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

Sử dụng:

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

Giải thích (phải sang trái):

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

Hãy thử trực tuyến tại đây.

— ngẫu nhiên
nguồn
2

Con trăn, 77

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

Đối với mỗi s*sgiá trị của n:

  • Tính toán tọa độ qua divmod (i,j)=(n/s,n%s)
  • Tính toán vị trí trong ốp lát như (i%8,j%8)
  • Tính toán vị trí bit thích hợp như 8*(i%8)+(j%8)
  • Trích xuất bit đó wbằng cách dịch chuyển wnhiều khoảng trắng sang phải và lấy bit cuối cùng với &1.
  • Tham gia một trong '| -' tại vị trí đó
  • Thêm dòng mới vào cuối mỗi hàng bất cứ khi nào n%s==0

Trên thực tế, tất cả những gì kết thúc nhận được ốp lát ngược, vì nó đọc wtừ cuối. Chúng tôi khắc phục điều này bằng cách sử dụng ~nthay thế n. Tôi đã thử một cách tiếp cận đệ quy thay thế, nhưng nó hơi dài ra.

Các biểu hiện w>>~n/s%8*8+~n%s%8&1là một phép lạ của ưu tiên toán tử.

— xnor
nguồn
1

Python 2, 132 byte

Chắc chắn đó không phải là giải pháp tao nhã nhất và nó chỉ ngắn hơn C, nhưng đó là một sự khởi đầu .. Đầu vào được phân tách bằng dấu phẩy.

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
nguồn
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);}

Một số môn đánh gôn nữa có thể được thực hiện ở đây và cần một lời giải thích, nhưng tôi không có thời gian vào lúc này :)

Ung dung:

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
nguồn
Bạn có thể định dạng tiêu đề như "C, 100 byte" không? Bằng cách đó, nó sẽ hiển thị trong bảng xếp hạng tốt hơn.
— Anubian Noob
Vâng, xin lỗi về điều đó.
— Cole Cameron
1
Tôi gặp sự cố khi mã của bạn chạy chính xác trên môi trường của tôi. Bạn đang biên dịch với bất kỳ tùy chọn cụ thể?
— ankh-morpork
@ dohaqatar7 Dường như một số môi trường Linux yêu cầu stdlib.hphải được đưa vào một cách rõ ràng. Tôi đã không bị buộc phải đưa nó sớm hơn khi tôi thử nghiệm trên CentOS (tôi tin rằng đó là những gì tôi đã làm). Bây giờ trên Ubuntu, tôi không thể chạy nó mà không cần biên dịch như vậy:gcc -include stdlib.h w.c
— Cole Cameron
Có nghĩa là tôi đã thử nghiệm trên Ubuntu
— ankh-morpork
1

Bình thường, 31 30 byte

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

Các đầu vào nên có trên hai dòng, W sau đó S .

Hãy thử nó ở đây

Giải trình

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
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.