"स्लैश" क्रम में मैट्रिक्स

23

दो सकारात्मक संख्याओं को देखते हुए N >= 2और N <= 100एक मैट्रिक्स बनाएं जो निम्नलिखित नियमों का पालन करता है:

  • पहली संख्या स्थिति पर शुरू होती है [0,0]
  • दूसरी संख्या स्थिति पर शुरू होती है [0,1]
  • तीसरा नंबर फर्स्ट नंबर (स्थिति [1,0]) से नीचे जाता है
  • निम्नलिखित संख्या "स्लैश" दिशा में जाती है
  • प्रयुक्त संख्याओं की श्रेणी है [1, N1 * N2]। तो, दोनों इनपुट्स के गुणन के परिणाम में संख्या 1 से शुरू होती है।

इनपुट

  • दो नंबर N >= 2और N <= 100। पहली संख्या पंक्तियों की मात्रा है, दूसरी संख्या स्तंभों की मात्रा है।

उत्पादन

  • मैट्रिक्स। (एक बहुआयामी सरणी या लाइन ब्रेक के साथ एक स्ट्रिंग के रूप में आउटपुट किया जा सकता है)

उदाहरण:

दिए गए संख्या 3 and 5आउटपुट:

1   2   4   7   10
3   5   8   11  13
6   9   12  14  15

संख्या दी 2 and 2

1   2
3   4

दिए गए नंबर 5 and 5

1   2   4   7   11
3   5   8   12  16
6   9   13  17  20
10  14  18  21  23
15  19  22  24  25

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

code-golf  matrix 
— लुइस फेलिप डी जीसस मुनोज
स्रोत
2
क्या हम किसी भी संख्या के लिए 0 अनुक्रमण का उपयोग कर सकते हैं?
— जो राजा
2
@JoKing नंबर 1 से शुरू होना चाहिए
— लुइस felipe De jesus Munoz
5
— AdmBorkBork
1
@LuisfelipeDejesusMunoz शायद आदेश के लिए एक बेहतर शब्द "विकर्ण" है? व्यक्तिगत रूप से, मैं इसे "ज़िग-ज़ैग" कहूंगा, क्योंकि यह मुझे कैंटर के ज़िग-ज़ैग प्रमाण की याद दिलाता है, लेकिन यह भ्रामक हो सकता है।
— mbomb007
2
@LuisfelipeDejesusMunoz एंटी-विकर्ण अन्य विकर्ण के लिए शब्द है।
— qwr

जवाबों:

21

जेली , 6 5 बाइट्स

pSÞỤs

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

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

pSÞỤs  Main link. Left argument: n. Right argument: k

p      Take the Cartesian product of [1, ..., n] and [1, ..., k], yielding
       [[1, 1], [1, 2], ..., [n, k-1], [n, k]].
 SÞ    Sort the pairs by their sums.
       Note that index sums are constant on antidiagonals.
   Ụ   Grade up, sorting the indices of the sorted array of pairs by their values.
    s  Split the result into chunks of length k.
— डेनिस
स्रोत
अरे नहीं। मेरा 200+ बाइट्स है। आप कुछ स्पष्टीकरण pls जोड़ सकते हैं?
— लुइस फेलिप डी जेउस मुनोज
3
भगवान यह लानत है, डेनिस। साथ ही, अच्छी नौकरी।
— लीख
6
वाह, यह बहुत "संबंधित" है। यह मीलों के उत्तर की पहली कड़ी के समान है । दोनों को आगे बढ़ाने पर विचार करें। :)
— user202729
1
मुझे लगता है कि ऐसा करना संभव हो सकता है <atom><atom>¥þलेकिन मुझे सही संयोजन नहीं मिल रहा है। oþ++þकरीब है, लेकिन वहाँ नहीं मिलता है
— dylnan
1
@akozi अब तक, इतना अच्छा। क्रमबद्ध सरणी के सूचक हैं [1, 2, 3, 4, 5, 6]। Ụइस सरणी को सॉर्ट करें, जो कि, मैप्स 1टू [1, 1], 2टू [1, 2], 3टू [2, 1], वगैरह का उपयोग करते हुए अनिवार्य रूप से, यह सॉर्ट-बाय-सोमस एरे से प्रत्येक जोड़ी के इंडेक्स को सॉर्ट-लेक्सिकोग्राफिक एरे
— डेनिस
7

