Compte tenu de la spirale de taille Set du pas N, sortez la S*Sspirale "carrée" comportant des Nastérisques, construite du rayon extérieur au rayon intérieur dans le sens des aiguilles d'une montre.

Cas de test (exemples) ci-dessous.

1. Contribution: 4 3

   Sortie:

   ***
   

2. Contribution: 4 6

   Sortie:

   ****
      *
      *
   

3. Contribution: 4 11

   Sortie:

   ****
      *
   *  *
   ****
   

4. Contribution: 6 18

   Sortie:

   ******
        *
        *
   *    *
   *    *
   ******
   

5. Contribution: 6 22

   Sortie:

   ******
   ***  *
   *    *
   *    *
   *    *
   ******
   

6. Contribution: 6 27

   Sortie:

   ******
   ******
   *   **
   *   **
   *   **
   ******
   

7. Contribution: 1 1

   Sortie:

   *
   

Il n'est pas nécessaire de gérer les cas lorsque:

• à condition que les Nastérisques ne puissent pas "tenir" dans la spirale de S*Sdimensions données .

• soit Nou Sest nul.

Le défi est le golf de code, les octets les plus courts l'emportent, toutes les langues peuvent être utilisées.

Votre sortie peut comporter autant d'espaces / de nouvelles lignes à la fin (mais pas au début) que vous le souhaitez.

MATL , 17 16 octets

UGlYLGoQ&P->42*c

Essayez-le en ligne!

Explication (avec exemple)

Considérez les entrées 4et 11comme exemple.

U       % Implicit input: S. Push S^2
        % STACK: 16
G       % Push S again
        % STACK: 16, 4
lYL     % Outward, clockwise, east-first spiral of that size
        % STACK: 16,
                 [ 7  8  9 10;
                   6  1  2 11;
                   5  4  3 12;
                  16 15 14 13]
GoQ     % Push S, compute parity, add 1. Gives 1 for even S, 2 for odd
        % STACK: 16,
                 [ 7  8  9 10;
                   6  1  2 11;
                   5  4  3 12;
                  16 15 14 13],
                 1
&P      % Flip along that dimension (1 is vertical, 2 is horizontal).
        % This corrects for the orientation of the spiral
        % STACK: 16,
                 [16 15 14 13;
                   5  4  3 12;
                   6  1  2 11;
                   7  8  9 10]
-       % Subtract, element-wise. The upper-left corner becomes 0
        % STACK: [ 0  1  2  3
                  11 12 13  4
                  10 15 14  5
                   9  8  7  6]
>       % Implicit input (below): N. Greater than?, element-wise.
        % This transforms the first N entries, starting from
        % upper-left, inward, east-first, into 1, and the rest
        % into 0
        % STACK: [1 1 1 1;
                  0 0 0 1;
                  1 0 0 1;
                  1 1 1 1]
42*     % Multiply each entry by 42
        % STACK: [42 42 42 42;
                   0  0  0 42;
                  42  0  0 42;
                  42 42 42 42]
c       % Convert to char. Char 0 will be displayed as space.
        % Implicit display
        % STACK: ['****';
                  '   *';
                  '*  *';
                  '****']

Stax , 19 octets

±♪☺ÿzMæ¡♠à╣♂7☼V♀§9↓

Exécuter et déboguer

Il commence par construire une chaîne contenant tous les caractères dans le résultat avec tous les astérisques alignés à gauche. Ensuite, il enlève des tranches de plus en plus grandes de l'extrémité de la chaîne et les «enroule» autour d'une grille en faisant tourner la grille.

Voici le même programme, décompressé, non golfé et commenté.

