Dessinez des étoiles ASCII

15

Écrivez un programme ou une fonction qui dessine une étoile ASCII, étant donné la taille des bras en entrée.

Voici une étoile de taille 1

_/\_
\  /
|/\|

Voici une étoile de taille 2

   /\
__/  \__
\      /
 \    /
 | /\ |
 |/  \|

Voici une étoile de taille 3

     /\
    /  \
___/    \___
\          /
 \        /
  \      /
  |  /\  |
  | /  \ |
  |/    \|

Etc.

Contribution

Un seul entier positif dans un format pratique , n > 0.

Production

Une représentation ASCII d'une étoile, suivant les règles ci-dessus. Les sauts de ligne de début / fin ou d'autres espaces sont facultatifs, à condition que les points s'alignent correctement.

Règles

  • Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
  • Les failles standard sont interdites.
  • Il s'agit de donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.
AdmBorkBork
la source
6
Est-ce juste mon écran ou les étoiles semblent-elles anormalement hautes et minces?
caird coinheringaahing
2
ASCII stupide et son manque de pentes peu profondes ...
totalement humain
@cairdcoinheringaahing La police utilisée par SE n'est pas carrée - il y a un espace important entre les lignes, ce qui augmente la distorsion.
AdmBorkBork

Réponses:

12

Fusain , 20 17 octets

-3 octets grâce à Neil.

Nν↙ν↑↑ν↖ν ×_ν↗ν‖M

Essayez-le en ligne!Le lien est vers la version détaillée.

Je suis assez content de ce golf alors ...

Explication

Nν                 take a number as input and store in ν
  ↙ν               print / ν times downwards to the left
    ↑              move up once
     ↑ν            print | ν times upwards
       ↖ν          print \ ν times upwards to the left
                   print a space
          ×_ν      print _ ν times
             ↗ν    print / ν times upwards to the right
               ‖M  reflect horizontally
     /\                           
    /  \    "No, this is Patrick!"
___/    \___                      
\   ☉ ☉    /                      
 \   𝐷    /                       
  \      /                        
  |  /\  |                        
  | /  \ |                        
  |/    \| 
totalement humain
la source
Le dessiner de bas en haut permet d'économiser 2 octets.
Neil
Pour une raison quelconque, je dois augmenter l'argument pour Polygon... Suis-je en train de faire quelque chose de mal?
totalement humain
C'est parce que Polygonlaisse le curseur sur le dernier caractère, mais je n'utilisais pas Polygon... en fait, je n'utilisais pas non plus le meilleur code, j'ai maintenant 17 ans.
Neil
Je ne sais pas si si j'avais 17 ans de la même manière que vous, mais ... Merci!
2017 totalement humain
Assez près. J'avais en fait Move(:Right); for (n) Print("_");.
Neil
5

SOGL V0.12 , 27 24 octets

╔*¹.╚№┼№.╝+ø┐.∙.1ž.╚┼+╬³

Essayez-le ici!

Explication:

╔*                        push a string with input amount of underscores
  ¹                       wrap that in an array
   .╚                     push a "/" diagonal of the size of the input (the top lines)
     №                    reverse vertically
      ┼                   add horizontally the underscores behind the array
       №                  reverse vertically back
        .╝+               below that add a "\" diagonal (middle lines)
           ø              push an empty string as the base of the vertical bars
            ┐.∙           get an array of "|" with the length of the input
               .1ž        at [input; 1] in the empty string insert that
                  .╚┼     horizontally append a "/" diagonal
                     +    add that below everything else
                      ╬³  palindromize horizontally
dzaima
la source
4

Python 2 ,  166 160 157 157 155  152 octets

L' execapproche est exactement le même nombre d'octets.

i=input();t,z=" \\";y=t*2
for k in range(i*3):s=k%i;o=i+~s;p=i+o;g="_ "[i>k+1]*p;print[g+"/"+y*k+z+g,t*s+z+y*p+"/",~-i*t+"|"+o*t+"/"+y*s+z+o*t+"|"][k/i]

Essayez-le en ligne!

Enregistré 3 octets grâce à Jonathan Frech .

M. Xcoder
la source
Vous pouvez économiser quelques octets en remplaçant t=" ";y,z=t*2,"\\"par t,z=" \\";y=t+t.
Jonathan Frech
@JonathanFrech Merci.
M. Xcoder, du
3

Java 8, 385 376 344 304 285 280 268 264 252 250 + 19 octets

