एक स्तंभ घुमाएँ

Question

पूर्णांक k और या तो पाठ के एक खंड, या 2d सरणी को देखते हुए कि आंतरिक सरणियों में असमान लंबाई हो सकती है (जो पाठ का एक खंड जैसा होता है), k -th कॉलम में प्रत्येक वर्ण या तत्व को अगली स्थिति में ऊपर या नीचे घुमाएं। वह मौजूद है।

उदाहरण

निम्नलिखित पाठ का 20 वां कॉलम घुमाएँ (1-आधारित):

A line with more than k characters.
A longer line with more than k character.
A short line.
Rotate here: ------v--
This is long enough.

This is not enough.
Wrapping around to the first line.

आउटपुट:

A line with more thtn k characters.
A longer line with aore than k character.
A short line.
Rotate here: ------m--
This is long enoughv

This is not enough.
Wrapping around to .he first line.

घूर्णन कश्मीर ही इनपुट जहां 35 <के मई के स्तंभ कश्मीर <42 इनपुट पाठ अपरिवर्तित प्राप्त करेगी।

नियम

• आप कच्चे पाठ का उपयोग कर सकते हैं, लाइनों की एक सरणी, वर्णों का 2d सरणी या डेटा का प्रतिनिधित्व करने के लिए कोई भी उचित प्रारूप। आप वर्णों के अलावा डेटा प्रकारों का भी उपयोग कर सकते हैं।
• यदि आपके कोड की लंबाई इस पर निर्भर करती है, तो तत्वों के डेटा प्रकार के संभावित मानों की संख्या कम से कम 20 होनी चाहिए, अन्यथा कम से कम 2. यह मूल प्रकार में समर्थित वर्ण या अन्य मानों का सबसेट हो सकता है।
• रिक्त स्थान और किसी भी प्रकार के शून्य मान सामान्य मान हैं, यदि आप उन्हें इनपुट में अनुमति देते हैं। आप तत्व प्रकार में उन्हें भी बाहर कर सकते हैं।
• नियम परिवर्तन: यदि आप डेटा को संग्रहीत करने के लिए समान लंबाई वाले सरणियों का उपयोग करना पसंद करते हैं, तो आपको सामान्य डिफ़ॉल्ट मान (जैसे रिक्त स्थान) के साथ छोटी सरणियों को पैड करने की अनुमति है।
• k 0-आधारित या 1-आधारित हो सकता है। यह इनपुट में सबसे लंबी लाइन के अंदर होने की गारंटी है (इनपुट का मतलब है कि कम से कम एक गैर-खाली लाइन है)।
• आप चुन सकते हैं कि यह ऊपर या नीचे घूमता है या नहीं।
• या तो केवल एक स्थिति को घुमाएं, या n पदों को घुमाएं जहां n इनपुट में दिया गया एक पूर्णांक है।
• सबसे छोटा कोड जीतता है।

Answer 1

एपीएल (Dyalog विस्तारित) , 9 बाइट्स ^SBCS

पूरा कार्यक्रम। पाठ के 2 डी ब्लॉक के लिए संकेत स्टड, फिर k (0-आधारित या 1-आधारित, APL की वर्तमान सेटिंग पर निर्भर करता है), फिर n । पॉजिटिव एन रोटेट अप, नेगेटिव एन रोटेट डाउन।

डोमेन में निम्नलिखित में से कोई एक है:

1. सभी यूनिकोड वर्ण, रिक्त स्थान को छोड़कर , 1114111 ने मानों की अनुमति दी, जो कि आवश्यक 20 से अधिक है।

2. सभी संख्याएँ, 0 को छोड़कर , लगभग 2 ¹²⁹ अनुमत मूल्यों को छोड़कर , जो कि आवश्यक 20 से अधिक है।

चूंकि एपीएल को 2 डी ब्लॉकों को आयताकार होने की आवश्यकता होती है, इसलिए इनपुट को रिक्त स्थान / शून्य के साथ गद्देदार किया जाना चाहिए। यह ↑तार / संख्यात्मक सूचियों की सूची के बाईं ओर प्रवेश करके स्वचालित रूप से किया जा सकता है ।

⎕⌽@≠@⎕⍢⍉⎕

