एक विरल मैट्रिक्स को संपीड़ित करें

18

संपीड़ित विरल पंक्ति (CSR, CRS या येल प्रारूप) का उपयोग करके एक विरल मैट्रिक्स को संपीड़ित करें ।

ये सभी संपीड़न के समान रूप हैं (नए येल को अनदेखा करें)।

इनपुट किसी भी 2d डेटा संरचना (सूची की सूची, आदि) हो सकता है: उदाहरण के लिए

[[0 0 0 0],
 [5 8 0 0],
 [0 0 3 0],
 [0 6 0 0]]

और आउटपुट तीन 1d डेटा संरचना (सूची आदि) होना चाहिए, जो आउटपुट को निरूपित करता है A, IAऔर JA, उदाहरण के लिए

[5, 8, 3, 6]
[0, 0, 2, 3, 4]
[0, 1, 2, 1,]

इस प्रक्रिया का वर्णन विकिपीडिया द्वारा किया गया है:

  • सरणी A लंबाई NNZ की है और बाएं से दाएं ऊपर-नीचे ("पंक्ति-प्रमुख") क्रम में M की सभी गैर-अक्षीय प्रविष्टियाँ रखती हैं।

  • सरणी IA लंबाई m + 1 है। यह इस पुनरावर्ती परिभाषा द्वारा परिभाषित किया गया है:

    • IA [0] = 0 IA [i] = IA [i - 1] + (मूल मैट्रिक्स में (i - 1) -th रो पर नॉनजरो तत्वों की संख्या)

    • इस प्रकार, IA के पहले m तत्व M की प्रत्येक पंक्ति में पहले गैर-अक्ष तत्व में से एक में अनुक्रमणिका को संग्रहीत करते हैं, और अंतिम तत्व IA [m] NNZ को संग्रहीत करता है, A में तत्वों की संख्या, जिन्हें इस प्रकार भी माना जा सकता है मैट्रिक्स एम के अंत से परे एक प्रेत पंक्ति के पहले तत्व के ए में सूचकांक। मूल मैट्रिक्स की आई-वें पंक्ति के मूल्यों को ए [आईए [आईए] तत्वों से पढ़ा जाता है। 1] - 1] (दोनों सिरों पर सम्मिलित), यानी अगली पंक्ति के शुरू होने से ठीक पहले एक पंक्ति से अंतिम सूचकांक तक। [५]

    • तीसरा सरणी, JA, A के प्रत्येक तत्व के M में कॉलम इंडेक्स सम्‍मिलित करता है और इसलिए NNZ की लंबाई भी है।

यदि आपकी भाषा वास्तविक डेटा संरचनाओं का समर्थन नहीं करती है, तो इनपुट और आउटपुट पाठ हो सकता है।

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

इनपुट 1: 

[[0 0 0 0],
 [5 8 0 0],
 [0 0 3 0],
 [0 6 0 0]]

आउटपुट 1:

[ 5, 8, 3, 6 ]
[ 0, 0, 2, 3, 4 ]
[ 0, 1, 2, 1, ]

इनपुट 2

[[10 20 0 0 0 0],
 [0 30 0 40 0 0],
 [0 0 50 60 70 0],
 [0 0 0 0 0 80]]

आउटपुट 2:

[ 10 20 30 40 50 60 70 80 ]
[  0  2  4  7  8 ]
[  0  1  1  3  2  3  4  5 ]

इनपुट 3:

[[0 0 0],
 [0 0 0],
 [0 0 0]]

आउटपुट 3:

[ ]
[ 0 0 0 0 ]
[ ]

इनपुट 4:

[[1 1 1],
 [1 1 1],
 [1 1 1]]

आउटपुट 4:

[ 1 1 1 1 1 1 1 1 1 ]
[ 0 3 6 9 ]
[ 0 1 2 0 1 2 0 1 2 ]

इनपुट 5: 

[[0 0 0 0],
 [5 -9 0 0],
 [0 0 0.3 0],
 [0 -400 0 0]]

