pssssssssssssst

Question

परिचय

यह एक बहुत सीधा है। हम अस्सी में सांप खींच रहे होंगे। यह उस पुराने साँप के खेल से प्रेरित था जहाँ आपको फल इकट्ठा करना होता है और आप लगातार बढ़ते रहते हैं।

परिभाषा

सांप की लंबाई का प्रतिनिधित्व करने वाले एक सकारात्मक पूर्णांक एन को देखते हुए, एक सांप को आकर्षित करें ताकि उसके पास एन प्लस सिर और पूंछ का एक शरीर हो।

हिस्से:

• सिर: <, >, ^, v
• पूंछ: @
• ऊर्ध्वाधर: |
• horizonal: -

सभी कोनों को क्रमशः \या उससे संतुष्ट होना चाहिए /। जब तक कि सिर एक कोने पर समाप्त न हो जाए, जिस स्थिति में सिर <, >, ^, vउस दिशा में प्राथमिकता लेता है, जिसमें साँप घुसा हुआ है। लंबाई 1 उदाहरण के लिए, यह घड़ी की दिशा में उल्टा है और इसलिए सिर को इस तरह से मोड़ दिया गया है। एक दक्षिणावर्त समाधान के लिए यह सही होगा >।

सांप को अपनी पूंछ के साथ बीच में शुरू करना चाहिए, लेकिन यह किसी भी दिशा में बाहर की ओर जा सकता है, जिसे आप दक्षिणावर्त या काउंटर-क्लॉकवाइज चुनते हैं। यह भी अपने आप को कसकर लपेटना चाहिए क्योंकि यह एक गोलाकार तरीके से बाहर की ओर फैलता है।

उदाहरण

/--\
|/\|
||@|
|\-/
\--->

जहां @पूंछ और शुरुआती स्थिति है। जैसा कि पूंछ के ऊपर देखा गया है कि बीच में शुरू होता है, एक काउंटर-क्लॉकवाइज रोटेशन में बाहर की ओर बाईं ओर जाता है।

यहाँ लंबाई 19प्लस एक पूंछ और एक सिर है।

एक अन्य उदाहरण के रूप में, यहां लंबाई है 1:

<\
 @

जीतना

यह कोड-गोल्फ है इसलिए उत्तर को बाइट्स की सबसे छोटी संख्या के साथ प्रस्तुत किया जाता है, समय के साथ टाई ब्रेकर के रूप में उपयोग किया जाता है।

मज़े करो!

Comments

यह बहुत स्पष्ट नहीं है कि मुझे सीधे सांप की तरह आकर्षित करने की अनुमति नहीं है @---->। आप शायद साँप के आकार के बारे में अधिक सख्त शर्तें रखते हैं। यह भी स्पष्ट करें कि

— व्हॉट्सएप

"सांप को पूंछ के साथ बीच में शुरू होना चाहिए, लेकिन यह आपके द्वारा चुने गए किसी भी दिशा में बाहर की ओर जा सकता है और या तो दक्षिणावर्त या काउंटर-

— क्लॉकवाइज

इसलिए मैं कहता हूं कि @मध्य (संभव है कि इसे बनाने के लिए कुछ रिक्त स्थान जोड़ें), "सही करने के लिए" दिशा की घोषणा करें और बस सिर को नीचे बिंदु बनाएं और उस घड़ी को घोषित करें। आपकी शर्तें आपको स्पष्ट लग सकती हैं, लेकिन वे वास्तव में अस्पष्ट हैं। मुझे लगता है कि आप शायद संभव के रूप में एक के रूप में संभव कुंडलित साँप का मतलब है, लेकिन आप स्पष्ट करना चाहिए कि

— टन 10

चिंता मत करो। उस चुनौती में अपसेट होने के कारण यह बहुत कठिन है।

— मार्टिन एंडर 14

अच्छी पहली चुनौती! साइट पर आपका स्वागत है!

— लुइस मेंडो

Answer 1

MATL , 85 83 बाइट्स

और मैंने सोचा था कि एक spiralबिल्डिन के पास शॉर्ट कोड होगा ...