आर , 101 60 54 बाइट्स

function(M,N)matrix(rank(outer(1:M,1:N,"+"),,"l"),M,N)

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

के सुझाव के लिए @nwellnhof को धन्यवाद rank

पोर्ट्स डेनिस 'जेली जवाब ।

पुराना उत्तर, 101 बाइट्स:

function(M,N)matrix(unsplit(lapply(split(1:(M*N),unlist(split(x,x))),rev),x<-outer(1:M,1:N,"+")),M,N)

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

splitयहाँ अधिकांश काम कर रहा है; संभवतः एक गोल्फ एल्गोरिथ्म है, लेकिन यह निश्चित रूप से काम करता है।

स्पष्टीकरण:

function(M,N){
x <- outer(1:M,1:N,"+")			# create matrix with distinct indices for the antidiagonals
idx <- split(x,x)			# split into factor groups
items <- split(1:(M*N),unlist(idx))	# now split 1:(M*N) into factor groups using the groupings from idx
items <- lapply(items,rev)		# except that the factor groups are
					# $`2`:1, $`3`:2,3, (etc.) but we need
                                        # $`2`:1, $`3`:3,2, so we reverse each sublist
matrix(unsplit(items,x),M,N)		# now unsplit to rearrange the vector to the right order
					# and construct a matrix, returning the value
}

इसे ऑनलाइन आज़माएं! - आप अंतिम परिणाम को बदलने के बिना मध्यवर्ती परिणामों को देखने printके लिए असाइनमेंट के किसी भी दाहिने हाथ के चारों ओर रैप का उपयोग कर सकते हैं <-, जैसा कि printइसके इनपुट को वापस करता है।

— ग्यूसेप
स्रोत
1
आप कुछ स्पष्टीकरण pls जोड़ सकते हैं?
— लुइस फेलिप डी जेउस मुनोज
1
@LuisfelipeDejesusMunoz गयी। अगर कुछ स्पष्ट नहीं है, तो मुझे बताएं और मैं कोशिश करूंगा और स्पष्ट करूंगा।
— Giuseppe
1
rank(x,1,"f")2 बाइट्स से छोटा है order(order(x))।
— nwellnhof
@nwellnhof ओह, बहुत अच्छा है, लेकिन उपयोग rank(x,,"l")करने से छुटकारा मिल जाएगा t।
— Giuseppe
6

जावा 10, 121 120 109 105 बाइट्स

m->n->{var R=new int[m][n];for(int i=0,j,v=0;i<m+n;)for(j=++i<n?0:i-n;j<i&j<m;)R[j][i-++j]=++v;return R;}

-11 बाइट्स की बदौलत @ OlivierGrégoire ।
-4 बाइट्स @ceilingcat की बदौलत ।

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

स्पष्टीकरण:

m->n->{                // Method with two integer parameters and integer-matrix return-type
  var R=new int[m][n]; //  Result-matrix of size `m` by `n`
  for(int i=0,j,       //  Index integers, starting at 0
          v=0;         //  Count integer, starting at 0
      i<m+n;)          //  Loop as long as `i` is smaller than `m+n`
    for(j=++i<n?0      //   Set `j` to 0 if `i+1` is smaller than `n`
               :i-n;   //   or to the difference between `i` and `n` otherwise
        j<i&j<m;)      //   Inner loop `j` until it's equal to either `i` or `m`,
                       //   so basically check if it's still within bounds:
      R[j][i-++j]=++v; //    Add the current number to cell `j, i-(j+1)`
  return R;}           //  Return the result-matrix
— केविन क्रूज़सेन
स्रोत
मैंने महसूस किया कि यह पहले कॉलम लेता है और फिर पंक्तियाँ।
— लुइस फेलिप डी जीसस मुनोज
@ मुझे लगता है कि यह कन्वेंशन लेने के लिए कन्वेंशन है x,y/width,height
— जो किंग
2
— ओलिवियर ग्रेजायर
5

जे , 15 बाइट्स

$1(+/:@;)</.@i.

