ASCII Art Octagons

22

Biorąc pod uwagę liczbę całkowitą wejściową n > 1, wyślij ośmiokąt artystyczny ASCII o długości boku złożonej ze nznaków. Zobacz przykłady poniżej:

n=2
 ##
#  #
#  #
 ##

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

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

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

and so on.

Możesz wydrukować go do STDOUT lub zwrócić jako wynik funkcji.

Dopuszczalna jest dowolna ilość obcych białych znaków, o ile znaki są odpowiednio ustawione w jednej linii.

Reguły i I / O

  • Dane wejściowe i wyjściowe można podać dowolną dogodną metodą .
  • Możesz użyć dowolnego drukowalnego znaku ASCII zamiast #(oprócz spacji), ale znak „tła” musi być spacją (ASCII 32).
  • Dopuszczalny jest pełny program lub funkcja.
  • Standardowe luki są zabronione.
  • To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).
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 
— AdmBorkBork
źródło
1
Czy możemy używać różnych znaków wyjściowych, czy też musi być spójny?
— Emigna,
@Emigna Różne znaki są w porządku.
— AdmBorkBork
1
— Charlie,

Odpowiedzi:

22

05AB1E , 3 bajty

7ÝΛ

Wypróbuj online!

Wyjaśnienie

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

Zobacz tę odpowiedź, aby zrozumieć płótno 05AB1E.

— Emigna
źródło
Z pewnością powinno to być 5 bajtów? Albo czy wyzwania golfowego kodu postrzegają bajty i znaki jako wymienne
— Doug
3
@Doug: Jest 3 bajtów na stronie kodowej
— 05ab1e
Fajnie! Dzięki za link do dokumentacji!
— Doug
> :( cholera, adnan
— tylko ASCII
11

JavaScript (ES6), 114 106 105 104 103 bajtów

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)

Wypróbuj online!

W jaki sposób?

To buduje znak wyjściowy po znaku.

Biorąc pod uwagę wejście n , obliczamy:

n′=n−1w=3n′

Dla każdego znaku w (x,y) obliczamy (h,v) :

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

Komórki należące do ośmiokąta spełniają jeden z następujących warunków:

  • ( h=0 LUB v=0 ) AND h+v≥n′ (na czerwono poniżej)
  • h+v=n′ (na pomarańczowo poniżej)

Na przykład n=4 (i 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
źródło
Wow, to jest niesamowite! Myślę, że można uprościć do h + v > n ′ , chociaż nie jestem pewien, czy to w ogóle pomaga logice gry w golfa. h+v≥n′h+v>n′
— Giuseppe,
@Giuseppe Rzeczywiście można by to uprościć, gdyby przetestowano oba warunki. Ale w kodzie przypadki i h v ≠ 0 są rozdzielone. Jednak faktycznie testuję przeciwny warunek ( n ′ > h + v ), który jest już o 1 bajt krótszy. hv=0hv≠0n′>h+v
— Arnauld,
@Giuseppe Twój komentarz skłonił mnie do bliższego przyjrzenia się formule i ostatecznie zapisałem bajt, pisząc go nieco inaczej. :)
— Arnauld,
1
heh, cóż, twój komentarz na temat skłonił mnie do przejrzenia mojego portu twojej logiki i zapisania kolejnych kilku bajtów! hv=0
— Giuseppe,
8

Węgiel drzewny , 5 bajtów

ＧＨ*Ｎ#

Moja pierwsza odpowiedź z węglem drzewnym!

Wyjaśnienie:

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

Wypróbuj online!

— Cowabunghole
źródło
3
Dla tych, którzy preferują pełny węgiel drzewny, to jest to PolygonHollow(:*, InputNumber(), "#");.
— Neil,
5

Płótno , 15 14 12 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie:

/             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

Alternatywnie 12-bajtowy .

— dzaima
źródło
4

R , 122 117 115 bajtów

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,,"")}

Wypróbuj online!

Przenosi logikę z odpowiedzi Arnaulda , szczególnie tej wersji na wypadek, gdyby pojawiły się dalsze ulepszenia. Kolejne 2 bajty zaoszczędzone dzięki sugestii Arnaulda o odwróceniu logiki!

— Giuseppe
źródło
-2 bajty , robiąc to na odwrót (nie mogę tego zrobić h*v&h+v-nw JS, ponieważ &jest operatorem bitowym; ale jest to logiczne w R, więc to działa).
— Arnauld
@Arnauld dzięki!
— Giuseppe,
3

PowerShell, 91 bajtów

param($n)($s=' '*--$n+'#'*$n+'#')
--$n..0+,0*$n+0..$n|%{' '*$_+"#$(' '*(3*$n-2*$_+2))#"}
$s
— mazzy
źródło
2

PowerShell , 107 97 bajtów

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

Wypróbuj online!

