क्या मैट्रिक्स सेंट्रोसिमेट्रिक है ... और इसलिए कोड है?

Question

defintion

एक सेंट्रोस्मेटिक मैट्रिक्स एक वर्ग मैट्रिक्स है जो इसके केंद्र के बारे में सममित है। अधिक कठोरता से, आकार का एक मैट्रिक्स सेंट्रोसिमेट्रिक है यदि, किसी भी के बाद, निम्न संबंध संतुष्ट है: n × n i $A$$n \times n$एक मैं $i,\: j \in ([1, n] \cap \mathbb{Z})$

$$A_{i,\:j}=A_{n+1-i,\:n+1-j}$$

ऐसे मेट्रिसेस के उदाहरण

यहाँ इस तरह के एक मैट्रिसेस की समरूपता का चित्रण है (उपरोक्त विकिपीडिया लेख से उधार लिया गया है):

एक सम-साइड-लंबाई ( ) सेंटीमीटर मैट्रिक्स:$4\times 4$

$$\left(\begin{matrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 8 & 7 & 6 & 5 \\ 4 & 3 & 2 & 1\end{matrix}\right)$$

और एक विषम-पक्ष-लंबाई ( ) एक:$3\times 3$

$$\left(\begin{matrix} 1 & 2 & 3 \\ 5 & 6 & 5 \\ 3 & 2 & 1\end{matrix}\right)$$

टास्क और स्पेक्स

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

हालांकि, आपका कोड भी सेंट्रोसिमेट्रिक होना चाहिए। यही है, यह एक प्रोग्राम / फ़ंक्शन (या समतुल्य) होना चाहिए जिसमें लाइनें शामिल हों, जिनमें से प्रत्येक में आपकी भाषा एन्कोडिंग में बाइट्स हों , और ऊपर दी गई परिभाषा को पूरा करना होगा, लेकिन सकारात्मक पूर्णांक के बजाय बाइट्स के साथ। आपका सबमिशन का स्कोर का मान होगा , जिसमें कम बेहतर होगा।n n $n$$n$ $n$$n$

आप इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से और किसी भी उचित प्रारूप में आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। आप (वैकल्पिक रूप से) आकार, , इनपुट के रूप में भी ले सकते हैं (जब तक कि आप 1D सूची के रूप में इनपुट नहीं लेते हैं, उस स्थिति में आप केवल को अतिरिक्त इनपुट के रूप में ले सकते हैं )।n $n$$n^2$

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

Truthy:

[[1, 2], [2, 1]]
[[1, 2, 3], [5, 6, 5], [3, 2, 1]]
[[10, 5, 30], [2, 6, 2], [30, 5, 10]]
[[100, 100, 100], [100, 50, 100], [100, 100, 100]]
[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]]
[[3, 4, 5, 6, 7], [5, 6, 7, 8, 9], [3, 2, 10, 2, 3], [9, 8, 7, 6, 5], [7, 6, 5, 4, 3]]

Falsy:

[[1, 2], [1, 2]]
[[1, 2, 10], [5, 6, 5], [11, 2, 1]]
[[14, 5, 32], [2, 6, 2], [30, 5, 16]]
[[19, 19, 19], [40, 50, 4], [19, 19, 19]]
[[1, 2, 20, 4], [7, 6, 7, 8], [8, 7, 6, 6], [3, 3, 2, 1]]
[[3, 4, 5, 6, 7], [5, 6, 7, 8, 9], [4, 5, 10, 4, 5], [5, 6, 7, 8, 9], [3, 4, 5, 6, 7]]

Comments