'**     repeat "*" specified number of times
,J(     square the top of the input stack, and right-pad string to that length
z       push an empty array - this is the result grid built up in the loop
{       begin a block to loop
  ~     push grid to the input stack
  ihNv  push -(i / 2) - 1 where i is the 0-based iteration index using integer division
  :/]   split the string at that index and wrap the second half in a singleton array
  ,     pop the grid from the input stack
  rM+   rotate the grid clockwise, then prepend the split string as the new first row
  n     copy what's left of the original string to top of stack for the loop condition
w       while; execute block until condition is truthy
m       display resulting grid

Exécuter et déboguer

Python 2 , 117 octets

n,k=input()
i=0;d=1
l=(' '*n+'\n')*n
exec"l=l[:i]+'*'+l[i+1:];d=[~n/d*cmp(d*d,2),d][' '<l[i+d:]<'*'];i+=d;"*k
print l

Essayez-le en ligne!

APL (Dyalog) , 65 octets

' *'[1+⎕>⊖∘⌽⍣o(⊖×⍨-,⍨⍴∘(⍋+\)×⍨↑(⌈2÷⍨×⍨),(+⍨⍴1,⊢,¯1,-)(/⍨)2/⍳)o←⎕]

Essayez-le en ligne!

Le code de la matrice en spirale est tiré d' une autre réponse de la mienne .

PHP, 118 octets

ajusté et joué ma solution pour la spirale de l'alphabet .

for($w=$n=$argv[$s=1],$r="*";--$argv[2];$r[$p+=$s*$d+$s]="*")if(!$c=++$c%$n)($d^=$w)?$n--:$s=-$s;echo wordwrap($r,$w);

Courez avec php -nr '<code>' <S> <N>ou essayez-le en ligne .

Python 2 , 150 octets

S,N=input()
X=y=n=0
Y=x=c=-1
s=eval(`[[' ']*S]*S`)
exec"if n%S<1:S-=c%2<1;X,Y=-Y,X;c+=1;n=0\nx+=X;y+=Y;s[y][x]='*';n+=1\n"*N
for i in s:print`i`[2::5]

Essayez-le en ligne!

Fusain , 34 octets

ＮθＦＥ⮌Ｅ⊗Ｎ∨ι¹÷⁺鬬겫Ｆ‹θι≔θι×ι*≧⁻ιθ↷

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

Ｎθ

Entrée N.

ＦＥ⮌Ｅ⊗Ｎ∨ι¹÷⁺鬬겫

Les longueurs des bras en spirale ( à l' exclusion des coins) sont S-1, S-1, S-1, S-2, S-2, S-3, ..., 3, 2, 2, 1, 1, 1. Ceci est formé en commençant par la plage allant de 0jusqu'à mais en excluant 2S, en changeant le 0 en 1, en l'inversant, en ajoutant 1 à chaque élément après le premier, et enfin un entier divisant tous les éléments par 2. Cette liste est ensuite bouclée.

Ｆ‹θι≔θι

S'il reste moins d'étoiles à dessiner que la longueur du bras suivant, réduisez le bras à cette longueur.

×ι*

Dessinez le nombre d'étoiles approprié.

≧⁻ιθ

Soustrayez du nombre d'étoiles restantes.

↷

Faites pivoter le sens du dessin de 90 ° dans le sens des aiguilles d'une montre.

J, 60 56 octets

-4 octets en modifiant le processus de construction de la spirale afin qu'il ne soit pas nécessaire de la soustraire de y ^ 2

4 :'''* ''{~x<|."1|.(|:@|.,<:@{:@{:-i.@#)^:(+:<:y),.*:y'

Essayez-le en ligne!

Explication à venir bientôt maintenant.

Explication:

4 :'''* ''{~x<|."1|.(|:@|.,<:@{:@{:-i.@#)^:(+:<:y),.*:y'  | Explicit dyad definition
                    (|:@|.,<:@{:@{:-i.@#)^:(+:<:y),.*:y   | Generate a y by y inward spiral
                                                  ,.*:y   | The matrix [[y^2]]
                    (                   )^:(+:<:y)        | 2*(y-1) times...
                     |:@|.                                | Rotate
                          ,                               | Append
                                    i.@#                  | [0..len(n)-1]
                           <:@{:@{:-                      | Subtracted from the previous value and decremented
              |."1|.                                      | Flip around antidiagonal
            x>                                            | Test if each entry is less than x
    '' *''{~                                              | ' ' for 0, '*' for 1

Exemples:

   3 :'(|:@|.,<:@{:@{:-i.@#)^:(+:<:y),.*:y' 4
7  8  9 10
6 15 16 11
5 14 13 12
4  3  2  1
   3 :'|."1|.(|:@|.,<:@{:@{:-i.@#)^:(+:<:y),.*:y' 4
1  2  3 4
12 13 14 5
11 16 15 6
10  9  8 7
   11(4 :'x<|."1|.(|:@|.,<:@{:@{:-i.@#)^:(+:<:y),.*:y') 4
0 0 0 0
1 1 1 0
0 1 1 0
0 0 0 0
   11(4 :'''* ''{~x<|."1|.(|:@|.,<:@{:@{:-i.@#)^:(+:<:y),.*:y') 4
****
   *
*  *
****

Kotlin , 361 355 353 334 octets

6 octets enregistrés grâce à Jonathan
2 octets enregistrés passant à quand
19 octets enregistrés basculant vers lambda et suivi des bords extérieurs

{s:Int,n:Int->var a=Array(s,{_->Array(s,{_->' '})})
var r=0
var c=0
var d=0
var e=0
var f=1
var g=s-1
var h=g
for(i in 1..n){a[r][c]='*'
when(d){0->if(c<g)c++
else{d=1
r++
g--}
1->if(r<h)r++
else{d=2
c--
h--}
2->if(c>e)c--
else{d=3
r--
e++}
3->if(r>f)r--
else{d=0
c++
f++}}}
for(i in 0..s-1){for(j in 0..s-1)print(a[i][j])
println()}}

Essayez-le en ligne!

Java 10, 284 282 281 263 octets

s->n->{var c=new char[s][s];for(var d:c)java.util.Arrays.fill(d,' ');for(int i=0,j=0,y=0,x=1,u=s-1,l=0;n-->0;c[j][i]=42,i+=x,j+=y,l+=i==l&x==0?1:0,u-=i==l&j==l&y<1?1:0)if(x!=0){var b=x>0?i<u:i>l;y=b?0:x;x=b?x:0;}else{var b=y>0?j<u:j>l;x=b?0:-y;y=b?y:0;}return c;}

Un défi amusant!

Essayez-le en ligne ici .

Merci à Kevin Cruijssen d' avoir joué au golf 18 octets.

Version non golfée:

s -> n -> { // lambda taking two integer arguments in currying syntax
    var c = new char[s][s]; // the matrix containing the spiral
    for(var d : c) // for every row
        java.util.Arrays.fill(d, ' '); // fill it with spaces
    for(int i = 0, j = 0, // the coordinates of the next '*'
            y = 0, x = 1, // the direction to move in
            u = s-1, l = 0; // the upper and lower bounds
        n-- > 0; // decrecement the length of the spiral and repeat as many times
        c[j][i] = 42, // draw the '*', 42 is ASCII code
        i += x, j += y, // move to the next cell
        l += i == l & x == 0 ? 1 : 0, // adjust lower bound if necessary
        u -= i == l & j == l & y < 1 ? 1 : 0) // adjust upper bound if necessary
        if(x != 0) { // if moving in x direction
            var b = x > 0 ? i < u : i > l; // if we hit the bounds
            y = b ? 0 : x; // flip directions,
            x = b ? x : 0; // turning around
        } else { // if moving in y direction
            var b = y > 0 ? j < u : j > l; // if we hit the bounds
            x = b ? 0 : -y; // flip directions,
            y = b ? y : 0;  // turning around
        }
    return c; // return the matrix
}

JavaScript (Node.js) , 167 164 163 octets

• merci à @Erik the Outgolfer et @nicael pour les espaces (3 octets)
• merci à @micha pour join''split ,au lieu de map (1 octet)

(l,s)=>{a=(b=[...Array(l)]).map(x=>b.map(_=>" "))
for(d=1,x=y=D=0;s--;x+=d,y+=D)a[y][x]="*",(a[y+D]||[])[x+d]!=" "?[d,D]=[-D,d]:0
return a.join`
`.split`,`.join``}

Essayez-le en ligne!