12

से प्रेरित होकर इस ।

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

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

 function line(x0, y0, x1, y1)
     real deltax := x1 - x0
     real deltay := y1 - y0
     real deltaerr := abs(deltay / deltax)    // Assume deltax != 0 (line is not vertical),
           // note that this division needs to be done in a way that preserves the fractional part
     real error := 0.0 // No error at start
     int y := y0
     for x from x0 to x1 
         plot(x,y)
         error := error + deltaerr
         while error ≥ 0.5 then
             y := y + sign(deltay) * 1
             error := error - 1.0

(ध्यान दें कि यह छद्मकोड केवल 1 से कम ढलानों के लिए काम करता है; लंबे ग्रिड के लिए, एक समान उपचार किया जाना चाहिए, लेकिन एक लूप ओवर के साथ y। दो मामलों के लिए यह अनुभाग देखें ।)

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

कार्य

एक मैट्रिक्स ए को देखते हुए , उन तत्वों का योग लौटाएं जो रेखागणित मुख्य विकर्ण (ऊपर से बाएं से नीचे दाएं) पर स्थित हैं, जहां बाद को ब्रेसेनहम के लाइन एल्गोरिदम द्वारा निर्धारित किया जाता है। यही है, यह मानते हुए कि मैट्रिक्स एक m × n ग्रिड का प्रतिनिधित्व करता है , उस ग्रिड पर A [1, 1] से A [m, n] तक ब्रेशेनहैम के एल्गोरिथ्म का उपयोग करते हुए, और लाइन पर सभी तत्वों का योग लेते हैं। ध्यान दें कि 1 × N और N × 1 मैट्रिसेस के लिए, पूरा मैट्रिक्स अपना स्वयं का विकर्ण बन जाता है (क्योंकि यह पहली पंक्ति के पहले तत्व से अंतिम पंक्ति के अंतिम तत्व तक एक रेखा खींचता है)।

इनपुट: एक वास्तविक मैट्रिक्स ( 1 × 1 मैट्रिक्स, एक पंक्ति मैट्रिक्स, एक स्तंभ मैट्रिक्स, या एक आयताकार मैट्रिक्स) हो सकता है। आउटपुट: एक संख्या।

ध्यान दें कि कुछ स्रोत (ई। जी। ऊपर विकिपीडिया का छद्मकोश) स्थिति जाँच का उपयोग करते हैं error≥0.5, जबकि अन्य स्रोत उपयोग करते हैं error>0.5। आपको मूल रूप से पोस्ट किए गए एक ( error≥0.5) का उपयोग करना चाहिए , लेकिन यदि विकल्प error>0.5आपके कोड में छोटा है, तो आपको इसे लागू करने की अनुमति है (क्योंकि यह कोड गोल्फ है), लेकिन स्पष्ट रूप से इसका उल्लेख करें । देखें टेस्ट केस 4

चुनौती के नियम

I / O प्रारूप लचीले हैं। एक मैट्रिक्स अंतरिक्ष-सीमांकित संख्याओं की कई पंक्तियाँ हो सकती हैं, जिन्हें अलग-अलग संख्याओं से अलग किया जाता है, या पंक्ति वैक्टर की एक पंक्ति, या स्तंभ वैक्टर की एक सरणी आदि।
यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है।
डिफ़ॉल्ट कमियां निषिद्ध हैं।

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

[[1,2,3],[4,5,6],[7,8,9]]→ 1+5+9→ आउटपुट 15:।

[[1,2,3,4],[5,6,7,8]]→ 1+2+7+8→ आउटपुट 18:।

[[1,2,3,4,5,6],[7,8,9,10,11,12],[13,14,15,16,17,18],[19,20,21,22,23,24]]→ 1+8+9+16+17+24→ आउटपुट 75:।

[[1,2,3,4,5],[6,7,8,9,10]]→ 1+2+8+9+10( ≥त्रुटि स्थिति का उपयोग करके ) → आउटपुट 30:।

हालांकि, यदि >आपके कोड में सख्त असमानता का उपयोग करना कम होगा , तो अनुमत आउटपुट है 1+2+3+9+10=25, लेकिन आपको इसे अलग से उल्लेख करना चाहिए।

[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]→ 1+5+8+12→ आउटपुट 26:।

[[-0.3,0.5]]→ उत्पादन: 0.2।
[[3.1],[2.9]]→ उत्पादन: 6।
[[-5]]→ उत्पादन: -5।

ब्रेसेनहैम के एल्गोरिथ्म के बारे में अधिक जानकारी

http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm - विभिन्न भाषाओं के लिए एल्गोरिदम का एक संग्रह;
https://www.cs.helsinki.fi/group/goa/mallinnus/lines/bresenh.html - ढलानों के लिए विभिन्न मामलों की विशेषता वाली एक अच्छी व्याख्या;
https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm ;

code-golf matrix algorithm

— आंद्रे कोस्टीर्का
स्रोत

अनुरोध किया गया परीक्षण का मामला: [[1,2,3,4,5],[6,7,8,9,10]]।

— user202729

@ user202729 ने अस्पष्टता को हल करने के लिए इसे जोड़ा।

— आंद्रे

क्या हम एक परीक्षण का मामला प्राप्त कर सकते हैं जो कि चौड़ा है? जैसे[[1,2],[3,4],[5,6],[7,8],[9,10]]

— Giuseppe

