एक स्ट्रिंग वसंत

Question

यहां सैंडबॉक्स पोस्ट ।

एक फ़ंक्शन या प्रोग्राम बनाएं जो एक स्ट्रिंग "स्प्रिंगलाइज़" करता है।

• इनपुट स्टिंग में एक स्ट्रिंग होगा, या निकटतम विकल्प होगा
• इनपुट में केवल मुद्रण योग्य ASCII और / या रिक्त स्थान होंगे
• आउटपुट स्टडआउट या निकटतम विकल्प के लिए होगा
• एक अनुगामी newlines और रिक्त स्थान स्वीकार्य हैं

कैसे एक स्ट्रिंग वसंत

1. स्ट्रिंग को आवश्यकतानुसार ASCII स्प्रिंग कॉइल में रूपांतरित करें
2. कॉइल को रिक्त स्थान के साथ रखें, निकटतम कुंडल तक
3. कुंडल के चारों ओर वसंत का पालन करते हुए, वर्णों को पढ़ें

यह एक ASCII वसंत का तार है:

#
# ####
 #    #
# ####
#

जहां #स्ट्रिंग के पात्र हैं

यहाँ एक उदाहरण है:

abcdefghijklmnopqrstuvwxyz

हो जाता है

a
b cdef
 g    h
i jklm
n
o
p qrst
 u    v
w xyz.
.

जहां .दृश्यता के लिए स्थान बदलते हैं।

फिर, स्ट्रिंग छोरों के चारों ओर, वापस पढ़ा जाता है, ASCII वसंत नीचे की ओर निम्नलिखित, मार gऔर uदो बार:

1| a  <-3
 V b cdef
    g    h
4| i jklm
 V n  2->
  ...

... दे रही है:

abgjklmhfedcginopuxyz vtsrquw (अनुगामी स्थान के साथ)

परीक्षण के मामलों

(अनुगामी स्थानों को उजागर करने के लिए जोड़े गए उद्धरण - कृपया IO के संदर्भ में ध्यान न दें)

I: "abcdefghijklmnopqrstuvwxyz"
O: "abgjklmhfedcginopuxyz vtsrquw "

I: "!@#"
O: "!@         #   "

I: ""
O: ""

I: "12345 67890"
O: "12690  7 54368 "

I: " "
O: "               "

ध्यान दें कि आउटपुट की लंबाई हमेशा 15 से अधिक होती है, स्प्रिंग कॉइल की लंबाई

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

Comments

मुझे लगता है कि यह कॉइल के साथ पैटर्न का पालन करने के लिए बहुत अधिक चुनौती है।

— मैजिक ऑक्टोपस Urn

@carusocomputing आप उलटा मतलब है?

— माइल्डलीवेटकास्ट

codegolf.stackexchange.com/a/107531/59376 से पता चलता है कि मैंने चुनौती को लिखित रूप में नहीं समझा, यही चुनौती अहा है।

— मैजिक ऑक्टोपस Urn

Answer 1

जेली , 26 बाइट्स

“4ṘƝ;þ¦Ɱ’b®¤ị
;⁶x14©¤s®ṖÇ€

TryItOnline!

कैसे?

“4ṘƝ;þ¦Ɱ’b®¤ị - Link 1, output for a single coil: char array
           ¤  - nilad followed by link(s) as a nilad
“4ṘƝ;þ¦Ɱ’     - base 250 number, 13140239220751650
          ®   - retrieve from register (14 from main link)
         b    - convert to base, [1,2,7,10,11,12,13,8,6,5,4,3,7,9,0]
            ị - index into the char array

;⁶x14©¤s®ṖÇ€ - Main link: theString
      ¤      - nilad followed by link(s) as a nilad
 ⁶           - a space character
  x          - repeated
   14©       - place 14 into the register and yield 14
;            - concatenate theString with the 14 spaces
       s     - split into chunks of length
        ®    -     retrieve from register (14)
         Ṗ   - pop last entry from the result (removes the space only last entry of 14 chars or less)
          Ç€ - call the last link (1) as a monad for €ach
             - implicit print

Answer 2

पायथन 2, 104 102 98 बाइट्स

f=lambda t:''.join((t+' '*13)[ord(x)-97+y*14]for y in range(len(t)/14+1)for x in'abgjklmhfedcgin')

