इस चुनौती के लिए, आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो किसी दिए गए वर्ग मैट्रिक्स के विकर्णों को आउटपुट करता है। हालांकि, यदि आप अपने समाधान के स्रोत कोड की पंक्तियों और स्तंभों को स्थानांतरित करते हैं, तो इसके बजाय यह एक प्रोग्राम या फ़ंक्शन बनना चाहिए जो मैट्रिक्स के एंटीडिओग्नल को लौटाता है। बारीकियों के लिए पढ़ें ...

नियम

आपके समाधान के स्रोत कोड को वर्णों के 2 डी ग्रिड के रूप में माना जाता है, जो आपकी पसंद के मानक न्यूलाइन (लाइनफीड, कैरिज रिटर्न या दोनों के संयोजन) द्वारा अलग किया जाता है।
आपके स्रोत कोड की कोई भी पंक्ति पिछले एक से अधिक नहीं हो सकती है। यहां मान्य लेआउट के कुछ उदाहरण दिए गए हैं:
```
###
###
###
```
```
########
#######
###
###
#
```
और यहां एक अमान्य लेआउट का उदाहरण दिया गया है (चूंकि तीसरी पंक्ति दूसरी से लंबी है):
```
######
####
#####
###
```
आपके दो समाधान एक दूसरे के स्थानान्तरण होना चाहिए, यही है कि आप पंक्तियों और स्तंभों को स्वैप करके एक से दूसरे को प्राप्त करें। यहाँ दो वैध जोड़े हैं:
```
abc
def
ghi
```
```
adg
beh
cfi
```
तथा
```
print 10
(~^_^)~
foo
bar
!
```
```
p(fb!
r~oa
i^or
n_
t^
 )
1~
0
```
ध्यान दें कि रिक्त स्थान किसी भी अन्य वर्णों की तरह व्यवहार किया जाता है। विशेष रूप से, अनुगामी रिक्त स्थान महत्वपूर्ण हैं क्योंकि वे स्थानान्तरण में अनुगामी रिक्त स्थान नहीं हो सकते हैं।
प्रत्येक समाधान एक प्रोग्राम या फ़ंक्शन होना चाहिए जो इनपुट के रूप में एकल-अंक पूर्णांक के गैर-खाली वर्ग मैट्रिक्स लेता है। एक समाधान को मैट्रिक्स के सभी विकर्णों की एक सूची का उत्पादन करना चाहिए और दूसरे को सभी एंटीडायंगल की सूची का उत्पादन करना चाहिए। आप किसी भी उचित, अस्पष्ट इनपुट और आउटपुट प्रारूप का उपयोग कर सकते हैं, लेकिन वे दो समाधानों के बीच समान होना चाहिए (इसका मतलब यह भी है कि उन्हें या तो दोनों कार्य या दोनों कार्यक्रम करने होंगे)।
प्रत्येक विकर्ण ऊपर से नीचे दाईं ओर चलता है, और उन्हें ऊपर से नीचे तक आदेश दिया जाना चाहिए।
प्रत्येक एंटीडायंगल नीचे से ऊपर की ओर दाईं ओर चलता है, और उन्हें ऊपर से नीचे तक आदेश दिया जाना चाहिए।

स्कोरिंग

संभव के रूप में "वर्ग" के रूप में समाधान को प्रोत्साहित करने के लिए, प्राथमिक स्कोर पंक्तियों की संख्या या आपके समाधान के स्तंभों की संख्या है, जो भी बड़ा है । कम बेहतर है। समाधान में पात्रों की संख्या से संबंध टूट जाते हैं, नई संख्याओं की गिनती नहीं करते हैं। फिर, कम बेहतर है। उदाहरण:

abcd
efg
h

इस और इसके स्थानान्तरण का प्राथमिक स्कोर 4 होगा (जैसा कि 4 कॉलम हैं) और 8 का टाई-ब्रेकिंग स्कोर (जैसा कि 8 गैर-नई वर्ण हैं)। कृपया अपने उत्तर के शीर्ष लेख में दोनों मानों का हवाला दें।

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

दो समाधानों द्वारा निष्पादित वास्तविक कार्य यहां प्राथमिक चुनौती नहीं होनी चाहिए, लेकिन आपके समाधानों का परीक्षण करने में मदद करने के लिए यहां दो उदाहरण हैं:

