24

कार्य बहुत सरल है, जब एक इनपुट दिया जाता है, तो निम्न में से एक सर्पिल का उत्पादन होता है:

Input = 1Aशीर्ष बाएं कोने में शुरू अक्षर के साथ एक सर्पिल देता है :

A B C D E F
T U V W X G
S 5 6 7 Y H
R 4 9 8 Z I
Q 3 2 1 0 J
P O N M L K

Input = 2Aशीर्ष दाएं कोने में शुरू अक्षर के साथ एक सर्पिल देता है :

P Q R S T A
O 3 4 5 U B
N 2 9 6 V C
M 1 8 7 W D
L 0 Z Y X E
K J I H G F

Input = 3Aनीचे दाएं कोने में शुरू अक्षर के साथ एक सर्पिल देता है :

K L M N O P
J 0 1 2 3 Q
I Z 8 9 4 R
H Y 7 6 5 S
G X W V U T
F E D C B A

Input = 4Aनीचे बाएं कोने में शुरू अक्षर के साथ एक सर्पिल देता है :

F G H I J K
E X Y Z 0 L
D W 7 8 1 M
C V 6 9 2 N
B U 5 4 3 O
A T S R Q P

जैसा कि आप देख सकते हैं, सर्पिल हमेशा दक्षिणावर्त जाता है और बाहर से अंदर की ओर बढ़ता है ।

नियम सरल हैं:

आपको STDIN और STDOUT या संभव नहीं होने पर निकटतम समकक्ष का उपयोग करके एक पूर्ण कार्यक्रम प्रदान करने की आवश्यकता है।
एक इनपुट ( 1, 2, 3, 4) को देखते हुए , संबंधित सर्पिल आउटपुट।
ट्रेलिंग व्हाट्सएप की अनुमति है
लगातार इस्तेमाल करने पर अग्रणी व्हाट्सएप की अनुमति है
आपको आउटपुट के लिए अपरकेस अक्षर का उपयोग करने की आवश्यकता है, लोअरकेस अक्षरों की अनुमति नहीं है।
यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीतने वाला कार्यक्रम जीत जाता है!

— अदनान
स्रोत

3

संबंधित । इस तरह की

— भावनाएं

2

अधिक निकटता से संबंधित ।

— पीटर टेलर

2

क्या रिक्त स्थान आवश्यक हैं?

— माल्टसेन

@ मैलेटेन हाँ, वे आवश्यक हैं।

— अदनान

5

CJam, 45 43 42 बाइट्स

'[,65>A,+W%(s{W%z_,@s/(@.+}A*ri{W%z}*Sf*N*

इसका परीक्षण यहां करें।

व्याख्या

'[,65>  e# Push the upper-case alphabet.
A,+     e# Append the digits.
W%      e# Reverse everything.
(s      e# Pull off the 9 and turn it into a string.
{       e# Repeat this 10 times to roll the string up in a spiral...
  W%z   e#   Rotate the existing grid clockwise.
  _,    e#   Duplicate grid so far and get the number of rows.
  @s    e#   Pull up the list of characters and flatten it into one string.
  /     e#   Split the string into chunks of the size of the number of rows.
  (     e#   Pull off the first chunk.
  @.+   e#   Pull up the grid so far and prepend the chunk as a new column.
}A*     e# We now have the spiral as desired, with the A in the bottom left corner.
ri      e# Read input and convert to integer.
{       e# Repeat this code that often..
  W%z   e#   Rotate the spiral clockwise.
}*
Sf*     e# Join each line with spaces.
N*      e# Join the lines with linefeeds.

— मार्टिन एंडर
स्रोत

10

जाप , 53 बाइट्स 58 59 60

सहेजे गए 5 बाइट्स @ETHproductions की बदौलत

"FGHIJK EXYZ0L DW781M CV692N BU543O ATSRQP"¸zU ®¬¸} ·

यह रोटेट कमांड का उपयोग करता है जिसके बारे में मैंने कभी नहीं सोचा था कि यह इतना उपयोगी होगा

स्पष्टीकरण और & nbsp;

"FGHIJK EXYZ0L DW781M CV692N BU543O ATSRQP"qS zU m_q qS} qR

             // Implicit: U = input