इसे ऑनलाइन आज़माएं! (स्पष्ट स्थान वास्तव में गैर-तोड़ने वाले स्थान हैं)

⎕ पाठ ब्लॉक के लिए संकेत

⍢⍉ जबकि ट्रांसपोज़्ड:

 @⎕ निम्नलिखित इनपुट इनपुट पंक्ति पर लागू करें:

  @≠ उनके प्रोटोटाइप से भिन्न तत्वों पर (वर्णों के लिए स्थान, संख्याओं के लिए शून्य):

   ⎕⌽ "इनपुट" चरणों को घुमाएं छोड़ दिया

एपीएल (Dyalog यूनिकोड) , 22+ बाइट्स ^SBCS

यह संस्करण शून्य को पहचानने योग्य भरण तत्व के रूप में उपयोग करके पूर्ण वर्ण सेट करने की अनुमति देता है।

0~¨⍨↓⍉⎕⌽@(0≠⊢)@⎕⍉↑0,¨⎕

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

इस पाठ्यक्रम का मतलब है कि संख्यात्मक तर्कों में शून्य की अनुमति नहीं है। सभी नंबरों के लिए इसी कार्यक्रम की 0जगह तीन घटनाएं होंगी ' 'और इस तरह से भरने के रूप में जगह का उपयोग करें:

' '~¨⍨↓⍉⎕⌽@(' '≠⊢)@⎕⍉↑' ',¨⎕

यदि हम वास्तव में वर्णों और संख्याओं (दोनों का मिश्रण) की पूरी श्रृंखला चाहते हैं, तो हम भरण के रूप में अशक्त का उपयोग कर सकते हैं:

n~¨⍨↓⍉⎕⌽@(n≠⊢)@⎕⍉↑⎕,¨⍨n←⎕NULL

और अंत में, यदि हम इनपुट डोमेन में नल और वस्तुओं को शामिल करना चाहते थे, तो हम एक भरण क्लास को परिभाषित कर सकते हैं और इस तरह के उदाहरणों को भर सकते हैं:

~∘I¨⍨↓⍉⎕⌽@(~⊢∊I←⎕INSTANCES⊢∘C)@⎕⍉↑⎕,¨⍨⎕NEW⎕FIX':Class C' ':EndClass'

Comments

अब इसे आधिकारिक रूप से घोषित करें (और इस तरह के नए उत्तर) एक वैध उत्तर के रूप में। क्षमा करें यदि इसने आपको बहुत परेशान किया है।

— jimmy23013

आपके अशक्त संस्करण की तुलना में छोटा n~¨⍨↓⍉⎕⌽@(≢¨)@⎕⍉↑⎕,¨⍨n←⊂⊂⍬:। हो सकता है कि आप ↑ ↓आगे गोल्फिंग की मदद करने के लिए अपने विस्तार में modded जोड़ सकते हैं (लेकिन मुझे यकीन नहीं है कि वे कितने उपयोगी हैं)।

— jimmy23013

@ jimmy23013 हाँ, मैंने सोचा था कि, लेकिन फिर यह मनमाने ढंग से नेस्टेड सामान की सूची नहीं ले सकता। अंतिम एक अंतिम समाधान है, खासकर अगर वे स्थानीय हैं Cऔर Iइसलिए वे प्रदूषित नहीं करते हैं:{~∘I¨⍨↓⍉⎕⌽@(~⊢∊I←⎕INSTANCES⊢∘C)@⎕⍉↑⎕,¨⍨⎕NEW⎕FIX I←C←':Class C' ':EndClass'}

— Adám

Answer 2

पायथन 2 , 111 110 109 99 98 96 94 बाइट्स

lambda a,n:[l[:n]+(l[n:]and[L[n]for L in a[i:]+a if L[n:]][1]+l[n+1:])for i,l in enumerate(a)]

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

इनपुट को लाइनों और 0-इंडेक्स कॉलम की सूची के रूप में लेता है, और स्ट्रिंग्स की एक सूची देता है।

कॉलम 1 घुमाया जाता है।

_{-11 बाइट्स, जो किंग के लिए धन्यवाद}

Answer 3

जावा 8, 107 106 135 107 बाइट्स