Input:
1 2 3
4 5 6
7 8 9
Diagonals:
3
2 6
1 5 9
4 8
7
Antidiagonals:
1
4 2
7 5 3
8 6
9

Input:
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1
Diagonals:
0
1 1
0 0 0 
1 1 1 1
0 0 0
1 1
0
Antidiagonals:
1
0 0
1 1 1
0 0 0 0
1 1 1
0 0
1

code-challenge source-layout matrix

— मार्टिन एंडर
स्रोत

सम्बंधित।

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

जैसा कि मैंने महसूस किया कि सैंडबॉक्स पोस्ट आपके द्वारा आधे रास्ते से पहले होने से पहले थी, इससे पहले कि मैं एसई पर

— पहुंचता,

19

जावास्क्रिप्ट, स्कोर 20 14, ( 258 176 गैर-नई वर्ण)

///mmm()mu[=+r
///=.av=a,pr"=
///> p,>px=[ [
m=>//(yv()xp"]
m. ////.(=+]+)
map((////>y?u&
v,y)=>v//r]r:&
.map((u,x//[ur
)=>r[p=m.//p)
length-1-//],
x+y]=r[p]////
?r[p]+" "+u//
:u),r=[])&&r

तथा

///mmmv.)lx?:
///=.a,m=e+ru
///> pya>ny[)
m=>//()prg]p,
m. //(=([t=]r
map(//>(phr+=
(v,y//vu=-["[
)=>v.//,m1p ]
map((//x.-]")
u,x)=>r////+&
[p=x+y]////u&
=r[p]?r[p]//r
+" "+u:u),//
r=[])&&r

उदाहरण कोड स्निपेट:

f=

///mmm()mu[=+r
///=.av=a,pr"=
///> p,>px=[ [
m=>//(yv()xp"]
m. ////.(=+]+)
map((////>y?u&
v,y)=>v//r]r:&
.map((u,x//[ur
)=>r[p=m.//p)
length-1-//],
x+y]=r[p]////
?r[p]+" "+u//
:u),r=[])&&r

console.log(f([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]))

स्निपेट का विस्तार करें

तथा

f=

///mmmv.)lx?:
///=.a,m=e+ru
///> pya>ny[)
m=>//()prg]p,
m. //(=([t=]r
map(//>(phr+=
(v,y//vu=-["[
)=>v.//,m1p ]
map((//x.-]")
u,x)=>r////+&
[p=x+y]////u&
=r[p]?r[p]//r
+" "+u:u),//
r=[])&&r

console.log(f([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]))

स्निपेट का विस्तार करें

— हरमन एल
स्रोत

क्या आप सिंटैक्स हाइलाइटिंग को सक्षम कर सकते हैं? पहले कोड ब्लॉक से पहले रखें ।

— कैलक्यूलेटरफ़्लीन

8

MATL , स्कोर 10 (100 नॉन-न्यूलाइन वर्ण)

%P!       
  Q&%     
  TXd!    
  %d      
     P!   
      "@% 
       Xz 
      %z  
         q
         !

10 वर्णों की 10 पंक्तियाँ हैं (अनुगामी रिक्त स्थान पर ध्यान दें)।

उपरोक्त कोड विकर्णों का उत्पादन करता है। इसे ऑनलाइन आज़माएं!

प्रत्यारोपित संस्करण एंटी-विकर्ण पैदा करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

ध्यान दें कि

% एक टिप्पणी प्रतीक है, जिसके कारण शेष रेखा को अनदेखा किया जाता है।
दो-चार कार्यों Xdको एक Xऔर dलगातार लाइनों में विभाजित नहीं किया जा सकता है ।

मूल कोड

मूल कोड, रैखिक और टिप्पणी किए बिना भाग है

Q&TXd!P!"@Xzq!

जो निम्नानुसार काम करता है:

Q      % Implicit input. Add 1 to each entry to make them positive
&      % This modifes default inputs/ouputs of next function, which is Xd
       % Specifically, it specifies 2 inputs and 1 ouput
T      % Push true
Xd     % Diagonals of matrix. With second input true, it gives all diagonals,
       % starting from below. The columns are arranged as columns of a matrix,
       % padding with zeros