"FGH...SRQP" // String, " " represent newlines
qS           // Split   " "
zU           // Rotate
m_           // Loop the lines
  q qS}      // Insert spaces
qR           // Join by newlines

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

— दुष्ट भेड़
स्रोत

अजीब बात है, जब मैं कार्यक्रम को ऑनलाइन चलाने की कोशिश करता हूं, तो यह गंजा हो जाता है और शिकायत करता है कि यह चर च नहीं पा रहा है।

— डेविड डिक

@DavidCarraher मैं फ़ायरफ़ॉक्स पर कोशिश करने की सलाह देता हूं, यह है कि ब्राउज़र दुभाषिया में सबसे अच्छा काम करने लगता है

— Downgoat

हां, यह फ़ायरफ़ॉक्स पर काम करता है। अच्छा लगा।

— डेविड डिक

अरे वाह! कुछ यूनिकोड शॉर्टकट का उपयोग करते हुए, आप बाइट की गिनती को पाँच में कटौती कर सकते हैं:"FGHIJK EXYZ0L DW781M CV692N BU543O ATSRQP"¸zU ®¬¸} ·

— ETHproductions

@ETHproductions ने पहले उन लोगों को नहीं देखा, धन्यवाद!

— ईविल भेड़

3

Mathematica 156 बाइट्स

अक्षरों की प्रारंभिक स्ट्रिंग "ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK"को एक सरणी में परिवर्तित करता है। उस सरणी समय Nestपर लागू होता fहै n-1, जहां n इनपुट संख्या है। प्रत्येक पंक्ति पर लागू होने के बाद सरणी fद्वारा काम करता है । अंतिम सरणी को एक स्ट्रिंग में परिवर्तित करता है।TransposeReverseg