Gdyby istniał tani sposób na odwrócenie pierwszej połowy, ta odpowiedź byłaby o wiele lepsza. Tworzy lewą połowę, a następnie rdzeń (czyli x #'slub spacje), a następnie odzwierciedla logikę lewicy, aby zrobić prawą. Ciekawostka, że ​​nie musisz kopiować po białych znakach.

Rozwinięto i wyjaśniono:

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
źródło
2

C (brzęk) , -DP=printf( -DF=for(i + 179 = 199 180 bajtów

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

Wypróbuj online!

Nie golfowany: 

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 bajtów dzięki @ceilingcat

— Logern
źródło
— pułapkat
1

Python 2 , 130 bajtów

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

Wypróbuj online!

Na telefon komórkowy, więc nie niesamowicie golfowy.

— TFeld
źródło
Możesz usunąć spację później (n+2*i).
— Zacharý
1

Partia, 260 bajtów

@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%%#

Wyprowadza dwie spacje wiodące w każdej linii. Objaśnienie: Partia nie ma operatora powtarzania łańcuchów, ma ograniczone możliwości krojenia ciągów i wymaga osobnych instrukcji do wykonania arytmetyki. Dlatego najbardziej golfowym było utworzenie ciągu długości wejściowej w spacjach (Batch może przynajmniej przełożyć je na #s dla linii górnej i dolnej), a następnie pokroić z lub do określonej pozycji w zakresie od 3 do długości, aby wygenerować przekątne (właśnie to osiąga ostatni wiersz skryptu).

— Neil
źródło
1

Rubinowy , 96 bajtów

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

Wypróbuj online!

Jeszcze nie bardzo golfa. Może golf, jeśli znajdę czas.

— GB
źródło
1

Czerwony , 171 bajtów

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]

Wypróbuj online!

Wyjaśnienie:

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 Iwanow
źródło
1

APL (Dyalog Unicode) , 46 bajtów SBCS

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

To rozwiązanie zostało dostarczone przez Adám - dzięki!

Wypróbuj online!

Moje (prawie) oryginalne rozwiązanie:

APL (Dyalog Unicode) , 61 bajtów SBCS

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

Wypróbuj online!

Dzięki Adámowi za pomoc!

Chodzi o to, aby znaleźć „diament” leżący częściowo w kwadracie i zastosować filtr wykrywający krawędzie, aby „obrysować” ośmiokąt.

— Galen Iwanow
źródło
1
— Adám,
1
Z tego powodu nie możesz używać Classic ⌺. Zamiast tego policz 1 bajt / znak, odnosząc się do SBCS zgodnie z Meta .
— Adám
@ Adám Thanks! Nie wiem jak edytować nagłówek, możesz to dla mnie zrobić?
— Galen Iwanow
Co rozumiesz przez edycję nagłówka?
— Adám
1
Edytuj i skopiuj stąd .
— Adám
1

Perl 5, 201 197 188 187 186 bajtów:

$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

Wypróbuj online!

Odczytuje rozmiar ośmiokąta z pierwszego wiersza STDIN.

— Nathan Mills
źródło
Witamy w PPCG! Prawdopodobnie możesz zgolić kilka bajtów tu i tam, używając sztuczek znalezionych w tym poście .
— Mego
@Mego Yep. Byłem w stanie zapisać 4 bajty, używając $"zamiast " ".
— Nathan Mills,
1

Perl 5, 176 bajtów

$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

Na podstawie powyższej odpowiedzi Nathana Millsa (do której nie mam wystarczającego przedstawiciela, aby skomentować!).

$emożna uprościć $a-1zapisywanie 6 bajtów; $fmoże być przypisany łańcuchowo; zapisywanie dwóch bajtów; Nie jestem pewien, skąd pochodzą dwie pozostałe!

Chociaż $emożna go zastąpić $a-1w dwóch miejscach, w których występuje, dodatkowe potrzebne wsporniki oznaczają, że tylko się psuje.

Nie golfowany:

$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
— Rich Farmbrough
źródło
0

Python 3 , 224 bajty

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)

Wypróbuj online!

— Glietz
źródło
0

Perl 5, 170 168 166 bajtów

$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

Działa to dzięki magii wyrażeń regularnych. „If” jest potrzebne tylko do poradzenia sobie z patologicznym przypadkiem n = 2, który w przeciwnym razie generuje coś takiego:

 ##
 ##
#  #
 ##

prawdopodobnie można to zakodować.

Myślę, że może być o wiele więcej do zyskania, tworząc łańcuch do połowy punktu, a następnie odwracając go. Oczywiście musimy wstawić / usunąć dodatkową spację, jeśli n jest nieparzyste (lub użyć cienkiej spacji: p).

Nie golfił

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

Myślę, że to może być nieco bardziej golfa, z wyjątkiem znaczących zmian, takich jak forsowanie $@ i drukowanie tego na końcu.

[Golfowe przestrzenie wokół ..i przeniesiony wydruk przed przypisaniem w dwóch przypadkach, oszczędzając na średnikach.]

— Rich Farmbrough
źródło
zapisano 20 bajtów, zmieniając niektóre instrukcje TIO , \sa nie tylko miejsce w ostatnim wyrażeniu regularnym
— Nahuel Fouilleul
0

Perl 5, 98 bajtów

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

TIO

— Nahuel Fouilleul
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.