पाठ के ग्रिड के विकर्णों को पंक्तिबद्ध करें

Question

पाठ के एक आयताकार ग्रिड को देखते हुए, उन विकर्णों को पंक्तिबद्ध करें जो ऊपरी-बाएं से नीचे-दाएं स्तंभों में ऐसे जाते हैं जैसे कि सभी विकर्णों के सबसे निचले-दाएं वर्ण एक स्तर पर हों। इंडेंटेशन के लिए रिक्त स्थान का उपयोग करें।

उदाहरण के लिए, यदि पाठ का इनपुट ग्रिड है

abcd
1234
WXYZ

तो आप विकर्ण लाइन अप था W, 1X, a2Y, b3z, c4, और dइस उत्पादन दे रही है स्तंभों में:

  ab
 123c
WXYZ4d

ध्यान दें कि सभी विकर्णों के सबसे कम-सही वर्ण WXYZ4dसमान स्तर पर हैं।

विवरण

• पाठ की इनपुट ग्रिड आकार में न्यूनतम 1 × 1 होगी और सभी लाइनें समान लंबाई की होंगी।

• आप इनपुट ग्रिड को मल्टीलाइन स्ट्रिंग या सिंगल लाइन स्ट्रिंग्स की सूची के रूप में ले सकते हैं।

• इनपुट ग्रिड में केवल मुद्रण योग्य ASCII वर्ण (स्थान शामिल हैं) होगा।

• आउटपुट में वैकल्पिक रूप से एक अनुगामी नई रेखा हो सकती है लेकिन कोई अन्य खाली रेखा नहीं होनी चाहिए।

• आउटपुट की पंक्तियों में वैकल्पिक रूप से अनुगामी स्थान हो सकते हैं लेकिन अनावश्यक प्रमुख स्थान नहीं होने चाहिए।

अन्य उदाहरण

खाली लाइनें अलग उदाहरण देती हैं। प्रत्येक इनपुट सीधे इसके आउटपुट के बाद होता है।

123
456
789

  1
 452
78963

123.?!
456??!
789!!!

  123.
 456???
789!!!!!

**@
@  

 **
@  @


/\/\
\/ /
/ /\
\/\/

   /
  \/\
 / / /
\/\/\/\

12
34
56
78
90

 7531
908642

Code

Code

G
O
L
F

FLOG

~

~

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

सम्बंधित। संबंधित टिप।

— मार्टिन एंडर

क्या इनपुट 2 डी चार सरणी (चार्ट का मैट्रिक्स) हो सकता है?

— लुइस मेंडू

क्या इनपुट के पहले कॉलम में स्थान हो सकते हैं?

— क्रिक्टी लिथोस

@LuisMendo जो ठीक लगता है।

— केल्विन के शौक

@KritiiLithos हाँ, यह हो सकता है।

— केल्विन के शौक

Answer 1

जे , 12 बाइट्स

|./.&.|:&.|.

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

व्याख्या

|./.&.|:&.|.
|.            Reversed
  /.          anti-diagonals
    &.        under
      |:      transpose
        &.    under
          |.  reversal

जे में, u &. v(पढ़ें: uअंडर v) का अर्थ है "वी, फिर यू, फिर वी का उलटा"। उत्क्रमण और पारगमन आत्म-व्युत्क्रम हैं, इसलिए कार्यक्रम का वास्तव में अर्थ है "रिवर्स, ट्रांसजेंड, एक्सट्रैक्टेड एंटी-विकर्ण, अट्रैक्शन, रिवर्स।"

उदाहरण इनपुट के साथ:

abcd
1234
WXYZ

उल्टा:

WXYZ
1234
abcd

स्थानांतरित:

W1a
X2b
Y3c
Z4d

उलटा विरोधी विकर्ण निकालें (और रिक्त स्थान के साथ पैड):

W  
X1 
Y2a
Z3b
4c 
d  

स्थानांतरित:

WXYZ4d
 123c 
  ab  

उल्टा:

  ab  
 123c 
WXYZ4d

Comments

क्रियाविशेषणों की शक्ति का उत्कृष्ट प्रदर्शन

— मील

मैं उठा और याद किया कि वास्तव में वे शंकालु थे।

— मील

Answer 2

जेली , 11 या 10 बाइट्स

