Ausgehend von der Spirale der Größe Sund der Stufe Ngeben Sie die "quadratische" S*SSpirale mit NSternchen aus, die vom äußeren zum inneren Radius im Uhrzeigersinn aufgebaut sind.

Testfälle (Beispiele) unten.

1. Eingang: 4 3

   Ausgabe:

   ***
   

2. Eingang: 4 6

   Ausgabe:

   ****
      *
      *
   

3. Eingang: 4 11

   Ausgabe:

   ****
      *
   *  *
   ****
   

4. Eingang: 6 18

   Ausgabe:

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

5. Eingang: 6 22

   Ausgabe:

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

6. Eingang: 6 27

   Ausgabe:

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

7. Eingang: 1 1

   Ausgabe:

   *
   

Es ist nicht notwendig, die Fälle zu behandeln, wenn:

• vorausgesetzt, NSternchen können nicht in die Spirale gegebener S*SDimensionen "passen" .

• entweder Noder Sist Null.

Die Herausforderung ist Code-Golf, kürzeste Bytes beantworten Gewinne, alle Sprachen können verwendet werden.

Ihre Ausgabe kann beliebig viele nachgestellte (aber nicht führende) Leerzeichen / Zeilenumbrüche enthalten.

MATL , 17 16 Bytes

UGlYLGoQ&P->42*c

Probieren Sie es online!

Erklärung (mit Beispiel)

Betrachten Sie Eingaben 4und 11als Beispiel.

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 Bytes

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

Führen Sie es aus und debuggen Sie es

Zunächst wird eine Zeichenfolge erstellt, in der alle Zeichen des Ergebnisses mit allen Sternchen linksbündig angeordnet sind. Dann nimmt es immer größere Schnitte vom Ende der Zeichenkette und "wickelt" sie um ein Gitter, während es das Gitter dreht.

Hier ist das gleiche Programm, entpackt, ungolfed und kommentiert.

'**     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

Führen Sie es aus und debuggen Sie es

Python 2 , 117 Bytes

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

Probieren Sie es online!

APL (Dyalog) , 65 Bytes

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

Probieren Sie es online!

Der Code für die Spiralmatrix stammt aus einer anderen Antwort von mir .

PHP, 118 Bytes

meine lösung für die alphabet spirale angepasst und golfen .

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

Laufen Sie mit php -nr '<code>' <S> <N>oder versuchen Sie es online .

Python 2 , 150 Bytes

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]

Probieren Sie es online!

Kohle , 34 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Eingabe N.

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

Die Längen der Spiralarme (ohne Ecken) sind S-1, S-1, S-1, S-2, S-2, S-3, ..., 3, 2, 2, 1, 1, 1. Dies wird gebildet, indem mit dem Bereich von 0bis, aber ausschließlich begonnen wird 2S, die 0 in 1 geändert wird, diese umgekehrt wird, jedem Element nach der ersten eine 1 hinzugefügt wird und schließlich alle Elemente durch 2 ganzzahlig dividiert werden. Diese Liste wird dann durchlaufen.

Ｆ‹θι≔θι

Wenn weniger Sterne zum Zeichnen übrig sind als die Länge des nächsten Arms, reduzieren Sie den Arm auf diese Länge.

×ι*

Zeichnen Sie die entsprechende Anzahl von Sternen.

≧⁻ιθ

Von der Anzahl der verbleibenden Sterne abziehen.

↷

Zeichnungsrichtung um 90 ° im Uhrzeigersinn drehen.

J 60 56 Bytes

-4 Bytes durch Ändern des Erstellungsprozesses für die Spirale, sodass ein Subtrahieren von y ^ 2 nicht erforderlich war

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

Probieren Sie es online!

Erklärung folgt in Kürze .

Erläuterung:

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

Beispiele:

   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 Bytes

6 Bytes gespart dank Jonathan
2 Bytes gespart als
19 Bytes beim Umschalten auf Lambda und Verfolgung der Außenkanten

{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()}}

Probieren Sie es online!

Java 10, 284 282 281 263 Bytes

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

Eine lustige Herausforderung!

Probieren Sie es hier online aus .

Vielen Dank an Kevin Cruijssen für das Golfen mit 18 Bytes.

Ungolfed-Version:

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 Bytes

• danke an @Erik the Outgolfer und @nicael für die Leerzeichen (3 Bytes)
• danke an @micha für join``split ,statt map (1 byte)

(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``}

Probieren Sie es online!