एक कोने से एक आयताकार सरणी का पुनर्निर्माण करें

30

मैं एक बार एक सुंदर आयताकार सरणी था। यह बहुत सममित था, लेकिन दुर्भाग्य से यह अलग हो गया है और अब मेरे पास केवल शीर्ष बाएं कोने है। आपका कार्य मूल सरणी का पुनर्निर्माण करना होगा।

आपके कार्यक्रम को पूर्णांक के 2 आयामी सरणी प्राप्त होगी। पार्सिंग में आसानी के लिए, आप मान सकते हैं कि वे सभी 1 और 9 के बीच हैं। आपका कार्य सरणी के कॉलम, इसकी पंक्तियों को उल्टा करना है और दोनों, परिणामस्वरूप कोनों को एक साथ सिलाई करते हैं, और परिणामी सरणी को वापस करते हैं।

आप मान सकते हैं कि सरणी आयाम कम से कम 1x1 होगा।

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

Input:
1 2 3
4 5 6

Output:
1 2 3 3 2 1
4 5 6 6 5 4
4 5 6 6 5 4
1 2 3 3 2 1

Input:
1

Output:
1 1
1 1

Input:
9
9
9

Output:
9 9
9 9
9 9
9 9
9 9
9 9

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है!

code-golf  array-manipulation  matrix 
— पावेल
स्रोत
1
मैं शर्त लगा सकता हूँ कि लकड़ी का कोयला 10 से कम में कर सकता है
— FantaC
1
@tbfninja chat.stackexchange.com/transcript/message/43184083#43184083 लेकिन एक अलग इनपुट प्रारूप के साथ शायद कम हो।
— पावेल
@MagicOctopusUrn हां
— पावेल
2
@tfbninja ＷＳ⟦ι⟧‖Ｍ→↓शायद? इनपुट को पढ़ने के लिए 5 बाइट्स और इसे प्रतिबिंबित करने के लिए 4।
— नील
4
मुझे लगता है कि 99% यकीन है कि वहाँ एक लंगड़ा है कि ╬(या कुछ इसी तरह के चरित्र के साथ) बस याद नहीं कर सकते हैं जो एक: c
— रॉड

जवाबों:

1

प्रोटॉन , 29 बाइट्स

a=>[b+b[by-1]for b:a+a[by-1]]

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

हालांकि कुछ अन्य दिलचस्प दृष्टिकोण हैं:

प्रोटॉन , 29 बाइट्स

a=>map(g,(g=x=>x+x[by-1])(a))

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

आप दर्पण को उप-कार्य gमें परिभाषित कर सकते हैं , क्योंकि प्रोटॉन। हालांकि यह कम नहीं है।

प्रोटॉन , 36 बाइट्स

(a=>[x[0]for x:zip(*(a+a[by-1]))])*2

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

यह होना चाहिए (a=>zip(*(a+a[by-1])))*2जो 24 बाइट्स है, लेकिन ज़िप फ़ंक्शन पूरी तरह से टूट गया है। मूल रूप से, आप इसे मिरर करते हैं और ज़िप करते हैं, और फिर दो बार करते हैं (आप फ़ंक्शन को कई बार लागू करने के लिए एक सकारात्मक पूर्णांक द्वारा गुणा कर सकते हैं)।

— HyperNeutrino
स्रोत
19

कैनवस , 1 बाइट

╬

यहाँ कोशिश करो!

एक बहुस्तरीय स्ट्रिंग के रूप में आउटपुट

— dzaima
स्रोत
2
अच्छा लगा, @Rod ने कहा कि एक हा! क्या यह आपकी भाषा भी द्विज है?
— मैजिक ऑक्टोपस Urn
धिक्कार है ... मुझे याद रखना चाहिए ...
— बिलकुल अमानवीय
@MagicOctopusUrn हाँ, IIRC का मूल रूप से SOGL II होना है: इलेक्ट्रिक बूगालू?
— ASCII-only
5

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

lambda a:[b+b[::-1]for b in a+a[::-1]]

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

सूचियों की सूची लेता है और सूचियों की सूची लौटाता है।

स्पष्टीकरण: 

