वहां, मैंने इसे (रस्सी के साथ) ठीक किया


10

संबंधित: बल्कि इसी तरह (लेकिन बहुत आसान) चुनौती क्षैतिज रूप से: वहाँ मैंने इसे (टेप के साथ) तय किया

चुनौती:

केवल ऊपरी और / या निचले अक्षरों (जो भी आप पसंद करते हैं) और नई-लाइनों वाली एक स्ट्रिंग को देखते हुए, ropeइसे ठीक करने के लिए लंबवत रखें। हम वर्णमाला में दो आसन्न पत्रों के अंतर की जांच करके यह कर (अनदेखी रैप-अराउंड और केवल नीचे की ओर जा रहा है), और साथ के रूप में ज्यादा जगह भरने ROPE/ ropeके रूप में हम की आवश्यकता होगी।
नोट: इस चुनौती और वहाँ के बीच एक अन्य महत्वपूर्ण अंतर मैंने इसे (टेप के साथ) चुनौती दी है कि हम ropeइस समय को बर्बाद नहीं कर रहे हैं जैसा कि हमने tape( चुनौती में एक भाग में @JonathanAllan द्वारा सुझाया गया है )।

उदाहरण:

इनपुट:

abc
bcd
ddd
eex
gfz
hka
imh

आउटपुट:

abc
bcd
Rdd
deE
efR
OPO
gEP
hRE
iOR
 kO
 PP
 mE
  R
  O
  P
  E
  R
  O
  P
  E
  R
  O
  x
  P
  z
  a
  E
  R
  O
  P
  E
  R
  h

क्यों?

  • बीच bऔर dस्तंभ में 1 होना चाहिए c(लंबाई 1), तो हम साथ इस भरने R;
  • बीच eऔर gस्तंभ में 1 होना चाहिए f(लंबाई 1), तो हम साथ इस भरने O;
  • बीच fऔर kकॉलम में 2 होना चाहिए ghij(लंबाई 4), तो हम साथ इस भरने PERO;
  • बीच kऔर mकॉलम में 2 होना चाहिए l(लंबाई 1), तो हम साथ इस भरने P;
  • बीच dऔर cस्तंभ में 3 होना चाहिए efghijklmnopqrstuvw(लंबाई 19), तो हम साथ इस भरने EROPEROPEROPEROPERO;
  • बीच xऔर zस्तंभ में 3 होना चाहिए y(लंबाई 1), तो हम साथ इस भरने P;
  • बीच aऔर hकॉलम 3 में होना चाहिए bcdefg, (लंबाई 6) इसलिए हम साथ इस भरने EROPER

चुनौती नियम:

  • अंतर केवल नीचे की ओर लागू होता है, इसलिए बीच में कोई रस्सी नहीं है za(ऊपर उदाहरण में कॉलम 3)।
  • समान आसन्न अक्षरों में से कई का होना संभव है, जैसे dd(ऊपर दिए उदाहरण में कॉलम 3)।
  • आप ROPEभागों को बर्बाद नहीं करने के लिए एक बार में एक कॉलम का उपयोग करना जारी रखेंगे ( चुनौती के भाग 1 में @ जोनाथन ऑलन द्वारा सुझाए गए )।
  • आपको किसी भी उचित प्रारूप में इनपुट लेने की अनुमति है। एकल स्ट्रिंग, स्ट्रिंग-सरणी / सूची, चरित्र-मैट्रिक्स, आदि हो सकते हैं। आउटपुट में समान लचीलापन है।
  • आपको किसी भी तरह से लोअरकेस और / या अपरकेस का उपयोग करने की अनुमति है। यह इनपुट, आउटपुट और दोनों पर लागू होता है ROPE
  • अनुगामी स्थान वैकल्पिक हैं (ध्यान दें कि प्रमुख रिक्त स्थान की सही मात्रा अनिवार्य है ताकि कॉलम सही हो)।
    अनुगामी और / या नई लाइनों के अग्रणी राशि भी वैकल्पिक हैं।
  • आप मान सकते हैं कि सभी प्रकार के परीक्षण सभी पंक्तियों में एक ही लंबाई होगा, तो a\naa/ [[a][a,a]]एक मान्य इनपुट नहीं होगा।
  • यह संभव नहीं ROPEहै कि आवश्यक नहीं है, जिस स्थिति में इनपुट अपरिवर्तित रहता है।

