29

आकार Sऔर कदम के सर्पिल को देखते हुए N, "स्क्वायर" S*Sसर्पिल वाले Nतारांकन, बाहरी से आंतरिक रडार घड़ी की दिशा में निर्मित होते हैं।

नीचे दिए गए परीक्षण मामले (उदाहरण)।

इनपुट: 4 3

आउटपुट:
```
***
```
इनपुट: 4 6

आउटपुट:
```
****
   *
   *
```
इनपुट: 4 11

आउटपुट:
```
****
   *
*  *
****
```

इनपुट: 6 18

आउटपुट:

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

इनपुट: 6 22

आउटपुट:

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

इनपुट: 6 27

आउटपुट:

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

इनपुट: 1 1

आउटपुट:
```
*
```

जब मामलों को संभालना जरूरी न हो तो:

दिए गए Nतारांकन दिए गए S*Sआयामों के सर्पिल में "फिट" नहीं हो सकते हैं ।
या तो Nया Sशून्य है।

चुनौती कोड-गोल्फ है, सबसे छोटी बाइट्स उत्तर जीतती हैं, किसी भी भाषा का उपयोग किया जा सकता है।

आपके आउटपुट में कई अनुगामी (लेकिन अग्रणी नहीं) रिक्त स्थान / न्यूलाइन्स हो सकते हैं जैसे आप चाहते हैं।

code-golf ascii-art

— nicael
स्रोत

क्या हमारे पास अनुगामी स्थान / न्यूलाइन्स हो सकते हैं?

— user202729

2

मैं S आकार (या कम से कम व्यास ) को त्रिज्या के

— लुइस मेंडो

@ लव मेला स्थल!

— nicael

3

प्रिय दोस्तों , कृपया उत्तर पर भी वोट दें, न कि केवल प्रश्न। इस चुनौती को बनाना आसान है। इसका उत्तर प्रदान करना (मुझे लगता है) निश्चित रूप से अधिक कठिन है।

— 19

2

केवल आप ऐसा सोचते हैं। एक अच्छी तरह से प्राप्त और स्पष्ट चुनौती लिखना बहुत मुश्किल है। (यहीं पर कमेंट थ्रेड को देखें, चैलेंज पोस्ट किए जाने के बाद कुछ सुझाव हैं)

— user202729

16

MATL , 17 16 बाइट्स

UGlYLGoQ&P->42*c

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण (उदाहरण के साथ)

इनपुट पर विचार करें 4और 11एक उदाहरण के रूप में।

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: ['****';
                  '   *';
                  '*  *';
                  '****']

— लुइस मेंडो
स्रोत

1

वाह, मैं गोल्फ में कभी अच्छा नहीं था, लेकिन इसे 17 बाइट्स के साथ हल करूं ... जो जादू की तरह दिखता है :) (मुझे पता है कि संभवतः छोटे जवाब आ रहे हैं, लेकिन आप पहले हैं और यहां मेरे छापे हैं :)

— nicael

1

नौकरी का हिस्सा एक अंतर्निहित सर्पिल फ़ंक्शन द्वारा किया जाता है। मैंने सिर्फ एक स्पष्टीकरण जोड़ा

— लुइस मेंडो

@nicael विशिष्ट उद्देश्यों के उद्देश्य से गोल्फ भाषाओं की दुनिया में आपका स्वागत है। :)

— आउटगोल्फर

3

पूर्ण उदाहरण के लिए +1 स्पष्टीकरण के साथ

— IanF1

1

@ user202729 codegolf.stackexchange.com/questions/125966/…

— लुइस

6

स्टैक्स , 19 बाइट्स

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

इसे चलाएं और डीबग करें

यह एक स्ट्रिंग के निर्माण से शुरू होता है जिसमें परिणाम के सभी वर्ण बाएं-संरेखित होते हैं। फिर यह स्ट्रिंग के अंत में तेजी से बड़े स्लाइस लेता है, और ग्रिड के चारों ओर "लपेटता है" क्योंकि यह ग्रिड को घुमाता है।

यहाँ एक ही कार्यक्रम है, unpacked, ungolfed, और टिप्पणी।

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

इसे चलाएं और डीबग करें

— पुनरावर्ती
स्रोत