k->m->{int s=m.length,i=-1;for(char p=0,t;i<s;t=m[i%s][k],m[i%s][k]=p<1?t:p,p=t)for(;m[++i%s].length<=k;);}

बग-फिक्स के लिए +29 बाइट्स ।।

0 अनुक्रमित; उदाहरण की तरह घूमता है।
एक चरित्र-मैट्रिक्स के रूप में इनपुट; बाइट्स को बचाने के लिए एक नया वापस करने के बजाय चार-मैट्रिक्स को संशोधित करता है।

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

स्पष्टीकरण:

k->m->{                 // Method with integer and char-matrix parameters and no return-type
  int s=m.length,       //  Amount of lines in the matrix `s`
      i=-1;             //  Index-integer `i`, starting at -1
  for(char p=0,         //  Previous-character, starting at 0
           t;           //  Temp-char, uninitialized
      i<s               //  Loop as long as `i` is smaller than `s`:
      ;                 //    After every iteration:
       t=m[i%s][k],     //     Set the temp to the `k`th character of the `i`'th line
       m[i%s][k]=       //     Replace the `k`'th character of the `i`'th line with:
         p<1?           //      If `p` is still 0:
          t             //       Set it to the temp we just set
         :              //      Else:
          p,            //       Set it to the previous-character instead
       p=t)             //     And then replace `p` with the temp for the next iteration
    for(;m[++i          //   Increase `i` by 1 before every iteration with `++i`,
             %s].length //   And continue this loop until the length of the `i`'th line
           <=k;);}      //   is smaller than or equal to the input `k`

Comments

एक बात मैंने गौर की है कि आप एक धारणा बनाते हैं कि पहली पंक्ति में पर्याप्त वर्ण हैं - char p=m[0][k]- यदि ऐसा नहीं है, तो क्या यह अपवाद नहीं होगा? अच्छा काम बी.टी.वी. आप मेरे सी # प्रयास को बड़े अंतर से हरा रहे हैं :)

— दाना

@ डाना आह, बकवास, आप सही हैं .. मैं शायद आपको इस बड़े अंतर से हरा रहा हूं क्योंकि मैं गलती से यह धारणा बना रहा हूं .. इसे ठीक करने की कोशिश करेंगे।

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

@ डाना फिक्स्ड, नोटिंग के लिए धन्यवाद।

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

@ डडाना और फिर से 107 पर वापस। ;)

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

@EmbodimentofIgnorance आह, यह बदलना भूल गया nkn$k$int p=0,t;pm[i%s][k]=(char)(p<1?t:p)

Answer 4

ज़श , 94 87 78 74 69 बाइट्स

-7 बाइट्स को एक अंकगणितीय टर्नरी में बदलकर ; -9 बाइट्स को कैरेक्टर इन-प्लेस (टीआईएल) में बदलकर, -4 बाइट्स को स्टैन्ड पर इंडेक्स इनपुट करके और तर्कों के रूप में स्ट्रिंग्स के द्वारा , -5 बाइट्स एक स्ट्रिंग के बजाय एक स्ट्रिंग का उपयोग करके। घूर्णन पात्रों को संग्रहीत करने के लिए।