Oli2+XH:UQXItH:+XJh(YsXKoQ3I(4J(5l(H:)0HX^XkU(6H(3M1YL3X!P)'|-\/@' '<v>^'KHq))h0hw)

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

व्याख्या

चलिए N इनपुट को निरूपित करते हैं। हम एक वेक्टर की लंबाई बनाएंगे ceil(sqrt(N+2))^2, जो कि सबसे छोटा पूर्ण वर्ग है जो N +2 के बराबर या उससे अधिक है । यह वेक्टर संख्यात्मक मूल्यों से भरा होगा, एक सर्पिल में लुढ़का होगा (यही कारण है कि इसकी लंबाई एक पूर्ण वर्ग की आवश्यकता है), और फिर संख्यात्मक मान वर्णों द्वारा प्रतिस्थापित किया जाएगा।

चलो एन प्रत्येक चरण के सर्पिल के केंद्र में 1 से शुरू निरूपित करते हैं। सांपों के मुड़ने के चरण n ² +1 (अर्थात: 2, 5, 10, ...) \प्रतीकों के लिए और n ² + n +1 (जो कि: 3, 7, 13, ...) द्वारा दिए गए हैं। के लिए /। एक के बीच चरणों \और एक /होना चाहिए -, और एक के बीच उन /और एक \होना चाहिए |।

वेक्टर इस तरह बनाया जाता है कि इसमें 1टर्न पॉइंट्स (2,3,5,7,10,13 ...) और होते हैं0 बाकी हिस्सों में होते हैं। संचयी योग की समता बताती है कि क्या प्रत्येक प्रविष्टि एक -या एक होनी चाहिए |। इस परिणाम में 1 जोड़ने पर हमें एक वेक्टर युक्त 1(के लिए |) या 2(के लिए -) मिलता है। लेकिन इससे टर्न पॉइंट खुद बन जाते हैं 1या बन जाते 2हैं। इसलिए मोड़ बिंदु, जिनके पदों को हम जानते हैं, वे ओवरराइट किए गए हैं: पद n ² +1 भरे हुए हैं 3और n ² + n +1 वाले पद भरे हुए हैं 4। पूंछ और सिर भी विशेष मामले हैं: वेक्टर (पूंछ) का पहला तत्व 5और एन के साथ तत्व सेट है+2 (सिर) पर सेट है 6। अंत में, N +2 से अधिक सूचकांकों वाले तत्वों को सेट किया गया है 0।

उदाहरण के रूप में इनपुट एन = 19 लेना , हमारे पास अब 25 की लंबाई वाला एक वेक्टर है:

5 3 4 1 3 2 4 1 1 3 2 2 4 1 1 1 3 2 2 2 6 0 0 0 0

हमें इस वेक्टर को एक सर्पिल में रोल करने की आवश्यकता है। इसके लिए हम एक निर्मित फ़ंक्शन का उपयोग करते हैं जो एक सर्पिल मैट्रिक्स उत्पन्न करता है, इसके बाद प्रतिबिंब और उत्पादन के लिए एक ट्रांसपोज़न:

13 12 11 10 25
14  3  2  9 24
15  4  1  8 23
16  5  6  7 22
17 18 19 20 21 

मैट्रिक्स को वेक्टर के साथ अनुक्रमण करता है

4 2 2 3 0
1 4 3 1 0
1 1 5 1 0
1 3 2 4 0
3 2 2 2 6

जहां 0अंतरिक्ष से मेल खाती है, 1से मेल खाती है |, 2करने के लिए -, 3करने के लिए \, 4करने के लिए /, 5करने के लिए @, और 6सिर पर।

यह जानने के लिए कि चार वर्ण कौन से हैं ^ में <से v, या >, सिर में से होना चाहिए, हम मोड़ बिंदुओं के संचयी योग का उपयोग करते हैं जो हमने पहले गणना की थी। विशेष रूप से, इस संचयी योग का दूसरा-अंतिम मूल्य (यानी एन + 1-वें मूल्य) modulo 4 हमें बताता है कि सिर के लिए किस वर्ण का उपयोग किया जाना चाहिए। हम क्योंकि आवश्यकता "अगर एक कोने पर सिर समाप्त होता है सिर के संचयी योग, पिछले नहीं की दूसरी अंतिम मान लेते हैं, <, >, ^, vप्राथमिकता दिशा साँप curled में लेता है"। के लिए एन = 19 उदाहरण सिर है >।

अब हम छठे स्थान पर सिर के लिए उपयुक्त चरित्र सहित सभी सर्प पात्रों से युक्त एक तार का निर्माण कर सकते हैं '|-\/@> ':। फिर हम इस स्ट्रिंग को उपरोक्त मैट्रिक्स के साथ इंडेक्स करते हैं (इंडेक्सिंग 1-आधारित और मॉड्यूलर है, इसलिए स्पेस अंतिम हो जाता है), जो देता है

/--\ 
|/\| 
||@| 
|\-/ 
\--->

Comments

शानदार कार्य! भाग लेने के लिए धन्यवाद!

— जैक्सनसेक

Answer 2

अजगर 2, 250 233 191 बाइट्स

n=input()
l=[''],
a=x=0
b='@'
while a<=n:x+=1;l+=b,;l=zip(*l[::-1]);m=x%2;b='\/'[m]+x/2*'-|'[m];k=len(b);a+=k
l+=b[:n-a]+'>v'[m]+' '*(k-n+a-1),
if m:l=zip(*l[::-1])
for i in l:print''.join(i)

• 39 बाइट्स @JonathanAllan की बदौलत सहेजे गए

repl.it

पूरे सांप को 90 sn क्लॉकवाइज घुमाकर और नीचे के खंड को जोड़कर सांप को खींचे, इस तरह से सांप हमेशा एंटीलॉकवाइज रहेगा।
नया सेगमेंट हमेशा के साथ शुरू होगा \और -शरीर के समान पक्ष और / -विषम पक्षों के लिए होगा। खंड आकार (कोनों के बिना) हैं0 , 1, 1, 2, 2, 3... जो floor(side/2)।
यदि खंड अंतिम है, तो यह अतिरिक्त वर्णों को हटा देता है, सिर जोड़ देता है और रिक्त स्थान के साथ पूरा होता है।

desired_size=input()
snake=[['']]
snake_size=side=0
new_segment='@'
while snake_size<=desired_size:
    side+=1
    snake+=[new_segment]
    snake=zip(*snake[::-1])
    odd_side=side%2
    new_segment='\/'[odd_side]+side/2*'-|'[odd_side]
    snake_size+=len(new_segment)
diff=desired_size-snake_size
snake+=[new_segment[:diff]+'>v'[odd_side]+' '*(len(new_segment)-diff-1)]
if odd_side:
    snake=zip(*snake[::-1])

for line in snake:print ''.join(line)

Comments

अच्छी नौकरी! आपके पास टाईब्रेकर जीत है। आइए देखें कि लोग और क्या करते हैं।

— जैक्सनसेक 17

निश्चित रूप से यह इस चुनौती को हल करने के लिए आदर्श भाषा है।

— नील

+1। केवल गड़बड़ यह है कि जब सिर एक कोने पर होता है तो इसका मतलब सीधा होना चाहिए, न कि कोने के आसपास।

— जोनाथन एलन

इसलिए जैसे तार में अनुक्रमण द्वारा 16 बाइट्स सहेजें: '\/'[m],'-|'[m] और'>v'[m]

— जोनाथन एलन

के बीच की जगह को हटाकर 1 और बचाएं print और''.join

— जोनाथन एलन

Answer 3

जावास्क्रिप्ट (ईएस 6), 193 201 203 215 220 224

संपादित 4 बाइट्स सहेजे गए thx @Arnauld
Edit2 ने तर्क बदल दिए, x और y के लिए वर्तमान वेतन वृद्धि को संग्रहीत नहीं किया, बस उन्हें वर्तमान दिशा से प्राप्त करें
Edit3 कुछ बाइट्स बचा रहा है, मैंने उन्हें रिक्त स्थान के बेहतर प्रबंधन के लिए उपयोग करने का निर्णय लिया
Edit4 8 बाइट्स ने अन्य दिशाओं की तरह - सिर की दिशा के बारे में बिल्कुल उदाहरणों का पालन नहीं किया

वर्तमान संस्करण क्रोम, फ़ायरफ़ॉक्स और एमएस एज के साथ काम करता है

यह उत्तर कुछ अनुगामी और अग्रणी स्थान (और रिक्त लाइनें) देता है।

n=>(t=>{for(x=y=-~Math.sqrt(++n)>>1,g=[i=t];(g[y]=g[y]||Array(x).fill` `)[x]='^<v>|-/\\@'[t?n?i-t?4+t%2:x-y?7:6:t%4:8],n--;i=i>1?i-2:++t)d=t&2,t&1?x+=d-1:y+=d-1})(0)||g.map(x=>x.join``).join`
`

थोड़ा कम गोल्फ वाला

n=>
{
  g = [],
  // to save a few bytes, change line below (adds a lot of spaces)
  // w = ++n,
  w = -~Math.sqrt(++n)
  x = y = w>>1,
  s=c=>(g[y] = g[y] || Array(x).fill(' '))[x] = c, // function to set char in position
  s('@'); // place tail
  for (
     i = t = 0; // t increases at each turn, t%4 is the current direction
     n--;
     i = i > 0 ? i - 2 : t++ // side length increases every 2 turns
  )
     d = t & 2,
     t & 1 ? x += d-1: y += d-1
     s(!n ? '^<v>' [t % 4] // head
          : '|-/\\' [i > 0 ? t % 2 : x-y ? 3 : 2]) // body
  return g.map(x=>x.join``).join`\n`
}

f=
n=>(t=>{for(x=y=-~Math.sqrt(++n)>>1,g=[i=t];(g[y]=g[y]||Array(x).fill` `)[x]='^<v>|-/\\@'[t?n?i-t?4+t%2:x-y?7:6:t%4:8],n--;i=i>1?i-2:++t)d=t&2,t&1?x+=d-1:y+=d-1})(0)||g.map(x=>x.join``).join`
`

function update() {
  O.textContent=f(+I.value);
}

update()

<input type=number id=I value=19 oninput='update()' 
 onkeyup='update() /* stupid MS browser, no oninput for up/down keys */'>
<pre id=O>

Comments

आप की जगह में कुछ बाइट्स बचा सकता है (' ')के साथ ` ` और ('@')साथ`@`

— Arnauld

@ अरनल्ड एरे (2) .फिल `` ==> [ Array[1], Array[1] ], जबकि Array(2).fill(' ')==>[' ',' ']

— usandfriends

@usandfriends - सच। लेकिन इससे जुड़ने के बाद कोई फर्क नहीं पड़ना चाहिए।

— Arnauld

@Arnauld सबसे पहले मैं usandfriends से सहमत था, लेकिन यह वास्तव में काम करता है। धन्यवाद

— edc65

@TravisJ क्रोम में काम नहीं करता है, लेकिन फ़ायरफ़ॉक्स काम करने लगता है।

— अदनान

Answer 4

जावास्क्रिप्ट (ईएस 7), 200 बाइट्स

(n,s=(n*4+1)**.5|0,i=+`1201`[s%4],d=i=>`-`.repeat(i))=>[...Array(s-2>>2)].reduce(s=>`/-${d(i)}\\
${s.replace(/^|$/gm,`|`)}
|\\${d(i,i+=2)}/`,[`/\\
|@`,`/-\\
|@/`,`@`,`/@`][s%4])+`
\\${d(n-(s*s>>2))}>`

परीक्षण में आसानी के लिए ES6 संस्करण:

f=(n,s=Math.sqrt((n*4+1))|0,i=+`1201`[s%4],d=i=>`-`.repeat(i))=>[...Array(s-2>>2)].reduce(s=>`/-${d(i)}\\
${s.replace(/^|$/gm,`|`)}
|\\${d(i,i+=2)}/`,[`/\\
|@`,`/-\\
|@/`,`@`,`/@`][s%4])+`
\\${d(n-(s*s>>2))}>`;

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

Comments

दिलचस्प कार्यान्वयन। मैंने ऐसा करने के बारे में नहीं सोचा था। योगदान और अच्छी नौकरी के लिए धन्यवाद !!

— जैक्सनसेक 11

Answer 5

पर्ल, 111 110 बाइट्स

के लिए +1 शामिल है -p

STDIN पर आकार दें

snake.pl:

#!/usr/bin/perl -p
s%> %->%+s%\^ %/>%||s/
/  
/g+s%.%!s/.$//mg<//&&join"",//g,$/%seg+s/ /^/+y%/\\|>-%\\/\-|%for($\="/
\@
")x$_}{

Comments

बहुत बढ़िया! अच्छी नौकरी! योगदान के लिए धन्यवाद!

— जैक्सनसेक

Answer 6

बैच, 563 बाइट्स

@echo off
if %1==1 echo /@&echo v&exit/b
set w=1
:l
set/ah=w,a=w*w+w
if %a% gtr %1 goto g
set/aw+=1,a=w*w
if %a% leq %1 goto l
:g
call:d
set r=/%r%\
set/ae=h%%2,w=%1-h*w+2
for /l %%i in (1,1,%h%)do call:r
call:d
echo \%r%^>
exit/b
:d
set r=
for /l %%i in (3,1,%w%)do call set r=%%r%%-
exit/b
:r
echo %r:!=^|%
if %e%==0 set r=%r:@!=\/%
set r=%r:@/=\/%
set r=%r:!\=\-%
set r=%r:/@=\/%
set r=%r:/!=-/%
set r=%r:@!=\/%
set r=%r:/\=!@%
set r=%r:/-=!/%
if %e%==1 set r=%r:/\=@!%
set r=%r:/\=@/%
set r=%r:-\=\!%
if %e%==1 set r=%r:/\=/@%

स्पष्टीकरण: विशेष-मामलों 1 के रूप में कोड के बाकी हिस्सों में कम से कम दो की एक साँप की चौड़ाई की आवश्यकता होती है। अगला, सबसे बड़ा तिमाही वर्ग (या तो एक सटीक वर्ग या एक आयत 1 व्यापक से अधिक है) की गणना करता है जिसका क्षेत्र सांप की लंबाई से कम है। साँप को इस आयत में नीचे बाएँ कोने पर शुरू किया जाएगा और बीच में पूंछ के साथ समाप्त किया जाएगा, और शेष लंबाई आयत के तल के नीचे चलेगी। आयत वास्तव में सरल स्ट्रिंग प्रतिस्थापन से उत्पन्न होती है; अधिकांश समय प्रत्येक पंक्ति पिछली पंक्ति से विकर्ण 1 कदम आगे बढ़ने से उत्पन्न होती है, लेकिन जाहिर है कि पूंछ से भी निपटना पड़ता है, और आयत की ऊंचाई समान या विषम है या नहीं, इसके आधार पर मामूली अंतर हैं।

Comments

बहुत बढ़िया! योगदान के लिए धन्यवाद!

— जैकसनकैक

Answer 7

पायथन 2.7, एक व्हॉटिंग 1230 बाइट्स

मैं अजगर और कोड गोल्फ के लिए नया हूं, लेकिन मुझे लगा कि मुझे अपने सवाल का जवाब देना होगा और इस तथ्य के बाद शर्म से झुकना होगा। हालांकि इस पर काम करने में बहुत मज़ा आता है!

def s(n):
x = []
l = 0
if n % 2 == 1:
    l = n
else:
    l = n + 1
if l < 3:
    l = 3
y = []
matrix = [[' ' for x in range(l)] for y in range(l)] 
slash = '\\'
newx = l/2
newy = l/2
matrix[l/2][l/2] = '@'
newx = newx-1
matrix[newx][newy] = slash
#newx = newx-1
dir = 'West'

for i in range(0, n-1):    
    newx = xloc(newx, dir)
    newy = yloc(newy, dir)
    sdir = dir
    dir = cd(matrix, newx, newy, dir)
    edir = dir

    if (sdir == 'West' or sdir == 'East') and sdir != edir:
        matrix[newx][newy] = '/'
    else:
        if (sdir == 'North' or sdir == 'South') and sdir != edir:
            matrix[newx][newy] = '\\'
        else:
            if dir == 'East' or dir == 'West':
                matrix[newx][newy] = '-'
            else:
                matrix[newx][newy] = '|'
newx = xloc(newx, dir)
newy = yloc(newy, dir)
sdir = dir
dir = cd(matrix, newx, newy, dir)
edir = dir
print 'eDir: ' + dir
if dir == 'North':
    matrix[newx][newy] = '^'
if dir == 'South':
     matrix[newx][newy] = 'v'
if dir == 'East':
     matrix[newx][newy] = '>'
if dir == 'West':
     matrix[newx][newy] = '<'    


p(matrix, l)

def cd(matrix, x, y, dir):    
if dir == 'North':
    if matrix[x][y-1] == ' ':
        return 'West'
if dir == 'West':
    if matrix[x+1][y] == ' ':
        return 'South'
if dir == 'South':
    if matrix[x][y+1] == ' ':    
        return 'East'
if dir == 'East':
    if matrix[x-1][y] == ' ':        
        return 'North'
return dir

def p(a, n):
for i in range(0, n):
    for k in range(0, n):
        print a[i][k],
    print ' '

def xloc(x, dir):
if dir == 'North':
    return x -1
if dir == 'West':
    return x
if dir == 'East':
    return x 
if dir == 'South':
    return x + 1
 def yloc(y, dir):
if dir == 'North':
    return y
if dir == 'West':
    return y - 1
if dir == 'East':
    return y + 1
if dir == 'South':
    return y

s(25)

https://repl.it/Dpoy

Comments

अनावश्यक रूप से रिक्त स्थान, न्यूलाइन्स, टिप्पणियों, कार्यों, आदि को हटाकर इसे बड़े पैमाने पर कम किया जा सकता है ..

— Addison Crump