@ गुइसेप्पे कैच। केस 5 देखें अब। आपके उदाहरण के लिए, उत्तर 28( ≥अपेक्षित कार्यान्वयन के साथ) या 27 ( >वैकल्पिक कार्यान्वयन के साथ) होना चाहिए ।

— आंद्रेka कोस्टीर्का

क्या कार्यक्रम केवल एक निश्चित आकार तक मैट्रिस का समर्थन कर सकता है (जैसे, 500 × 500)?

— user202729

3

जेली , 25 बाइट्स

ZXL>LƲ¡µLḶ÷’Ɗ×XL’Ɗær0ị"OS

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

— user202729
स्रोत

यदि जेली के पास पूर्ण-निर्मित पूर्णांक में 1 या 2-बाइट राउंड होता है, तो यह उत्तर 23 या 24 बाइट होगा।

— user202729

3

स्माइलबासिक, 101 99 बाइट्स

DEF D A,W,H
GCLS
GTRI.,0,0,0,W-1,H-1FOR I=0TO W*H-1=I MOD W
S=S+A[I/W,M]*!!GSPOIT(M,I/W)NEXT?S
END

मैंने मूल रूप से एक रेखा खींचने के लिए GLINE फ़ंक्शन का उपयोग करने के बारे में सोचा था, लेकिन यह सही एल्गोरिथ्म का उपयोग करने के लिए प्रकट नहीं होता है। हालांकि, GTRI करता काम करने लगते हैं,

टेस्ट केस 4 आउटपुट 30।

इनपुट एक 2 डी सरणी है [Y, X] फॉर्म में, चौड़ाई / ऊंचाई के साथ (किसी सरणी के आयामों की जांच करने का कोई तरीका नहीं है, केवल तत्वों की कुल संख्या)।

— 12Me21
स्रोत

1

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

254 वें परीक्षण मामले के लिए आउटपुट ।

a=>(X=a[x=y=0].length-1,Y=1-a.length,g=e=>a[y][x]+(x-X|y+Y&&g(e+(e*2>Y&&++x&&Y)+(e*2<X&&++y&&X))))(X+Y)

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

या 88 बाइट यदि मैट्रिक्स के आयामों को इनपुट के रूप में लेने की अनुमति है।

— Arnauld
स्रोत

1

अजगर 3.X, 269 बाइट्स

अंतरिक्ष-सीमांकित संख्याओं के अल्पविराम-पंक्तियों के रूप में इनपुट के साथ।

import math;c=math.ceil;a=[[float(k)for k in q.split(" ")]for q in input().split(",")];_=len;m=lambda f,t,x,y,e,d:sum(x[0]for x in a)if 2>_(a[0])else m(*[0]*4,*[(_(a)-1)/(_(a[0])-1)]*2)if f else m(f,t+a[y][x],x+1,y+c(e-0.5),e+d-c(e-0.5),d)if x<_(a[0])else t;m(1,*[0]*5)

पूर्व गोल्फ:

def line(a):
   if len(a[0])<2: return sum([x[0] for x in a])
   e = d = abs((len(a)-1)/(len(a[0])-1))
   y=t=0
   for x in range(len(a[0])): 
       t += a[y][x]
       f = ceil(e-0.5)
       y += f
       e += d-f
   return t

— बड
स्रोत

ऐसा लगता है कि c=math.ceilकार्यक्रम को लंबा बनाते हैं ...

— user202729

इसके अलावा, आप के []बीच की जरूरत नहीं है sum(..)। a if c else bअक्सर हो सकता है c and a or b।

— user202729

input("")हो सकता है input()।

— user202729

इसके अलावा ... इनपुट / आउटपुट प्रारूप क्या है? स्क्रीन पर प्रिंट करें?

— user202729

1

FMSLogo , 136 बाइट्स

make 1 rl
setxy -1+count :1 -1+count last :1
pu home
make 9 0
foreach :1[foreach ?[if
0=last pixel[make 9 :9+?]fd 1]setxy xcor+1 0]pr :9

पूर्ण कार्यक्रम, इनपुट (डायलॉग बॉक्स पॉपअप) के लिए उपयोगकर्ता को संकेत दें और फिर आउटपुट को स्क्रीन पर प्रिंट करें।

बस स्क्रीन पर एक रेखा खींचें और आउटपुट की गणना करें। सख्त असमानता का उपयोग करें।

यह केवल FMSLogo के कैनवास आकार तक मैट्रिक्स आकार का समर्थन करता है (लगभग 500 × 500)

अघोषित कोड:

Make "input ReadList
SetXY (-1+Count :input) (-1+Count Last :input)
PenUp
Home
Make "sum 0
ForEach :input[
    ForEach ?[
        If 0=Last Pixel[
            Make "sum :sum+?
        ]
        Forward 1
    ]
    SetXY XCor+1 0
]
Print :sum

— user202729
स्रोत

मैट्रिक्स के माध्यम से किसी भी मैट्रिक्स के लिए मैट्रिक्स का पता लगाने ... Bresenham की लाइन रेखांकन

कार्य

चुनौती के नियम

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

ब्रेसेनहैम के एल्गोरिथ्म के बारे में अधिक जानकारी

जेली , 25 बाइट्स

स्माइलबासिक, 101 99 बाइट्स

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

अजगर 3.X, 269 बाइट्स

FMSLogo , 136 बाइट्स