!P!    % Flip horizontally. This is to produce the correct display order
"      % For each column
  @    %   Push current column
  Xz   %   Remove zeros
  q    %   Subtract 1
  !    %   Transpose into a row
       % Implicit end. Implicit display of stack contents

ट्रांसपोंड कोड

ट्रांसपोंड कोड, रैखिककृत, है

P!QT&Xd!P!"@Xzq!

जिसके मूल कोड की तुलना में निम्नलिखित दो अंतर हैं:

Tऔर &अदला-बदली की जाती है। इसका कोई प्रभाव नहीं है, क्योंकि Tएक शाब्दिक है, एक फ़ंक्शन नहीं है, इसलिए यह &विनिर्देश को बाधित नहीं करता है।
P! भीख माँगने पर जोड़ा जाता है।

अतिरिक्त कोड इनपुट मैट्रिक्स को संशोधित करता है ताकि संशोधित मैट्रिक्स के विकर्ण इनपुट के विरोधी-विकर्ण हों:

P      % Implicit input. Flip vertically
!      % Transpose

— लुइस मेंडो
स्रोत

7

जेली , स्कोर 7, 49 गैर-न्यूलाइन बाइट्स

विकर्ण मुद्रण कार्यक्रम

......U
......Œ
......D
......ṙ
......L
......Ṛ
ŒDṙLṚUU

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

विरोधी विकर्ण-मुद्रण कार्यक्रम

......Œ
......D
......ṙ
......L
......Ṛ
......U  
UŒDṙLṚU

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

पुराना उत्तर (अनियंत्रित आउटपुट), स्कोर 3, 6 नॉन-न्यूलाइन बाइट्स

विकर्ण-मुद्रण कार्यक्रम

UU
UŒ
ŒD

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

विरोधी विकर्ण मुद्रण कार्यक्रम

UUŒ
UŒD

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

— officialaimm
स्रोत

6

जेली , स्कोर 4 (12 अक्षर)

^{पिछले स्कोर: 5 (16 अक्षर), 4 (16 अक्षर)}

मूल

ŒDṙṚ
D  ñ
ṙLñL

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

खिसकाना

ŒDṙ
D L
ṙ ñ
ṚñL

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

पृष्ठभूमि

विकर्णों

एक वर्ग मैट्रिक्स के विकर्णों (बॉटलमोस्ट के सबसे ऊपर) को प्राप्त करने का सीधा तरीका इस प्रकार है।

ŒDṙLṚ

एक इनपुट मैट्रिक्स एम के लिए , मुख्य विकर्ण के साथ शुरू होने वाले एम के विकर्णों को ŒDसूचीबद्ध करता है और ऊपर की ओर बढ़ता है।

इनपुट के लिए

1 2 3
4 5 6
7 8 9

यह प्रदान करता है

ṙLफिर M की लंबाई के साथ गणना करता है Lऔर परिणाम लंबाई (M) इकाइयों को बाईं ओर घुमाता है ।

हमारे उदाहरण के लिए, लंबाई 3 है और हम प्राप्त करते हैं

अंत में, Ṛविकर्णों के क्रम को उलट देता है, लौटता है

हमारे उदाहरण इनपुट के लिए।

विरोधी विकर्ण

एक ही बिल्डिंग ब्लॉक्स का उपयोग एक वर्ग मैट्रिक्स के एंटी-विकर्ण (फिर से, सबसे ऊपर से बॉटलमॉस्ट) प्राप्त करने के लिए किया जा सकता है।

ṚŒDṙL

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

इनपुट के लिए

1 2 3
4 5 6
7 8 9

यह प्रदान करता है

7 8 9
4 5 6
1 2 3

पहले की तरह, ŒDṙLपरिणाम के विकर्ण (सबसे ऊपर)

हमारे उदाहरण के लिए, यह रिटर्न करता है

जैसी इच्छा।

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

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

अन्य लिंक को कॉल करना होगा। यह उत्तर उपयोग करता है ñ, जो नीचे दिए गए लिंक को डायडिकली निष्पादित करता है। ñचारों ओर लपेटता है, इसलिए जब इसे मुख्य लिंक से बुलाया जाता है, तो यह पहली पंक्ति पर लिंक को निष्पादित करता है।