हम्म, यह अभी भी गैर-गोल्फ भाषाओं के लिए बहुत कठिन दिखता है क्योंकि यह बिना टिप्पणियों के कोष्ठक और कोष्ठक को तोड़ता है। एक भोली दृष्टिकोण एक टिप्पणी चरित्र (जैसे पायथन #) के साथ प्रत्येक पंक्ति को समाप्त करने के लिए होगा , ताकि कोड के निचले आधे हिस्से में सभी एक टिप्पणी हो।

— जुंगह्वान मिन जुले

@JungHwanMin इस विशेष मामले में पायथन #काम नहीं करेगा क्योंकि पूर्व में की गई टिप्पणियाँ #केवल इनलाइन हैं: P

— श्री एक्सकोडर

I am a palindrome

— पावेल

मुझे लगता है कि मैं बस अलग होने की माँग करूँगा, क्योंकि स्रोत पर प्रतिबंध चीजों को काफी बदल देता है और जीतने की कसौटी अलग है। मेरी राय में, ये अंतर पर्याप्त हैं। इसके अलावा, अन्य तकनीकें हैं (कई भाषाओं में छोटी हैं - जैसे गणितज्ञ) जिनका उपयोग चपटा + पैलिंडन चेक के बजाय किया जा सकता है।

— मिस्टर एक्सकोडर

@ संक्षेप में, चुनौती को सरल बनाए रखने और किसी भी तरह के अवांछित मामले से बचने के लिए। इसके अलावा, इसे रखना मेरे लिए अधिक सहज है।

— मिस्टर एक्सकोडर

Answer 1

जावास्क्रिप्ट (ईएस 6), आकार 12 11 9

सभी संस्करण सेंट्रोसिमेट्रिक के लिए गलत हैं या गैर-सेंट्रोसिमेट्रिक के लिए सही हैं ।

---

1-आयामी सरणी + लंबाई, आकार 9 (89 बाइट्स)

करी सिंटैक्स में इनपुट लेता है (length)(array), जहां सरणी 1-आयामी है।

w=>a=> //
a.some //
(v=>v- //
a[--w])//
/////////
//)]w--[a
// -v>=v(
// emos.a
// >=a>=w

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

---

मैट्रिक्स + चौड़ाई, आकार 11 (131 बाइट्स)

करी सिंटैक्स में इनपुट लेता है (width)(matrix)।

/**/w=>a=>a
.some(r=>r.
some(v=>v-a
[y][w-++x],
x=!y--),y=w
);'*/'/*';)
w=y,)--y!=x
,]x++-w[]y[
a-v>=v(emos
.r>=r(emos.
a>=a>=w/**/

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

पेलोड

w => a => a.some(r => r.some(v => v - a[y][w - ++x], x = !y--), y = w)

पात्र

/**/CODE;'*/'/*';EDOC/**/

---

केवल मैट्रिक्स, आकार 12 (155 बाइट्स)

यह मेरा मूल समाधान है, जो मैट्रिक्स की चौड़ाई को खुद से गणना करता है।

/**/a=>a[w=a
.length-1,s=
'some']((r,y
)=>r[s]((v,x
)=>v-a[w-y][
w-x]))////*/
/*////))]x-w
[]y-w[a-v>=)
x,v((]s[r>=)
y,r((]'emos'
=s,1-htgnel.
a=w[a>=a/**/

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

कैसे?

हमें कुछ महत्वपूर्ण टोकन की आवश्यकता है जिन्हें विभाजित नहीं किया जा सकता है:

• some
• length
• )=>

लाइन-फीड लगभग कहीं और भी डाले जा सकते हैं।

अनियंत्रित पेलोड कोड इस प्रकार है:

a => a[w = a.length - 1, s = 'some']((r, y) => r[s]((v, x) => v - a[w - y][w - x]))

और निम्नलिखित संरचना के अंदर लपेटा गया है:

/**/CODE////*/

जो, एक बार पलट जाने पर, एक मान्य ब्लॉक टिप्पणी बन जाती है:

/*////EDOC/**/

Answer 2

जेली , स्कोर २

⁼Ṛ
Ṛ⁼

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

एक चपटा वर्ग मैट्रिक्स (आकार का वेक्टर ) के रूप में इनपुट लेता है ।$n^2$

Answer 3

बेगुंज -93 , आकार 24

   &:00p110p920p::*:v   
vp01:+1g01-1pg02g01&_v#<
>00g`#v_>:           1$^
v2p011<  v:g00p029p01< @
>0g1+20p^>*:#v_1# .#<@ .
v+1g00gg02g01<$ >1+10pv0
>:10g-\88++20g -g-     |
vg02p011_v#`g00g01-1  <1
>1+20p   >:   ^ ^      <
                        
                        
                        
                        
                        
                        
<      ^ ^   :>   p02+1>
1<  1-10g00g`#v_110p20gv
|     -g- g02++88\-g01:>
0vp01+1> $<10g20gg00g1+v
. @<#. #1_v#:*>^p02+1g0>
@ <10p920p00g:v  <110p2v
^$1           :>_v#`g00>
<#v_&10g20gp1-10g1+:10pv
   v:*::p029p011p00:&   

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

इनपुट: n सरणी के तत्वों के बाद, सभी रिक्त स्थान से अलग हो गए। नोट: यदि आपके पास एक बड़ा पर्याप्त इनपुट है, तो आपको एक अलग दुभाषिया का उपयोग करने की आवश्यकता हो सकती है।

मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है, मैं बस Befunge में यह कोशिश करना चाहता था। वास्तविक कोड भाग शीर्ष आधा है।

कैसे?

कोड को दो मुख्य वर्गों में बांटा गया है, आरंभ और सत्यापन ।

प्रारंभ:

   &:00p110p920p::*:v   