2

यह मुझे अचंभित करता है कि एंड्रॉइड पर इस उत्तर में एक नारंगी बूँद स्माइली है।

— StarWeaver

@StarWeaver Stax में कई उत्तर हैं जो ऐसा करते हैं।

— वीजुन झोउ

जब मैंने स्पष्टीकरण पढ़ा तो मैं वास्तव में उलझन में था और एक को नहीं देखा। मैंने अभी सोचा कि स्टैक्स के पास एक बहुत ही अजीब कोड पेज था!

— ndm13

@ ndm13: मुझे लगता है कि इसमें एक अजीब कोड पेज है। यह CP437 से लिया गया है जो कि एक "वास्तविक" एन्कोडिंग है जो इसमें समान वर्ण है। यदि आप अपने फोन पर उस लिंक का अनुसरण करते हैं तो आपको वही मुस्कुराता हुआ चेहरा देखना चाहिए।

— पुनरावर्ती

5

पायथन 2 , 117 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत

4

एपीएल (डायलॉग) , 65 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सर्पिल मैट्रिक्स के लिए कोड मेरा एक और उत्तर से लिया गया है ।

— Uriel
स्रोत

आपका कोड गलत दिशा में सर्पिल खींचता है अगर Nविषम है :)

— nicael

@nicael फिक्स्ड (पैच की तरह अधिक)। धन्यवाद

— ऊरीएल

लेकिन ... i.stack.imgur.com/gGJsS.png

— nicael

शायद मैं गलत तरीके से इनपुट का उपयोग कर रहा हूं?

— nicael

@ अनिकेल अर्घ। ठीक है, मुझे लगता है कि अब ठीक है।

— एरियल

4

PHP, 118 बाइट्स

समायोजित और वर्णमाला सर्पिल के लिए मेरे समाधान गोल्फ ।

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

इसे ऑनलाइन चलाएं php -nr '<code>' <S> <N>या इसके लिए प्रयास करें ।

— टाइटस
स्रोत

4

पायथन 2 , 150 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

3

चारकोल , 34 बाइट्स

ＮθＦＥ⮌Ｅ⊗Ｎ∨ι¹÷⁺ι¬¬κ²«Ｆ‹θι≔θι×ι*≧⁻ιθ↷

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

इनपुट N।

ＦＥ⮌Ｅ⊗Ｎ∨ι¹÷⁺ι¬¬κ²«

सर्पिल भुजाओं वाले (कोनों को छोड़कर) की लंबाई हैं S-1, S-1, S-1, S-2, S-2, S-3, ..., 3, 2, 2, 1, 1, 1। यह 0ऊपर से सीमा के साथ शुरू करके, लेकिन 2S0 से 1 को बदलने, इसे उलटने, 1 के बाद प्रत्येक तत्व को जोड़ने और अंत में सभी तत्वों को विभाजित करने वाले 2. से विभाजित करके बनाया गया है। यह सूची तब लूप की गई है।

Ｆ‹θι≔θι

यदि अगले हाथ की लंबाई की तुलना में कम सितारे बचे हैं, तो हाथ को उस लंबाई तक कम करें।

×ι*

सितारों की उचित संख्या ड्रा करें।

≧⁻ιθ

शेष सितारों की संख्या से घटाएं।

↷

90 ° दक्षिणावर्त द्वारा ड्राइंग दिशा घुमाएँ।

— नील
स्रोत

3

जे, 60 56 बाइट्स

-4 बाइट्स सर्पिल के लिए बिल्ड को सफल बनाकर संशोधित करता है ताकि इसे y ^ 2 से घटाया जा सके

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

इसे ऑनलाइन आज़माएं!

अब ~~जल्द~~ आ रहा है स्पष्टीकरण ।

स्पष्टीकरण:

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

उदाहरण:

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

— बोलस बूसियर
स्रोत

क्या आप निष्पादन योग्य उदाहरण के लिए एक लिंक भी जोड़ सकते हैं?

— nicael

@nicael जोड़ा :)

— बोल्से बस्सेर

2

कोटलिन , 361 355 353 334 बाइट्स

6 बाइट्स ने जोनाथन की बदौलत
2 बाइट्स बचाए, जब
19 बाइट्स ने लैम्ब्डा में स्विच करने और बाहरी किनारों को ट्रैक करने से बचाया

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