आउटपुट 5:

[ 5, -9, 0.3, -400 ]
[ 0, 0, 2, 3, 4 ]
[ 0, 1, 2, 1, ]

मान लें कि इनपुट में कोई वास्तविक संख्या हो सकती है, तो आपको गणितीय प्रतीकों या घातांक प्रतिनिधित्व पर विचार करने की आवश्यकता नहीं है (उदाहरण 5,000 को 5e3 के रूप में कभी भी दर्ज नहीं किया जाएगा)। आप को संभालने के लिए की जरूरत नहीं होगी inf, -inf, NaNया किसी अन्य 'छद्म संख्या'। आप संख्या का एक अलग प्रतिनिधित्व आउटपुट कर सकते हैं ( यदि आप चुनते हैं तो 5,000 का उत्पादन 5e3 के रूप में हो सकता है)।

स्कोरिंग:

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

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  number  array-manipulation  matrix 
— Pureferret
स्रोत
1-आधारित सूचकांकों का उपयोग अंतिम पंक्ति के लिए किया जा सकता है?
— सिंह
JA के लिए @Leo? नं।
— प्यूरफेरेट
1
IA[0] = 0पूरी तरह से अनावश्यक नहीं है ? यह केवल परिभाषित करने के लिए आवश्यक है IA[i] = IA[i − 1]..., फिर भी हम केवल यह बता सकते हैं कि यदि i-1 < 00. का उपयोग करना है, अर्थात IA [0] हमेशा 0 के बराबर होता है, तो इसे संपीड़ित किया जा सकता है (हाँ, मुझे पता है कि यह एल्गोरिथ्म का एक समालोचक है,) यह चुनौती नहीं है)।
— Draco18s अब SE
क्या हमारे पास उलटा चुनौती भी होगी?
— एडम जूल
1
साफ! पहले किसी भी प्रारूप में नहीं चला था, लेकिन मुझे यह देखकर खुशी हुई कि किसी और ने यह देख लिया कि इससे पहले (मुझे इस तरह का व्यक्ति नहीं होना चाहिए जो इस पुराने एल्गोरिदम में तुच्छ अनुकूलन करता है)।
— Draco18s अब SE

जवाबों:

6

MATL , 19 बाइट्स

!3#f!Dx0Gg!XsYshDq!

इनपुट ;पंक्ति विभाजक के रूप में उपयोग करता है ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें: 1 , 2 , 3 , 4 , 5 ।

व्याख्या

!     % Implicit input. Transpose
3#f   % 3-output version of find: it takes all nonzero values and pushes
      % their column indices, row indices, and values, as column vectors
!     % Transpose into a row vector
D     % Display (and pop) vector of values
x     % Delete vector of row values
0     % Push 0
G     % Push input
g     % Convert to logical: nonzeros become 1
!     % Transpose
Xs    % Sum of columns. Gives a row vector
Ys    % Cumulative sum
h     % Prepend the 0 that's below on the stack
D     % Display (and pop) that vector
q     % Subtract 1 from the vector of row indices
!     % Transpose into a row vector. Implicitly display
— लुइस मेंडो
स्रोत
3

हास्केल, 87 बाइट्स

f s|a<-filter(/=0)<$>s=(id=<<a,scanl(+)0$length<$>a,s>>= \t->[i|(i,e)<-zip[0..]t,e/=0])

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

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

a<-filter(/=0)<$>s           -- let a be the list of lists with all 0 removed]
                             -- e.g. [[1,0,0],[0,3,4]] -> [[1],[3,4]]

                             -- return a triple of

id=<<a                       -- a concatenated into a single list -> A 

scanl(+)0$length<$>a         -- partial sums of the length of the sublists of a
                             -- strating with an additional 0 -> IA

s>>=                         -- map the lambda over the sublists of s and concatenate
                             -- into a single list
   \t->[i|(i,e)<-zip[0..]t,e/=0]  -- the indices of the non-zero elements -> JA
— nimi
स्रोत
2