मूल

मुख्य लिंक

ṙLñL

एक इनपुट मैट्रिक्स M लेता है , इसकी लंबाई के साथ गणना करता है L, फिर इनपुट लंबाई (M) इकाइयों को बाईं ओर घुमाता है ṙ(ध्यान दें कि यह M को परिवर्तित नहीं करता है ), और अंत में परिणाम ( M ) और लंबाई के साथ पहला लिंक कहता है ( M) तर्क के रूप में।

पहली कड़ी

ŒDṙṚ

के विकर्ण की गणना करता है एम के साथ ŒD(पिछले अनुभाग में देखा जाता है), परिणाम घूमता लंबाई (एम) के साथ छोड़ दिया करने के लिए इकाइयों ṙ, तो साथ परिणाम के आदेश को उलट देता है Ṛ।

दूसरी कड़ी को कभी नहीं बुलाया जाता है।

खिसकाना

मुख्य लिंक

 ṚñL

एक इनपुट मैट्रिक्स M लेता है और इसके साथ उल्टा गणना करता है Ṛ। यह तब M की लंबाई के साथ गणना करता है Lऔर तर्कों के साथ पहले लिंक को रिवर्स (M) और लंबाई (M) कहता है ।

पहली कड़ी

ŒDṙ

इसके बाद (पिछले भाग में देखा गया ) के साथ रिवर्स (M) के विकर्णों की गणना की जाती है ŒD, और अंत में परिणाम लंबाई (M) इकाइयों को बाईं ओर घुमाता है ṙ।

शेष लिंक को कभी नहीं बुलाया जाता है।

— डेनिस
स्रोत

5

आर, स्कोर १४ १३ ११ ( ९९ ९ ५ नॉन-न्यूलाइन अक्षर)

स्कोर में सुधार के लिए @Giuseppe के लिए धन्यवाद। 1. कुछ पात्रों को बंद कर दिया। गैर-गोल्फिंग भाषा के लिए वर्तमान में सर्वश्रेष्ठ स्कोर!

######`,scr
`::`(#:fpoo
pryr,#:)llw
f)(###`(i((
split (#tmm
p,col(p#())
)+row#r#m-)
(p)))#y#,#)
######r

और प्रत्यारोपित:

#`pfsp)(#
#:r)p,+p#
#:y(lcr)#
#`r#ioo)#
#(,#tlw)#
#### (###
`::`(pryr
,f)(####
split(m,
col(m)-#
row(m)))

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

— rturnbull
स्रोत

1

row(m)+col(m)विरोधी विकर्णों के लिए कम है।

— Giuseppe

@Giuseppe बेशक, धन्यवाद! अब संपादित किया गया।

— 22 सितंबर को rturnbull

4

हस्क , 7 9 4 अक्षर, स्कोर 4 3

∂T
m
↔

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

-4 अक्षर BMO को धन्यवाद ।

— आउटगोल्फर को एरिक करें
स्रोत

स्थानांतरण और विकर्ण

नियम

स्कोरिंग

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

जावास्क्रिप्ट, स्कोर 20 14, ( 258 176 गैर-नई वर्ण)

MATL , स्कोर 10 (100 नॉन-न्यूलाइन वर्ण)

व्याख्या

मूल कोड

ट्रांसपोंड कोड

जेली , स्कोर 7, 49 गैर-न्यूलाइन बाइट्स

विकर्ण मुद्रण कार्यक्रम

विरोधी विकर्ण-मुद्रण कार्यक्रम

पुराना उत्तर (अनियंत्रित आउटपुट), स्कोर 3, 6 नॉन-न्यूलाइन बाइट्स

विकर्ण-मुद्रण कार्यक्रम

विरोधी विकर्ण मुद्रण कार्यक्रम

जेली , स्कोर 4 (12 अक्षर)

मूल

खिसकाना

पृष्ठभूमि

विकर्णों

विरोधी विकर्ण

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

मूल

खिसकाना

आर, स्कोर १४ १३ ११ ( ९९ ९ ५ नॉन-न्यूलाइन अक्षर)

हस्क , 7 9 4 अक्षर, स्कोर 4 3