टिप्पणी मदद के लिए धन्यवाद!

https://tio.run/#2VDVy

मूल:

t=raw_input()+' '*13
print''.join(t[ord(x)-97+y*14]for y in range(len(t)/14)for x in'abgjklmhfedcgin')

Comments

आप केवल input()प्रारूप में इनपुट का उपयोग कर सकते हैं और कर सकते हैं "<stuff>"।

— हाइपरनेत्रिनो

महान पहला गोल्फ! जैसा कि एलेक्स एल बताते हैं, हम इनपुट को उद्धरणों में लेने की अनुमति देते हैं। आप lambdaप्रोग्राम के बजाय अनाम फ़ंक्शन देने के लिए भी उपयोग कर सकते हैं - यह अक्सर छोटा होता है ।

— xnor

एक IndexError के साथ खाली स्ट्रिंग परीक्षण के मामले में विफल रहता है। मुझे लगता है कि आपको 13 से 14 को बदलने और अंतिम मूल्य को पॉप करने की आवश्यकता हो सकती है (मेरे जेली उत्तर की तरह)।

— जोनाथन एलन

... को बदलने +13के लिए +14और +1करने के लिए +(len(t)%14>0)यह करना होगा, लेकिन एक छोटे रास्ते होना चाहिए।

— जोनाथन एलन

Answer 3

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

f=
s=>s.replace(/.{1,14}/g,s=>'0169abc7543268d'.replace(/./g,c=>s['0x'+c-0]||' '))

<input oninput=o.textContent=f(this.value)><pre id=o>

हेक्साडेसिमल स्ट्रिंग बेशर्मी से @ETHproductions से चुराया गया।

Comments

@ETHproductions धन्यवाद, निश्चित।

— नील

ये तो बहुत खूब है!

— डोडोव

यह अच्छा है कि स्निपेट आपको परिणाम लिखते समय कैसे देखता है

— MildlyMilquetoast

Answer 4

रेटिना , 71 बाइट्स

