एक लहरदार स्ट्रिंग लाइन-दर-लाइन प्रिंट करें

Question

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक स्ट्रिंग sऔर पूर्णांक nमें पैरामीटर के रूप में लेता है । आपके प्रोग्राम को स्ट्रिंग को तब प्रिंट करना चाहिए (या वापस लौटना चाहिए) जब यह इस प्रकार है:

ऊपरी-बाएँ में शुरू करना और नीचे और दाईं ओर बढ़ना, sऊँचाई की लहर के रूप में लिखना n। फिर, ऊपर से नीचे तक, प्रत्येक पंक्ति को एक स्ट्रिंग (रिक्त स्थान के बिना) के रूप में संयोजित करें।

उदाहरण

स्ट्रिंग "वाटरलोन" और 3 की ऊंचाई को देखते हुए:

लहर इस तरह दिखनी चाहिए:

W   R   O
 A E M L N
  T   E

फिर, ऊपर से नीचे की पंक्तियों को मिलाएं:

WRO
AEMLN
TE

तो, आपके प्रोग्राम को स्ट्रिंग "WROAEMLNTE" वापस करना चाहिए

इसी तरह, ऊँचाई 4 के साथ "वाटिमेलन" को निम्न तरंग का उत्पादन करना चाहिए:

W     E
 A   M L
  T R   O
   E     N

आपके कार्यक्रम को फिर स्ट्रिंग "WEAMLTROEN" लौटना चाहिए

नियम

इनपुट

इनपुट किसी भी उचित प्रारूप में लिया जा सकता है। स्ट्रिंग किसी भी मामले में हो सकती है जिसे आप पसंद करते हैं। आप ऐसा मान सकते हैं0 < n <= s.length

उत्पादन

आउटपुट में केवल परिवर्तित स्ट्रिंग (चाहे वह STDOUT में लौटाया या मुद्रित किया गया हो) शामिल होना चाहिए, साथ ही कोई अनुगामी न्यूलाइन्स भी।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है! मानक खामियों की अनुमति नहीं है।

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

Input                        Output

programmingpuzzles, 5 ->     piermnlsomgzgapzru
codegolf, 3           ->     cgoeofdl
elephant, 4           ->     enlatehp
1234567, 3            ->     1524637
qwertyuiop, 1         ->     qwertyuiop

Comments

क्या हम मान सकते हैं n> 1? कृपया स्पष्ट करें और यदि कोई परीक्षण मामला नहीं जोड़ रहा है

— लुइस मेंडो

आप मान सकते हैं n > 0, लेकिन n=1एक वैध मामला है। मैं अब सवाल को अपडेट करूंगा।

— काउबुनघोल

@Cowabunghole मुझे पता है। :) संबंधित केवल इसका मतलब है कि यह कुछ समान है और मौजूदा उत्तर इस चुनौती के लिए सहायक हो सकते हैं। मैं केवल इसका उल्लेख करता हूं कि उन्हें दाईं ओर लिंक किए गए प्रश्नों में दिखाई देता है। संबंधित = नकलची। ;)

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

मैंने कभी नहीं देखा है कि केवल एक रेल के साथ एक रेल बाड़ के साइफन को इनकोड किया गया है। बस 'कह

— wooshinyobject

@Veskah आह, पुरानी डबल रोट 13 चाल।

— वूशिनोबोबेक्ट

Answer 1

भूसी , 6 बाइट्स

δÖK…¢ḣ

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

n = 1साथ ही काम करता है ।

व्याख्या