मील द्वारा इस समाधान के लिए -4 और बाइट्स। धन्यवाद!

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

जे , 22 19 बाइट्स

-3 बाइट्स FrownyFrog के लिए धन्यवाद!

,$[:>:@/:@/:@,+/&i.

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

जे में डेनिस के शानदार जेली समाधान का कार्यान्वयन।

स्पष्टीकरण:

डायडिक क्रिया, बाएँ और दाएँ तर्क (mfn)

+/&i. सूची बनाता है 0..m-1 और 0..n-1 और उनके लिए एक अतिरिक्त तालिका बनाता है:

   3 +/&i. 5
0 1 2 3 4
1 2 3 4 5
2 3 4 5 6

[:>:@/:@/:@, तालिका को चपटा करता है और सूची को दो बार ग्रेड करता है और इसमें 1 जोड़ता है:

   3 ([:>:@/:@/:@,+/&i.) 5
1 2 4 7 10 3 5 8 11 13 6 9 12 14 15

,$ सूची को वापस mxn तालिका में बदल देता है:

   3 (-@],\[:>:@/:@/:@,+/&i.) 5
1 2  4  7 10
3 5  8 11 13
6 9 12 14 15
— गैलेन इवानोव
स्रोत
1
-@],\→ ,$for3 बाइट्स के लिए।
— FrownyFrog
@FrownyFrog - बेशक, मैं बेवकूफ महसूस कर रहा हूं, यह अब बहुत बुरा है। धन्यवाद!
— गैलन इवानोव
1
$1(+/:@;)</.@i.एक सरणी के रूप में इनपुट के साथ 15 बाइट्स[r, c]
— मील
@ मीलों: बहुत अच्छा, धन्यवाद! मैंने कोशिश की, /.लेकिन अपना परिणाम हासिल नहीं कर पाया :)
— गैलन इवानोव
4

एपीएल + विन, 38 या 22 बाइट्स

पूर्णांक इनपुट स्तंभ के लिए संकेत तब पंक्ति:

m[⍋+⌿1+(r,c)⊤m-1]←m←⍳(c←⎕)×r←⎕⋄(r,c)⍴m

या:

(r,c)⍴⍋⍋,(⍳r←⎕)∘.+⍳c←⎕

डेनिस के ग्रेड अप के दोहरे आवेदन पर आधारित है। याद किया कि :(

— ग्राहम
स्रोत
1
प्रश्न के लिए क्षमा करें, लेकिन क्या मैं इसे परख सकता हूं?
— लुइस फेलिप डी जेउस मुनोज
@ उपसर्ग felipe De jesus Munoz कोई समस्या नहीं है। APL + WIN लाइन पर उपलब्ध नहीं है, लेकिन आप अपनी पसंद के पूर्णांकों के साथ gers वर्णों को बदलने पर tryapl.org पर Dyalog वेबसाइट पर इसका परीक्षण कर सकते हैं ।
— ग्राहम
4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 73 67 बाइट्स

उपरोक्त पंक्तियों में तत्वों की गणना करें: Min[j+k,#2]~Sum~{k,i-1}

वर्तमान पंक्ति और नीचे के तत्वों की गणना करें: Max[j-k+i-1,0]~Sum~{k,i,#}

एक तालिका में डालें और 1. वॉयला जोड़ें:

1+Table[Min[j+k,#2]~Sum~{k,i-1}+Max[j-k+i-1,0]~Sum~{k,i,#},{i,#},{j,#2}]&

अद्यतन: मुझे एहसास हुआ कि मैट्रिक्स में सामान्य रूप से निर्दिष्ट स्थिति से आगे सभी पदों को गिनने का एक छोटा तरीका है, जिसमें दो आयाम हैं:

Table[1+Sum[Boole[s-i<j-t||s-i==j-t<0],{s,#},{t,#2}],{i,#},{j,#2}]&

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

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

— केली लोडर
स्रोत
4

एपीएल (डायलॉग यूनिकोड) , 14 12 बाइट्स

{⍵⍴⍋⍋∊+/↑⍳⍵}

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

-2 ngn के लिए धन्यवाद , उसके चतुर उपयोग के कारण ↑⍳।

डेनिस के 5-बाइट जेली समाधान के आधार पर।

— आउटगोल्फर को एरिक करें
स्रोत
∘.+⌿⍳¨⍵->+/↑⍳⍵
— ngn
Wngn वाह, यह ⍳संयुक्त का एक चतुर उपयोग है ↑।
— एरिक आउटफोलर
2

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

from numpy import*
r=range
def h(x,y):
 a,i,k,j=-array([i//y+i%y for i in r(x*y)]),1,2,0
 while j<x+y:a[a==-j],i,k,j=r(i,k),k,k+sum(a==~j),j+1
 a.shape=x,y;return a

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

यह निश्चित रूप से सबसे छोटा समाधान नहीं है, लेकिन मुझे लगा कि यह एक मजेदार था।

— maxb
स्रोत
from numpy import*और दोनों n.को छोड़ना थोड़ा कम है। इसके अलावा, आप पर जगह छोड़ सकते हैं ) for। और पायथन 2 में बदलने return aसे आपको print a(पायथन 3 में print(a)) समान बाइट-काउंट को बदलने की अनुमति मिलती है ।
— केविन क्रूज़सेन
धन्यवाद! मुझे सोचना चाहिए था import*। मैं डेनिस के उत्तर को कभी नहीं
— हराऊंगा
2

जाप , 25 24 बाइट्स

शायद ही सुरुचिपूर्ण है, लेकिन काम हो जाता है। जाप में 2 डी डेटा के साथ काम करना मुश्किल है।

;N×Ç<U©Ap[] A®Ê<V©Zp°T
A

;                      // Set alternative default vars where A is an empty array.
 N×Ç                   // Multiply the inputs and map the range [0..U*V).
    <U                 // If the current item is less than the second input,
      ©Ap[]            // add a new empty subarray into A.
            A®         // Then, for each item in A,
              Ê<V      // if its length is less than the first input,
                 ©Zp°T // Add the next number in the sequence to it.
A                      // Output the results, stored in A.

मैंने -Qपरिणामों के आसान दृश्य के लिए TIO में ध्वज जोड़ा , यह समाधान को प्रभावित नहीं करता है। ओलिवर
के लिए एक बाइट के लिए धन्यवाद ।

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

— लीख
स्रोत
के बोलते हुए ×, आप के *V साथ बदल सकते हैं N×।
— ओलिवर
1
@ ओलिवर और यहाँ मैं सोच रहा था कि शॉर्टकट आसान है, लेकिन एक सामान्य उपयोग मामला नहीं है। आपका बहुत बहुत धन्यवाद!
— Nit
2

टीआई-बेसिक, 76 बाइट्स

Prompt A,B
{A,B🡒dim([A]
1🡒X
For(E,1,B+A
For(D,1,E
If D≤A and E-D<B
Then
X🡒[A](D,E-D+1
X+1🡒X
End
End
End
[A]

उपयोगकर्ता इनपुट के लिए संकेत देता है और मैट्रिक्स को Ansइसमें प्रिंट करता है और प्रिंट करता है।

टीआई-बेसिक ए है टोकन भाषा है ; यहां उपयोग किए जाने वाले सभी टोकन एक बाइट हैं, [A]जिसके अलावा 2 बाइट्स हैं।

नोट: TI-Basic (कम से कम TI-84 Plus CE पर) केवल 99x99 तक के मैट्रिसेस का समर्थन करता है, और इसलिए यह प्रोग्राम करता है।

स्पष्टीकरण:

Prompt A,B        # 5 bytes, prompt for user input
{A,B🡒dim([A]      # 9 bytes, make the matrix the right size
1🡒X               # 4 bytes, counter variable starts at 1
For(E,1,B+A       # 9 bytes, Diagonal counter, 1 to A+B-1, but we can over-estimate since we have to check later anyway.
For(D,1,E         # 7 bytes, Row counter, 1 to diagonal count
If D≤A and E-D<B  # 10 bytes, Check if we are currently on a valid point in the matrix
Then              # 2 bytes, If so,
X🡒[A](D,E-D+1     # 13 bytes, Store the current number in the current point in the matrix
X+1🡒X             # 6 bytes, Increment counter
End               # 2 bytes, End dimension check if statement
End               # 2 bytes, End row for loop
End               # 2 bytes, End dimension for loop
[A]               # 2 bytes, Implicitly return the matrix in Ans and print it
— pizzapants184
स्रोत
2

जावा (JDK 10) , 142 131 बाइट्स

X->Y->{var A=new int[X][Y];int E=1;for(int y=0;y<Y+X-1;y++)for(int x=0;x<X;x++){if(y-x<0|y-x>Y-1)continue;A[x][y-x]=E++;}return A;}

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

स्पष्टीकरण: 

X->Y->{                            // Method with two integer parameters and integer-matrix return-type
    var A=new int[X][Y];           // The Matrix with the size of X and Y
    int E=1;                       // It's a counter
        for(int y=0;y<Y+X-1;y++)   // For each column plus the number of rows minus one so it will run as long as the bottom right corner will be reached
            for(int x=0;x<X;x++){  // For each row
                if(y-x<0|y-x>Y-1)  // If the cell does not exist becouse it's out of range
                    continue;      // Skip this loop cycle
                A[x][y-x]=E++;     // Set the cell to the counter plus 1
            }
    return A;                      // Return the filled Array
}

केविन क्रूज़सेन के लिए बड़ा धन्यवाद क्योंकि मुझे नहीं पता था कि tio पर अपना कोड कैसे चलाना है ।
हेडर और फुटर जैसे कुछ कोड उससे चुराए गए हैं। -> उसका जवाब

— Hille
स्रोत
1
119 बाइट्स: tio.run/…
— इग्नोरेंस
1
— सीलिंगकैट
1

PHP, 115 बाइट्स

एक बहुत आलसी दृष्टिकोण; शायद कम से कम संभव नहीं है।

function($w,$h){for(;$i++<$h*$w;$r[+$y][+$x]=$i,$x--&&++$y<$h||$x=++$d+$y=0)while($x>=$w|$y<0)$y+=!!$x--;return$r;}

अनाम फ़ंक्शन, पैरामीटर और चौड़ाई को पैरामीटर के रूप में लेता है, 2d मैट्रिक्स देता है

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

— टाइटस
स्रोत
1

अटैची , 45 बाइट्स

{Chop[Grade//2<|Flat!Table[`+,1:_2,1:_],_]+1}

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

अनाम लंबोदर, जहां पैरामाटर्स स्विच किए जाते हैं। इस ~कार्यक्रम के लिए तैयार करके, +1 बाइट के लिए तय किया जा सकता है । परीक्षण सुइट पहले से ही ऐसा करता है।

व्याख्या

यह दृष्टिकोण J उत्तर और जेली उत्तर के समान है ।

पहला विचार मूल्यों की एक तालिका उत्पन्न करना है:

Table[`+,1:_2,1:_]

यह दोनों इनपुट मापदंडों की श्रेणियों का उपयोग करके एक अतिरिक्त तालिका बनाता है। इनपुट के लिए [5, 3], यह देता है:

A> Table[`+,1:3,1:5]
 2 3 4 5 6
 3 4 5 6 7
 4 5 6 7 8

फिर, हम इस के साथ समतल करते हैं Flat!:

A> Flat!Table[`+,1:3,1:5]
[2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8]

J उत्तर में दृष्टिकोण का उपयोग करते हुए, हम दो बार के साथ, सरणी को ग्रेड कर सकते हैं (अर्थात, सॉर्ट किए गए मानों को लौटाते हैं) Grade//2:

A> Grade//2<|Flat!Table[`+,1:3,1:5]
[0, 1, 3, 6, 9, 2, 4, 7, 10, 12, 5, 8, 11, 13, 14]

फिर, हमें जेली उत्तर में मानों को सही ढंग से काटने की आवश्यकता है। हम _ऐसा करने के लिए हर तत्वों को काट सकते हैं :

A> Chop[Grade//2<|Flat!Table[`+,1:3,1:5],5]
 0 1  3  6  9
 2 4  7 10 12
 5 8 11 13 14

उसके बाद, हमें केवल 0 के अनुक्रमण के लिए क्षतिपूर्ति करने की आवश्यकता है +1:

A> Chop[Grade//2<|Flat!Table[`+,1:3,1:5],5]+1
 1 2  4  7 10
 3 5  8 11 13
 6 9 12 14 15

और इस प्रकार हमारे पास परिणाम है।

— कोनोर ओ ब्रायन
स्रोत
1

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

इसलिए मैंने यह एक अजीब तरीका किया। मैंने देखा कि सरणी के रूप में दो पैटर्न थे।

पहला यह है कि शीर्ष पंक्तियों के पैटर्न में प्रत्येक शब्द के बीच अंतर 1 से बढ़ रहा है -> h जहां h ऊँचाई है और l लंबाई है। तो मैं उस पैटर्न के आधार पर शीर्ष पंक्ति का निर्माण करता हूं

मैट्रिक्स ऑफ मंद (3,4) देने के लिए max RoC = 3हम फॉर्म की शीर्ष पंक्ति देखेंगे

1, (1+1), (2+2), (4+3) = 1, 2, 4, 7

इसके बजाय मान लें कि मंद (3,9) max RoC = 3हम देने के बजाय एक शीर्ष पंक्ति देखेंगे

`1, (1+1), (2+2), (4+3), (7+3), (10+3), (13+3), (16+3), (19+3) = 1, 2, 4, 7, 10, 13, 16, 19, 22

दूसरा पैटर्न यह है कि पंक्तियाँ एक दूसरे से कैसे बदलती हैं। यदि हम मैट्रिक्स पर विचार करते हैं:

1   2   4   7   11
3   5   8   12  16
6   9   13  17  20
10  14  18  21  23
15  19  22  24  25

और नीचे की पंक्ति से प्रत्येक पंक्ति को घटाएं (अतिरिक्त पंक्ति को अनदेखा करते हुए) जो हमें मिलती है

2 3 4 5 5
3 4 5 5 4
4 5 5 4 3
5 5 4 3 2

इस मैट्रिक्स को देखने पर हम देख सकते हैं कि यह मैट्रिक्स वह क्रम है 2 3 4 5 5 4 3 2जहाँ प्रत्येक पंक्ति में प्रत्येक पंक्ति के लिए 1 द्वारा स्थानांतरित किए गए इस पैटर्न की 5 शर्तें हैं। दृश्य के लिए नीचे देखें।

         |2 3 4 5 5| 4 3 2
       2 |3 4 5 5 4| 3 2
     2 3 |4 5 5 4 3| 2
   2 3 4 |5 5 4 3 2|

इसलिए अंतिम मैट्रिक्स पाने के लिए हम अपनी पहली पंक्ति बनाते हैं और उस पंक्ति को इस पैटर्न के 5 आवश्यक शब्दों के साथ जोड़ते हैं।

इस पैटर्न में हमेशा शुरुआत 2-> max valueऔर अंत की विशेषताएं होंगी max value -> 2जहां max value = min(h+1, l)अधिकतम मूल्य दिखाई देगा और appearances of max = h + l -2*c -2जहां कितनी बार होगीc = min(h+1, l) - 2

तो नई पंक्तियों को बनाने की मेरी पूरी विधि में ऐसा लगता है

1  2  3  7  11 +      |2 3 4 5 5|4 3 2  = 3  5  8  12 16

3  5  8  12 16 +     2|3 4 5 5 4|3 4 2  = 6  9  13 17 20

6  9  13 17 20 +   2 3|4 5 5 4 3|4 2    = 10 14 18 21 23

10 14 18 21 23 + 2 3 4|5 5 4 3 2|       = 15 19 22 24 25

नीचे दिया गया प्रासंगिक कोड। यह छोटा नहीं था, लेकिन मुझे अभी भी यह तरीका पसंद है।

o,r=len,range
def m(l,h):
 a,t=[1+sum(([0]+[x for x in r(1,h)]+[h]*(l-h))[:x+1]) for x in r(l)],min(l,h+1);s,c=[x for x in r(2,t)],[a[:]]
 for i in r(h-1):
  for j in r(o(a)):
   a[j]+=(s+[t]*(l+h-2*(t-2)-2)+s[::-1])[0+i:l+i][j]
  c+=[a[:]]
 for l in c:print(l)

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

— akozi
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.