Tạo một ma trận bàn cờ


26

Lấy một số nguyên dương n làm đầu vào và xuất ra ma trận bảng kiểm tra n-by-n bao gồm 10 .

Chữ số trên cùng bên trái phải luôn là 1 .

Các trường hợp thử nghiệm:

n = 1
1

n = 2
1 0
0 1

n = 3
1 0 1
0 1 0
1 0 1

n = 4
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1

Định dạng đầu vào và đầu ra là tùy chọn. Xuất ra ma trận như một danh sách các danh sách được chấp nhận.


Là một danh sách các chuỗi OK?
xnor

Vâng điều đó ổn.
Stewie Griffin


2
Các ví dụ của bạn hiển thị khoảng trắng giữa các số trên cùng một hàng, có bắt buộc không, để trông giống hình vuông hơn?
BradC

@BradC không bắt buộc. Cách tiếp cận đầu tiên ở đây là hợp lệ.
Stewie Griffin

Câu trả lời:



9

MATL , 5 byte

:otYT

Hãy thử nó tại MATL trực tuyến!

Giải trình

Hãy xem xét đầu vào 4là một ví dụ.

:    % Implicit input, n. Push range [1 2 ... n]
     %   STACK: [1 2 3 4]
o    % Parity, element-wise
     %   STACK: [1 0 1 0]
t    % Duplicate
     %   STACK: [1 0 1 0], [1 0 1 0]
YT   % Toeplitz matrix with two inputs. Implicit display
     %   STACK: [1 0 1 0;
     %           0 1 0 1;
     %           1 0 1 0;
     5           0 1 0 1]

7

Japt , 6 byte

ÆÇ+X v

Kiểm tra nó trực tuyến! (Sử dụng -Qcờ để dễ hình dung hơn)

Giải trình

 Æ   Ç   +X v
UoX{UoZ{Z+X v}}  // Ungolfed
                 // Implicit: U = input number
UoX{          }  // Create the range [0...U), and map each item X to
    UoZ{     }   //   create the range [0...U), and map each item Z to
        Z+X      //     Z + X
            v    //     is divisible by 2.
                 // Implicit: output result of last expression

Một điều thú vị để lưu ý là vkhông một "chia hết cho 2" built-in. Thay vào đó, nó được tích hợp "chia hết cho X". Tuy nhiên, không giống như hầu hết các ngôn ngữ chơi gôn, các chức năng của Japt không có tính cố định (chúng có thể chấp nhận bất kỳ số lượng đối số đúng). Khi được đưa ra 0 đối số đúng, vgiả sử bạn muốn 2và do đó hành động chính xác như được đưa ra 2thay vì không có gì.



7

Haskell , 50 41 39 38 byte

Cảm ơn nimi và xnor vì đã giúp loại bỏ tổng cộng 9 10 byte

f n=r[r"10",r"01"]where r=take n.cycle

Cách khác, để có thêm một byte:

(!)=(.cycle).take
f n=n![n!"10",n!"01"]

hoặc là:

r=flip take.cycle
f n=r[r"10"n,r"01"n]n

Có lẽ là tối ưu, nhưng một cách tiếp cận rõ ràng, đơn giản.


concat.repeatcycle: n!l=take n$cycle l. Nếu bạn đi pointfree, nó sẽ tiết kiệm thêm một byte : (!)=(.cycle).take.
nimi

Đáng yêu! Tôi biết có một bản dựng sẵn cho điều đó, nhưng không thể nhớ tên cho cuộc đời của tôi
Julian Wolf

Tôi sẽ đề nghị f n|r<-take n.cycle=r[r"10",r"01"]hoặc tương tự. nhưng Haskell dường như suy ra loại sai cho r? Nó hoạt động với gõ rõ ràng f n|r<-take n.cycle::[a]->[a]=r[r"10",r"01"].
xnor

1
@JulianWolf Haskell dường như gặp khó khăn khi suy ra các loại đa hình
xnor