n -> {int s = 2 * n, w = 2 * s, e = n-1, i = 0, o, l [] [] = new int [n * 3] [w]; for (; i <n; l [i] [s + ~ i] = l [n + i] [w + ~ i] = l [o] [s + ~ i] = 47, l [i] [o] = l [o] [ o] = l [n + i] [i] = 92, l [e] [i] = l [e] [w - ++ i] = 95, l [o] [e] = l [o] [ s + n] = 124) o = s + i; for (int [] b: l) System.out.println (new String (b, 0, w) .replace (" ", ""));}

Essayez-le en ligne!

Roberto Graham
la source
Vous pouvez le raccourcir de 10 octets en utilisant des astuces au niveau du bit et en déplaçant toutes vos déclarations d'entiers en dehors de vos boucles ( 270 octets )
M. Xcoder
Et vous pouvez économiser encore 2 octets en déplaçant également l' int o=extérieur de la boucle ( 268 octets )
M. Xcoder
Vous pouvez économiser 4 octets supplémentaires en supprimant les crochets pour la boucle for et en utilisant ++directement la dernière occurrence de i, comme ceci: 264 octets .
Kevin Cruijssen
1
252 octets
Nevay
@Nevay Très intelligent, merci
Roberto Graham
2

Mathematica, 189 octets

n(
  s_±x_±y_:=s->Array[If[x==y,s," "]&,{n,n}];
  StringRiffle[Characters@{"_/\\_","\\  /","|/\\:"}/.
    {"_"±#±n,"|"±#2±n,":"±#2±1,"\\"±#±#2,"/"±(n-#+1)±#2," "±0±1}
    /.":"->"|"//ArrayFlatten,"
",""])

La ligne 2 définit l'opérateur d'assistance ±, qui est utilisé pour faire évaluer la ligne 4 à:

{"_"  -> Array[If[#1 == n,          "_", " "] &, {n, n}], 
 "|"  -> Array[If[#2 == n,          "|", " "] &, {n, n}], 
 ":"  -> Array[If[#2 == 1,          ":", " "] &, {n, n}], 
 "\\" -> Array[If[#1 == #2,         "\\"," "] &, {n, n}], 
 "/"  -> Array[If[1 + n - #1 == #2, "/", " "] &, {n, n}], 
 " "  -> Array[If[0 == 1,           " ", " "] &, {n, n}]}

À la ligne 3, le ReplaceAll( /.) prend une matrice représentant l'étoile de taille 1 ainsi que la liste des règles ci-dessus. Pour les étapes finales, nous utilisons ArrayFlatten, qui est plus court que SubstitutionSystem, et StringRiffle.

hftf
la source
2

Java 7, 295 octets

La solution est la méthode f.

String s(String s,int n){while(n-->0)s=" "+s;return s;}String f(int x){String n="\n",s="/",b="\\",o="",u="_";int i=0;for(x--;i<x;u+="_")o+=s(s,2*x-i+1)+s(b,2*i++)+n;o+=u+s+s(b,2*i)+u+n;while(i>=0)o+=s(b,x-i)+s(s,4*x-2*(x+~i--))+n;while(i++<x)o+=s("|",x)+s(s,x-i)+s(b,2*i)+s("|",x-i)+n;return o;}

Essayez-le en ligne (JDK 8)

Non golfé

String s(String s, int n) {
    while (n-- > 0)
        s = " " + s;
    return s;
}

String f(int x) {
    String
        n = "\n",
        s = "/",
        b = "\\",
        o = "",
        u = "_"
    ;
    int i = 0;
    for (x--; i < x; u += "_")
        o += s(s, 2*x - i + 1) + s(b, 2 * i++) + n;
    o += u + s + s(b, 2 * i) + u + n;
    while (i >= 0)
        o += s(b, x - i) + s(s, 4*x - 2*(x + ~i--)) + n;
    while (i++ < x)
        o += s("|", x) + s(s, x - i) + s(b, 2 * i) + s("|", x - i) + n;
    return o;
}

Remerciements

  • -1 octet grâce à Kevin Cruijssen
Jakob
la source
0

Python 2 , 137 octets

n=input()
b,f,s,v='\/ |'
for i in range(3*n):u=i/~-n*n*'_';d=f+i%n*2*s+b;print[u+d+u,b+s*2*(3*n+~i)+f,v+d.center(2*n)+v][i/n].center(4*n)

Essayez-le en ligne!

Lynn
la source