Nghệ thuật bát giác ASCII

22

Cho một số nguyên đầu vào n > 1, xuất ra một hình bát giác nghệ thuật ASCII với độ dài cạnh bao gồm các nký tự. Xem ví dụ dưới đây:

n=2
 ##
#  #
#  #
 ##

n=3
  ###
 #   #
#     #
#     #
#     #
 #   #
  ###

n=4
   ####
  #    #
 #      #
#        #
#        #
#        #
#        #
 #      #
  #    #
   ####

n=5
    #####
   #     #
  #       #
 #         #
#           #
#           #
#           #
#           #
#           #
 #         #
  #       #
   #     #
    #####

and so on.

Bạn có thể in nó sang STDOUT hoặc trả lại dưới dạng kết quả chức năng.

Bất kỳ số lượng khoảng trắng ngoại lai nào cũng được chấp nhận, miễn là các ký tự xếp hàng một cách thích hợp.

Quy tắc và I / O

  • Đầu vào và đầu ra có thể được đưa ra bởi bất kỳ phương pháp thuận tiện .
  • Bạn có thể sử dụng bất kỳ ký tự ASCII có thể in nào thay vì #(trừ khoảng trắng), nhưng ký tự "nền" phải là khoảng trắng (ASCII 32).
  • Một chương trình đầy đủ hoặc một chức năng được chấp nhận.
  • Sơ hở tiêu chuẩn bị cấm.
  • Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.
code-golf  ascii-art  code-golf  geometry  code-golf  balanced-string  code-golf  cops-and-robbers  code-challenge  cops-and-robbers  code-golf  code-golf  random  cryptography  code-golf  array-manipulation  number  code-challenge  integer  code-golf  math  integer  code-golf  math  math  parsing  image-processing  test-battery  math  number  combinatorics  fastest-code  code-golf  code-golf  math  number-theory  rational-numbers  polynomials  code-golf  math  geometry  code-golf  code-golf  number-theory  primes  factoring  code-golf  restricted-source  code-golf  string  decision-problem  counting  code-golf  math  sequence  fibonacci  code-golf  array-manipulation  counting  code-golf  array-manipulation  number-theory  code-golf  array-manipulation  code-golf  random  code-golf  string  hexadecimal  code-golf  string  code-challenge  sorting  code-golf  number  floating-point  code-golf  sorting  code-golf  decision-problem  fibonacci  code-golf  number  combinatorics  code-golf  string  code-golf  math  code-golf  electrical-engineering  code-golf  javascript  code-golf  base-conversion  code-golf  array-manipulation  matrix  binary-matrix  code-golf  kolmogorov-complexity  python  perl  ruby  code-golf  number  code-golf  optimization  integer-partitions  code-golf  string  code-golf  ascii-art 
— AdBorkBork
nguồn
1
Chúng ta có thể sử dụng các ký tự đầu ra khác nhau, hoặc nó cần phải nhất quán?
— Emigna
@Emigna Nhân vật khác nhau là tốt.
— admBorkBork
1
— Charlie

Câu trả lời:

22

05AB1E , 3 byte

7ÝΛ

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

Giải trình

      # implicit input as length
      # implicit input as string to print
7Ý    # range [0...7] as directions
  Λ   # canvas print

Xem câu trả lời này để hiểu canvas 05AB1E.

