Thử thách nghệ thuật ASCII hexplosive

20

Trong trò chơi chiến lược "Hexplode" , người chơi thay phiên nhau đặt mã thông báo lên bảng lục giác. Khi số lượng mã thông báo bằng với số lượng gạch liền kề, mã lục giác đó và di chuyển tất cả các mã thông báo trên nó sang các hàng xóm xung quanh. Bạn có thể chơi trò chơi trực tuyến tại đây .

Tôi thích trò chơi này, nhưng đôi khi thật khó để biết chính xác có bao nhiêu mã thông báo đi trên một ô cụ thể; Tôi luôn luôn đếm số lượng hàng xóm. Sẽ thực sự thuận tiện nếu tôi có nghệ thuật ASCII để giúp tôi nhớ có bao nhiêu mã thông báo trên mỗi ô.

Bạn cần phải viết một chương trình hoặc chức năng mà phải mất một số nguyên dương như là đầu vào, sản xuất và đại diện ASCII này của lục giác kích thước N . Mỗi ô sẽ là số hàng xóm mà ngói có. Vì 1 là trường hợp góc kỳ lạ với hàng xóm bằng 0, bạn chỉ phải xử lý các đầu vào lớn hơn 1.

Bạn có thể lấy số này ở bất kỳ định dạng hợp lý nào, chẳng hạn như STDIN, đối số hàm, đối số dòng lệnh, từ tệp, v.v. Đầu ra cũng có thể ở bất kỳ định dạng hợp lý nào, chẳng hạn như in sang STDOUT, ghi vào tệp, trả về một danh sách các chuỗi, một chuỗi phân tách dòng mới, v.v.

Dưới đây là một số đầu ra mẫu cho 5 đầu vào đầu tiên:

2)

 3 3
3 6 3
 3 3


3)

  3 4 3
 4 6 6 4
3 6 6 6 3
 4 6 6 4
  3 4 3


4)

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

5)

    3 4 4 4 3
   4 6 6 6 6 4
  4 6 6 6 6 6 4
 4 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 4
  4 6 6 6 6 6 4
   4 6 6 6 6 4
    3 4 4 4 3

6)

     3 4 4 4 4 3
    4 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
 4 6 6 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
    4 6 6 6 6 6 4
     3 4 4 4 4 3

Và mô hình tiếp tục theo cách tương tự. Như thường lệ, các sơ hở tiêu chuẩn được áp dụng và câu trả lời có số byte thấp nhất sẽ được trao cho người chiến thắng!

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

# Perl, 43 + 2 (-p flag) = 45 bytes

Bạn cũng có thể đặt tên ngôn ngữ thành một liên kết mà sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Hiển thị đoạn mã

code-golf  ascii-art  hexagonal-grid 
— DJMcMayhem
nguồn
1
Liên quan (nhưng hỏi về quy trình chứ không phải số lượng hàng xóm).
— trichoplax
1
Tôi muốn học Hexagony chỉ vì thử thách này. ;)
— Kevin Cruijssen

Câu trả lời:

11

MATL , 39 37 byte

4*3-:!G:+o~YRtP*!tPw4LY)vtI5&lZ+47+*c

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Tôi có thể sử dụng tích chập một lần nữa!

Xem xét đầu vào n = 3. Mã đầu tiên xây dựng một ma trận có kích thước 4*n-3× nbằng cách thêm vectơ cột vào vectơ [1; 2; ...; 9]hàng [1, 2, 3]với phát sóng. Điều này có nghĩa là tính toán một mảng mảng 2D của tất cả các bổ sung theo cặp:

 2  3  4
 3  4  5
 4  5  6
 5  6  7
 6  7  8
 7  8  9
 8  9 10
 9 10 11
10 11 12

Thay thế số chẵn bằng 1và số lẻ bằng cách 0đưa ra mô hình bàn cờ

1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

Điều này sẽ được sử dụng để tạo (một phần) lưới lục giác. Những người sẽ đại diện cho các điểm trong lưới và số không sẽ đại diện cho không gian.

Góc trên bên phải được xóa bằng cách xóa tất cả các mục bên trên "đường chéo" chính của ma trận: 

1 0 0
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

Yếu tố khôn ngoan nhân ma trận này với một phiên bản lật theo chiều dọc của chính nó cũng loại bỏ góc dưới bên phải. Chuyển đổi sau đó cho

1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

Điều này bắt đầu trông giống như một hình lục giác. Sử dụng tính đối xứng, lưới được mở rộng để tạo ra nửa trên:

0 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