vp01:+1g01-1pg02g01&_v#<
>00g`#v_>:           1$^

कोड का यह खंड ASCII वर्णों के रूप में कोड के ठीक नीचे इनपुट मैट्रिक्स लिखता है। यह और अगला भाग डेटा के रूप में कोड के शीर्ष पर तीन कक्षों का उपयोग करता है। वे के रूप में संग्रहित हैं n, i, j।

सत्यापन:

                     v 
                     1
v2p011<  v:g00p029p01< @
>0g1+20p^>*:#v_1# .#<@ .
v+1g00gg02g01<$ >1+10pv0
>:10g-\88++20g -g-     |
vg02p011_v#`g00g01-1  <1
>1+20p   >:   ^ ^      <

यह खंड प्रत्येक सूचकांक [1-अनुक्रमित] को विरुद्ध जाँचता है । हालांकि, हम एक समस्या है: हमारे पास की भरपाई । इसे ठीक करने के लिए, निम्न सूत्रों का उपयोग किया जाता है:$i, j$$A_{i, j} = A_{n+1-i, n+1-j}$$j$$8$

$i' = (n + 1) - i$

$j' = n + 1 - (j - 8) + 8 = (n + 1) + (8 + 8) - j$

कोड के अन्य भागों को अपठित करने के लिए अपठित कचरा कचरा है।

Answer 4

हास्केल ,$n = 8$

कोई टिप्पणी नहीं!

1-डी सूची के रूप में इनपुट लेता है

s a b=  
    a/=b
f =s<*> 
 reverse
esrever 
 >*<s= f
b=/a     
  =b a s

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

$n= 10$

2-डी मैट्रिक्स के रूप में इनपुट लेता है

r =reverse
s a b=a/=b
f   =s<*>r
c  =concat
g =  f<$>c
c>$<f  = g
tacnoc=  c
r>*<s=   f
b=/a=b a s
esrever= r

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

चैट में उनकी सभी मदद के लिए आलू के लिए धन्यवाद । और लिन एक पंक्ति में गोल्फ खेलने के लिए।

व्याख्या

यहां सामान्य विचार एक सरल है, हम concatसूची की तुलना करते हैं और इसे उल्टा करते हैं। हालाँकि जब से हम सेंटीमीटर होना चाहते हैं हमें सावधानी से चलना होगा। पहले हम कोड लिखते हैं जैसा कि हम सामान्य रूप से लिखते हैं:

g=((==)<*>reverse).concat