s=StringJoin;r=Riffle;f=Nest[Reverse/@Transpose@#&,Partition[Characters@"ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK",6],#-1]&;
g@n_:=s@r[s/@(r[#," "]&/@f[n]),"\n"]

उदाहरण

g[4]

यदि आउटपुट को एक सरणी के रूप में दिया जा सकता है, तो फ़ंक्शन gअनावश्यक होगा।

f[4]

{"F", "G", "H", "I", "J", "K"}, {"E", "X", "Y", "Z", "0", "L "", {"D", "W", "7", "8", "1", "M"}, {"C", "V", "6", "9", "2", "एन"}, "" बी "," यू "," 5 "," 4 "," 3 "," ओ "}, {" ए "," टी "," एस "," आर "," क्यू " "," P "}}

— DavidC
स्रोत

कुछ क्षेत्रों में इन्फ़िक्स फ़ॉर्म का उपयोग किया जा सकता है।

— लीजनमोनमाल 978

3

MATLAB, 61 89 बाइट्स

b=[65:90 48:57];n=zeros(12,6);n(2:2:end)=rot90(b(37-spiral(6)),input('')-2);disp([n' ''])

मैं देखूंगा कि क्या मैं इसे थोड़ा नीचे ला सकता हूं। हालांकि यकीन नहीं होता।

यह ए से जेड तक सभी अक्षरों की एक सरणी बनाता है, इसके बाद 0 से 9 तक, फिर एक सर्पिल लेता है और सही क्रम में डेटा को व्यवस्थित करने के लिए उपयोग करता है। फिर सरणी को उपयोगकर्ता द्वारा निर्दिष्ट राशि से घुमाया जाता है और फिर प्रिंट आउट किया जाता है।

आउटपुट लगातार अग्रणी रिक्त स्थान का उपयोग करता है जैसा कि प्रश्न द्वारा अनुमति दी जाती है (वास्तव में बिना किसी अतिरिक्त बाइट लागत के, यह इसके बजाय अनुगामी रिक्त स्थान कर सकता है)। यहाँ एक उदाहरण है:

 F G H I J K
 E X Y Z 0 L
 D W 7 8 1 M
 C V 6 9 2 N
 B U 5 4 3 O
 A T S R Q P

जैसा कि मैंने देखा कि रिक्त स्थान आवश्यक हैं, यह मूल कोड (61 के लिए) मान्य नहीं है क्योंकि यह प्रत्येक वर्ण के बीच एक स्थान नहीं जोड़ता है। लेकिन मैं इसे संदर्भ के लिए यहां जोड़ूंगा।

b=['A':'Z' '0':'9'];disp(rot90(b(37-spiral(6)'),6-input('')))

और उत्पाद:

ABCDEF
TUVWXG
S567YH
R498ZI
Q3210J
PONMLK

— टॉम बढ़ई
स्रोत

2

जावास्क्रिप्ट ईएस 6, 165 172

सरल घुमाव, एक हार्डकोड स्ट्रिंग से शुरू

नोट 1 बाइट बचाया thx @ user81655

p=prompt();alert("ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK".split` `.map((r,y,a)=>[...r].map((c,x)=>p<2?c:a[p<3?5-x:p<4?5-y:x][p<3?y:p<4?5-x:5-y]).join` `).join`
`)

टेस्ट स्निपेट:

// Test: redefine alert to write inside the snippet
alert=x=>P.innerHTML=x

p=prompt();
alert(
  "ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK"
  .split` `
  .map(
    (r,y,a)=>
    [...r].map(
      (c,x)=>p<2?c:
      a
       [p<3?5-x:p<4?5-y:x]
       [p<3?y:p<4?5-x:5-y]
    ).join` `
  ).join`\n`
)

<pre id=P></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

आप टेम्प्लेट स्ट्रिंग्स के अंदर खुद `<newline>`को एक नया बाइट दे सकते हैं जो बाइट से छोटा है `\n`।

— user81655

@ user81655 thx, यहां तक कि 1 बाइट भी मायने रखती है, लेकिन यह वैसे भी बहुत

— भयानक है

1

पायथ - 60 बाइट्स

स्ट्रिंग को हार्डकोड करता है और सभी विकल्पों को प्राप्त करने के लिए मैट्रिक्स ऑपरेशन का उपयोग करता है।

jjL\ @[_CKc6"ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK"KC_K__MK)Q

टेस्ट सूट ।

— Maltysen
स्रोत

2

+<G6"इसके बजाय "ABCDEF2 बाइट्स बचाता है।

— पुरकाकूदरी

1

रूबी, 173 बाइट्स

->i{_,r,o=->s{s.map{|i|i*' '}},->s{s.transpose.map{|i|i.reverse}},%W(ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK).map(&:chars);puts i<2?_[o]:i<3?_[t=r[o]]:i<4?_[r[t]]:_[r[r[t]]]}

Ungolfed:

-> i {
  _ = -> s { s.map{|i| i*' ' } }
  r = -> s { s.transpose.map{|i| i.reverse } }
  o = %W(ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK).map(&:chars)
  puts i<2?_[o]:i<3?_[t=r[o]]:i<4?_[r[t]]:_[r[r[t]]]
}

उपयोग:

->i{_,r,o=->s{s.map{|i|i*' '}},->s{s.transpose.map{|i|i.reverse}},%W(ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK).map(&:chars);puts i<2?_[o]:i<3?_[t=r[o]]:i<4?_[r[t]]:_[r[r[t]]]}[4]
F G H I J K
E X Y Z 0 L
D W 7 8 1 M
C V 6 9 2 N
B U 5 4 3 O
A T S R Q P

— वासु अडारी
स्रोत

1

पायथन, 152 बाइट्स

s=[r for r in "ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK".split(" ")]
for i in range(1,int(input())):s=zip(*list(s)[::-1])
for x in s:print(" ".join(x))

— गैब्रिएल डी'अटन
स्रोत

अल्फ़ान्यूमेरिक सर्पिल