δÖK…¢ḣ  Implicit inputs, say n=4 and s="WATERMELON"
     ḣ  Range: [1,2,3,4]
    ¢   Cycle: [1,2,3,4,1,2,3,4,1,2,3,4..
   …    Rangify: [1,2,3,4,3,2,1,2,3,4,3,2..
δÖK     Sort s by this list: "WEAMLTROEN"
        Print implicitly.

उच्च आदेश फ़ंक्शन δहुड के तहत इस तरह काम करता है। मान लीजिए कि आपके पास एक उच्च क्रम फ़ंक्शन है जो एक असमान फ़ंक्शन और एक सूची लेता है, और एक नई सूची देता है। उदाहरण के लिए, Öएक फ़ंक्शन लेता है और कुंजी के रूप में इसका उपयोग करके एक सूची को सॉर्ट करता है। फिर δÖएक बाइनरी फ़ंक्शन और दो सूचियां लेता है, एक साथ सूचियों को ज़िप करता है, Öबाइनरी फ़ंक्शन का उपयोग करके जोड़े को कुंजी के रूप में सॉर्ट करने के लिए लागू होता है, और अंत में जोड़े को दूसरे समन्वय के लिए प्रोजेक्ट करता है। हम Kमुख्य फ़ंक्शन के रूप में उपयोग करते हैं, जो बस अपना पहला तर्क देता है और दूसरे को अनदेखा करता है।

Answer 2

MATL , 16 बाइट्स

Zv3L)t?yn:)2$S}i

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

आदानों पर विचार करें 5, 'programmingpuzzles'।

Zv     % Input, implicit: number n. Symmetric range
       % STACK: [1 2 3 4 5 4 3 2 1]
3L     % Push [1 -1+1j]. When used as an index, this means 1:end-1
       % STACK: [1 2 3 4 5 4 3 2 1], [1 -1+1j]
)      % Index. Removes last element
       % STACK: [1 2 3 4 5 4 3 2]
t      % Duplicate
       % STACK: [1 2 3 4 5 4 3 2], [1 2 3 4 5 4 3 2]
?      %   If non-empty and non-zero
       %   STACK: [1 2 3 4 5 4 3 2]
  y    %   Implict input: string s. Duplicate from below
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2], 'programmingpuzzles'
  n    %   Number of elements
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2], 18
  :    %   Range
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2], [1 2 3 ··· 17 18]
  )    %   Index modularly
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2 1 2 3 4 5 4 3 2 1 2]
  2$S  %   Two-input sort: stably sorts first input as given by the second
       %   STACK: 'piermnlsomgzgapzru'
}      % Else. This branch is entered when n=1. The stack contains an empty array
       %   STACK: []
  i    %   Take input
       %   STACK: [], [], 'programmingpuzzles'
       % End, implicit
       % Display stack, implicit. Empty arrays are not displayed

Answer 3

हास्केल , 64 बाइट्स

s#n=[c|m<-[0..n],(c,i)<-zip s.cycle$[0..n-1]++[n-2,n-3..1],i==m]

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

Answer 4

जे , 54, 29, 27 26 बाइट्स

-1 बाइट धन्यवाद करने के लिए hoosierEE