ZŒDṙLUz⁶ṚUY

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

मेरे अन्य समाधान से काफी अलग एल्गोरिथ्म; यह मैन्युअल रूप से चीजों को करने के बजाय विकर्णों पर प्राप्त करने के लिए एक बिलिन का उपयोग करता है।

स्पष्टीकरण:

ZŒDṙLUz⁶ṚUY
Z           transpose
 ŒD         diagonals, main diagonal first
    L       number of lines in the original array
   ṙ        rotate list (i.e. placing the short diagonal first)
     U      reverse inside lines
      z⁶    transpose, padding with spaces
        ṚU  rotate matrix 180 degrees
          Y (possibly unnecessary) join on newlines

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

Answer 3

सीजेएम , 29 बाइट्स

qN/{)\z}h]2/{~W%+}%eeSf.*W%N*

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

व्याख्या

विकर्णों को निकालने के बजाय, हम अंत से परतों को छीलते हैं, बाएं और दाएं बारी-बारी से। निम्नलिखित इनपुट पर विचार करें:

GFDB
EEDB
CCCB
AAAA

अगर हम चुनौती के अनुसार विकर्णों को लिखते हैं, तो हमें यह मिलता है:

   G
  EEF
 CCCDD
AAAABBB

ध्यान दें कि यह बस (नीचे से ऊपर तक), सबसे नीचे की पंक्ति है, जिसे सबसे दाहिने कॉलम के साथ समतल किया गया है। यदि इनपुट आयताकार है तो यह परिभाषा भी काम करती है।

{      e# Run this loop while there are still lines left in the input.
  )    e#   Pull off the bottom-most row.
  \    e#   Swap with the remaining rows.
  z    e#   Transpose the grid so that the next iteration pulls off the last
       e#   column instead. However, it should be noted that transposing
       e#   effectively reverses the column, so the second half of each output
       e#   line will be the wrong way around. We'll fix that later.
}h     e# When the loop is done, we'll have all the individual layers on the
       e# stack from bottom to top, alternating between horizontal and vertical
       e# layers. There will be an empty string on top.
]      e# Wrap all those strings in a list.
2/     e# Split into pairs. There may or may not be a trailing single-element
       e# list with the empty string.
{      e# Map this block over each pair...
  ~    e#   Dump the pair on the stack.
  W%   e#   Reverse the second element.
  +    e#   Append to first element.
       e#   If there was a trailing single-element list, this will simply
       e#   add the empty string to the previous pair, which just removes
       e#   the empty string.
}%
ee     e# Enumerate the list, which pairs each string (now containing both halves)
       e# of an output line from bottom to top) with its index.
Sf.*   e# Turn those indices X into strings of X spaces, to get the correct
       e# indentation.
W%     e# Reverse the list of strings so the longest line ends up on the bottom.

Comments

सावधान, कि ]पूरे ढेर लपेट जाएगा! मुझे लगता है कि कार्यों को इनपुट के नीचे स्टैक सामग्री की परवाह किए बिना काम करना चाहिए, और आप सहमत लगते हैं ^ ^

— लिन

@Lynn वूप्स, भूल गए कि ]जब मैं इसे एक फ़ंक्शन में बदल रहा था तो मैं उपयोग कर रहा था ।

— मार्टिन एंडर

मुझे लगता है कि आप [{)\z}h]27 बाइट्स के लिए इसे कर और रख सकते हैं ।

— लिन

Answer 4

जावास्क्रिप्ट, 116 101 बाइट्स

f=(s,r='$&',l='',z=s.replace(/.$|\n?(?!.*\n)..+/gm,x=>(l=x+l,'')))=>l?f(z,r+' ')+l.replace(/\n?/,r):l


G.onclick=()=>O.textContent=f(I.value);

<textarea id=I style=height:100px>/\/\
\/ /
/ /\
\/\/</textarea><button id=G>Go</button><pre id=O></pre>