अब हमारी रिवर्स लाइनों के लिए भी मान्य हास्केल होना चाहिए हमें फ़ंक्शन समीकरण की तरह दिखने के लिए हमारे समीकरणों के बाएं हाथ की आवश्यकता है tacnoc.)esrever>*<)==((।

इसे ठीक करने का पहला कदम कोष्ठकों का निपटान है।

s a b=a==b
f=s<*>reverse
g=f.concat

हालाँकि अभी हमें कुछ नई समस्याएं हैं। दोनों .और ==जब उलट एक समान होते हैं, तो हमारी उलट लाइनें ऑपरेटरों को फिर से परिभाषित करने का प्रयास करती हैं ( <*>उल्टा है >*<इसलिए हम इस मोर्चे पर ठीक हैं)। फंक्शंस के फंक्शनल .होने के साथ इसे बदला जा सकता है <$>। और हम जगह ले सकता है ==के साथ /=है, जो हमारे उत्पादन को नकारता है, लेकिन है कि अभी भी चश्मा के भीतर है। अब हमारे पास है

s a b=a/=b
f=s<*>reverse
g=f<$>concat

हमारी लाइन की लंबाई को कम करने के लिए हम उर्फ concatऔर reverse।

r=reverse
s a b=a/=b
f=s<*>r
c=concat
g=f<$>c

अब हम इसे सब कुछ सेंट्रोसिमेट्रिक और स्क्वायर बनाकर खत्म करते हैं।

छोटा 1-D संस्करण बहुत ही समान तरीके से काम करता है, क्योंकि concatहमें कोई आवश्यकता नहीं है कि हम इसे हटाकर दो लाइनों को बचा सकते हैं।

Comments

कैसे n = 10 के लिए इस बारे में ?

— लिन

@Lynn धन्यवाद! मेरे सिर में <$>भी उल्टा था <$>।

— गेहूं जादूगर

Answer 5

अजगर 2 , आकार 10 (109 बाइट्स)

def f(a):#
 return(a#
==[r[::-1#
]for r in#
a[::-1]])#
#)]]1-::[a
#ni r rof]
#1-::[r[==
#a(nruter 
#:)a(f fed

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

पिछला पायथन 2 , आकार 14 (209 बाइट्स)

lambda a:all(#
a[i][j]==a[-i#
-1][-j-1]for #
i in range(  #
len(a))for j #
in range(len(#
a)))         #
#         )))a
#(nel(egnar ni
# j rof))a(nel
#  (egnar ni i
# rof]1-j-[]1-
#i-[a==]j[]i[a
#(lla:a adbmal

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

Comments

यकीन नहीं है कि यह एक पुनर्व्यवस्था के लिए पर्याप्त होगा, लेकिन FYI करें -i-1और -j-1बस हो सकता है~i~j

— श्री एक्सकोडर

@श्री। Xcoder: मैं उस के साथ एक सा है, लेकिन यह परिणाम नहीं बदलता है।

— चास ब्राउन

Python3.6 में भी काम करता है, लेकिन इष्टतम नहीं हो सकता है।

— SIGSTACKFAULT

Answer 6

अजगर, आकार 6 (41 बाइट्स)

q_M_QQ
q.q   


   q.q
QQ_M_q

इसे यहाँ आज़माएँ

व्याख्या

पहली पंक्ति इनपुट और प्रत्येक पंक्ति को उलट देती है, और जांचती है कि क्या हम इनपुट की कॉपी के साथ रह गए हैं। दूसरी पंक्ति में कार्यक्रम से बाहर निकल जाता है, ताकि बाद सब कुछ है, साथ ही यह पहले, नो-सेशन है।
.qq

Answer 7

APL (Dyalog Unicode) , स्कोर 7 6 5 4

पूरा कार्यक्रम। स्टड से मैट्रिक्स अभिव्यक्ति के लिए संकेत। 1 या 0 प्रिंट करता है और फिर एक निरंतर त्रुटि फेंकता है। कोई टिप्पणी नहीं!

r←,⎕
r≡⌽r
r⌽≡r
⎕,←r

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

⎕ अभिव्यक्ति के लिए संकेत और इसका मूल्यांकन करें
, (चपटा करें) यह
r← परिणाम को r( r avelled के लिए) संग्रहीत करता है

⌽r दर्पण r
r≡ स्पष्ट रूप से प्रिंट करता rहै कि क्या इसके समान है

≡ की गहराई r(1) को घुमाने के लिए
r⌽ उपयोग rकरता है
^{(यह हमेशा कारण होगा RANK ERRORऔर छोड़ देगा क्योंकि मैट्रिक्स को बाएं तर्क के रूप में अनुमति नहीं है ⌽)}

Answer 8

पर्ल 6 , आकार 9 8 7

{.flat#
#}talf.
#  ],R[
eq # qe
[R,]  #
.flat}#
#talf.{

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

reverseयहाँ अड़चन है। मैंने इसे तकनीकी रूप से लंबे समय तक बदल दिया है, लेकिन बहुत अधिक शानदार है [*-1 X-^*]। ठीक है, मैंने ब्रैड गिल्बर्ट के एक अन्य प्रश्न के उत्तर को [R,]देखने के बाद इसे बदल दिया है ।

चपटा कोड है {.flat eq [R,] .flat}।

संपादित करें: धिक्कार है, मैंने महसूस किया है कि मुझे पहली सूची को समतल करने की आवश्यकता नहीं है , लेकिन इसे 6 के आकार तक छोटा करने के प्रयास केवल एक बाइट के साथ बहुत से फिट होने में विफल रहे हैं ...

{@_#}_@
eq#<<|
[R,] #
# ],R[
|<<#qe
@_}#_@{

:(

हालांकि अगर हम इसे एक आयामी सरणी के रूप में लेते हैं, तो इसे 6 आकार में फिट करना आसान है।

{$_# }
eq #_$
[R,] #
# ],R[
$_# qe
} #_${

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

Answer 9

वोल्फ्राम भाषा (गणितज्ञ) (केवल REPL), आकार 8 (71 बाइट्स)

f=#[[c=-
1;;1;;-1
,c]]==#&
(*      
      *(
&#==]]c,
1-;;1;;1
-=c[[#=f

Trueसेंट्रोसिमेट्रिक इनपुट के लिए रिटर्न , और Falseअन्यथा।

Mathematica REPL पर, सिंटैक्स त्रुटियों वाली रेखाओं को अनदेखा किया जाता है (स्क्रीन के किनारे एक मोटी लाल पट्टी दिखाई देती है)। यहां, केवल पहली तीन पंक्तियों f=#[[c=-1;;1;;-1,c]]==#&को निष्पादित किया जाता है।

यह कोड नाम में फ़ंक्शन को कैप्चर करता है f।

अफसोस की बात है, बिल्ट-इन PalindromeQबहुत लंबा है।

Answer 10

पाइट , आकार १

₽

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

जाँचता है कि क्या इनपुट (संघनित पंक्तियों के रूप में) एक पैलिंड्रोम है।

Comments

._। ठीक है, यह चुनौती के अनुसार सेंट्रोसिमेट्रिक नहीं है: , लेकिन अच्छा काम। $n>=2$

— ज़ाचरी

मेरी समझ से इनपुट पर एक बाधा है, न कि एक सेंट्रोसिमेट्रिक मैट्रिक्स की परिभाषा पर । $n \geq 2$

— लिन

वूप्स, यह भूल गया।

— जकार्इ

Answer 11

जाप , आकार ९ ४ (११ बाइट्स)

UªSê


êSªU

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

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

W=U  I
Wz2;II
Vc)eUc
cUe)cV
II;2zW
I  U=W

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

Comments

अच्छा! मुझे लगता है कि मेरे पास एक 6 है और मैं एक असहयोगी 4 को भी जमा करने की कोशिश कर रहा हूं, लेकिन वे दोनों इस से बहुत अधिक तुच्छ हैं।

— झबरा

@ शैगी मैं एक ही समाधान प्राप्त करने में कामयाब रहा छह के बाद इसे एक नया रूप देने के लिए, चार बहुत प्रभावशाली होगा।

— लीख

यह देखते हुए कि इनपुट (1) एक 1 आयामी सरणी हो सकता है, यह 2 के स्कोर के साथ किया जा सकता है

— झबरा

@ शैगी मुझे यकीन नहीं है कि अगर मैं देखूं कि कैसे, स्रोत NxN होना चाहिए।

— लीख

जैसे

— झबरा

Answer 12

भूसी , आकार ३

Ṡ=↔
=↔=
↔=Ṡ

इसे ऑनलाइन आज़माएं! 1D- सूची के रूप में इनपुट। प्रत्येक पंक्ति एक फ़ंक्शन को परिभाषित करती है, लेकिन पहली पंक्ति में केवल एक को कहा जाता है।

Ṡ=↔एक पलिंड्रोम परीक्षण है जो यह जांचता है कि इनपुट बराबर होता है ( =) इसके विपरीत ( ↔)।

---

भूसी , आकार ४

Ṡ=↔Σ
Σ↔=Ṡ
Ṡ=↔Σ
Σ↔=Ṡ

इसे ऑनलाइन आज़माएं! 2 डी-मैट्रिक्स के रूप में इनपुट के लिए, हम Σजाँच करते हैं ( ) सूचियों की सूची की जाँच करने से पहले कि यह एक पैलिंड्रोम है।

Answer 13

MATL , स्कोर 4

t,!P
]=%?
?%=]
P!,t

इनपुट में प्रारूप है [1 2; 2 1], ;पंक्ति विभाजक के रूप में।

आउटपुट STDERR ( डिफ़ॉल्ट रूप से अनुमत ) के माध्यम से होता है :

• सेंट्रोसिमेट्रिक इनपुट के लिए एक सुसंगत त्रुटि त्रुटि उत्पन्न होती है। TIO में वर्तमान लिनक्स और ऑक्टेव संस्करणों के साथ, निम्न STDERR आउटपुट का उत्पादन होता है (अंतिम लाइनों की उपेक्षा जो इसके साथ शुरू होती है Real time: ...):

  octave: X11 DISPLAY environment variable not set
  octave: disabling GUI features
  Python 2.7.15 (default, May 16 2018, 17:50:09) 
  [GCC 8.1.1 20180502 (Red Hat 8.1.1-1)] on linux2
  Type "help", "copyright", "credits" or "license" for more information.
  >>> >>> /usr/include/c++/8/bits/basic_string.h:1048: std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::reference std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator[](std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::reference = char&; std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int]: Assertion '__pos <= size()' failed.
  panic: Aborted -- stopping myself...
  

  लिनक्स और ऑक्टेव संस्करणों के आधार पर त्रुटि अलग हो सकती है, लेकिन पूरे इनपुट के अनुरूप होगी।

• गैर-सेंट्रोसिमेट्रिक इनपुट के लिए कोई त्रुटि उत्पन्न नहीं होती है, और TIO पर STDERR आउटपुट है

  octave: X11 DISPLAY environment variable not set
  octave: disabling GUI features
  Python 2.7.15 (default, May 16 2018, 17:50:09) 
  [GCC 8.1.1 20180502 (Red Hat 8.1.1-1)] on linux2
  Type "help", "copyright", "credits" or "license" for more information.
  >>> >>> 
  

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

• Centrosymmetric: 1 , 2 , 3 , 4 , 5 , 6 ।
• गैर-सेंट्रोमीटर: 1 , 2 , 3 , 4 , 5 , 6 ।

जांचें कि कार्यक्रम सेंट्रोसिमेट्रिक है।

व्याख्या

%टिप्पणी प्रतीक है, जिसके कारण ओ लाइन के बाकी हिस्सों को अनदेखा किया जाता है। नई कहानियों को भी नजरअंदाज कर दिया जाता है। तो कोड बस है

t,!P]=?P!,t