([\:#@[$[:}:|@i:@<:@]) ::[

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

Comments

@LuisMendo हम्म, एक बार फिर मैं कुछ महत्वपूर्ण याद किया। धन्यवाद! फिक्स्ड।

— गैलन इवानोव

मैंने शुरू में इसे भी याद किया, फिर महसूस किया और ओपी से पूछा। n=1शुरुआत से ही एक परीक्षण मामला होना चाहिए था

— लुइस मेंडू

|@i:इसके बजाय [:|i:एक बाइट बचाता है

— hoosierEE

@hoosierEE हाँ, धन्यवाद!

— गैलन इवानोव

Answer 5

आर , 68 बाइट्स

function(s,n)intToUtf8(unlist(split(utf8ToInt(s),-(n:(2.9-n)-1)^2)))

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

• -10 बाइट्स @Giuseppe को धन्यवाद
• -17 बाइट्स क्योंकि मैं मूर्ख था
• -9 बाइट्स और n=1केस @ JDoe का धन्यवाद
• -3 बाइट्स @JayCe को धन्यवाद

Answer 6

पायथन 2 , 119 108 98 92 91 97 93 91 90 बाइट्स

lambda s,n:''.join(c*(j%(2*n-2or 1)in(i,2*n-i-2))for i in range(n)for j,c in enumerate(s))

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

_{-1 बाइट, जोनाथन फ्रेच को धन्यवाद}

Comments

संभव 90 बाइट्स ।

— जोनाथन फ्रीच

Answer 7

05AB1E (विरासत) , 11 8 बाइट्स

Σ²Lû¨¾è¼

@LuisMendo के MATL उत्तर से प्रेरित ।
-3 बाइट्स @ @ अदनान को धन्यवाद क्योंकि मैं एक बेवकूफ हूँ ..>।>

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

स्पष्टीकरण:

Σ           # Sort the (implicit) input-string by:
 ²L         #  Create a list in the range [1, second input-integer]
            #   i.e. 5 → [1,2,3,4,5]
   û        #  Palindromize it
            #   i.e. [1,2,3,4,5] → [1,2,3,4,5,4,3,2,1]
    ¨       #  Remove the last item
            #   i.e. [1,2,3,4,5,4,3,2,1] → [1,2,3,4,5,4,3,2]
     ¾è     #  Index into it (with wraparound) using the counter_variable (default 0)
            #   i.e. counter_variable = 0 → 1
            #   i.e. counter_variable = 13 → 4
       ¼    #  And after every iteration, increase the counter_variable by 1

नोट: इसका counter_variableउपयोग किया जाता है, क्योंकि 05AB1E के पायथन लिगेसी संस्करण में, Σएक अंतर्निहित इंडेक्स नहीं था- N, जो कि यह 05AB1E के नए एलिक्जिर रीराइट संस्करण में है। तो मैं अभी भी लिगेसी संस्करण का उपयोग क्यों करूं? क्योंकि अमृत में यह फिर से लिखा है कि यह स्ट्रिंग को वर्णों की सूची में }Jबदल देता है , अतिरिक्त को इसे वापस स्ट्रिंग में बदलने के लिए आउटपुट की आवश्यकता होती है (और इसमें अभी एक बग भी शामिल है जहां èलंबी सूची में अनुक्रमित करने के लिए बिल्कुल भी काम नहीं करता है। ..: एस)

Comments

आपको इस ¹g∍भाग की आवश्यकता नहीं है क्योंकि 05AB1E के लिए चक्रीय अनुक्रमण का उपयोग करता है è।

— अदनान

@ अदनान आह, मैं एक बेवकूफ हूँ ..>> धन्यवाद!

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

Answer 8

जाप , 16 बाइट्स

¬üÏu´VÑ aV°ÃÔc q

इसे ऑनलाइन टेस्ट करें!

व्याख्या

 ¬ üÏ   u´ VÑ  aV° Ã Ô c q
Uq üXY{Yu--V*2 aV++} w c q    Ungolfed
                               Implicit: U = input string, V = size of wave
Uq                             Split U into chars.
   üXY{            }           Group the items in U by the following key function:
       Y                         Take the index of the item.
        u--V*2                   Find its value modulo (V-1) * 2.
               aV++              Take the absolute difference between this and (V-1).
                                 This maps e.g. indices [0,1,2,3,4,5,6,7,...] with V=3 to
                                                        [2,1,0,1,2,1,0,1,...]
                                 The items are then grouped by these values, leading to
                                 [[2,6,...],[1,3,5,7,...],[0,4,...]].
                     w         Reverse the result, giving [[0,4,...],[1,3,5,7,...],[2,6,...]].
                       c       Flatten.
                         q     Join back into a single string.

Comments

o वह üतरीका नया है?

— लुइस फेलिप डी जीसस मुनोज

हां, शनिवार को जोड़ा गया :-)

— ETHproductions

आप एक बाइट और आउटपुट को बचाने के लिए एक चरित्र सरणी के रूप में इनपुट ले सकते हैं या -Pदूसरे को बचाने के लिए ध्वज का उपयोग कर सकते हैं 2.

— Shaggy

Answer 9

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

ऊंचाई 1 के लिए 6 बटर विफल; दो बाइट्स इसे संबोधित करते थे ... शायद एक 7 पाया जा सकता है?

ŒḄṖȯ1ṁỤị

एक सकारात्मक लिंक और वर्णों की एक सूची देने वाले वर्णों की सूची को स्वीकार करने वाला एक डियाडिक लिंक।

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

कैसे?

ŒḄṖȯ1ṁỤị - Link: positive integer N; list of characters, T
ŒḄ       - bounce (implicit range of) N -> [1,2,3,...,N-1,N,N-1,...,3,2,1]
  Ṗ      - pop off the final entry         [1,2,3,...,N-1,N,N-1,...,3,2]
   ȯ1    - OR one                          if this is [] get 1 instead
     ṁ   - mould like T (trim or repeat to make this list the same length as T)
      Ụ  - grade-up (get indices ordered by value - e.g. [1,2,3,2,1,2] -> [1,5,2,4,6,3])
       ị - index into T

Answer 10

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

@MattH (-3 बाइट्स) द्वारा सुझाया गया छोटा सूत्र

के रूप में इनपुट लेता है (string)(n)।

s=>n=>--n?[...s].map((c,x)=>o[x=x/n&1?n-x%n:x%n]=[o[x]]+c,o=[])&&o.join``:s

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

---

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

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

के रूप में इनपुट लेता है (string)(n)।

s=>n=>--n?[...s].map((c,x)=>o[x=n*n-(x%(n*2)-n)**2]=[o[x]]+c,o=[])&&o.join``:s

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

Comments

मेरा समाधान आप के समान सुंदर समाप्त हो गया। oके x/n&1?n-x%n:x%nबजाय डालने सूचकांक की गणना कर आप -3 बाइट्स बचा सकते हैं n*n-(x%(n*2)-n)**2।

— मट्ठ

@ मत्त निकली। धन्यवाद!

— अरनौलड

Answer 11

के ( कोना ), 23 बाइट्स

गैलेन द्वारा जे जवाब का एक अनुवाद

{y@<(#y)#-1_(!x),|!x-1}

Answer 12

MBASIC , 146 159 155 बाइट्स

1 INPUT S$,N:DIM C$(N):P=1:D=1:FOR I=1 TO LEN(S$):C$(P)=C$(P)+MID$(S$,I,1)
2 IF N>1 THEN P=P+D
3 IF P=N OR P=1 THEN D=-D
4 NEXT:FOR I=1 TO N:PRINT C$(I);:NEXT

एन = 1 को संभालने के लिए अद्यतन किया गया

आउटपुट:

? programmingpuzzles, 5
piermnlsomgzgapzru

? codegolf, 3
cgoeofdl

? elephant, 4
enlatehp

? 1234567, 3
1524637

? WATERMELON, 4
WEAMLTROEN

? qwertyuiop, 1
qwertyuiop

Comments

वर्तमान में सपोर्ट केस n = 1 नहीं है।

— wooshinyobject

मामले को संभालने के लिए अद्यतन किया गया n = 1

— wooshinyobject

तुलना को साफ करके 4 बाइट्स बचाए।

— wooshinyobject

Answer 13

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

->\n{*.comb.sort({-abs n-1-$++%(2*n-2||1)}).join}

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

एक करी फ़ंक्शन के रूप में इनपुट लेता है।

स्पष्टीकरण:

->\n{*.comb.sort({-abs n-1-$++%(2*n-2||1)}).join}
->\n{                                           }  # Take an number
     *.comb        # Turn the string into a list of chars
           .sort({                       })   # And sort them by
                           $++    # The index of the char
                              %(2*n-2||1)  # Moduloed by 2*(n-1) or 1 if n is 0
                       n-1-       # Subtract that from n-1
                   abs            # get the absolute value
                  -               # And negate to reverse the list
                                          .join  # and join the characters

अनुक्रम जो इसे क्रमबद्ध करता है वह इस तरह दिखता है (के लिए n=5):

(-4 -3 -2 -1 0 -1 -2 -3 -4 -3 -2 -1 0 -1 -2 -3 -4 -3 -2 -1)

Answer 14

जे , 24 बाइट्स

4 :'x\:(#x)$}:|i:<:y'::[

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

स्पष्ट रंगादि क्रिया। इसे वैसे ही चलाएं 'codegolf' f 3।

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

4 :'x\:(#x)$}:|i:<:y'::[    x: string, y: height
4 :                         Define a dyadic verb:
               i:<:y        Generate a range of -(y-1) .. y-1
            }:|             Take absolute value and remove last
       (#x)$             1) Repeat to match the string's length
    x\:                     Sort x by the decreasing order of above
                     ::[    If 1) causes `Length Error`, return the input string instead

आम तौर पर, स्पष्ट कार्य के रूप में अतिरिक्त 5 बाइट्स लेता है n :'...'। लेकिन अगर एरर हैंडलिंग को जोड़ा जाता है, तो परेंस और स्पेस के कारण अंतर 2 बाइट्स तक नीचे चला जाता है (tacit)<space>::।

Comments

मैं हमेशा उपयोग क्यों करते हैं sort up?! आपकी स्पष्ट क्रिया अभी भी 3 बाइट्स छोटी है। अच्छा निर्णय!

— गैलेन इवानोव

Answer 15

APL (Dyalog Classic) , 23 बाइट्स

{⍺[⍋(≢⍺)⍴(¯1↓⊢,1↓⌽)⍳⍵]}

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

Answer 16

पॉवरशेल, 99 95 बाइट्स

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[((1..$n+$n..1)*$s.Length|gu)[$i++*($n-gt1)]-1]+=$_}
-join$r

टेस्ट स्क्रिप्ट:

$f = {

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[((1..$n+$n..1)*$s.Length|gu)[$i++*($n-gt1)]-1]+=$_}
-join$r

}

@(
    ,("1234567", 3            ,     "1524637")
    ,("qwertyuiop", 1         ,     "qwertyuiop")
    ,("codegolf", 3           ,     "cgoeofdl")
    ,("elephant", 4           ,     "enlatehp")
    ,("programmingpuzzles", 5 ,     "piermnlsomgzgapzru")
) | % {
    $s,$n,$e = $_
    $r = &$f $s $n
    "$($r-eq$e): $r"
}

आउटपुट:

True: 1524637
True: qwertyuiop
True: cgoeofdl
True: enlatehp
True: piermnlsomgzgapzru

व्याख्या

लिपी:

• पंक्तियों की एक सरणी बनाता है,
• उपयुक्त मूल्यों के साथ पंक्तियों को भरता है,
• और शामिल पंक्तियों को लौटाता है।

अभिव्यक्ति ((1..$n+$n..1)*$s.Length|gu जैसा क्रम उत्पन्न करती है 1,2,3,3,2,1,1,2,3,3,2,1... और आसन्न डुप्लिकेट को हटा देती है। गेट-यूनिक केgu लिए उपनाम है ।

• के लिए $n=3deduplicated अनुक्रम है:1,2,3,2,1,2,3,2,1...
• के लिए $n=1deduplicated अनुक्रम है:1

एक्सप्रेशन $i++*($n-gt1) डेडिकेटेड सीक्वेंस में एक इंडेक्स देता है। =$i++यदि $n>1, अन्यथा=0

Answer 17

रूबी , 75 65 बाइट्स

->s,h{a=['']*h;x=-k=1;s.map{|c|a[x+=k=h-x<2?-1:x<1?1:k]+=c};a*''}

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

इनपुट को एक वर्ण के रूप में लेता है, स्ट्रिंग लौटाता है

यह कैसे जागता है:

• बनाएं hतार
• इनपुट स्ट्रिंग में प्रत्येक वर्ण के लिए, यह तय करें कि इसे किस स्ट्रिंग को इसके सूचकांक के आधार पर रखा जाए (संशोधित किए जाने वाले स्ट्रिंग का सूचकांक hतब तक ऊपर जाता है और तब तक नीचे 0और इतने पर)
• लौटें सभी तार एक साथ शामिल हो गए

Comments

64 बाइट्स

— जीबी

@ जीबी यह अंतिम केस के लिए काम नहीं करता है

— Asone Tuhid

Answer 18

सी, 142 134 बाइट्स

8 बाइट्स ने जोनाथन फ्रीच को धन्यवाद दिया

कोड:

t;i;j;d;f(s,n)char*s;{for(t=strlen(s),i=0;i<n;i++)for(j=0;j+i<t;j=d+i+(n<2))d=j-i+2*~-n,putchar(s[i+j]),i>0&i<n-1&d<t&&putchar(s[d]);}

स्पष्टीकरण:

// C variable and function declaration magic
t;i;j;d;f(s,n)char*s;{
    // Iterate through each "row" of the string
    for(t=strlen(s),i=0;i<n;i++)
        // Iterate through each element on the row
        // Original index iterator here was j+=2*(n-1), which is a full "zig-zag" forward
        // The (n<2) is for the edge case of n==1, which will break the existing logic.
        for(j=0; j+i<t; j=d+i+(n<2))
            // If j+i is the "zig", d is the "zag": Original index was d=j+i+2*(n-i-1)
            // Two's complement swag here courtesy of Jonathan Frech
            d=j-i+2*~-n,
            putchar(s[i+j]),
            // Short circuit logic to write the "zag" character for the middle rows
            i>0 & i<n-1 & d<t && putchar(s[d]);
}

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

Comments

नमस्कार और पीपीसीजी में आपका स्वागत है; अच्छा पहला गोल्फ। 134 बाइट्स (जीसीसी मानकर)।

— जोनाथन फ्रेच

Answer 19

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

⭆ＮΦη¬⌊Ｅ²﹪⁺μ⎇νι±ι∨⊗⊖θ¹

$m$$i$$m \pm i = 0 \pmod {2n - 2}$

 Ｎ                      First input as a number
⭆                       Map over implicit range and join
   η                    Second input
  Φ                     Filter over characters
       ²                Literal 2
      Ｅ                 Map over implicit range
          μ             Character index
             ι ι        Outer index
              ±         Negate
            ν           Inner index
           ⎇            Ternary
         ⁺              Plus
                   θ    First input
                  ⊖     Decremented
                 ⊗      Doubled
                    ¹   Literal 1
                ∨       Logical Or
        ﹪               Modulo
     ⌊                  Minimum
    ¬                   Logical Not
                        Implicitly print

Answer 20

SNOBOL4 (CSNOBOL4) , 191 बाइट्स

	S =INPUT
	N =INPUT
	A =ARRAY(N)
	A<1> =EQ(N,1) S	:S(O)
I	I =I + -1 ^ D
	S LEN(1) . X REM . S	:F(O)
	A<I> =A<I> X
	D =EQ(I,N) 1
	D =EQ(I * D,1)	:(I)
O	Y =Y + 1
	O =O A<Y>	:S(O)
	OUTPUT =O
END

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

Sफिर Nअलग लाइनों पर ले जाता है ।

स्पष्टीकरण:

	S =INPUT			;* read S
	N =INPUT			;* read N
	A =ARRAY(N)			;* create array of size N
	A<1> =EQ(N,1) S	:S(O)		;* if N = 1, set A<1> to S and jump to O
I	I =I + -1 ^ D			;* index into I by I + (-1)^D (D starts as '' == 0)
	S LEN(1) . X REM . S	:F(O)	;* extract the first character as X and set S to the
					;* remaining characters, jumping to O when S is empty
	A<I> =A<I> X			;* set A<I> to A<I> concatenated with X
	D =EQ(I,N) 1			;* if I == N, D=1
	D =EQ(I * D,1)	:(I)		;* if I == D == 1, D = 0. Goto I
O	Y =Y + 1			;* increment the counter
	O =O A<Y>	:S(O)		;* concatenate the array contents until last cell
	OUTPUT =O			;* and print
END

Answer 21

क्लीन , 105 84 बाइट्स

import StdEnv,Data.List
$s n=[c\\l<-[1..n],c<-s&m<-cycle([1..n]++[n-1,n-2..2])|m==l]

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

Answer 22

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

c=>g=(s,d=c*2-2,r=d,n=o='')=>s&&([...s].map((c,i)=>i%d%r?n+=c:o+=c),o)+g(n,r-1,r-2)

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

Answer 23

पायथ , 22 21 बाइट्स

|seMhD,V*lz+PUQP_UQzz

इनपुट के nबाद sअलग-अलग लाइनों पर ले जाता है । इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

|seMhD,V*lz+PUQP_UQzz   Implicit: Q=eval(input()), z=remaining input

             UQ         Range [0-Q)
            P           All but last from the above
                         e.g. for Q=3, yields [0,1]
               P_UQ     All but last of reversed range
                         e.g. for Q=3, yields [2,1]
           +            Concatenate the previous two results
                          e.g. for Q=3, yields [0,1,2,1]
        *lz              Repeat len(z) times
      ,V           z    Vectorised pair the above with z, truncating longer to length of shorter
                          e.g. for Q=3, z=WATERMELON, yields:
                          [[0,'W'],[1,'A'],[2,'T'],[1,'E'],[0,'R'],[1,'M'],[2,'E'],[1,'L'],[0,'O'],[1,'N']]
    hD                  Sort the above by the first element
                          Note this is a stable sort, so relative ordering between equal keys is preserved
  eM                    Take the last element of each
 s                      Concatenate into string
                          Note that if n=1, the result of the above will be 0 (sum of empty array)
|                   z   If result of above is falsey, yield z instead

संपादित करें: खाली चेक को प्रसंस्करण के अंत में ले जाकर एक बाइट को बचाया। पुराना वर्जन: seMhD,V*lz|+PUQP_UQ]0z

Answer 24

लाल , 153 बाइट्स

func[s n][i: v: m: 1 b: collect[foreach c s[keep/only reduce[v i c]v: v + m
if all[n > 1(i: i + 1)%(n - 1)= 1][m: -1 * m]]]foreach k sort b[prin last k]]

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

स्पष्टीकरण:

f: func [ s n ] [                      ; s is the string, n is the height
    i: 1                               ; index of the current character in the string
    v: 1                               ; value of the "ladder"
    m: 1                               ; step (1 or -1)
    b: collect [                       ; collect the values in a block b
        foreach c s [                  ; foreach character in the string 
            keep/only reduce [ v i c ] ; keep a block of the evaluated [value index char] 
            i: i + 1                   ; increase the index
            v: v + m                   ; calculate the value 
            if all [ n > 1             ; if height is greater than 1 and
                    i % (n - 1) = 1    ; we are at a pick/bottom of the ladder
                   ]
                [ m: -1 * m ]          ; reverse the step
        ]
    ]
    foreach k sort b [ prin last k ]   ; print the characters in the sorted block of blocks
]

Answer 25

मेरे पास समस्या के दो समाधान हैं। पहला समाधान मैंने पहले किया था फिर मैंने इसे करने का एक और तरीका सोचा कि मुझे लगा कि बाइट्स बचेंगे, लेकिन ऐसा नहीं था, मैंने इसे वैसे भी शामिल किया।

---

समाधान 1

PHP , 152 144 116 बाइट्स

<?php
for($i=0;$i<$n=$argv[2];$i++)
    for($j=$i;$s=$argv[1][$j];$j+=$n<2|(($f=!$f|!$i)?$i<$n-1?$n+~$i:$i:$i)*2)
        echo $s;

• 8 बाइट्स @JoKing की बदौलत
• 28 बाइट्स @ शुग्गी को धन्यवाद

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

---

समाधान २

PHP , 162 बाइट्स

<?php
$s=$argv[0];
$n=$argv[1];
$l=strlen($s);
for($i=0;$i<$l;){
    for($j=0;$j<$n&&$i<$l;)
        $a[$j++].=$s[$i++];
    for($j=$n-2;$j>0&&$i<$l;)
        $a[$j--].=$s[$i++];
}
echo join($a);

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

Comments

आपको आरंभ करने की आवश्यकता नहीं है $fऔर $n-1-$iहो सकता है $n-~$i। 144 बाइट्स

— जो किंग

@ जोकिंग के सुधार पर -28 बाइट्स ।

— झबरा

OOP; वह टूट जाता है जब n=1। यह एक ही बाइट गिनती के लिए काम करता है।

— झबरा

आप 5 और बाइट्सecho को बचाने के

— Shaggy

Answer 26

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

->s,n{r=['']*n;[*0...n,*(2-n)..-1].map{|x|r[x.abs]+=s.slice!(0)||''}while s[0];r*''}

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

Comments

83 बाइट्स

— आसून तुहिद