$
13$* 
M!`.{14}|$
(.)(.)(.)(.)(.)(.)(.)(....)(.)¶
$5$8$6$4$3$2$1$5$7$9

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

अनुमति देने के तार रेटिना में बिल्कुल संक्षिप्त नहीं हैं ...

Answer 5

जावास्क्रिप्ट (ईएस 7), 144 143 141 114 104 103 बाइट्स

10B बचाने के लिए ETHProductions के लिए धन्यवाद!

a=>[...b=a+' '.repeat(15-a.length%15)].map((_,c)=>b['0x'+'0169abc7543268d'[c%15]-0+(c/15|0)*14]).join``

उदाहरण

f=a=>[...b=a+' '.repeat(15-a.length%15)].map((_,c)=>b['0x'+'0169abc7543268d'[c%15]-0+(c/15|0)*14]).join``
f('abcdefghijklmnopqrstuvwxyz')

उत्पादन

abgjklmhfedcginopuxyz vtsrquw 

Comments

बहुत अच्छा। आप कुछ बाइट्स को हेक्साडेसिमल स्ट्रिंग में परिवर्तित करके बचा सकते हैं, और +('0x'+whatever)इसे एक संख्या में बदलने के लिए उपयोग कर सकते हैं :(_,c)=>b[(c/15|0)*14+ +('0x'+'0169abc7543268d'[c%15])]

— ETHproductions

कारगर तरकीब। मैं पहले से ही सरणी लिखने के अन्य तरीकों के बारे में सोच रहा था, लेकिन मैं किसी के साथ नहीं आ सका। मैं अभी भी छोटा कर सकता हूं, पहले हेक्साडेसिमल नंबर और फिर गुणा करके, अंतरिक्ष को अनावश्यक बना सकता हूं।

— ल्यूक

तुम भी '0x'+'...'[c%15]-0+(c/15|0)*14खुद को कोष्ठकों की एक जोड़ी बचाने के लिए कर सकते हैं :-)

— ETHproductions

आप सही हे। जोड़ा गया।

— ल्यूक

Answer 6

पर्ल 6 , 61 बाइट्स

{S:g/(.)**1..14/{[~] $0["abgjklmhfedcgin".ords X-97]X//" "}/}

यह काम किस प्रकार करता है

मूल संरचना यह है:

{                                  }  # A lambda.
 S:g/(.)**1..14/{                }/   # Regex-replace segments of 1-14 characters, with:
                     $0               #   The single-char submatches captured by the parens.
                       [  ]           #   Index them using certain indices (see below).
                           X//" "}    #   Replace each undefined element with a space.
                 [~]                  #   Concatenate the characters.

प्रत्येक 14-वर्ण खंड में अनुक्रमणिका के लिए प्रयुक्त अभिव्यक्ति है "abgjklmhfedcgin".ords X- 97, जो निम्नानुसार काम करती है:

1. हार्ड-कोडेड स्ट्रिंग लें abgjklmhfedcgin।
2. इसके कोडपाइंट प्राप्त करें 97 98 103 106 107 108 109 104 102 101 100 99 103 105 110:।
3. प्रत्येक संख्या से 97 घटाएँ 0 1 6 9 10 11 12 7 5 4 3 2 6 8 13:।

---

पर्ल 6 , 64 बाइट्स

{[~] .comb(14)».comb»[0,1,6,9..12,7,5...2,6,8,13].flat X//" "}

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

यह काम किस प्रकार करता है

मूल संरचना यह है:

{                                    }  # A lambda.
     .comb(14)                          # Split the argument into substrings of <= 14 chars.
              ».comb                    # Split each substring into a list of characters.
                    »[  ]               # Index each list using the same indices (see below).
                         .flat          # Flatten the resulting nested list.
                               X//" "   # Replace each undefined element with a space.
 [~]                                    # Concatenate the list to get a string again.

ऊपर के समान संकेत, लेकिन चूंकि हम .flatवैसे भी बुला रहे हैं , हम उनके लिए एक नेस्टेड (लेकिन 1 बाइट कम) अभिव्यक्ति का उपयोग कर सकते हैं 0,1,6,9..12,7,5...2,6,8,13:।

(तुच्छ दिखता है, लेकिन वास्तव में रकोडो पर्ल 6 की एक अजीब ख़ासियत पर निर्भर करता है, जो शायद एक बग है । उस बग का दोहन किए बिना इसे लिखने के लिए, एक को आसपास के पार्न्स को जोड़ना होगा 5...2।)

Answer 7

बेफुंज -93, 97 बाइट्स

<>0>v%2g3\p89:-1+*"!"!:+1<_@#`0:~
,^\,_\:98g\9p1+:76+`#v_:~^
^,,g96g98g9+67,,,,,$$_
==    =  ====

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

यह हाइलाइट किए गए विभिन्न घटक भागों के साथ स्रोत कोड का टूटना है।

मुख्य लूप बाएं से दाएं निष्पादित करना शुरू कर देता है, प्लेफील्ड के दाहिने हाथ की ओर लपेटता है। यह वह जगह है जहां हम स्टड से पहला चरित्र पढ़ते हैं, और यदि यह ईओएफ है, तो इसे समाप्त कर दें।
अगला खंड यह सुनिश्चित करता है कि कोई ईओएफ वर्ण सूत्र का उपयोग करके रिक्त स्थान में परिवर्तित हो गया है c = c + 31*!(c+1)। हालांकि यह पहली पुनरावृत्ति पर लागू नहीं होगा, यह बाद के पास पर हो सकता है।
चरित्र की एक प्रतिलिपि अस्थायी मेमोरी में सहेजी जाती है, और फिर वर्तमान सूचकांक का एक लुक लाइन चार ( ) पर तालिका में प्रदर्शित किया जाता है ताकि यह निर्धारित किया जा सके कि चरित्र आउटपुट होना चाहिए या नहीं।
यदि चरित्र को आउटपुट की आवश्यकता होती है, तो हम बाईं शाखा लेते हैं। एक स्वैप यहां निष्पादित किया जाता है ताकि अगले स्वैप को रद्द किया जा सके, और फिर शाखा को सही करने के लिए एक शून्य धक्का दिया जाता है।
यदि चरित्र आउटपुट नहीं था, तो हम इसे इंडेक्स काउंटर के नीचे स्टैक स्वैप करते हैं (यह स्वैप है जो बाईं शाखा में रद्द हो जाता है)। और दोनों ही मामलों में हम चरित्र को वर्तमान इंडेक्स ऑफ़सेट पर मेमोरी में सहेजते हैं, इंडेक्स को बढ़ाते हैं, और यह जांचते हैं कि क्या यह 13 से अधिक है।
यदि नहीं, तो हम अगले चरित्र को स्टड से पढ़ते हैं और इनर लूप को दोहराते हैं।
यदि यह है, तो हम 14 वर्णों का एक सेट पूरा कर चुके हैं, 7 आउटपुट ( abgjklm), और 7 स्टैक पर शेष हैं ( cdefhin)। हम अंतिम दो को छोड़ते हैं, शेष 5 ( hfedc) का उत्पादन करते हैं , और फिर विशेष मामलों को पुनर्प्राप्त और आउटपुट करते हैं g, iऔर nमेमोरी से।
और यह हमें मुख्य लूप की शुरुआत में वापस लाता है, जहां हम अगले 14 वर्णों के लिए फिर से प्रक्रिया को दोहराते हैं।

Comments

अच्छी व्याख्या, अच्छी तरह से किया

— MildlyMilquetoast

Answer 8

गणितज्ञ, 77 72 बाइट्स

5 बाइट बचाने के लिए JungHwan Min को धन्यवाद!

Join@@Partition[#,14,14,{1,1}," "][[;;,LetterNumber@"abgjklmhfedcgin"]]&

वर्णों की सूची को इनपुट के रूप में लेने और वर्णों की सूची लौटाने का कार्य करें। Partition[#,14,14,{1,1}," "]यदि आवश्यक हो तो रिक्त स्थान के साथ पैडिंग 14 की लंबाई के उपविभागों में इनपुट को विभाजित करता है। LetterNumber@"abgjklmhfedcgin"का मूल्यांकन करता है {1,2,7,10,11,12,13,8,6,5,4,3,7,9,14}, जो प्रत्येक लंबाई -14 सबलिस्ट को (7 वें तत्व को उचित रूप से दोहराते हुए) लेने के आदेश को इंगित करता है। फिर [[;;,...]]उस क्रम में सभी लंबाई -14 उपखंड के तत्वों को लेता है, और Join@@एक साथ उत्तर जोड़ता है।

पिछला सबमिशन:

Join@@Partition[#,14,14,{1,1}," "][[All,83224017339955102~IntegerDigits~16]]&

Comments

LetterNumber@"abgjklmhfedcgin"सूची को संक्षिप्त करने का एक छोटा तरीका है। इसके ;;बजाय Allएक बाइट बचाता है।

— जुंगवान मिन

शानदार सुझाव!

— ग्रेग मार्टिन

Answer 9

पायथन 3 , 86 बाइट्स

lambda s:''.join(t[i%14]for t in zip(*[iter(s+' '*13)]*14)for i in b'Tq>]zQ|1/X;:L$o')

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

एक बोनस के रूप में, स्ट्रिंग Tq>]zQ|1/X;:L$oएक मान्य सीजेएम प्रोग्राम है जो मानक इनपुट पर अद्वितीय वर्णों को प्रिंट करता है, सॉर्ट किया जाता है। इसे ऑनलाइन आज़माएं! (+ अर्थ)

Answer 10

PHP, 94 बाइट्स

foreach(str_split($argv[1],14)as$s)for($i=0;$c=abgjklmhfedcgin[$i++];)echo$s[ord($c)-97]??" ";

14-बाइट विखंडू को कमांड लाइन तर्क को विभाजित करता है और उप-स्ट्रिंग के सूचकांक के रूप में अनुवाद स्ट्रिंग के माध्यम से छोरों। के साथ चला php -nr '<code>' <string>।

मुझे यह जानकर खुशी हुई कि ??यह रिक्त स्ट्रिंग ("अमान्य" सूचकांक के लिए) को शून्य के रूप में भी स्वीकार करता है।

Answer 11

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

->s{v="";(s+" "*13).scan(/.{14}/){|y|"0169:;<7543268=".chars{|o|v+=y[o.ord-48]}};v}

पहले विचार हेक्स संख्या का उपयोग कर रहा था, लेकिन ord-48 एक अन्य बाइट (थ्रोक्स के जवाब से चोरी) को बचाता है।