APL (Dyalog) , 31 28 वर्ण या 36 33 बाइट्स *

⎕IO←0शून्य आधारित अनुक्रमण के लिए आवश्यक है । I / O सूचियों की सूची है।

{(∊d)(0,+\≢¨d←⍵~¨0)(∊⍸¨⍵≠0)}

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

{… } अनाम फ़ंक्शन जहां तर्क argument द्वारा दर्शाया गया है

 (... )(... )(... ) तीन बातों की एक सूची प्रदान:

  ⍵≠0 बूलियन जहां 0 से तर्क अलग है
  ⍸¨ ɩ प्रत्येक उप-सूची के लिए उन लोगों में से ndices
  ∊ ε nlist (समतल) एकल सूची में गठबंधन करने के लिए

  ⍵~¨0 तर्क
  d← स्टोर के प्रत्येक उप-सूची से शून्य हटाएं कि डी के रूप में
  ≢¨ प्रत्येक
  +\ संचयी योग
  0, एक शून्य को प्रस्तुत करता है

  ∊d ε nlist (समतल) घ एकल सूची में गठबंधन करने के लिए

  

* Dyalog Classic में चलने के लिए, बस के ⍸साथ बदलें ⎕U2378।

— एडम
स्रोत
हालांकि, मुझे इनपुट प्रारूप की समझ नहीं है? f 4 4⍴और फिर मूल्यों?
— प्यूरफेरेट
@Pureferret कोड फ़ंक्शन को परिभाषित करता है f। इनपुट वास्तव में एक REPL है, जो fउस परिणाम पर कॉल करता है 4 4⍴…जिसमें r डेटा को 4 × 4 मैट्रिक्स में बदल देता है।
— आदम जूल
1
आर eshapes के लिए Rho । मैं समझ गया!
— प्यूरफेरेट
1
@Pureferret मैंने इसे ऑनलाइन आज़माया है ! बेहतर शो परीक्षण मामलों के लिए लिंक।
— एडम जूल
2

PHP , 107 बाइट्स

<?for($y=[$c=0];$r=$_GET[+$l++];)foreach($r as$k=>$v)!$v?:[$x[]=$v,$z[]=$k,$y[$l]=++$c];var_dump($x,$y,$z);

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

PHP , 109 बाइट्स

<?$y=[$c=0];foreach($_GET as$r){foreach($r as$k=>$v)if($v){$x[]=$v;$z[]=$k;$c++;}$y[]=$c;}var_dump($x,$y,$z);

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

— जार्ग हुल्सरमन
स्रोत
क्या इसके लिए संख्याओं का तार होना आवश्यक है?
— प्यूरफेरेट
1
@Pureferret PHP में कोई भी इनपुट स्ट्रिंग या स्ट्रिंग्स की एक सरणी है। मैंने इनपुट $x[]=$v$x[]=+$v
— कास्ट
2

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

a=>[a.map((b,i)=>(b=b.filter((x,c)=>x&&o.push(c)),m[i+1]=m[i]+b.length,b),m=[0],o=[]).reduce((x,y)=>x.concat(y)),m,o]

इनपुट संख्या का 2 डी सरणी है और आउटपुट एक सरणी है [A, IA, JA]।

व्याख्या की

a=>[
    a.map((b,i) => (                                // map each matrix row
            b = b.filter((x,c) => x                 // filter to only non-zero elements
                && o.push(c)                        // and add this index to JA
            )
            m[i+1] = m[i] + b.length,               // set next value of IA
            b                                       // and return filtered row
        ),
        m=[0],o=[]                          // initialize IA (m) and JA (o)
    ).reduce((x,y) => x.concat(y)),                 // flatten the non-zero matrix
m,o]                                                // append IA and JA

टेस्ट

कोड स्निपेट दिखाएं

— जस्टिन मेरिनर
स्रोत
1

पर्ल 6 , 84 बाइट्स

{.flatmap(*.grep(+*)),(0,|[\+] .map(+*.grep(+*))),.flat.kv.flatmap:{$^a%.[0]xx?$^b}}

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