सामान्य नियम:

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

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

As string:
 Input:  "abc\nbcd\nddd\neex\ngfz\nhka\nimh"
 Output: "abc\nbcd\nRdd\ndeE\nefR\nOPO\ngEP\nhRE\niOR\n kO\n PP\n mE\n  R\n  O\n  P\n  E\n  R\n  O\n  P\n  E\n  R\n  O\n  x\n  P\n  z\n  a\n  E\n  R\n  O\n  P\n  E\n  R\n  h"
As array-matrix:
 Input:  [[a,b,c],[b,c,d],[d,d,d],[e,e,x],[g,f,z],[h,k,a],[i,m,h]]
 Output: [[a,b,c],[b,c,d],[R,d,d],[d,e,E],[e,f,R],[O,P,O],[g,E,P],[h,R,E],[i,O,R],[ ,k,O],[ ,P,P],[ ,m,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,O],[ , ,x],[ , ,P],[ , ,z],[ , ,a],[ , ,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,h]]

As string:
 Input:  "a\nz\na"
 Output: "a\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nz\na"
As array-matrix:
 Input:  [[a],[z],[a]]
 Output: [[a],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[z],[a]]

As string:
 Input:  "zz\nyy\nxx\nxx\ncc\ncc\nbb\nad"
 Output: "zz\nyy\nxx\nxx\ncc\ncc\nbb\naR\n d"
As array-matrix:
 Input:  [[z,z],[y,y],[x,x],[x,x],[c,c],[c,c],[b,b],[a,d]]
 Output: [[z,z],[y,y],[x,x],[x,x],[c,c],[c,c],[b,b],[a,R],[ ,d]]

As string:
 Input:  "a\nb\nc\nc\nx\nx\ny\nz"
 Output: "a\nb\nc\nc\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nx\nx\ny\nz"
 As array-matrix:
  Input:  [[a],[b],[c],[c],[x],[x],[y],[z]]
  Output: [[a],[b],[c],[c],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[x],[x],[y],[z]]

As string:
 Input:  "zai\nybj\nxcq\nxcu\ncxw\ncxw\nbyr\nazw"
 Output: "zai\nybj\nxcR\nxcO\ncRP\ncOE\nbPR\naEO\n Rq\n OP\n PE\n ER\n Ru\n OO\n Pw\n Ew\n Rr\n OP\n PE\n ER\n RO\n Ow\n P \n E \n x \n x \n y \n z "
As array-matrix:
  Input:  [[z,a,i],[y,b,j],[x,c,q],[x,c,u],[c,x,w],[c,x,w],[b,y,r],[a,z,w]]
  Output: [[z,a,i],[y,b,j],[x,c,R],[x,c,O],[c,R,P],[c,O,E],[b,P,R],[a,E,O],[ ,R,q],[ ,O,P],[ ,P,E],[ ,E,R],[ ,R,u],[ ,O,O],[ ,P,w],[ ,E,w],[ ,R,r],[ ,O,P],[ ,P,E],[ ,E,R],[ ,R,O],[ ,O,w],[ ,P, ],[ ,E, ],[ ,x, ],[ ,x, ],[ ,y, ],[ ,z, ]]

As string:
 Input:  "asdljasdjk"
 Output: "asdljasdjk"
As array-matrix:
 Input:  [[a,s,d,l,j,a,s,d,j,k]]
 Output: [[a,s,d,l,j,a,s,d,j,k]]

As string:
 Input:  "asdljasdjk\nlkawdasuhq\nasjdhajksd"
 Output: "asdljasdjk\nRkaOdasPhR\nOPOPEajEPO\nPEPER  REP\nERERO  ORE\nROROh  POR\nOPOP   EPq\nPEPE   ROd\nERER   OR \nRsRO   PO \nO jP   EP \nl  w   RE \na  d   Os \n       P  \n       E  \n       R  \n       O  \n       u  \n       k  "