Bây giờ chúng ta cần thay thế mỗi mục bằng một số lượng hàng xóm. Đối với điều này, chúng tôi sử dụng tích chập với vùng lân cận 3 × 5 (nghĩa là hạt nhân là ma trận 3 × 5). Kết quả,

2 3 4 5 5 5 4 3 2
4 5 7 7 8 7 7 5 4
4 6 7 8 7 8 7 6 4
4 5 7 7 8 7 7 5 4
2 3 4 5 5 5 4 3 2

có hai vấn đề (sẽ được giải quyết sau):

  1. Các giá trị đã được tính toán cho tất cả các vị trí, trong khi chúng ta chỉ cần chúng ở các vị trí của các vị trí trong lưới zero-one.
  2. Đối với mỗi vị trí đó, số hàng xóm bao gồm chính điểm đó, vì vậy nó bị tắt 1.

Mã bây giờ thêm 47vào mỗi giá trị tính toán. Điều này tương ứng với phép trừ 1để giải quyết vấn đề (2) và thêm 48(ASCII cho '0'), chuyển đổi từng số thành điểm mã của char tương ứng.

Ma trận kết quả sau đó được nhân với một bản sao của lưới zero-one. Điều này giải quyết vấn đề (1) ở trên, làm cho các điểm không phải là một phần của lưới lục giác bằng 0 lần nữa:

 0  0 51  0 52  0 51  0  0
 0 52  0 54  0 54  0 52  0
51  0 54  0 54  0 54  0 51
 0 52  0 54  0 54  0 52  0
 0  0 51  0 52  0 51  0  0

Cuối cùng, mảng số này được chuyển thành một mảng char. Không ký tự được hiển thị dưới dạng không gian, cho kết quả cuối cùng:

  3 4 3  
 4 6 6 4 
3 6 6 6 3
 4 6 6 4 
  3 4 3
— Luis Mendo
nguồn
15

JavaScript (ES6), 118 117 byte

n=>[...Array(m=n+--n)].map((_,i,a)=>a.map((_,j)=>(k=j-(i>n?i-n:n-i))<0?``:k&&++j<m?i/2%n?6:4:3+!i%n).join` `).join`\n`

Trường hợp \nđại diện cho một nhân vật dòng chữ mới. Giải thích: Giả sử n=4. Chúng tôi bắt đầu với hình vuông chữ số phân tách không gian sau đây:

0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0

Các |n-i| 0s đầu tiên bị xóa, nhưng các khoảng trắng vẫn còn:

   0 0 0 0
  0 0 0 0 0
 0 0 0 0 0 0
0 0 0 0 0 0 0
 0 0 0 0 0 0
  0 0 0 0 0
   0 0 0 0

Lục giác tức thì! Sau đó, nó đủ để tính giá trị phù hợp thay cho từng giá trị 0bằng cách kiểm tra xem chúng tôi ở hàng đầu tiên hoặc cuối cùng và / hoặc cột. Chỉnh sửa: Đã lưu 1 byte nhờ @Arnauld.

— Neil
nguồn
Sử dụng một số công thức của bạn, tôi đã đến phiên bản 107 byte với for / console.log ():n=>{for(i=n+--n;i--;)console.log(' '.repeat(l=i>n?i-n:n-i)+(j=3+!l%n)+` ${l-n?6:4}`.repeat(2*n-l-1)+' '+j)}
— Arnauld
@Arnauld Mình thích thế 3+!i%n!
— Neil
7

Python 2, 125 123 byte

def h(n):m=n-1;t=[' '*(m-r)+' '.join(('46'[r>0]*(r+m-1)).join('34'[r%m>0]*2))for r in range(n)];print'\n'.join(t+t[-2::-1])

Các bài kiểm tra là trên ideone

Chạy qua đỉnh đến các hàng giữa for r in range(n), xây dựng các chuỗi:
- tạo hai góc hoặc hai cạnh , '34'[r%m>0]*2;
- điền bằng cách tham gia với chúng lặp đi lặp lại '6'hoặc '4', '46'[r>0]*(r+m-1);
- nối các góc và cạnh với ' ';
- chuẩn bị với không gian , ' '*(m-r);

Sau đó in nó và nó phản chiếu ở hàng giữa được nối bởi các dòng mới, print'\n'.join(t+t[-2::-1])

— Jonathan Allan
nguồn
4

Python 2, 96 byte

n=input();m=n-1
while n+m:n-=1;j=abs(n);c='34'[0<j<m];print' '*j+c+' '+'46  '[j<m::2]*(2*m+~j)+c

Điều này có vẻ khá lộn xộn và hơi golf ...

— Sp3000
nguồn
3

Java, 375 363 361 339 329 317 293 byte