मैं सिर्फ इस regex पैटर्न /.$|\n?(?!.*\n)..+/gmविचार का उपयोग करना चाहता था । ^{( https://regex101.com/r/mjMz9i/2 )}

जावास्क्रिप्ट रेगेक्स स्वाद निराशाजनक है, मुझे इसका उपयोग करना पड़ा (?!.*\n)क्योंकि यह \Zलागू नहीं हुआ है , और किसी तरह मुझे उपयोग करने के लिए नहीं मिला \0।

• 15 बाइट्स थैंक्स @Neil।

Comments

मुझे इस दृष्टिकोण से प्यार है, लेकिन आप .इसके बजाय का उपयोग कर सकते हैं [^]क्योंकि आपको केवल एक नई लाइन खोजने के लिए गैर-न्यूलाइन वर्णों को छोड़ने की आवश्यकता है, जो 2 बाइट्स बचाता है।

— नील

मुझे नहीं लगता कि ^अंतिम रेगेक्स में यह आवश्यक है, क्योंकि कोई भी \nपहले से ही वैसे भी स्ट्रिंग की शुरुआत में है, ताकि दूसरे बाइट की बचत हो।

— नील

मैं गोल्फ के लिए एक तरह से आया हूँ '$&'+' '.repeat(n)। मूल रूप से यह है कि अभिव्यक्ति बस है $&लेकिन एक अंतरिक्ष प्रत्येक कॉल, जो रिकर्सिवली लागू करने के लिए मामूली बात है जोड़ा साथ - की जगह n=0के साथ r='$&'और f(z,n+1)साथ f(z,r+' ')और फिर rवांछित प्रतिस्थापन स्ट्रिंग है। अगर मैंने सही ढंग से गिना है जो 12 बाइट्स बचाता है।

— नील

@Neil। यह कमाल है !!, शुक्रिया

— वाशिंगटन गाइड्स

Answer 5

जेली , 15 या 14 बाइट्स

L’⁶x;\Ṛ;"µZUZṚY

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

यह एक एल्गोरिथ्म है जो विकर्णों के लिए जेली के अंतर्निहित का उपयोग नहीं करता है। ऐसा करने से वह कम हो सकता है; मैं अच्छी तरह से कोशिश कर सकता हूँ कि अगले।

यहाँ बताया गया है कि एल्गोरिथ्म कैसे काम करता है। आइए इस इनपुट से शुरू करते हैं:

["abc",
 "def",
 "ghi"]

हम साथ शुरू करते हैं L’⁶x;\। L’हमें इनपुट माइनस 1 की लंबाई देता है (इस मामले में, 2)। फिर ⁶xहमें उस लंबाई के रिक्त स्थान की एक स्ट्रिंग देता है ( " "इस मामले में); और ;\जब यह (रिक्तियों का एक त्रिभुज) समेटता है तो हमें संचयी परिणाम देता है। फिर हम त्रिभुज को उल्टा करते हैं और इसे मूल के बाईं ओर स्थित करते हैं ( ;"सूचियों के संबंधित तत्वों को µसम्मिलित करता है, जबरन पार्सिंग में विराम का कारण बनता है और इस प्रकार मूल इनपुट का उपयोग दूसरी सूची के रूप में डिफ़ॉल्ट रूप से करता है), हमें यह दे।

["  abc",
 " def",
 "ghi"]

यह लगभग समाधान है जो हम चाहते हैं, लेकिन हमें तत्वों को नीचे की ओर ले जाने की आवश्यकता है ताकि अंतिम तार के साथ फ्लश किया जा सके। यह ट्रांसपोज़िंग ( Z), प्रत्येक लाइन के अंदर ( U), फिर से ट्रांसपोज़िंग ( Z), और लाइनों को उलटने ( ) का मामला है Ṛ:

["  abc",
 " def",
 "ghi"]

पक्षांतरित

["  g",
 " dh",
 "aei",
 "bf",
 "c"]

पंक्तियों के भीतर उल्टा

["g  ",
 "hd ",
 "iea",
 "fb",
 "c"]

पक्षांतरित

["ghifc",
 " deb",
 "  a"]

पंक्तियों को उलट दें

["  a",
 " deb",
 "ghifc"]

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

Answer 6

पायथ, 16 बाइट्स

j_.t_M.Tm+*;l=tQ

बड़ा अजगर :

join-on-newline
reverse transpose-and-fill-with-spaces reverse func-map transpose-justified
map
  plus
    times innermost-var
      length assign tail input
    implicit-innermost-var
  implicit-input

चूंकि लोग कहते हैं कि गोल्फ की भाषाएं पढ़ना मुश्किल है, इसलिए मैंने बिग पाइथ को डिजाइन किया है, जो पाइथ के लिए आसानी से पठनीय और आसानी से अनुवाद योग्य दोनों है। लिंक की गई फ़ाइल बिग पायथ की एक इनपुट स्ट्रीम को पायथ में बदल देती है। प्रत्येक व्हाट्सएप से अलग बिग पाइथ टोकन एक पायथन टोकन से मेल खाता है, या तो एक चरित्र या .एक चरित्र द्वारा पीछा किया जाता है। अपवाद implicitटोकन हैं, जो पाइथ कोड में निहित हैं।

मैं यह देखना चाहता हूं कि बिग पाइथ का व्याख्यात्मक प्रारूप कितना अच्छा है, इसलिए मैं कोई अन्य स्पष्टीकरण नहीं देने जा रहा हूं। मुझसे पूछें कि क्या आप चाहते हैं कि कुछ समझाया जाए।

Answer 7

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

a=>[...Array(m=(h=a.length)<(w=a[0].length)?h:w)].map((_,i)=>[...Array(h+w-1)].map((_,j)=>(a[x=i+h-m-(++j>w&&j-w)]||``)[x+j-h]||` `).join``)

तार के सरणियों के रूप में इनपुट और आउटपुट लेता है। इसके अलावा एक दो आयामी चरित्र सरणी इनपुट स्वीकार करता है, और एक दो आयामी चरित्र सरणी उत्पादन स्वीकार्य है, तो 7 बाइट्स बचाओ। स्पष्टीकरण: परिणाम mकी ऊंचाई मूल सरणी की ऊंचाई hऔर चौड़ाई wका न्यूनतम है , जबकि चौड़ाई मूल सरणी की ऊंचाई और चौड़ाई के योग से केवल एक कम है। परिणाम के मुख्य भाग पर वर्णों के लिए स्रोत पंक्ति सीधे मूल सरणी की उपयुक्त पंक्ति से आती है, नीचे से गिनती होती है, जबकि परिणाम के अतिरिक्त भाग पर स्रोत पंक्ति प्रत्येक अतिरिक्त स्तंभ के लिए एक पंक्ति ऊपर ले जाती है। परिणाम के दोनों हिस्सों के लिए स्रोत स्तंभ नीचे के ऊपर प्रत्येक स्रोत पंक्ति के लिए छोड़े गए एक स्तंभ के गंतव्य गंतव्य स्तंभ के बराबर हो जाता है।

Answer 8

ऑक्टेव, 57 बाइट्स

@(A){B=spdiags(A),C=B>0,D='  '(C+1),D(sort(C))=B(C),D}{5}

Answer 9

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

def a(s):
 s=s.split('\n')
 for i,l in enumerate(s):r=len(s)-i-1;s[i]=' '*r+l+' '*(len(s)-r-1)
 print(*[''.join(i) for i in list(zip(*[''.join(a).rstrip([::-1].ljust(min(len(s),len(s[0])))for a in zip(*[list(i)for i in s])]))[::-1]],sep='\n')`

Comments

बेकार व्हाट्सएप पर join(i) for।

— यति

Answer 10

पायथन 2, 150 बाइट्स

def f(l):w=len(l[0]);h=len(l);J=''.join;R=range;print'\n'.join(map(J,zip(*['%%-%ds'%h%J(l[h+~i][j-i]for i in R(h)if-w<i-j<1)for j in R(h-~w)]))[::-1])

स्ट्रिंग की सूची के रूप में इनपुट लेता है।

Answer 11

क्लोजर, 194 बाइट्स

वर्णों को समूहीकृत करने Gऔर फिर लाइनें बनाने के लिए कठिन तरीका लागू किया ।

#(let[n(count %)m(count(% 0))G(group-by first(for[i(range n)j(range m)][(min(- n i)(- m j))((% i)j)]))](apply str(flatten(for[k(reverse(sort(keys G)))][(repeat(dec k)" ")(map last(G k))"\n"]))))

एक के रूप में इनपुट लेता है vecकी vecतरह रों [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]। उदाहरण:

(def f #( ... ))
(print (str "\n" (f (mapv vec(re-seq #".+" "abcd\n1234\nWXYZ")))))

  ab
 c123
d4WXYZ