1
@zbw Tôi nghĩ đây là trường hợp nhưng sử dụng NoMonomorphismRestrictionkhông giúp được gì. Cũng không Rank2Typeshoặc RankNTypes. Bạn có biết những gì đang xảy ra ở đó?
xnor

5

APL (Dyalog) , 8 byte

~2|⍳∘.+⍳

Hãy thử trực tuyến!

Giải trình

Hãy gọi đối số n.

⍳∘.+⍳

Điều này tạo ra một ma trận

1+1 1+2 1+2 .. 1+n
2+1 2+2 2+3 .. 2+n
...
n+1 n+2 n+3 .. n+n

Sau đó 2|lấy modulo 2 của ma trận (nó vectơ) sau đó ~lấy KHÔNG của kết quả.



4

JavaScript ES6, 55 54 51 46 byte

Đã lưu 1 byte nhờ @Neil

Đã lưu 2 byte nhờ @Arnauld

n=>[...Array(n)].map((_,i,a)=>a.map(_=>++i&1))

Hãy thử trực tuyến!

Điều này đầu ra như là một mảng của mảng. Phạm vi JavaScript khá khó hiểu nhưng tôi sử dụng [...Array(n)]để tạo ra một mảng kích thướcn


Vẫn còn một byte ngắn hơn để sử dụng các tham số chỉ mục:n=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>(i+j+1)%2))
Neil

@Neil huh, tôi chưa bao giờ nghĩ sẽ sử dụng tham số thứ ba trong bản đồ, cảm ơn!
Hạ cấp

@Arnauld cảm ơn! đã truyền cảm hứng cho tôi để tiết kiệm thêm 5 byte!
Hạ cấp

4

Võng mạc , 33 30 byte

.+
$*
1
$_¶
11
10
T`10`01`¶.+¶

Hãy thử trực tuyến! Giải thích: Giai đoạn đầu tiên chuyển đổi đầu vào thành unary bằng cách sử dụng 1s (một cách thuận tiện!) Trong khi giai đoạn thứ hai biến giá trị thành một hình vuông. Giai đoạn thứ ba đảo ngược các bit thay thế trên mỗi hàng trong khi giai đoạn cuối cùng đảo ngược các bit trên các hàng thay thế. Chỉnh sửa: Đã lưu 3 byte nhờ @MartinEnder.


$`1$'chỉ là $_.
Martin Ender

@MartinEnder Ah, tôi không quen $_, cảm ơn!
Neil

3

MATL , 7 byte

:t!+2\~

Hãy thử trực tuyến!

Giải trình:

         % Implicit input (n)
:        % Range from 1-n, [1,2,3]
 t       % Duplicate, [1,2,3], [1,2,3]
  !      % Transpose, [1,2,3], [1;2;3]
   +     % Add        [2,3,4; 3,4,5; 4,5,6]
    2    % Push 2     [2,3,4; 3,4,5; 4,5,6], 2
     \   % Modulus    [0,1,0; 1,0,1; 0,1,0]
      ~  % Negate     [1,0,1; 0,1,0; 1,0,1]

Lưu ý: Tôi đã bắt đầu giải quyết vấn đề này trong MATL sau khi tôi đăng thử thách.


Tương đương và ngắn hơn::&+o~
Luis Mendo

1
Vẫn đang học :-) Tôi sẽ cập nhật vào ngày mai. Tôi cũng thích cách tiếp cận khác của bạn :-)
Stewie Griffin

1
Đây là những gì tôi đã đưa ra, quá. Và này, bạn chỉ sử dụng tập lệnh MATL thuần túy , không Ysử dụng các hướng dẫn đã được sửa đổi phiền phức mà @LuisMendo sử dụng.
Sanchise

@Sanchise Pesky, hả ? :-P
Luis Mendo

3

Brachylog , 15 byte

^₂⟦₁%₂ᵐ;?ḍ₎pᵐ.\

Hãy thử trực tuyến!

Giải trình

Example Input: 4