lambda a:                              # anonymous lambda function
                   for b in a+a[::-1]  # for each row in the array and the upside-down array
          b+b[::-1]                    # the row with its reverse appended
         [                           ] # return in a list
— pizzapants184
स्रोत
5

रेटिना , 13 बाइट्स

\%`$
$^$`
Vs`

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

व्याख्या

\%`$
$^$`

प्रत्येक पंक्ति ( %) पर, पंक्ति के अंत ( ) से मेल खाते हैं $, और $^संपूर्ण पंक्ति के रिवर्स ( ) डालें और (पीछे की रेखा के $`साथ) परिणाम को प्रिंट करें \। यह ऊर्ध्वाधर अक्ष के साथ प्रतिबिंब करता है और आउटपुट के पहले आधे हिस्से को प्रिंट करता है।

Vs`

यह बस पूरे स्ट्रिंग को उलट देता है, जो 180 ° डिग्री रोटेशन के बराबर है, या हमारे मामले में (क्षैतिज समरूपता के कारण) क्षैतिज अक्ष के साथ एक प्रतिबिंब है। इस तरह से यह काम करता है कि Vडिफ़ॉल्ट रेगेक्स है (?m:^.*$), जो सामान्यतः स्ट्रिंग की प्रत्येक पंक्ति से मेल खाता है। हालाँकि, हम सिंगललाइन विकल्प को सक्रिय करते हैं s, जो बनाता है. मैच लाइनफीड भी हो जाता है और इसलिए यह डिफॉल्ट रेगेक्स वास्तव में पूरे स्ट्रिंग से मेल खाता है।

इसका परिणाम कार्यक्रम के अंत में स्वचालित रूप से मुद्रित होता है, जिससे हमें आउटपुट का दूसरा आधा हिस्सा मिलता है।

— मार्टिन एंडर
स्रोत
यह मुझे पता है कि किसी भी regex स्वाद की तरह नहीं दिखता है: P
— पावेल
@ पावेल क्योंकि रेटिना सिर्फ रेगेक्स नहीं है। :)
— आउटगोल्फर
@ उस कोड का एकमात्र भाग जो वास्तविक रीजेक्स है, $पहली पंक्ति में है। ;) मैं बाद में एक स्पष्टीकरण जोड़ दूँगा।
— मार्टिन एंडर
5

05AB1E , 2 बाइट्स

∞∊

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

   # Input:Array of String | ['12','34']
---#-----------------------+------------------------------------------
∞  # Mirror horizontally.  | [12,34]       -> [1221,3443]
 ∊ # Mirror vertically.    | [1221,3443]   -> [1221\n3443\n3443\n1221]

श्री Xcoder के लिए क्रेडिट इंगित करता है कि स्ट्रिंग के सरणियों को 2 डी सरणियों और पावेल के रूप में गिना जा सकता है।

— जादू ऑक्टोपस Urn
स्रोत
— मिस्टर एक्सकोडर
पार्स करने में आसानी के लिए, आप मान सकते हैं कि वे सभी 1 और 9 के बीच हैं - इसलिए मुझे लगता है कि यह मान्य है। पावेल की पुष्टि की प्रतीक्षा में, मुझे लगता है
— श्री एक्सकोडर
@ Mr.Xcoder जो कि मेरे पास शुरू में था, फिर TIO 2D सरणियों के रूप में इनपुट अजीब था ... इसलिए इस हेडर सामान के साथ आना पड़ा।
— मैजिक ऑक्टोपस Urn
एक स्ट्रिंग वर्णों की एक सरणी है, इसलिए तार की एक सूची अभी भी एक 2d सरणी है। @ Mr.Xcoder का समाधान मान्य है।
— पावेल
कूलियो, मेरे लिए काम करता है।
— मैजिक ऑक्टोपस Urn
3

जावास्क्रिप्ट (Node.js) , 62 55 49 46 बाइट्स

A=>(j=x=>[...x,...[...x].reverse()])(A).map(j)

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

चूँकि Array.prototype.reverse()सरणी को उलट दिया जाता है, इसलिए मुझे पहले कहीं-कहीं उथली प्रतिलिपि बनानी होगी। A=>(j=x=>[...x,...x.reverse()])(A).map(j)काम नहीं करता।

— शायरु असाकोतो
स्रोत
2

त्रिकोणीयता , 31 बाइट्स

...)...
..IEM..
.DRs+}.
DRs+...

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

व्याख्या

पैडिंग के लिए बनने वाले पात्रों को हटा देना, यहाँ कार्यक्रम क्या है:

)IEMDRs+}DRs+ – Full program. Takes a matrix as a 2D list from STDIN.
)             – Push a 0 onto the stack.
 I            – Take the input at that index.
  E           – Evaluate it.
   M    }     – For each row...
    DR        – Duplicate and replace the second copy by its reverse.
      s+      – Swap and append.
         DR   – Duplicate the result and replace the second copy by its reverse.
           s+ – Swap and append.
— मिस्टर एक्सकोडर
स्रोत
2

एपीएल + विन, 11 बाइट्स

पूर्णांक के 2d सरणी के लिए संकेत।

m⍪⊖m←m,⌽m←⎕
— ग्राहम
स्रोत
2

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

:mm:m

इसे ऑनलाइन चलाएं और डीबग करें

:mदर्पण का अर्थ है, जो है input.concat(reverse(input))। m, इस संदर्भ में लागू करने के बाद प्रत्येक लाइन उत्पादन का मतलब है ...

इसलिए, पंक्तियों की सरणी को मिरर करें, और फिर प्रत्येक पंक्ति और आउटपुट को मिरर करें।

— पुनरावर्ती
स्रोत
2

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

->a{r=->b{b+b.reverse}
r[a].map &r}

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

एक लंबोदर ने 2 डी सरणी को स्वीकार किया और 2 डी सरणी लौटाया। यह सीधा है, लेकिन यहाँ वैसे भी ungolfed संस्करण है:

->a{
  r=->b{ b+b.reverse } # r is a lambda that returns the argument and its reverse
  r[a].map &r          # Add the array's reverse, then add each row's reverse
}
— benj2240
स्रोत
2

जावा 8, 140 131 बाइट्स

m->{String r="";for(int a=m.length,b=m[0].length,i=a+a,j;i-->0;r+="\n")for(j=b+b;j-->0;)r+=m[i<a?i:a+a+~i][j<b?j:b+b+~j];return r;}

स्पष्टीकरण:

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

m->{                      // Method with integer-matrix parameter and String return-type
  String r="";            //  Result-String, starting empty
  for(int a=m.length,     //  Amount of rows of the input-matrix
          b=m[0].length,  //  Amount of columns of the input-matrix
          i=a+a,j;        //  Index integers
      i-->0;              //  Loop over double the rows
      r+="\n")            //    After every iteration: append a new-line to the result
     for(j=b+b;j-->0;)    //   Inner loop over double the columns
       r+=                //    Append the result with:
          m[i<a?          //     If `i` is smaller than the amount of rows
             i            //      Use `i` as index in the input-matrix
            :             //     Else:
             a+a+~i]      //      Use `a+a+i-1` as index instead
           [j<b?          //     If `j` is smaller than the amount of columns
             j            //      Use `j` as index in the input-matrix
            :             //     Else:
             b+b+~j];     //      Use `b+b+j-1` as index instead
  return r;}              //  Return the result-String
— केविन क्रूज़सेन
स्रोत
2

जे , 11 बाइट्स

बेनामी tacit उपसर्ग समारोह।

|:@(,|.)^:2

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

|: पक्षांतरित

@(…) का परिणाम:

 , इसके बाद का तर्क

 |. इसका उल्टा है

^:2 और यह सब दो बार किया गया

— एडम
स्रोत
2

SNOBOL4 (CSNOBOL4) , 119 113 बाइट्स

	T =TABLE()
I	X =X + 1
	I =INPUT	:F(D)
	OUTPUT =T<X> =I REVERSE(I)	:(I)
D	X =X - 1
	OUTPUT =GT(X) T<X>	:S(D)
END

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

रिक्त स्थान के बिना, STDIN पर तार के रूप में इनपुट लेता है। यह केवल इसलिए काम करता है क्योंकि अंक हैं 1-9और अन्यथा विफल होंगे।

— ग्यूसेप
स्रोत
मैं देख सकता हूं कि लोग अब इस भाषा का उपयोग क्यों नहीं करते हैं। यह बहुत अजीब है।
— पावेल
1
@Pavel SNOBOL वास्तव में साथ काम करने के लिए एक भयानक भाषा है। यह इसका एक और आधुनिक सी कार्यान्वयन है जिसमें अतिरिक्त बिलिन फ़ंक्शन हैं जैसे REVERSE; मूल केवल समर्थित पूर्णांक अंकगणित और साथ ही, जहाँ तक मैं बता सकता हूँ।
— ग्यूसेप
2

सी (जीसीसी) , 114 111 बाइट्स

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)printf("%d,",A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]);}

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

सी (जीसीसी) , 109 बाइट्स (पार्सिंग की आसानी से दुरुपयोग)

  • केवल एक-अंक इनपुट पूर्णांक की अनुमति देने के सुझाव के लिए केविन क्रूज़सेन का धन्यवाद ; दो बाइट्स बचाए।
j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)putchar(A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]+48);}

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

— जोनाथन फ्रेच
स्रोत
आप छोरों को निष्क्रिय करके 3 बाइट्स बचा सकते हैं। for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)
— केविन क्रूज़सेन
कल्पना पूरी नहीं करता; इसे वापस करने के बजाय, सरणी को प्रिंट करता है।
" पार्सिंग में आसानी के लिए, आप मान सकते हैं कि वे सभी 1 और 9 के बीच हैं ", इसलिए आप printf("%d"अतिरिक्त -1 बाइट के लिए अल्पविराम हटा सकते हैं ।
— केविन क्रूज़सेन
@Rogem मैं कहूंगा कि सरणी को मुद्रित करना स्वीकृत i / o के अंतर्गत आता है।
— जोनाथन फ्रीच
1
@KevinCruijssen बहुत बहुत धन्यवाद; पार्स करने में आसानी का उपयोग करके मैं एक और बाइट से दाढ़ी बनाने में कामयाब रहा।
— जोनाथन फ्रीच
2

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

θ‖Ｃ→↓

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

ASCII- केवल बेहतर इनपुट प्रारूप के लिए धन्यवाद ।

— आउटगोल्फर को एरिक करें
स्रोत
मुझे आश्चर्य है कि अगर यह इनपुट प्रारूप वैध है, क्योंकि मुझे डर है कि चारकोल अन्यथा इनपुट को संभाल नहीं सकता है। यदि ऐसा नहीं है, तो मैं खुशी से इस उत्तर को हटा दूंगा।
— एलिक्जेलर आउट
यह मान्य I / o है।
— पावेल
@Pavel मैं बस आश्चर्यचकित था क्योंकि आपने कहा था कि "आपके कार्यक्रम को पूर्णांक 2 आयामी सरणी प्राप्त होगी", जबकि एक स्ट्रिंग 1-आयामी है (और नहीं, बाहरी []बिल्कुल इसे 2 डी नहीं बनाते हैं)।
— एलिक्जेलर आउट
@ ASCII- केवल चारकोल को वास्तव में एक बेहतर I / O विधि की आवश्यकता है ...
— नील
@ नील वह यहाँ नहीं मिला, लेकिन मैंने उसे टीएनबी पर पिंग किया। :)
— आउटगॉल्फ
2

++ , 30 बाइट्स जोड़ें

D,f,@,bU€{r}B]{r}
D,r,@,dbR+

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

पाद लेख केवल नेस्टेड सरणी को प्रश्न में प्रारूप में बदल देता है। एक फ़ंक्शन को परिभाषित करता है f, जो एक तर्क के रूप में एक मैट्रिक्स (नेस्टेड सरणी) की अपेक्षा करता है।

— केर्ड सिक्काहिरिंग
स्रोत
1

जूलिया 0.6 , 55 49 बाइट्स

~i=i:-1:1
!x=[x x[:,~end];x[~end,:] x[~end,~end]]

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

~(i)iनीचे से टुकड़ा बनाने के लिए एक समारोह है 1।
इसलिए~end स्लाइस देता हैend:-1:1

!(x) सरणी के पुनर्निर्माण के लिए कार्य करना है।

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