इसे ऑनलाइन आज़माएं!

— JohnWells
स्रोत

1

मुझे वास्तव में यकीन नहीं है कि इनपुट क्षेत्र खाली होने के बाद से इसे कैसे आज़माया जाए।

— निकेल

1

@nicael यह एक समारोह है। यह उपयोग करने के लिए आसान हो सकता है - कॉल फुटर में किया जाता है।

— जोनाथन एलन

1

मैं कोटलिन को बिलकुल नहीं जानता, लेकिन विश्वास है कि ==' 'इसे बदला जा सकता है <'*'। d==0साथ भी d<1और d==3साथ भी d>2। ये बहुत मौलिक गोल्फ की तरह लग रहे हैं तो शायद अन्य भी हैं!

— जोनाथन एलन

@nicael आप इनपुट क्षेत्र में दो पूर्णांक डाल सकते हैं, पहली पंक्ति पर आकार, दूसरे पर संख्या।

— जॉनवेल्स

1

@ जॉन वास्तव में, यह काम करता है। किसी तरह यह बहुत धीमा है, लेकिन इससे कोई फर्क नहीं पड़ता।

— निकेल

2

जावा 10, 284 282 281 263 बाइट्स

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

एक मजेदार चुनौती!

इसे यहाँ ऑनलाइन आज़माएँ ।

18 बाइट गोल्फिंग के लिए केविन क्रूजसेन को धन्यवाद ।

Ungolfed संस्करण:

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
}

— OOBalance
स्रोत

263 बाइट्स अंतिम दो छोरों को मुख्य रूप से बदल दिया जाता है, और एक var bजोड़ा जाता है ताकि आपको केवल दो बार x>0?i<u:i>lऔर y>0?j<u:j>lप्रत्येक के बजाय एक बार करना पड़े ।

— केविन क्रूज़सेन

@ केविनक्रूजसेन महान गोल्फ, धन्यवाद!

— ओबैलेंस

2

जावास्क्रिप्ट (Node.js) , 167 164 163 बाइट्स

Outgolfer @ @ के लिए धन्यवाद और रिक्त स्थान के लिए @nicael (3 बाइट्स)
,मानचित्र के बजाय ' `पुलिट' 'में शामिल होने के लिए @ मिखा का धन्यवाद

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

इसे ऑनलाइन आज़माएं!

— DanielIndie
स्रोत

1

अच्छा है, यह काम करता है! क्या आप इसे और भी छोटा बनाने के लिए रिक्त स्थान / नई लिंक हटा सकते हैं?

— निकेल

1

@nicael हाँ लगता है।

— आउटगोल्फर

1

सुंदर! यदि कोटलिन और जावा संस्करण एक ही विधि का उपयोग करेंगे तो वे बहुत छोटे होंगे! जब आप सर्पिल या सीमा से टकराते हैं और तब "कछुए" का पता लगाते हैं। बहुत चालाक! एक बाइट कम: वापसी में बदलें return a.join` `.split`,`.join``।

— माईका

सबसे पहले @micha आपको धन्यवाद :)। दूसरी a.join` .split, `.join`` सर्पिल आउटपुट" अच्छी तरह से "(नई लाइनों के साथ) तो मुझे लगता है कि इसकी समस्या है

— डैनियल एंडी

@DanielIndie, नई लाइन को स्वरूपित किया गया, पहले जुड़ने के लिए एक नई पंक्ति होनी चाहिए। इसे देखें

— micha

तारांकन सर्पिल

MATL , 17 16 बाइट्स

स्पष्टीकरण (उदाहरण के साथ)

स्टैक्स , 19 बाइट्स

पायथन 2 , 117 बाइट्स

एपीएल (डायलॉग) , 65 बाइट्स

PHP, 118 बाइट्स

पायथन 2 , 150 बाइट्स

चारकोल , 34 बाइट्स

जे, 60 56 बाइट्स

स्पष्टीकरण:

कोटलिन , 361 355 353 334 बाइट्स

जावा 10, 284 282 281 263 बाइट्स

जावास्क्रिप्ट (Node.js) , 167 164 163 बाइट्स