^₂               Square:                            16
  ⟦₁             1-indexed Range:                   [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
    %₂ᵐ          Map Mod 2:                         [1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0]
       ;?ḍ₎      Input-Chotomize:                   [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]
           pᵐ.   Map permute such that..
             .\  ..the output is its own transpose: [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]

3

Clojure, 36 byte

#(take %(partition % 1(cycle[1 0])))

Yay, công cụ phù hợp cho công việc.


3

05AB1E , 9 7 byte

-2 byte nhờ Emigna

LDÈD_‚è

Hãy thử trực tuyến!

Giải trình

LDÈD_‚sè» Argument n
LD        Push list [1 .. n], duplicate
  ÈD      Map is_uneven, duplicate
    _     Negate boolean (0 -> 1, 1 -> 0)
     ‚    List of top two elements of stack
      è   For each i in [1 .. n], get element at i in above created list
          In 05AB1E the element at index 2 in [0, 1] is 0 again

Bạn có thể cắt đầu ra »dưới dạng danh sách là ổn và bạn cũng có thể loại bỏ s.
Emigna

@Emigna Yep, cảm ơn!
kalsowerus

Giải thích là một chút không liên quan.
Erik the Outgolfer

3

Java (OpenJDK 8) , 80 77 byte

-3 byte nhờ Kevin Cruijssen

j->{String s="1";for(int i=1;i<j*j;s+=i++/j+i%j&1)s+=1>i%j?"\n":"";return s;}

Hãy thử trực tuyến!

Hãy nhìn xem, một câu trả lời java có độ dài bán hợp lý, với rất nhiều toán tử thú vị.

lambda lấy int và trả về String. Hoạt động bằng cách sử dụng số hàng và số cột bằng cách sử dụng / và% để xác định giá trị nào sẽ là, mod 2;

Ung dung:

j->{
    String s="1";
    for(int i=1; i<j*j; s+= i++/j + i%j&1 )
        s+= 1>i%j ? "\n" : "";
    return s;
}

Bạn có thể loại bỏ không gian để lưu một byte. Các thách thức nêu định dạng đầu ra là linh hoạt. Ồ, và bạn có thể lưu thêm hai byte bằng cách thay đổi (i++/j+i%j)%2để i++/j+i%j&1bạn sẽ không cần những dấu ngoặc đơn đó. Điều này làm cho tổng 1 byte ngắn hơn so với giải pháp vòng lặp lồng nhau ( n->{String r="";for(int i=0,j;i++<n;r+="\n")for(j=0;j<n;r+=j+++i&1);return r;}) của tôi, do đó +1 từ tôi. :)
Kevin Cruijssen

@KevinCruijssen Vâng, tôi vẫn đang chờ phản hồi trên không gian. Tôi đã không nghĩ về & có quyền ưu tiên cao hơn% và & 1 ==% 2
PunPun1000

2

Than, 8 byte

UON10¶01

Hãy thử trực tuyến! Giải thích: Điều này tạm dịch là mã verbose sau (không may là deverbosifier hiện đang nối thêm một dấu phân cách không cần thiết):

Oblong(InputNumber(), "10\n01");





2

R , 38 37 byte

n=scan();(matrix(1:n,n,n,T)+1:n-1)%%2

Hãy thử trực tuyến!

-1 byte nhờ Giuseppe

Tận dụng các quy tắc tái chế của R, trước tiên là khi tạo ma trận và thứ hai khi thêm 0: (n-1) vào ma trận đó.


Bạn có thể giảm một byte bằng cách loại bỏ tvà thay vào đó xây dựng ma trận với byrow=T, tức là,(matrix(1:n,n,n,T)+1:n-1)%%2
Giuseppe

1
outer(1:n,1:n-1,"+")%%2ngắn hơn một vài byte :)
JAD

2

Swi-Prolog, 142 byte.

t(0,1).
t(1,0).
r([],_).
r([H|T],H):-t(H,I),r(T,I).
f([],_,_).
f([H|T],N,B):-length(H,N),r(H,B),t(B,D),f(T,N,D).
c(N,C):-length(C,N),f(C,N,1).