interface J{static void main(String[]r){int i=0,k,h=Integer.decode(r[0]),a=1,l,n=0;for(;i++<h*2-1;n+=a){if(n==h-1)a=-1;String s="";for(k=0;k<n+h;k++,s+=" ")s+=n==0?k==0||k==n+h-1?3:4:k!=0&&k!=n+h-1?6:n==h-1?3:4;l=(h*4-3-s.trim().length())/2;System.out.printf((l==0?"%":"%"+l)+"s%s\n","",s);}}}

Ung dung

interface J {
    static void main(String[] r) {
        int i = 0, k, h = Integer.decode(r[0]), a = 1, l, n = 0;
        for (; i++ < h * 2 - 1; n += a) {
            if (n == h - 1) {
                a = -1;
            }
            String s = "";
            for (k = 0; k < n + h; k++, s += " ") {
                s += n == 0 ? k == 0 || k == n + h - 1 ? 3 : 4 : k != 0 && k != n + h - 1 ? 6 : n == h - 1 ? 3 : 4;
            }
            l = (h * 4 - 3 - s.trim().length()) / 2;
            System.out.printf((l == 0 ? "%" : "%" + l) + "s%s\n", "", s);
        }
    }
}

Cách sử dụng :

$ java J 5
    3 4 4 4 3     
   4 6 6 6 6 4    
  4 6 6 6 6 6 4   
 4 6 6 6 6 6 6 4  
3 6 6 6 6 6 6 6 3 
 4 6 6 6 6 6 6 4  
  4 6 6 6 6 6 4   
   4 6 6 6 6 4    
    3 4 4 4 3

Tôi chắc chắn rằng khối if-other lồng nhau khủng khiếp có thể được viết lại thành nhỏ hơn nhưng tôi không thể tìm ra nó vào lúc này. Mọi góp ý đều được chào đón :-)

Cập nhật

  • Thực hiện theo đề xuất của Kevin Cruijssen và giải mã được sử dụng thay vì parseInt.
  • Viết lại một số if bằng cách sử dụng toán tử ternary.
  • Nhiều nhà khai thác ternary.
  • Moar khai thác ternary! Tôi nghĩ rằng tôi đã tạo ra một con quái vật!
  • Viết lại khối if-other về việc in.
— Master_ex
nguồn
1
Tôi đã không xem xét kỹ phương pháp mà bạn sử dụng, nhưng một số mẹo chơi gôn nhỏ cho mã hiện tại của bạn: Integer.parseIntcó thể được chơi theo Integer.decode. l=(h*4-3-s.trim().length())/2;if(l==0)có thể được golfed tới if((l=(h*4-3-s.trim().length())/2)==0). Ngoài ra, hoàn toàn chấp nhận được khi chỉ đăng một phương thức không có lớp (trừ khi có câu hỏi khác), vì vậy void f(int i){...use i...}thay vào đó interface J{static void main(String[]r){...i=Integer.decode(r[0])...use i...}, điều đó sẽ giúp bạn tiết kiệm khá nhiều byte. Khi tôi có nhiều thời gian hơn tôi sẽ nhìn xa hơn.
— Kevin Cruijssen
@KevinCruijssen: Cảm ơn bạn đã góp ý. l=(h*4-3-s.trim().length())/2;if(l==0)thực sự là cùng chiều dài với if((l=(h*4-3-s.trim().length())/2)==0).
— Master_ex
2

05AB1E , 44 byte

FN_i4ë6}ð«¹ÍN+×ðìN_N¹<Q~i3ë4}.ø¹<N-ð×ì})¦«»

Giải trình

Vì đỉnh và đáy của hình lục giác được nhân đôi, chúng ta chỉ cần tạo phần trên.
Vì vậy, đối với đầu vào của X, chúng ta cần tạo các hàng X. Đó là những gì vòng lặp chính làm.

F                                        }

Sau đó, chúng tôi làm phần trung tâm của các hàng.
Đây là 4 cho hàng đầu tiên và 6 cho phần còn lại (vì chúng tôi chỉ làm phần trên).
Chúng tôi ghép số này với một khoảng trắng vì mẫu sẽ yêu cầu khoảng cách giữa các số.

N_i4ë6}ð«

Sau đó, chúng tôi lặp lại chuỗi X-2 + N lần này, trong đó N là hàng hiện tại được lập chỉ mục 0 và thêm một ký tự khoảng trắng ở phía bên trái.

¹ÍN+×ðì

Sau đó là thời gian cho các góc. Chúng sẽ là 3 cho hàng đầu tiên và cuối cùng và 4 cho hàng giữa.

N_N¹<Q~i3ë4}.ø