As array-matrix:
 Input:  [[a,s,d,l,j,a,s,d,j,k],[l,k,a,w,d,a,s,u,h,q],[a,s,j,d,h,a,j,k,s,d]]
 Output: [[a,s,d,l,j,a,s,d,j,k],[R,k,a,O,d,a,s,P,h,R],[O,P,O,P,E,a,j,E,P,O],[P,E,P,E,R, , ,R,E,P],[E,R,E,R,O, , ,O,R,E],[R,O,R,O,h, , ,P,O,R],[O,P,O,P, , , ,E,P,q],[P,E,P,E, , , ,R,O,d],[E,R,E,R, , , ,O,R, ],[R,s,R,O, , , ,P,O, ],[O, ,j,P, , , ,E,P, ],[l, , ,w, , , ,R,E, ],[a, , ,d, , , ,O,s, ],[ , , , , , , ,P, , ],[ , , , , , , ,E, , ],[ , , , , , , ,R, , ],[ , , , , , , ,O, , ],[ , , , , , , ,u, , ],[ , , , , , , ,k, , ]]

As string:
 Input:  "re\nop\npo\ner"
 Output: "re\noR\npO\neP\n E\n R\n O\n P\n E\n R\n O\n p\n o\n P\n E\n r"
As array-matrix:
 Input:  [[r,e],[o,p],[p,o],[e,r]]
 Output: [[r,e],[o,R],[p,O],[e,P],[ ,E],[ ,R],[ ,O],[ ,P],[ ,E],[ ,R],[ ,O],[ ,p],[ ,o],[ ,P],[ ,E],[ ,r]]

8
क्या मैं hopeइसके बजाय इसे ठीक कर सकता हूं ? आशा रस्सी से मजबूत है। (यह हास्य का एक घटिया प्रयास है, वास्तविक सवाल नहीं है)
मैजिक ऑक्टोपस यूरन

@ केविनक्रूजसेन का मतलब क्या यह है कि आप आसान है टेप आसान है ??
Dat

3
@MagicOctopusUrn नहींं, रस्सी हमारी एकमात्र आशा है।
स्थिर

क्या मैं स्तंभों की संख्या और माप कर सकता हूँ ??
दत्त

@ डैट tapeचुनौती बहुत आसान है ( इम्हो )। और हाँ, आप कॉलम की एक सरणी आउटपुट कर सकते हैं।
केविन क्रूज़सेन

जवाबों:


3

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

ZµOI’R“¡nⱮ»ṁż@"µF€z⁶Y

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

व्याख्या

ZµOI’R“¡nⱮ»ṁż@"µF€z⁶Y  Main Link
Z                      Transpose the input so the columns are now rows
 µ                     New monadic chain
  O                    [Vectorizing] Convert each letter to its character code
   I                   [Vectorizing] Get the differences (gap size)
    ’                  [Vectorizing] Add one
     R                 [Vectorizing] Range from 1 .. x
           ṁ           Mold the string        into the ranges
      “¡nⱮ»                            "rope"
            ż@"        Vectorizing zip the rope strings with the original string (place ropes in gaps)
               µ       New monadic chain
                F€     Flatten Each
                  z⁶   Zip and fill with spaces
                    Y  Join on newlines for output

-1 बाइट थैंक्स टू मिस्टर एक्सकोडर
-2 बाइट्स के लिए धन्यवाद एरिक द आउटगॉल्फ



@ केविनक्रूजसेन ने तय किया
HyperNeutrino


@EriktheOutgolfer ओह हाँ धन्यवाद आईडी मैं क्यों eachऑटो-प्रत्येक चीजें थी: पी
हाइपरन्यूट्रीनो

@ केविनक्रूजसेन ने किया
हाइपरनेट्रिनो

4

05AB1E , 38 37 25 बाइट्स

मैजिक ऑक्टोपस Urn और एक अन्य बाइट बदलते आउटपुट प्रारूप के सुझावों के साथ 10 बाइट्स सहेजे गए ।

तार की एक सूची आउटपुट करता है।
पाद सुंदर प्रिंट।

'ÙºUζεDÇ¥<)ζε`FX¬sÀU}J]Jζ

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

व्याख्या