Thử trực tuyến - http://swish.swi-prolog.org/p/BuabBPrw.pl

Nó đưa ra một danh sách lồng nhau, vì vậy các quy tắc nói:

  • t() là một chuyển đổi, nó làm cho 0 -> 1 và 1 -> 0.
  • r() thành công cho một hàng riêng lẻ, đó là kiểm tra đệ quy xuống một hàng mà chỉ là một hàng thay thế và số không.
  • f()kiểm tra đệ quy tất cả các hàng, rằng chúng có độ dài phù hợp, chúng là các hàng hợp lệ r()và mỗi hàng bắt đầu bằng 0/1 khác nhau.
  • c(N,C) nói rằng C là một trình kiểm tra hợp lệ có kích thước N nếu số lượng hàng (danh sách lồng nhau) là N và người trợ giúp f thành công.

Các trường hợp thử nghiệm: nhập mô tả hình ảnh ở đây


2

C, 69 67 63 byte

Cảm ơn @Kevin Cruijssen đã lưu hai byte và @ceilingcat để lưu bốn byte!

i,j;f(n){for(i=n;i--;puts(""))for(j=n;j;)printf("%d",j--+i&1);}

Hãy thử trực tuyến!


Bạn có thể loại bỏ không gian trong printf("%d ", vì đó là một phương thức đầu ra hợp lệ khác.
Conor O'Brien

@ ConorO'Brien Vâng, cảm ơn.
Steadybox

Bạn có thể lưu hai byte bằng cách thay đổi (j+++i)%2để j+++i&1loại bỏ những dấu ngoặc đơn.
Kevin Cruijssen

@ceilingcat Cảm ơn!
Steadybox

1

QBIC , 19 byte

[:|?[b|?(a+c+1)%2';

Giải trình

[:|         FOR a = 1 to b (b is read from cmd line)
?           PRINT - linsert a linebreak in the output
[b|         FOR c = 1 to b
?(a+c+1)%2  PRINT a=c=1 modulo 2 (giving us the 1's and 0's
';            PRINT is followed b a literal semi-colon, suppressing newlines and 
              tabs. Printing numbers in QBasic adds one space automatically.






1

/// , 87 byte + đầu vào

/V/\\\///D/VV//*/k#D#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&[unary input in asterisks]

Hãy thử trực tuyến! (đầu vào cho 4)

Đầu vào đơn nhất tính bằng 1s, 95 byte + đầu vào

/V/\\\///D/VV//&1/k#&D&|D/#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&&[unary input in ones]|

Hãy thử trực tuyến! (đầu vào cho 8)

Cái này hoạt động ra sao?

  • VDlà để chơi golf \///tương ứng.

  • /*/k#//&1/k#&//&|//tách đầu vào thành tương đương với'k#'*len(input())

  • /#k//k#//&k/k&//\/k/k\//di chuyển tất cả các ks đến /r/S/khối

  • Ss chỉ được sử dụng để đệm các trường hợp kxuất hiện sau /s để chúng không bị di chuyển đi nơi khác và Ssau đó chúng bị xóa

  • #s sau đó được chuyển thành r\ns

  • Chuỗi ks được biến thành một 1010...chuỗi xen kẽ

  • Các r\ns được biến thành 1010...\ns

  • Mỗi cặp 1010...\n1010\nđược biến thành1010...\01010...;\n

  • Hoặc là 0;hoặc 1;bị cắt bớt (vì 01010...chuỗi quá dài 1)


1

Toán học, 28 byte

Cos[+##/2Pi]^2&~Array~{#,#}&

Hàm thuần túy lấy một số nguyên dương làm đầu vào và trả về một mảng 2D. Sử dụng hàm tuần hoàn cos² (πx / 2) để tạo 1s và 0.

Để vui hơn một chút, làm thế nào về giải pháp 32 byte

Sign@Zeta[1-+##]^2&~Array~{#,#}&

trong đó sử dụng các vị trí của các số không tầm thường của hàm Riemann zeta.

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 cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.