Bây giờ chúng ta cần đảm bảo các hàng được xếp chính xác bằng cách thêm khoảng trắng vào phía trước mỗi hàng. Số lượng không gian được thêm vào sẽ là X-1-N .

¹<N-ð×ì

Bây giờ chúng ta đã hoàn thành phần trên của lưới, chúng ta thêm các hàng vào danh sách, tạo một bản sao đảo ngược và xóa mục đầu tiên khỏi bản sao đó (vì chúng ta chỉ cần hàng trung tâm một lần), sau đó hợp nhất 2 danh sách này lại với nhau và in.

)¦«»

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

Giải pháp bổ sung, cũng 44 byte:

ÍÅ10.øvN_i4ë6}ð«¹ÍN+×ðìyi4ë3}.ø¹<N-ð×ì})¦«»
— Biểu tượng
nguồn
2

Ruby, 87 byte

Hàm ẩn danh lấy n làm đối số và trả về một chuỗi các chuỗi.

->n{(1-n..n-=1).map{|i|j=i.abs
" "*j+(e=j%n>0?"4 ":"3 ")+["6 ","4 "][j/n]*(2*n-1-j)+e}}

Ungolfed trong chương trình thử nghiệm

Nhập thông qua stdin. Viết toàn bộ hình dạng để stdout. Khá tự giải thích.

f=->n{
  (1-n..n-=1).map{|i|            #reduce n by 1 and iterate i from -n to n
    j=i.abs;                     #absolute magnitude of i
    " "*j+                       #j spaces +
    (e=j%n>0?"4 ":"3 ")+         #start the string with 3 or 4 +
    ["6 ","4 "][j/n]*(2*n-1-j)+  #2*n-1-j 6's or 4`s as appropriate +
    e                            #end the string with another 3 or 4
  }
}

puts f[gets.to_i]
— Cấp sông St
nguồn
1

V , 60 byte

Àé x@aA4 xr3^.òhYpXa 6^òkyHç^/:m0
Pç 3.*6/^r4$.
òÍ6 4./6

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

Đây thực sự là cách quá dài. Đây là một hexdump, vì cái này chứa các ký tự không thể in được:

0000000: c0e9 2078 4061 4134 201b 7872 335e 2ef2  .. x@aA4 .xr3^..
0000010: 6859 7058 6120 361b 5ef2 6b79 48e7 5e2f  hYpXa 6.^.kyH.^/
0000020: 3a6d 300a 50e7 2033 2e2a 362f 5e72 3424  :m0.P. 3.*6/^r4$
0000030: 2e0a f2cd 3620 9334 852e 2f36            ....6 .4../6
— DJMcMayhem
nguồn
1

Vợt, 487 byte

(λ(n c e o)(let((sp(append(range(- n 1)-1 -1)(reverse(range(- n 1)0 -1))))
(mm(append(range(- n 2)(-(+ n(- n 1))2))(range(-(+ n(- n 1))2)(-(- n 1)2)-1)))
(r""))(for((i sp)(j mm))(define str"")(for((ss i))(set! str(string-append str" ")))
(set! str(string-append str(if(or(= i 0)(= i(- n 1))(= i(* 2(- n 1))))c e)" "))
(for((jj j))(set! str(string-append str(if(= j(- n 2))e o)" ")))(set! r(if(or(= i 0)
(= i(- n 1))(= i(* 2(- n 1))))c e))(set! str(string-append str r))(displayln str))))

Kiểm tra: 

(f 4 "3" "4" "6") 

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

(f 5 "o" "*" "-") 

    o * * * o
   * - - - - *
  * - - - - - *
 * - - - - - - *
o - - - - - - - o
 * - - - - - - *
  * - - - - - *
   * - - - - *
    o * * * o

Phiên bản chi tiết: 

(define(f1 n c e o)
  (let ((sp(append(range(sub1 n) -1 -1)
                  (reverse(range(sub1 n) 0 -1))))
        (mm(append(range(- n 2)(-(+ n(sub1 n)) 2))
                  (range(-(+ n(sub1 n)) 2)(-(sub1 n)2) -1) ))
        (r ""))
    (for((i sp)(j mm))
      (define str "")
      (for((ss i))(set! str(string-append str " ")))
      (set! str(string-append str
                              (if(or(= i 0)(= i(sub1 n))
                                    (= i(* 2(sub1 n)))) c e)
                              " "))
      (for((jj j))
        (set! str(string-append str
                                (if(= j(- n 2)) e o)
                                " ")))
      (set! r(if(or(= i 0)
                   (= i(sub1 n))
                   (= i(* 2(sub1 n)))) c e))
      (set! str(string-append str r))
      (displayln str))))
— rnso
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.