'ÙºU                       # store the string "rope" in variable X
    ζ                      # transpose input
     ε                ]    # for each transposed row
      D   )ζ               # zip the row with
       ǥ<                 # the decremented deltas of its character codes  
            ε              # for each pair of [letter, delta-1]
             `F     }      # delta-1 times do:
               X¬          # get the first letter of X (originally "rope")
                 sÀU       # rotate the letters left by 1 and store in X 
                     J     # join the rope-letter to the current row-letter
                       J   # join to list of strings (the new columns)
                        ζ  # transpose

@MagicOctopusUrn: मुख्य अंतर यह है कि Tapeहर बार जब हम इसे सम्मिलित करना चाहते हैं, तब हम इसके साथ शुरू होते हैं aTAdTAg। अब रस्सी के साथ हम जारी रखते हैं जहां हमने रस्सी पर छोड़ा था, इसलिए aROdPEg
एमिग्ना

1
उस tidbit को याद किया, जो "स्ट्रिंग को लंबाई X तक बढ़ाता है" और रिक्त स्थान सम्मिलित करने के लिए प्रत्येक वर्ण को उन स्थानों का संकेत देता है जहां "रस्सी" को जाना है, फिर रिक्त स्थान में विस्तारित स्ट्रिंग को सम्मिलित करना है?
मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: मुझे लगता है कि मेरे पास आपके सुझाव का उपयोग करके 32 है। अभी भी गोल्फ हो सकता है।
एमिगा

क्या 05AB1E में a: pop a,b,c | push c[b..a]टाइप डीलियो है ?
मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: नहींं। मैं सोच रहा था कि यह एक की जरूरत है।
एमिग्ना


2

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

->a{l=0;a.map!{|r|r.reduce{|x,y|x+("ROPE"*7)[l%4,-l+l+=[0,y.ord+~x[-1].ord].max]+y}}.map{|s|s.ljust a.map(&:size).max}}

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

हां, यह "टैप" चुनौती की तुलना में बहुत अधिक कठिन है। मैंने उस कार्य के लिए अपने समाधान का निर्माण करने की कोशिश की, लेकिन इसमें कुछ अतिरिक्त मोड़ हैं।

इनपुट को कॉलमवाइज़ सरणी के वर्ण के रूप में लेता है, स्ट्रिंग का एक सरणी देता है, कॉलमवाइज़ प्रारूप में भी। TIO लिंक के पाद लेख में कोड I / O डेटा का पूर्व और बाद का प्रसंस्करण करता है ताकि हम अधिक प्रबंधनीय स्ट्रिंग की आपूर्ति कर सकें और फिर परिणाम को अच्छी तरह से प्रिंट कर सकें।

व्याख्या

कोड इनपुट ऐरे से दो पास बनाता है।

पहले पास में हम उस reduceऑपरेशन को लागू करते हैं जो आरओपीई की आवश्यक मात्रा के साथ पात्रों के बीच की जगह को भरता है ( y.ord-x[-1].ord-1वर्ण, यदि सकारात्मक है)। हमें इस्तेमाल की गई ROPE लंबाई ( l) पर भी नज़र रखने की ज़रूरत है ।

TAPE मामले के विपरीत, हम केवल rjustभरने के लिए उपयोग नहीं कर सकते , क्योंकि यह हमेशा R अक्षर से शुरू होगा। इसके बजाय, लंबे "ROPEROPE ..." का एक उचित टुकड़ा लेने से स्ट्रिंग बाइट काउंट पर हल्का लगता है, खासकर जब से हमें lमक्खी पर अपडेट करने की भी आवश्यकता होती है ।

दूसरे पास में हमने उनमें से सबसे लंबे समय तक की लंबाई का मिलान करने के लिए रिक्त स्थान के साथ परिणामी तारों को छोड़ दिया। चूंकि हमें पिछले पुनरावृत्ति के पूर्ण परिणामों की आवश्यकता है, इसलिए पहली पास जगह में सरणी को संशोधित करता है (इसलिए map!, नहीं map)।


मेरे दिमाग में आपका कॉलमवाइज़ I / O फॉर्मेट पहले से ही समस्या का इतना हल करता है कि वह एक
खामियाजा

@ टोनहॉस्ट मैं पहले भी हिचकिचाया, लेकिन ओपी ने विशेष रूप से पुष्टि की कि यह चुनौती के लिए टिप्पणियों में ठीक है
किरिल एल।

आह, वह नहीं जो मैंने तय किया होगा, लेकिन यह ठीक है।
टन हास्पेल

1

-1 बाइट्स केविन क्रूज़सेन की बदौलत

-70 बाइट्स के लिए धन्यवाद जोनाथन फ्रेच , वाह ......।

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

def f(s,c=0,x=()):
	for i in range(len(s[0])):
		p,o=" ",""
		for j in s:t=j[i];y=p>' 'and~ord(p)+ord(t);o+=('ROPE'*y)[c:y+c]+t;c,p=c%4+y*(y>=0)%4,t
		x+=o,
	for i in x:yield i.ljust(len(max(x,key=len)))

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


ord(t)-ord(p)-1ord(t)+~ord(p)फिर से एक बाइट को बचाने के लिए किया जा सकता है। ;) यहाँ प्रासंगिक टिप है।
केविन क्रूज़सेन



चूँकि आप केवल मुद्रण योग्य वर्णों के साथ ही व्यवहार करते हैं, p!=' 'इसलिए भी इसके बराबर है p>' '
जोनाथन फ्रीच

1
एक जनरेटर का उपयोग करके 203 बाइट्स
जोनाथन फ्रीच

1

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

from itertools import*
def f(l):r=cycle('ROPE');return zip_longest(*(''.join(c+''.join(islice(r,max(ord(n)+~ord(c),0)))for c,n in zip(z,z[1:]+(' ',)))for z in zip(*l)),fillvalue=' ')

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

फ़ंक्शन अपने इनपुट को स्ट्रिंग्स की सूची (या पुनरावृत्ति) के रूप में लेता है और स्ट्रिंग्स के अनुक्रमों के लिए एक जनरेटर भी देता है, जो सूची के रूप में लगभग अच्छा है।

Ungolfed

… नेस्टेड जनरेटर की बेहतर पठनीयता के लिए।

def f(l):
    r = cycle('ROPE')
    return zip_longest(
        *(
            ''.join(
                c + ''.join(islice(r, max(ord(n) - ord(c) - 1, 0)))
                for c, n in zip(z, z[1:] + (' ',)))
            for z in zip(*l)),
        fillvalue=' ')

व्याख्या

  1. फ़ंक्शन zipस्तंभों के एक जनरेटर में लाइनों की आने वाली सूची को स्थानांतरित करने के लिए उपयोग करता है।

  2. अंतरतम जेनरेटर निकटवर्ती वर्णों और…

  3. … एक (अनंत) जनरेटर से निरंतर आरओपीई की आवश्यक मात्रा को स्लाइस करता है cycle

  4. जनरेटर से स्ट्रिंग की प्रचुर मात्रा में जुड़ने के बाद फ़ंक्शन एक जनरेटर या लाइनों पर कॉलम की सूची को फिर से स्थानांतरित करता है और लापता प्रविष्टियों को भरता है zip_longest


0

स्टैक्स , 25 बाइट्स

ÅiV╘ε╢+gA┘♦W[≈{`Co?-φvM«'

भागो और डिबग ऑनलाइन!

इनपुट और आउटपुट को अंतरिक्ष से अलग सूचियों के रूप में दिया जाता है। इनपुट आवश्यकतानुसार पंक्तियों की सूची है, आउटपुट अनुमति के अनुसार स्तंभों की सूची है।

व्याख्या

समझाने के लिए अनपैक्ड संस्करण का उपयोग करता है।

M"ROPE"s{2B{Ev|r%b:m~|(,m_s\mJ
M                                 Transpose
 "ROPE"                           The string "ROPE"
       s{                   mJ    Map each column (in the original input) with block, and output with space as the separator
         2B                       All contiguous pairs of current column
           {            m         Map each pair with block
            Ev|r%                     Pair [j,k] to length of range [j..k-2]
                 b:m                  Repeat current repeating string to given length
                    ~                 Last line gives the result the pair should map to, now store it on the input stack
                     |(               Rotate current repeating string `p` times, where `p` is the length of the range [j..k-1]
                       ,              Fetch back the result
                         _s\      Zip with current column, filling missing element with empty string
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.