— Biểu tượng
nguồn
Chắc chắn đây phải là 5 byte? Hoặc các thử thách chơi gôn mã xem các byte và ký tự có thể hoán đổi cho nhau
— Doug
3
@Doug: Đó là 3 byte trong trang mã của
— 05ab1e
Ồ tuyệt! Cảm ơn các liên kết tài liệu!
— Doug
> :( chết tiệt, adnan
— ASCII chỉ
11

JavaScript (ES6), 114 106 105 104 103 byte

n=>(g=x=>v=x*2>w?w-x:x,F=x=>~y?`# 
`[~x?(h=g(x--))*g(y)>0&h+v!=n|n>h+v:(y--,x=w,2)]+F(x):'')(y=w=--n*3)

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

Làm sao?

Điều này xây dựng các nhân vật đầu ra theo nhân vật.

Cho đầu vào n , chúng tôi tính toán:

n′=n−1w=3n′

Đối với mỗi ký tự tại (x,y) , chúng tôi tính (h,v) :

h=w/2−|x−w/2|v=w/2−|y−w/2|

Các ô thuộc hình bát giác thỏa mãn một trong các điều kiện sau:

  • ( h=0 HOẶC v=0 ) VÀ h+v≥n′ (màu đỏ bên dưới)
  • h+v=n′ (màu cam bên dưới)

Ví dụ, với n=4 (và n′=3 ):

(0,0)(1,0)(2,0)(3,0)(4,0)(4,0)(3,0)(2,0)(1,0)(0,0)(0,1)(1,1)(2,1)(3,1)(4,1)(4,1)(3,1)(2,1)(1,1)(0,1)(0,2)(1,2)(2,2)(3,2)(4,2)(4,2)(3,2)(2,2)(1,2)(0,2)(0,3)(1,3)(2,3)(3,3)(4,3)(4,3)(3,3)(2,3)(1,3)(0,3)(0,4)(1,4)(2,4)(3,4)(4,4)(4,4)(3,4)(2,4)(1,4)(0,4)(0,4)(1,4)(2,4)(3,4)(4,4)(4,4)(3,4)(2,4)(1,4)(0,4)(0,3)(1,3)(2,3)(3,3)(4,3)(4,3)(3,3)(2,3)(1,3)(0,3)(0,2)(1,2)(2,2)(3,2)(4,2)(4,2)(3,2)(2,2)(1,2)(0,2)(0,1)(1,1)(2,1)(3,1)(4,1)(4,1)(3,1)(2,1)(1,1)(0,1)(0,0)(1,0)(2,0)(3,0)(4,0)(4,0)(3,0)(2,0)(1,0)(0,0)

— Arnauld
nguồn
Wow, điều này thật tuyệt vời! Tôi nghĩ có thể được đơn giản hóa để h + v > n ' , mặc dù tôi không chắc chắn nếu điều đó giúp logic chơi golf ở tất cả. h+v≥n'h+v>n'
— Giuseppe
@Giuseppe Nó thực sự có thể được đơn giản hóa theo cách đó nếu cả hai điều kiện đã được thử nghiệm. Nhưng trong các mã, các trường hợp và h v ≠ 0 được tách ra. Tuy nhiên, tôi thực sự kiểm tra tình trạng ngược lại ( n ' > h + v ), mà đã là 1 byte ngắn hơn. hv= =0hv≠0n′>h+v
— Arnauld
@Giuseppe Nhận xét của bạn đã nhắc tôi xem xét kỹ hơn về công thức và cuối cùng tôi đã lưu một byte bằng cách viết nó một chút khác nhau. :)
— Arnauld
1
heh, nhận xét của bạn về đã thôi thúc tôi nhìn vào cổng logic của tôi và lưu một vài byte khác! hv= =0
— Giuseppe
8

Than , 5 byte

ＧＨ*Ｎ#

Câu trả lời đầu tiên của tôi với Than!

Giải trình:

ＧＨ*Ｎ#      //Full program
ＧＨ          //Draw a hollow polygon
   *         //with 8 sides
    Ｎ       //of side length from input
      #      //using '#' character

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

— Cowabunghole
nguồn
3
Đối với những người thích Charbose Char than, đó là PolygonHollow(:*, InputNumber(), "#");.
— Neil
5

Canvas , 15 14 12 byte

／⁸⇵╷+×＋：⤢ｎ╬┼

Hãy thử nó ở đây!

Giải trình:

/             a diagonal of length n
 ⁸            the input,
  ⇵           ceiling divided by 2, (storing the remainder)
   ╷          minus one
    #×        repeat "#" that many times
      +       append that to the diagonal
       :⤢n    overlap that with its transpose
          ╬┼  quad-palindromize with the overlap being the remainder stored earlier

Thay thế 12-byter .

— dzaima
nguồn
4

R , 122 117 115 byte

function(n){n=n-1
m=matrix(0,y<-3*n+1,y)
v=t(h<-(w=3*n/2)-abs(row(m)-1-w))
m[h*v&h+v-n|h+v<n]=' '
write(m,1,y,,"")}

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

Chuyển logic từ câu trả lời của Arnauld , cụ thể là sửa đổi này trong trường hợp có những cải tiến hơn nữa. Thêm 2 byte được lưu nhờ vào gợi ý đảo ngược logic của Arnauld!

— Giuseppe
nguồn
-2 byte bằng cách thực hiện theo cách khác (Tôi không thể thực hiện h*v&h+v-ntrong JS vì &là toán tử bit, nhưng nó là logic logic trong R, vì vậy nó hoạt động).
— Arnauld
@Arnauld cảm ơn!
— Giuseppe
3

Powershell, 91 byte

param($n)($s=' '*--$n+'#'*$n+'#')
--$n..0+,0*$n+0..$n|%{' '*$_+"#$(' '*(3*$n-2*$_+2))#"}
$s
— mê mẩn
nguồn
2

PowerShell , 107 97 byte

param($n)($z=$n-1)..1+,0*$n+1..$z|%{" "*$_+"#"+($x=" "*($z-$_))+(" ","#")[!($_-$z)]*($n-2)+"$x#"}

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

Nếu có một cách rẻ tiền để đảo ngược nửa đầu, câu trả lời này sẽ cảm thấy tốt hơn rất nhiều. Nó xây dựng một nửa bên trái, sau đó là lõi (là x #'shoặc dấu cách), sau đó phản chiếu logic của bên trái để tạo bên phải. Thực tế thú vị, bạn không cần phải sao chép trên không gian trắng.

Không được kiểm soát và giải thích:

param($n)
($z=$n-1)..1 + ,0*$n + 1..$z |%{  #Range that repeats 0 n times in the middle
" "*$_ + "#" +($x=" "*($z-$_)) +  #Left side
(" ","#")[!($_-$z)]*($n-2) +      #Core that swaps when it's the first or last row
"$x#"}                            #Right side which is left but backwards
— Veskah
nguồn
2

C (tiếng kêu) , -DP=printf( -DF=for(i + 179 = 199 180 byte

i;*m="%*s%*s\n";g(n){P"%*s",n,H;F;--i;)P H;P"\n");}f(n){g(n);F;--i;)P m,i,(H,3*n-i+~i,H;F-2;i--;)P"#%*s\n",3*n-3,H;F;--i;)P m,n-i,(H,n+i+i-1,H;g(n);}

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

Ung dung: 

f(n){
	int i;
	printf("%*d",n,0);
	for(i=0;i<n-1;i++){
		printf("0");
	}
	printf("\n");
	for(i=1;i<n;i++){
		printf("%*d%*d\n",n-i,0,n+i+i-1,0);
	}
	for(i=0;i<n-2;i++){
		printf("0%*d\n",n+n+n-3,0);
	}
	for(i=n-1;i>0;i--){
		printf("%*d%*d\n",n-i,0,n+i+i-1,0);
	}
	printf("%*d",n,0);
	for(i=0;i<n-1;i++){
		printf("0");
	}
}

-19 byte nhờ @ceilingcat

— Hậu cần
nguồn
— trần mèo
1

Python 2 , 130 byte

def f(n):
 a=[' '*~-n+n*'#']
 b=[' '*(n-i-2)+'#'+' '*(n+2*i) +'#'for i in range(n-2)]
 return a+b+['#%*s'%(3*n-3,'#')]*n+b[::-1]+a

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

Trên di động, vì vậy không phải là vô cùng golf.

— TFeld
nguồn
Bạn có thể loại bỏ không gian sau (n+2*i).
— Zacharý
1

Hàng loạt, 260 byte

@echo off
set s=
for /l %%i in (1,1,%1)do call set s= %%s%%
echo %s% %s: =#%
call:c %1,-1,3
for /l %%i in (1,1,%1)do echo   #%s:~2%%s%%s:~2%#
call:c 3,1,%1
echo %s% %s: =#%
exit/b
:c
for /l %%i in (%*)do call echo %%s:~,%%i%%#%%s:~%%i%%%s%%%s:~%%i%%#

Xuất ra hai không gian hàng đầu trên mỗi dòng. Giải thích: Batch không có toán tử lặp chuỗi, khả năng cắt chuỗi hạn chế và yêu cầu các câu lệnh riêng biệt để thực hiện số học. Do đó, nó là tốt nhất để tạo ra một chuỗi có độ dài đầu vào trong khoảng trắng (Batch ít nhất có thể dịch chúng thành #s cho các dòng trên cùng và dưới cùng) và sau đó cắt từ hoặc đến một vị trí cụ thể từ 3 đến chiều dài để tạo các đường chéo (đây là những gì dòng cuối cùng của kịch bản đạt được).

— Neil
nguồn
1

Ruby , 96 byte

->n{[*(n-=2).step(z=n*3+2,2),*[z]*n,*z.step(n,-2)].map{|x|([?#]*2*('# '[x<=>n]*x)).center(z+2)}}

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

Chưa chơi golf lắm. Có thể chơi golf nếu tôi tìm thấy thời gian.

— GB
nguồn
1

Màu đỏ , 171 byte

func[n][c:(a: n - 1)* 2 + n
b: collect[loop c[keep pad/left copy"^/"c + 1]]s: 1x1 s/1: n
foreach i[1x0 1 0x1 -1x1 -1x0 -1 0x-1 1x-1][loop a[b/(s/2)/(s/1): #"#"s: s + i]]b]

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

Giải trình:

Red[]
f: func [ n ] [
    a: n - 1                                         ; size - 1
    c: a * 2 + n                                     ; total size of widht / height 
    b: collect [                                     ; create a block
        loop c [                                     ; composed of size - 1 rows
            keep pad/left copy "^/" c + 1            ; of empty lines of size c (and a newline)
        ]
    ]
    s: a * 1x0 + 1                                   ; starting coordinate
    foreach i [ 1x0 1 0x1 -1x1 -1x0 -1 0x-1 1x-1 ] [ ; for each offset for the 8 directions
        loop a [                                     ; repeat n - 1 times  
            b/(s/2)/(s/1): #"#"                      ; set the array at current coordinate to "#"
            s: s + i                                 ; next coordinate
        ]        
    ]
    b                                                ; return the block 
]
— Galen Ivanov
nguồn
1

APL (Dyalog Unicode) , 46 byte SBCS

(' '@~5 6∊⍨1⊥⊢∘,)⌺3 3⊢<(⍉⌽⌊⊢)⍣2∘(∘.+⍨∘⍳¯2+3×⊢)

Giải pháp này được cung cấp bởi Adám - cảm ơn!

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

Giải pháp ban đầu của tôi (gần như):

APL (Dyalog Unicode) , 61 byte SBCS

(((⊃∘' #'¨1+5∘=+6∘=)⊢)1⊥⊢∘,)⌺3 3⊢<(((⊖⌊⊢)⌽⌊⊢)(∘.+⍨(⍳¯2+3×⊢)))

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

Cảm ơn Adám đã giúp đỡ!

Ý tưởng là tìm "viên kim cương" nằm một phần trong hình vuông và áp dụng bộ lọc phát hiện cạnh để "phác thảo" octagone.

— Galen Ivanov
nguồn
1
— Adám
1
Bạn thực sự không thể sử dụng Classic ở đây vì ⌺. Thay vì đếm 1 byte / char bằng cách tham khảo SBCS theo Meta .
— Adám
@ Adám Cảm ơn! Tôi không biết cách chỉnh sửa tiêu đề, bạn có thể làm điều đó cho tôi không?
— Galen Ivanov
Bạn có ý nghĩa gì khi chỉnh sửa tiêu đề?
— Adám
1
Chỉnh sửa và sao chép từ đây .
— Adám
1

Perl 5, 201 197 188 187 186 byte:

$a=<>;$b=3*$a-4;$c='$"x($e-$_)."#".$"x$f."#\n"';$e=($b-$a)/2+1;$d=$"x$e."#"x$a.$/;$f=$a;print$d,(map{(eval$c,$f+=2)[0]}1..$a-2),("#".$"x$b."#\n")x$a,(map{$f-=2;eval$c}reverse 1..$a-2),$d

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

Đọc kích thước của hình bát giác từ dòng đầu tiên của STDIN.

— Nô-ê
nguồn
Chào mừng đến với PPCG! Bạn có thể có thể loại bỏ một vài byte ở đây và ở đó bằng cách sử dụng các thủ thuật được tìm thấy trong bài viết này .
— Mego
@Mego Yep. Tôi đã có thể lưu 4 byte bằng cách sử dụng $"thay vì " ".
— Nathan Mills
1

Perl 5, 176 byte

$f=$a=<>;$b=3*$a-4;$c='$"x($e-$_)."#".$"x$f."#\n"';$e=$a-1;$d=$"x$e."#"x$a.$/;print$d,(map{(eval$c,$f+=2)[0]}1..$a-2),("#".$"x$b."#\n")x$a,(map{$f-=2;eval$c}reverse 1..$a-2),$d

Dựa trên câu trả lời của Nathan Mills ở trên (mà tôi không đủ đại diện để bình luận!).

$ecó thể được đơn giản hóa để $a-1tiết kiệm 6 byte; $fcó thể được phân công chuỗi; tiết kiệm hai byte; Không chắc hai người kia đến từ đâu!

Mặc dù $ecó thể được thay thế bằng $a-1hai vị trí xảy ra, dấu ngoặc phụ cần thiết có nghĩa là điều này chỉ hòa vốn.

Ung dung:

$f = $a = <>;
$b = 3 * $a - 4;
$c = '$"x($e-$_)."#".$"x$f."#\n"';
$e = $a - 1;
$d = $" x $e . "#" x $a . $/;
print $d, ( map { ( eval $c, $f += 2 )[0] } 1 .. $a - 2 ),
  ( "#" . $" x $b . "#\n" ) x $a,
  ( map { $f -= 2; eval $c } reverse 1 .. $a - 2 ), $d
— Nông trại giàu
nguồn
0

Python 3 , 224 byte

n=int(input())
z=" "*(n-1)+"#"*n+" "*(n-1)
print(z)
for i in range(n-2):print(" "*(n-i-2)+"#"+" "*(i*2+n)+"#")
print((("#"+" "*(n*3-4)+"#\n")*n)[:-1])
for i in range(n-3,-1,-1):print(" "*(n-i-2)+"#"+" "*(i*2+n)+"#")
print(z)

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

— glietz
nguồn
0

Perl 5, 170 168 166 byte

$a=<>-1;$\="#\n";print$x=$_=$"x$a."#"x$a;if(s/^( *)  #*/$1 #  $1 /){print}while (s/ #/#  /){print}$z=$_;for(1..$a){print$_=$z}while(s/#  (\s{$a})/ #$1/){print}print$x

Điều này hoạt động bởi sự kỳ diệu của regex. "Nếu" chỉ cần thiết để xử lý trường hợp bệnh lý của n = 2, nếu không thì xuất ra một cái gì đó như:

 ##
 ##
#  #
 ##

có lẽ điều này có thể được mã hóa đi.

Tôi nghĩ rằng có thể có nhiều hơn nữa để đạt được bằng cách tạo ra một chuỗi lên đến điểm giữa sau đó đảo ngược nó. Tất nhiên sau đó chúng ta cần chèn / xóa một khoảng trắng thừa nếu n là số lẻ (hoặc sử dụng khoảng trắng: p).

Bị đánh cắp

$a = <> -1;                          # Subtracting one is very useful! 
$\ = "#\n";                          # Every line ends with a '#' let perl provide.  
$x=$_ = " " x $a. "#" x $a;          # The horiz line (one short)  
print;                               # print it plus the extra #
if(s/^( *)  #*/$1 #  $1 /){print}    # create a hole and remove a leading space(if n=2 this fails)
while (s/ #/#  /){                   # make the hole bigger      
    print;                           # and print (with a trailing #)
}
$z=$_;                               # store $_ for later use
for (1 .. $a) {                      # nice that we don't have to do 2..$a but not golf-nice  
  $_ =$z;                            # restore $_ (we could use $z but since we have
  print;                             # to restore somewhere, doing  it here saves us bytes)
}
while (s/#  (\s{$a})/ #$1/){         # now move the # to the right and reduce the trailing spaces  
  print;
}
print $x;                            # and finish...

Tôi nghĩ rằng điều này có thể có thể được chơi golf nhiều hơn một chút, ngoài những thay đổi đáng kể như đẩy lên $@ và in nó vào cuối.

[Không gian chơi gôn xung quanh ..và di chuyển bản in trước khi gán trong hai trường hợp, tiết kiệm dấu chấm phẩy.]

— Nông trại giàu
nguồn
đã lưu 20 byte sắp xếp lại một số hướng dẫn TIO , tại sao \svà không chỉ là khoảng
— trắng
0

Perl 5, 98 byte

$_=2x$_.1x$_.$/;s/2//;s/.$/ #/,y/1/ /while$a.=$_,$b=$_.$b,s/2[#1]/# /;$_=$a.$_ x("@F"-2).$b;y/2/ /

TIO

— Nahuel Fouilleul
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.