read i
for s;c+=$s[i]
c=$c[-1]$c
for s;s[i]=$c[$[$#s<i?0:++j]]&&<<<$s

पुराने पुराने पुराने पुराने यह ऑनलाइन कोशिश करो!

इस उत्तर को बनाने की कुंजी इस प्रकार है:

• $array[0]या $string[0]हमेशा खाली है
• $array[n]या $string[n]रिक्त है यदि n सरणी / स्ट्रिंग की लंबाई से बड़ा है
• array[i]=cया string[i]=cतत्व / चरित्र को बदल देगा।
• में $[$#s<i?0:++j], jहै नहीं करता है, तो वृद्धि की जाती $#s<i।

---

मूल 94 बाइट उत्तर में, एक दिलचस्प मुद्दा था जिसे मैं <<<प्रिंट करने के लिए उपयोग करना शामिल था । मुझे echoइसे पाने के लिए उपयोग करना पड़ा :

for s;echo $s[0,i-1]$c[$[$#s<i?0:++j]]${s:$i}

इसका कारण यहां देखा जा सकता है:

echo $ZSH_SUBSHELL   # prints 0
<<< $ZSH_SUBSHELL    # prints 1

यहां उप-स्ट्रिंग्स को उप-श्रेणियों में चलाया जाता है क्योंकि उन्हें दूसरे प्रोग्राम में स्टड के रूप में दिया जाता है। यदि कोई कार्यक्रम नहीं दिया गया है, तो इसका निहितार्थ है cat। आप इसके साथ देख सकते हैं <<< $_। <<< $ZSH_SUBSHELLके समान है echo $ZSH_SUBSHELL | cat। चूंकि हमें वेतन वृद्धि की आवश्यकता है j, इसलिए हम एक उप-सीमा में नहीं हो सकते।

Answer 5

आर , 62 बाइट्स

function(L,n){L[A,n]<-rep(L[A<-L[,n]!=' ',n],2)[1+1:sum(A)];L}

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

वर्णों के स्पेस-पेड मैट्रिक्स के रूप में इनपुट लेता है। ऊपर की ओर घूमता है। सभी को धन्यवादकिरिल एल । !

आर , 74 बाइट्स

function(L,n){substr(L[A],n,n)=rep(substr(L[A<-nchar(L)>=n],n,n),2)[-1]
L}

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

यह सबमिशन गद्देदार लाइनों के भत्ते को दर्शाता है।

अलियासिंग substrयहाँ क्योंकि हम फोन करने से काम नहीं चलेगाsubstr और substr<-पहली पंक्ति में।

गैर-गद्देदार लाइनों की सूची के रूप में I / O; ऊपर की ओर घूमता है।

Comments

चूंकि आम सहमति इनपुट को संशोधित करने की अनुमति देती है, हम इस पागल बात को

— किरिल एल।

इसके अलावा, ओपी ने नियमों को शिथिल कर दिया, ताकि अब अंतरिक्ष-पेड मैट्रिस के साथ काम करना संभव हो, कुछ इस

— किरिल एल।

@KirillL। मुझे नहीं लगता कि R संदर्भ से गुजरता है इसलिए हमें शायद ऐसा करने की अनुमति नहीं है; यह मुझे बताता है कि यह केवल तभी काम करता है जब तर्क को Lमूल वातावरण में नाम दिया गया हो। मैं खुशी से अंतरिक्ष-गद्दी के लिए अद्यतन करूंगा, हालांकि!

— ग्यूसेप

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

— किरिल एल।

Answer 6

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 82 बाइट्स

k=>a=>{var c='0';a.Where(b=>b.Count>k&&((b[k],c)=(c,b[k])).c>0).ToList()[0][k]=c;}

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

सुझाव के लिए @ASCIIOnly को क्रेडिट foreachजिसके कारण 12 बाइट की बचत हुई!

-8 बाइट्स @someone को धन्यवाद!
-1 बाइट @EmbodimentofIgnorance के लिए धन्यवाद!

Comments

184 बाइट्स

— डेटा

हो सकता है कि 183 अगर चार्ट के बजाय चींटियों का उपयोग कर रहे हों

— डेटा

@ExpiredData ew int बजाय char

— केवल

बहुत बुरा आप इसका उपयोग नहीं कर सकते foreachक्योंकि यह विपरीत क्रम है :(

— ASCII- केवल

dynamicघोषणाओं को मर्ज करने के लिए उपयोग करें और 2 बाइट्स सहेजें (मैंने पहले कभी नहीं देखा है!) इसे ऑनलाइन आज़माएं!

— मेरा सर्वनाम

Answer 7

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

->a,k{b=a.map{|i|i[k]}-[p];c=-2;a.map{|i|i[k]&&=b[c+=1]}}

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

लाइनों की एक सरणी के रूप में इनपुट लेता है a। 0-स्थित स्थिति में पाठ को नीचे घुमाता है k। इनपुट को संशोधित करके लौटाता है a।

Answer 8

05AB1E , 21 बाइट्स

ʒg‹}U¹εXyk©diX®<èIèIǝ

निश्चित रूप से कुछ और गोल्फ हो सकता है ..

0 अनुक्रमित; इनपुट और आउटपुट दोनों स्ट्रिंग्स की एक सूची के रूप में।
यह उदाहरण की तरह नीचे की ओर घूमता है, लेकिन इसके बजाय घूमने के लिए <इसे बदला जा सकता है >।

इसे ऑनलाइन आज़माएं (पाद लेख सूची को नई सूचियों से जोड़ता है, वास्तविक सूची आउटपुट देखने के लिए इसे हटा दें)।

स्पष्टीकरण:

ʒ  }             # Filter the (implicit) input-list by:
 g               #  Where length of the current string
  ‹              #  is larger than the (implicit) input-integer
    U            # Pop and store this filtered list in variable `X`
¹ε               # Map over the first input-list again:
  Xyk            #  Get the index of the current string in variable `X`
     ©           #  Store it in the register (without popping)
      di         #  If the index is not -1, so the current string is present in variable `X`
        X®<è     #   Get the (index-1)'th string in variable `X`
            Iè   #   Get the character at the index of the input-integer
              Iǝ #   And insert it at the index of the input-integer in the current string

Answer 9

K4 , 41 बाइट्स

समाधान:

{.[x;i;:;.q.rotate[1;x . i:(&y<#:'x;y)]]}

स्पष्टीकरण:

सुनिश्चित नहीं हैं कि अगर मैंने कुछ ... 0 सूचकांक याद कर रहा हूँ, ऊपर घूमता है (बदल 1करने के लिए -1घुमाने नीचे के लिए)

{.[x;i;:;.q.rotate[1;x . i:(&y<#:'x;y)]]} / the solution
{                                       } / lambda taking implicit x and y
 .[x; ;:;                              ]  / index apply assignment back into x
         .q.rotate[1;                 ]   / left rotate 1 character
                           (       ; )    / two item list
                                    y     / index to rotate
                               #:'x       / count (#:) each (') input
                             y<           / index less than ?
                            &             / indexes where true
                         i:               / assign to variable w
                     x .                  / index into x
     i                                    / indexes we saved as i earlier

Answer 10

Japt v2.0a0, 18 बाइट्स

0-एक बहु-पंक्ति स्ट्रिंग के रूप में इनपुट और आउटपुट के साथ। 1 से घूमता है।

वहाँ एक छोटी विधि होना चाहिए!

yÈr\S_Y¦V?Z:°TgXrS

कोशिश करो

yÈr\S_Y¦V?Z:°TgXrS     :Implicit input of string U & integer V
y                      :Transpose
 È                     :Pass each line X at 0-based index Y through the following function & transpose back
  r                    :  Replace
   \S                  :  RegEx /\S/g
     _                 :  Pass each match Z through the following function
      Y¦V              :    Test Y for inequality with V
         ?Z:           :    If true, return Z, else
            °T         :    Increment T (initially 0)
              g        :    Index into
               XrS     :    X with spaces removed

Comments

मैंने टिप्पणियों और नए नियमों को करीब से नहीं देखा है (इसलिए शायद इसका कहीं उल्लेख किया गया है, जबकि अब इसकी अनुमति नहीं है, जबकि यह पहले नहीं था), लेकिन क्या इसे प्रारंभिक इनपुट के रिक्त स्थान को छोड़ देने की अनुमति है? मान लें कि आपने इनपुट-इंडेक्स को बदल दिया है 6, तो आपका उत्तर line withपहली पंक्ति में और Rotate hereचौथी पंक्ति में स्थान को छोड़ देगा , जबकि अन्य उत्तर उस स्थान को भी घुमाएंगे।

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

@KevinCruijssen, मैं थोड़ा सभी अतिरिक्त नियम और भत्तों से उलझन में हूँ लेकिन, अगर यह है एक मुद्दा है, ऐसा लगता है कि मैं कुछ मिल सकता है कि इनपुट में रिक्त स्थान की अनुमति नहीं दे द्वारा। मुझे लगता है।

— झबरा

" मुझे लगता है " यह हिस्सा वास्तव में है कि मैं भी कैसे जवाब दूंगा, हाहा। मुझे पता नहीं है कि अब क्या अनिवार्य और वैकल्पिक है, लेकिन मुझे लगता है कि आप वास्तव में इन और आउटपुट में रिक्त स्थान चुन सकते हैं; मुझे लगता है कि आप रिक्त स्थान गिनना चुन सकते हैं या नहीं; और मुझे लगता है कि आप आउटपुट में ट्रायलिंग स्पेस का उपयोग कर सकते हैं या नहीं; आदि सभी भ्रामक हैं। आह अच्छी तरह से ..

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

Answer 11

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

z⁷⁹ịỴFṙ-ṁƲY⁸ṛ⁹¦"

एक डाइएडिक लिंक जो बाईं ओर रेखाओं की सूची को स्वीकार करता है (वर्णों की सूची जिसमें कोई नई पंक्ति वर्ण नहीं है) दाईं ओर एक पूर्णांक है जो लाइनों की एक सूची देता है।

इसे ऑनलाइन आज़माएं!(पाद लेख newlines पर विभाजन, लिंक को कॉल करता है, और फिर से newlines द्वारा जुड़ता है)

कैसे?

z⁷⁹ịỴFṙ-ṁƲY⁸ṛ⁹¦" - Link: lines L; index I        e.g. example in question; 20
z⁷               - transpose L with filler '\n'       ['AAART\nTW', '   oh\nhr', ...]
  ⁹ị             - Ith item                           'am\nv.\n\nt'
    Ỵ            - split at newlines                  ['am', 'v.', '', 't']
         Ʋ       - last four links as a monad - i.e. f(X):
     F           -   flatten                          'amv.t'
       -         -   -1
      ṙ          -   rotate left by                   'tamv.'
        ṁ        -   mould like X                     ['ta', 'mv', '', '.']
          Y      - join with newlines                 'ta\nmv\n\n.'
                 -   -- call this C
           ⁸     - chain's left argument, L
               " - zip with - i.e. [f(L1,C1), f(L2,C2), ...]:
              ¦  -   sparse application...
             ⁹   -   ...to indices: chain's right argument, I
            ṛ    -   ...of: right argument, Cn

Answer 12

पर्ल 5 (-p ), 75 बाइट्स

k 0-अनुक्रमित है, नीचे घुमाएं

s/.*//;$r="^.{$&}";s/
//;/$r(.)/;$c=$1;s/$r\K.(?=(?s:.)*?$r(.)|)/$1||$c/gme

TIO

Answer 13

पर्ल 6 , 38 33 बाइट्स

जगह में सरणी को संशोधित करता है (नियम अस्वीकार नहीं करते हैं)

{@^a.grep(*>$^b+1)[*;$b].=rotate}

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

Comments

@ सबसे पहले मैंने सोचा था कि इसे आउटपुट करने के बजाय इसे स्टोर करना थोड़ा धोखा होगा, लेकिन नियमों को फिर से लागू करना, आउटपुट के लिए कोई वास्तविक वजीफा नहीं है ... हुर्रे। 31 को पाने के लिए (…) (…) करना जैसे आपको निश्चित रूप से धोखा दे रहा है, क्योंकि यह प्रभावी रूप से ब्लॉक से कॉल को हटा रहा है, लेकिन यह अभी भी 33 के साथ किया जा सकता है एक साथ एक कॉल के साथ तो मैं ' मैं उस के साथ जा रहा हूँ।

— user0721090601

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

— जो किंग

Answer 14

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

k=>a=>a.filter(b=>b[k]&&([b[k],a]=[a,b[k]]))[0][k]=a

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

-7 बाइट्स झबरा धन्यवाद!

अभी तक एक जावास्क्रिप्ट जवाब नहीं देखा! मेरे C # उत्तर का पोर्ट।

Comments

63 बाइट्स । शायद आगे गोल्फ हो सकता है।

— शैगी

@ शैगी - अच्छा :) ज्यादातर समय मैं जेएस के जवाब को हर तरह की पागल चीजें करते देखता हूं। इस बार मुझे लगा कि जब मैं रणनीति बनाऊंगा तो मैं इसे एक शॉट दूंगा।

— दाना

ओह, अच्छी तरह से गोल्फ! :)

— झबरा

Answer 15

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

θＪη⁰≔ΦＫＤＬθ↓℅ιζＵＭζ§ζ⊖κ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। इनपुट के रूप में स्ट्रिंग्स की एक सरणी लेता है। 0 अनुक्रमित। संपादित करें: अब जो PeekDirectionठीक कर दिया गया है, मैं इसे सीधे जोड़ सकता हूं। स्पष्टीकरण:

θ

इनपुट स्ट्रिंग्स प्रिंट करें।

Ｊη⁰

घुमाए जाने के लिए स्तंभ के शीर्ष पर जाएं।

≔ΦＫＤＬθ↓℅ιζ

उन कोशिकाओं को निकालें जिन्हें अंदर मुद्रित किया गया है।

ＵＭζ§ζ⊖κ

प्रत्येक मुद्रित सेल को पिछले सेल (साइक्लिकली) के मान से बदलें। PeekDirectionकॉल के समय सेल मानों को आसानी से पढ़ा जाता है, इसलिए यह तथ्य कि MapCommandकॉल सेल में नए मान लिखते हैं, कोई फर्क नहीं पड़ता।

Answer 16

पिप -rn , 32 बाइट्स

POgY#(g@_)>aFI,#gFiyAE@ySsg@i@ag

0-अनुक्रमित, नीचे घूमता है। इसे ऑनलाइन आज़माएं!

सभी पंक्तियों के सूचकांकों को खोजने के लिए फिल्टर जो कि रोटेशन में भाग लेने के लिए काफी लंबे हैं। फिर उन पंक्तियों पर छोरों, प्रत्येक पंक्ति पर एक अस्थायी चर के साथ उचित चरित्र गमागमन s। अंत में पहली पंक्ति को फिर से देखने पर डमी मान वापस बाहर आ जाता है।

Answer 17

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

ZnÄ×$ịḟ¹ṙ-;ɗɗʋ€⁹¦⁶Z

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

1 अनुक्रमित। नीचे घूमता है। एक मोनडिक लिंक जो कि जेली स्ट्रिंग्स (पात्रों की सूची की एक सूची) की सही-गद्देदार सूची लेता है, पहले तर्क के रूप में और दूसरे के रूप में के। इनपुट में सही पैडिंग के अलावा रिक्त स्थान की मनाही है, लेकिन अन्य सभी वर्णों को अनुमति है।

जैसा कि TIO पर लागू किया गया है, पाद लेख स्ट्रिंग और राइट-पैड की सूची में एकल स्ट्रिंग इनपुट को विभाजित करता है, लेकिन यह सुविधा पर है; जैसा कि मैं इसे समझता हूं, उस चरण के परिणाम को नियमों के अनुसार मुख्य लिंक के लिए इनपुट की अनुमति है।

Answer 18

GFortran , 199 बाइट्स

_{-20 या तो स्टड से पढ़ने के बजाय एक फ़ाइल
-14 के बजाय रिक्त स्थान को हटाने के लिए i, k, n
-4 के लिए अंतर्निहित पूर्णांक का उपयोग करके और::}

उपयोगकर्ता को इनपुट करने की आवश्यकता है kऔर nपहली पंक्ति पर, जहां kघुमाव के लिए कॉलम है, और nपाठ की पंक्तियों की संख्या है। बाद के इनपुटों को घुमाए जाने वाले पाठ की पंक्तियाँ हैं। यह लिखने के लिए एक दर्द था! फोरट्रान कितना पांडित्य है!

character(99),allocatable::A(:);character(1)r,s
read(*,*)k,n;allocate(A(n))
do i=1,n;read(*,'(A)')A(i);r=A(i)(k:k)
if(r.ne.''.or.r.ne.' ')then;A(i)(k:k)=s;s=r;endif;enddo
A(1)(k:k)=s;print'(A)',A;end

• टिप्पणियों और संकलन नोटों के साथ मूल, यहां अनगढ़ कार्यक्रम: rotcol.f
• 203-बाइट संस्करण: rextester.com
• 199-बाइट संस्करण (नया): इसे ऑनलाइन आज़माएं!

Answer 19

टी-एसक्यूएल, 195 बाइट्स

WITH C as(SELECT rank()over(order by i)r,sum(1)over()c,*FROM @t
WHERE len(x)>=@)SELECT
isnull(stuff(c.x,@,1,substring(e.x,@,1)),t.x)FROM @t t
LEFT JOIN c ON t.i=c.i
LEFT JOIN c e ON e.r%c.c+1=c.r

यह ऑनलाइन ungolfed संस्करण का प्रयास करें