जो निम्नलिखित है:

t       % Input, implicit. Duplicate
,       % Do twice
  !     %   Transpose
  P     %   Flip vertically
]       % End
=       % Compare element-wise
?       % If all comparisons gave true
  P     %   Implicit input. Transpose. Actually, since there is no more input, an
        %   error is prand the program exits. The rest of the code is not executed, 
        %   and will be described in parentheses
  !     %   (Transpose)
  ,     %   (Do twice)
    t   %     (Duplicate)
        %   (End, implicit)
        % (End, implicit)

Answer 14

हास्केल, आकार 11 , 10 , 9 , 8

एक 2 डी सूची के रूप में इनपुट लेता है! (श्रेय जोहानसन को श्रेय)

r= --r}-
 reverse
(==)<*> 
 r.map{-
-{pam.r 
 >*<)==(
esrever 
-}r-- =r

Comments

कीड़े: दूसरा <*>होना चाहिए >*<। 2 डी एक में, एक लापता -और उलटा हिस्सा सही स्थानों में रिक्त स्थान नहीं है।

— अर्जन जोहान्सन

2 डी को 8 से नीचे कर दिया

— अर्जन जोहान्सन

Answer 15

अजगर 2 , आकार 8

i=input#
a=i()###
a[::-1##
]!=a<_##
##_<a=!]
##1-::[a
###)(i=a
#tupni=i

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

$n^2$

सूची को केवल एक palindrome होने की जाँच की जाती है। यदि यह है, तो तुलना श्रृंखला चरण और शॉर्ट-सर्किट में a[::-1]!=a<_विफल रहती है !=; अन्यथा अज्ञात चर का _मूल्यांकन हो जाता है, जिससे प्रोग्राम क्रैश हो जाता है।

Answer 16

आर , आकार ९

   #)x-))
#(nacs-<x
#(ver(yna
#       #
#       #
#       #
any(rev(#
x<-scan(#
))-x)#   

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

अंतिम तीन लाइनें वास्तविक कार्यक्रम हैं जो इनपुट के रूप में 1D सरणी लेता है और जांच करता है कि क्या यह इसके विपरीत के बराबर है। सत्य मूल्य: FALSE, मिथ्या मूल्य: सही।

any(rev(x<-scan())-x)

आर + pryr, आकार 9

pryr::f(#
any(rev(#
x)-x))#  



  #))x-)x
#(ver(yna
#(f::ryrp

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

Answer 17

सी # (.NET कोर) , स्कोर 13 11 10

l=>a=>a.//
Where((e//
,i)=>e!=//
a[l-i-1]//
).Any()///
///()ynA.)
//]1-i-l[a
//=!e>=)i,
//e((erehW
//.a>=a>=l

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

लंबाई के रूप में 1 डी सरणी और एन ^{2 के} रूप में इनपुट लेता है ; falseसेंट्रोसिमेट्रिक के लिए और trueगैर-सेंट्रोसिमेट्रिक के लिए रिटर्न । यह संस्करण उपयोग करता है System.Linqलेकिन मुझे नहीं पता कि चुनौती की विशेष आवश्यकताओं के कारण इसे कोड सबमिशन में कैसे फिट किया जाए। अनियंत्रित कोड:

l => a => a.Where((e,i) => e != a[l-i-1]).Any()

निम्नलिखित मेरा पिछला सबमिशन है जो LINQ का उपयोग नहीं करता है:

सी # (.NET कोर) , स्कोर 16 15 13

l=>a=>{/////*
var r=1<2;for
(int i=0;i<l;
)r&=a[i]==a[l
-i++-1];
return r;}
     /*/
   };r nruter
     ;]1-++i-
l[a==]i[a=&r)
;l<i;0=i tni(
rof;2<1=r rav
*/////{>=a>=l

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

अनियंत्रित कोड:

l => a =>
{
    var r = 1<2;
    for (int i = 0; i < l;)
        r &= a[i] == a[l-i++-1];
    return r;
}

Comments

आप को बदलते हैं intकरने के लिए var(इस प्रकार भी tniकरने के लिए rav), दूसरे प्रस्तुत भी जावास्क्रिप्ट में काम करता है।

— जकार्इ

Answer 18

रूबी , स्कोर ९ 8

->z{z==#
z.######
reverse#
}#######
#######}
#esrever
######.z
#==z{z>-

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

एक लैम्ब्डा इनपुट के रूप में एक चपटा मैट्रिक्स ले रहा है। सेंट्रोसिमेट्रिक के लिए सही रिटर्न, अन्यथा गलत।

-1 Mr.XCoder के लिए धन्यवाद,

पैक नहीं किया गया:

->z{
  z == z.reverse
}

Answer 19

साफ , आकार ९

अर्जन जोहान्सन को धन्यवाद !

import //
 StdEnv//
r=reverse
?m=m==r//
    m    
//r==m=m?
esrever=r
//vnEdtS 
// tropmi

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

स्वच्छ , आकार १०

import/*//
*/StdEnv//
r =reverse
?m      //
 =m==r m//
//m r==m= 
//      m?
esrever= r
//vnEdtS/*
//*/tropmi

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

Comments

यह न्यूलाइन की वजह से नहीं है, यह इंडेंट के साथ काम करता है। 9 लाइनें

— अर्जन जोहान्सन

@ ForrjanJohansen विश्वास नहीं कर सकता कि मैं भूल गया कि आप उन्हें इंडेंट कर सकते हैं। धन्यवाद!

— Οसथ जूल

आपका स्वागत है, और मैंने पोस्ट करने के बाद मध्य रेखा को संपादित किया, यह सिर्फ होना चाहिए m।

— अर्जन जोहान्सन

@ TorjanJohansen मैंने उस उत्तर को प्रतिबिंबित करने के लिए अद्यतन किया है। यह वास्तव में बहुत खूबसूरत लग रहा है।

— Οसथ जूल

Answer 20

05AB1E , आकार 3 (11 बाइट्स )

ÂQq

qQÂ

एकल सूची के रूप में इनपुट
इसे ऑनलाइन आज़माएं।

मुझे लगता है कि यह कोई गिनती नहीं करता है .. पी

ÂQ
qâ

एकल सूची के रूप में इनपुट
इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

         # Bifurcate this list (short for DR: Duplicate & Reverse copy)
 Q        # Check if the input-list and the reversed list are equal
  q       # Terminate the program
   qQâ    # No-ops

---

कुछ आकार 3 (11 बाइट्स ) विकल्प:

R€R
QqQ
R€R

इनपुट के रूप में मैट्रिक्स।
इसे ऑनलाइन आज़माएं।

RQ 
 q  
 QR

इनपुट के रूप में एकल सूची।
इसे ऑनलाइन आज़माएं।

Answer 21

सी (जीसीसी) , 12 x 12

C(e,n,t,r)//
int*e;{for//
(r=t=0;e[t//
];r|=e[t]^//
e[~t+++n])//
;n=!!!!r;}//
//};r!!!!=n;
//)]n+++t~[e
//^]t[e=|r;]
//t[e;0=t=r(
//rof{;e*tni
//)r,t,n,e(C

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

Answer 22

> <>, आकार 6

!/l2(\
s\?\ ?
/{=/ ;
: /={/
? \?\s
\(2l/!

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

(यह पता चला है कि यह एक दर्द है, जो tio में -v से कई मान गुज़रता है)

-V के साथ प्रारंभिक स्टैक स्थिति के रूप में इनपुट को एक आयामी सरणी के रूप में लिया जाता है। यदि मैट्रिक्स सेंट्रोसिमेट्रिक है तो कोई आउटपुट नहीं होता है, एक त्रुटि के साथ बाहर निकलता है (प्रिंट "कुछ बदबूदार मछली ...") यदि नहीं।

l2(    Checks if the length of the stack is less than 2
?;     Exits cleanly if so

{=     Checks if the first and last elements are equal
?\s    Causes an error ('s' is not a valid instruction) if not

मैं इस आउटपुट प्रारूप से पूरी तरह से खुश नहीं था, इसलिए यहाँ एक आकार 7 एक है जो 1 आउटपुट के लिए सच है, और 0 झूठे के लिए।

!/l2(\\
 ?   ?0
 =;n1/n
;{   {;
n/1n;= 
0?   ? 
\\(2l/!

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

Comments

अच्छी नौकरी! > <> के साथ काम करने के लिए एक मजेदार भाषा हो सकती है, जब तक कि यह एक जटिल कार्यक्रम नहीं है, तब यह एक दर्द है।

— mbomb007

अगर आप सच्चाई और झूठे मूल्यों की अदला-बदली करते हैं, तो आप इसे 4 से नीचे ले जा सकते हैं{-?;

— जो किंग

Answer 23

स्टैक्स , एन = 3

$cr
=q=
rc$

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

स्पष्टीकरण:

$cr =q= rc$ Full program, implicit input
$           Flatten
 cr         Copy and reverse
    =       Compare to original
     q      Print result
      =     Silently error because there is only one item on stack
        rc$ Not executed

3 सबसे अच्छा संभव है क्योंकि मुझे कम से कम तीन आदेशों की आवश्यकता है: प्रतिलिपि, उल्टा, और तुलना करें

स्टैक्स , एन = 4

Mrxr
M=qX
Xq=M
rxrM

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

स्पष्टीकरण:

Mrxr M=qX Xq=M rxrM Full program, implicit input
Mr                  Transpose and reverse
  x                 Push input again
   r M              Reverse and transpose
      =             Compare
       qX Xq        Print result twice and save to X
            =       Silently error because there is only one item on stack
             M rxrM Not executed

Answer 24

जाप , आकार 2 (5 बाइट्स)

ê"
"ê

कोशिश करो

Answer 25

जावा 10, आकार 13 (181 बाइट्स)

a->{var r///*
=1>0;for(int 
l=a.length,i=
0;i<l;)r&=a[i
]==a[l-++i]; 
return r;}   
     /*/     
   };r nruter
 ;]i++-l[a==]
i[a=&r);l<i;0
=i,htgnel.a=l
 tni(rof;0>1=
*///r rav{>-a

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

@Charlie के C # उत्तर से प्रेरित ।

गोल्फ विवरण:

a->{var r=1>0;for(int l=a.length,i=0;i<l;)r&=a[i]==a[l-++i];return r;}

a->{                    //  Method with byte-array parameter and boolean return-type
  var r=1>0;            //  Result-boolean, starting at true
  for(int l=a.length,   //  The length of the input-array
      i=0;i<l;)         //  Loop `i` in the range [0, length)
    r&=                 //   Bitwise-AND the result-boolean with:
       a[i]             //    Whether the current item
           ==a[l-++i];  //    equals the opposite item
  return r;}            //  Return the result

Answer 26

सी (जीसीसी) , स्कोर 11

तर्कों के रूप में int और n की सूची लेता है। सत्य मान के रूप में n लौटाता है, 0 मिथ्या के रूप में।

/*//};n=l;k
--*==++l*=*
n);l>k;n*n+
l=k(rof{;l*
tni)n,l(f;k
*/*/////*/*
k;f(l,n)int
*l;{for(k=l
+n*n;k>l;)n
*=*l++==*--
k;l=n;}//*/

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

Answer 27

जावास्क्रिप्ट ईएस 6, आकार 8:

/***/a=>
""+a==a.
reverse(
)/////*/
/*/////)
(esrever
.a==a+""
>=a/***/

जावास्क्रिप्ट ईएस 6, आकार 7 (क्या यह मान्य है?):

a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a

परीक्षा:

<script>
f=

a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a
</script>

<script>
console.log([
  [1, 2, 2, 1],
  [1, 2, 3, 5, 6, 5, 3, 2, 1],
  [10, 5, 30, 2, 6, 2, 30, 5, 10],
  [100, 100, 100, 100, 50, 100, 100, 100, 100],
  [1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 3, 2, 10, 2, 3, 9, 8, 7, 6, 5, 7, 6, 5, 4, 3],
].every(f))

console.log([
  [1, 2, 1, 2],
  [1, 2, 10, 5, 6, 5, 11, 2, 1],
  [14, 5, 32, 2, 6, 2, 30, 5, 16],
  [19, 19, 19, 40, 50, 4, 19, 19, 19],
  [1, 2, 20, 4, 7, 6, 7, 8, 8, 7, 6, 6, 3, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 4, 5, 10, 4, 5, 5, 6, 7, 8, 9, 3, 4, 5, 6, 7],
].every(x=>!f(x)))
</script>

या भेड़ के बच्चे के साथ नामांकित चर को बचाया a:

a=

a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a

console.log([
  [1, 2, 2, 1],
  [1, 2, 3, 5, 6, 5, 3, 2, 1],
  [10, 5, 30, 2, 6, 2, 30, 5, 10],
  [100, 100, 100, 100, 50, 100, 100, 100, 100],
  [1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 3, 2, 10, 2, 3, 9, 8, 7, 6, 5, 7, 6, 5, 4, 3],
].every(a))

console.log([
  [1, 2, 1, 2],
  [1, 2, 10, 5, 6, 5, 11, 2, 1],
  [14, 5, 32, 2, 6, 2, 30, 5, 16],
  [19, 19, 19, 40, 50, 4, 19, 19, 19],
  [1, 2, 20, 4, 7, 6, 7, 8, 8, 7, 6, 6, 3, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 4, 5, 10, 4, 5, 5, 6, 7, 8, 9, 3, 4, 5, 6, 7],
].every(x=>!a(x)))

Answer 28

लौंग, आकार ९

#(= %(;;;
reverse;;
(map;;;;;
reverse;;
%)));)))%
;;esrever
;;;;;pam(
;;esrever
;;;(% =(#

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