एकल मैट्रिक्स तर्क में है $_।

  • .flatmap(*.grep(+*)) पूरे मैट्रिक्स के गैर-अक्षीय तत्वों का चयन करता है।
  • [\+] .map(+*.grep(+*))प्रत्येक पंक्ति में तत्वों की संख्या की त्रिकोणीय कमी है (जिसे कुछ भाषाएं कहते हैं scan)। (0,|...)उस सूची में एक शून्य डालता है।
  • .flat.kvमैट्रिक्स के सभी तत्वों की एक अनुक्रमित सूची बनाता है। .flatmap: { $^a % .[0] xx ?$^b }सरणी में कॉलम की संख्या (प्रत्येक .[0], पहली पंक्ति में तत्वों की संख्या) द्वारा प्रत्येक सूचकांक के मापांक पर फ्लैट-मैप्स , एक तत्व के रूप में दोहराया गया, जिसे बूलियन के रूप में व्याख्या किया गया है। यही है, गैर-एज़ेरो तत्वों को एक बार दोहराया जाता है, और शून्य तत्वों को शून्य बार (यानी हटा दिया गया) दोहराया जाता है।
— शॉन
स्रोत
1

पायथन + SciPy, 79 बाइट्स

मुझे लगता है कि बिल्ट-इन निषिद्ध नहीं थे

from scipy.sparse import*
A=csr_matrix(input())
print A.data,A.indptr,A.indices

प्रारूप में इनपुट स्वीकार करता है [[0, 0, 0, 0],[5, 8, 0, 0],[0, 0, 3, 0],[0, 6, 0, 0]]

— कार्ल नेफ
स्रोत
1

जाप , ३१ 27 बाइट्स

सरणियों के एक सरणी के रूप में इनपुट लेता है और सरणियों की एक सरणी देता है।

[Uc f U®£X©NpYÃZèÃå+ iT NÅ]

इसका परीक्षण करें ( -Qकेवल विज़ुअलाइज़ेशन उद्देश्यों के लिए ध्वज)

व्याख्या

सरणी का निहित इनपुट U।
[[1,1,1],[1,1,1],[1,1,1]]

Uc f

पहले उप = -रे के लिए, हम समतल करते हैं ( c) Uऔर फिर fइसे फ़िल्टर करते हैं ( ) इसे, किसी भी गलत तत्व को हटाते हैं (अर्थात, 0)
[1,1,1,1,1,1,1,1,1]

U®         Ã

हम एक ही समय में अन्य 2 उप-सरणियों का निर्माण करने जा रहे हैं, ओवर मैपिंग करके U।

£     Ã

हम प्रत्येक तत्व (उप-सरणी) पर मैप करते हैं U

X©

Xवर्तमान उप-सरणी का वर्तमान तत्व है और ©तार्किक है ( &&) है, यदि Xसत्य नहीं है (शून्य नहीं) तो अगला भाग निष्पादित नहीं किया जाएगा।

NpY

जाप में, Nएक सरणी है, जिसमें सभी इनपुट यहां हैं, अगर सत्य है, तो Xहम वर्तमान तत्व pके सूचकांक ( Y) को धक्का देते हैं N।
[[[1,1,1],[1,1,1],[1,1,1]],0,1,2,0,1,2,0,1,2]

Zè

मुख्य सरणी के मानचित्र पर वापस और, प्रत्येक तत्व ( Z) के लिए, हमें उस उप-सरणी में तत्वों की गिनती मिलती है जो सत्य हैं (शून्य नहीं)।
[3,3,3]

å+

संचयी रूप से इस सरणी को संक्षेप में कम करें।
[3,6,9]

iT

iदूसरी उप-सरणी को पूरा करने के लिए इंडेक्स 0 पर डालें ( ) 0।
[0,3,6,9]

NÅ

अंतिम उप-सरणी के लिए, हम केवल N1 तत्व से टुकड़ा करते हैं।
[0,1,2,0,1,2,0,1,2]

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