यह एक सरल है: इनपुट के रूप में पूर्णांकों का एक मैट्रिक्स लें, और सबसे गैर-शून्य तत्वों के साथ पंक्ति के सूचकांक को आउटपुट करें। आप मान सकते हैं कि सबसे गैर-शून्य तत्वों के साथ केवल एक पंक्ति होगी।
ये 1-अनुक्रमित हैं, आप चाहें तो 0 या 1-अनुक्रमित कर सकते हैं।
1
0
row = 1
---
0 -1
0 0
row = 1
---
1 1 0 0 0
0 0 5 0 0
2 3 0 0 0
0 5 6 2 2
row = 4
---
0 4 1 0
0 0 -6 0
0 1 4 -3
2 0 0 8
0 0 0 0
row = 3
जवाबों:
!gs&X>
इनपुट एक मैट्रिक्स है, ;पंक्ति विभाजक के रूप में।
इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।
! % Transpose
g % Logical: convert non-zeros to 1
s % Sum of each column, or sum of row if there's a single row
&X> % Arg max. Implicitly display
Ordering[Count@0/@#,1]&
ΣĀO}θk
-2 बाइट्स को धन्यवाद एग्री द आउटगोलर
ΣĀO}θk
Σ } # Sort input by following code
Ā # Is element not 0? (vectorized)
O # Sum
θk # Get index of "largest" element
# Implicit print
pryr::f(which.min(rowSums(!m)))एक अनाम फ़ंक्शन देता है जो एक मैट्रिक्स लेता है:
function(m)which.min(rowSums(!m))rowSumsपंक्तियों !mको 0 से 1 और बाकी सब को 0. में बदलने के साथ पंक्तियों which.minको पहले पंक्ति के 1-आधारित सूचकांक में वापस लौटाता है जिसमें न्यूनतम राशि (यानी, किस पंक्ति में सबसे कम शून्य है) है।
which.min()क्योंकि गैर-शून्य तत्व FALSE हो जाएंगे !m।
snd.minimum.(`zip`[1..]).map(filter(==0))
यह काम किस प्रकार करता है
map -- for each row
(filter(==0)) -- collect the 0s
(`zip`[1..]) -- pair with row index (<#0s>, <index>)
minimum -- find the minimum
snd -- extract index from pair
using System.Linq;m=>m.IndexOf(m.OrderBy(r=>r.Count(n=>n!=0)).Last())एक List<int[]>इनपुट के रूप में लेता है और 0-अनुक्रमित परिणाम देता है।
0@♀cñ♂RmN
स्पष्टीकरण:
0@♀cñ♂RmN
0@♀c count zeroes in each row
ñ♂R enumerate and reverse each row (each row becomes [count, index] pair)
m minimum
N last element (the index)
lambda a:a.index(min(a,key=lambda r:r.count(0)))6 बाइट्स से शेव किया हुआ। पुराना समाधान:
lambda a:min(range(len(a)),key=lambda i:a[i].count(0))(⊢⍳⌈/)+/0≠⎕0≠⎕ बूलियन मैट्रिक्स जहां गैर-शून्य है
+/ योग पंक्तियाँ
( रकम की सूची के लिए निम्नलिखित कार्य समारोह लागू करें
⌈/ अधिकतम
⍳ सूची
⊢ तर्क सूची में
)
TL$€M
1 अनुक्रमित।
इतने सारे 5-बाइट संस्करण ...
TL$€M, T€L€M, TJ$€M, T€J€M, ¬¬Ṣ€M, ṠAṢ€M, ṠAS€M, AṠṢ€M, AṠS€M, ¬ċ€0M, ...
सिराकुसा के लिए एक बाइट धन्यवाद!
पंक्तियों को शून्य अनुक्रमित किया जाता है
g=filter
m y=head$g((==maximum y).(y!!))[0..]
f=m.map(length.g(0/=))
f [[1,1,0,0,0],[2,3,0,0,0],[0,5,6,2,2],[1,1,1,1,1]]
g=filterआपको एक बाइट
m y=length$takeWhile(<maximum y)yऔर lengthइसके बजाय छोटा कर सकते हैंfilter
यह एक इनपुट में नकारात्मक संख्याओं के साथ भी काम करता है, सौभाग्य से मूल के समान लंबाई है:
#(nth(sort-by(fn[i](count(filter #{0}(% i))))(range(count %)))0)
मूल:
#(last(sort-by(fn[i](count(filter pos?(% i))))(range(count %))))
pos?यह सही नहीं है
समाधान:
(*)(<)sum(+)0=/:
उदाहरण:
q)(*)(<)sum(+)0=/:enlist(1;0)
0
q)(*)(<)sum(+)0=/:(0 -1;0 0)
0
q)(*)(<)sum(+)0=/:(1 1 0 0 0;0 0 5 0 0;2 3 0 0 0;0 5 6 2 2)
3
q)(*)(<)sum(+)0=/:(0 4 1 0;0 0 -6 0;0 1 4 -3;2 0 0 8;0 0 0 0)
2
स्पष्टीकरण:
first iasc sum flip 0=/: / ungolfed
/: / each right, apply a function to each item to the right
0= / returns boolean 1b or 0b if item in each list is equal to zero
flip / flip (rotate) the output
sum / sum these up
iasc / return indices if we were to sort ascending
first / take the first one
टिप्पणियाँ:
समस्या काफी सीधी है, यह समाधान अत्यधिक जटिल लगता है। जैसे ही मैंने हिट सबमिट किया मुझे अपने तरीकों की त्रुटि का एहसास हुआ।
बोनस:
यहाँ ak solution है जो 16 10 9 बाइट्स में वजन करता है - लगभग बिलकुल एक जैसा लेकिन 7 बाइट्स इस तथ्य के कारण कि हमें k-ins का उपयोग करते समय कोष्ठक की आवश्यकता नहीं है, और परिणामस्वरूप कुछ q कीवर्ड्स से छोटे हो जाते हैं ( उदाहरण के +/लिए sum( (+/)q में होगा ))।
*<+/+0=/:
òø0
jòÚDuu/"
dGؾ
अधिकांश V उत्तरों के विपरीत, यह 0-अनुक्रमित है।
00000000: f2f8 300a 6af2 da44 7575 2f12 220a 6447 ..0.j..Duu/.".dG
00000010: d8be ..
कोई सांख्यिक समर्थन वाली भाषा के लिए बुरा नहीं है! ;P
मुझे यह भी पता चला है कि गिनती कमांड का अपरकेस वैरिएंट , यानी कि Øबुरी तरह से टूटा हुआ है।
def f(x):
for e in x:
e.sort()
y=x[:]
y.sort()
return x.index(y[-1])पहले प्रत्येक पंक्ति को क्रमबद्ध करें जैसे कि प्रविष्टि [0,0,..,0,x,x,x]फिर पूरे मैट्रिक्स को क्रमबद्ध करें, ताकि अंतिम प्रविष्टि yवह पंक्ति है जिसे हम खोज रहे हैं। कार्यस्थल पर प्रतिलिपि y=x[:]आवश्यक है, .sort()इसलिए हम छँटाई के बाद मूल सूचकांक को नहीं जानते हैं।
मैं किसी भी मदद की सराहना करता हूं कि इस समाधान को आगे कैसे बढ़ाया जाए। प्रत्येक पंक्ति में व्हॉट्सएप के कारण अधिकांश बाइट्स खो जाते हैं। कोड ही 68 बाइट्स लंबा है।
def f(a):b=list(map(sorted,a));return b.index(sorted(b)[-1])
0करें और min()इसके बजाय उपयोग करेंmax()input()इसके बजाय उपयोग करेंdeflambdaहैश-मैप का उपयोग किया lambda x:x.index(min(x,key=lambda n:n.count(0)))minके साथ keyपैरामीटर
0 अनुक्रमित। इनपुट के रूप में एक 2D सरणी लेता है।
a=>(a=a.map(x=>x.filter(y=>y).length)).indexOf(Math.max(...a))
filterसंक्षेप में "फ़िल्टर" शून्य है?
filterथा।
ċ0$ÞḢi@
ċ0$ÞḢi@ Main link
Þ Sort by
ċ0$ the number of occurences of 0
Ḣ Take the first element
i@ Index in the original array
xQh/D0
सबसे गैर-शून्य तत्वों के साथ पंक्ति खोजने के बजाय, मैं सबसे कम शून्य तत्वों वाली पंक्ति पाता हूं।
/D0: शून्य ( ) की Dगिनती ( ) द्वारा ऑर्डर /( 0)। लागू करने के लिए Q, इनपुट।
h: पहला, और न्यूनतम, तत्व लें।
xQ: उस तत्व xके इनपुट ( Q) में इंडेक्स ( ) खोजें ।
%M`\b0
m`(?<=(¶.+)*)$
;$#1
O#`.+
!`(?<=^.+;).+
0 अनुक्रमित। सकारात्मक और नकारात्मक पूर्णांक (और 0) के साथ काम करता है। कोई अग्रणी शून्य नहीं मानता है।
import java.util.*;m->{int t=0,s=0,i=0,r=0;for(;i<m.size();i++){List l=(List)m.get(i);for(;l.remove(0L););s=l.size();if(s>t){t=s;r=i;}}return r;}
बदसूरत, लेकिन यह काम करता है ..
स्पष्टीकरण:
import java.util.*; // Required import for List
m->{ // Method with List parameter and integer return-type
int t=0,s=0,i=0, // Temp integers
r=0; // Result integer
for(;i<m.size();i++){ // Loop over the List of Lists
List l=(List)m.get(i); // Get the inner List
for(;l.remove(0L);); // Remove all zeros
s=l.size(); // Get the size of the List
if(s>t){ // If this size is larger than the previous
t=s; // Set `t` to this size
r=i; // And set the result to the index of this row
}
} // End of loop
return r; // Return result-integer
} // End of method
m->{int i=m.length,M=0,I=0,c;for(;i-->0;){c=0;for(int x:m[i])if(x!=0)c++;if(c>M){M=c;I=i;}}return I;}जावा, वह मीठी वाचाल भाषा :)
18 बाइट्स बचाने के लिए धन्यवाद, @ केविनक्रूजसेन;)
jतरह से j=m[i].length,और m[i][j]इस तरह के अन्य लंबे हिस्सों से छुटकारा पाने के लिए प्रत्येक-इनर लूप का उपयोग करके इसे गोल्फ कर सकते हैं : m->{int i=m.length,M=0,I=0,c;for(;i-->0;){c=0;for(int x:m[i])if(x!=0)c++;if(c>M){M=c;I=i;}}return I;}( 101 बाइट्स )
m=>m.reduce((a,e,i)=>e.filter(x=>x).length>a?i:a,0)
जहाँ m2 डी सरणी है और लौटाया गया सूचकांक 0-अनुक्रमित है
परीक्षण के मामलों:
m->m.indexOf(m.stream().map(z->{z.removeIf(x->x==0);return z;}).max((q,r)->q.size()-r.size()).get())
सूचियों और धाराओं की शक्ति! (और आयात के बिना, बूट करने के लिए!)
चलो इस छोटे से भेड़ के बच्चे को विखंडू में तोड़ दें:
m.stream().map(z->{z.removeIf(x->x==0);return z;}
हम अपनी सूची की सूची (प्रश्न में मैट्रिक्स) को एक स्ट्रीम में बदल देते हैं और प्रत्येक उप-सूची से उन सभी pesky शून्य को हटाते हुए प्रत्येक तत्व से गुजरते हैं। हमें यहां हर बार स्पष्ट रूप से सबलिस्ट को वापस करने की आवश्यकता होती है, क्योंकि Stream.map()स्ट्रीम में प्रत्येक ऑब्जेक्ट को मैपिंग रिटर्न में बदल देता है, और हम उन्हें बदलना नहीं चाहते हैं।
.max((q,r)->q.size()-r.size()).get()
हम अपने नए डी-शून्य उप-कलाकारों के माध्यम से जाते हैं, और बस यह जांचते हैं कि वे एक-दूसरे के कितने बड़े हैं, हमें सबसे बड़ी सबलिस्ट बनाते हैं। .get()क्योंकि है Stream.max()एक वैकल्पिक देता है, कि अतिरिक्त समारोह कॉल की जरूरत पड़ेगी।
m.indexOf()
हम उस सबसे बड़ी सबलिस्ट को लेते हैं, और पाते हैं कि यह मुख्य सूची में है, हमें अपना परिणाम दे रही है!
यह टूट जाता है अगर बाहरी सूची खाली है, लेकिन मैं ले रहा हूं
आप मान सकते हैं कि सबसे गैर-शून्य तत्वों के साथ केवल एक पंक्ति होगी।
इसका मतलब है कि हमेशा कम से कम एक पंक्ति होगी। यदि मैं गलत हूं तो मुझे सही करों।
def f(x,i=0):print i;x[i].remove(0);f(x,-~i%len(x))यह संस्करण 0 के उत्तरोत्तर को सरणियों के माध्यम से हटाता है, वर्तमान सूचकांक को प्रिंट करता है, और जब हटाने के लिए अधिक शून्य नहीं होते हैं तो क्रैश हो जाता है। अंतिम मुद्रित सूचकांक इसका उत्तर है।
lambda x,i=0:0in x[i]>x[i].remove(0)and f(x,-~i%len(x))|iयहां पहले से ही एक अलग दृष्टिकोण की कोशिश करना चाहता था। इसलिए यहाँ मैं एक 0 पर एक बार हटाने वाले सरणी पर पुनरावृत्ति करता हूँ जब तक कि वर्तमान सरणी में अब कोई शून्य नहीं है - और फिर उस सरणी के सूचकांक को आउटपुट करें।
0 अनुक्रमित। सरणी के एक सरणी के रूप में इनपुट लेता है।
mè
bUrw
सरणी का निहित इनपुट U।[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]
mè
प्रत्येक उप-सरणी में सत्य (गैर-शून्य) तत्वों की गिनती वापस करने mपर नक्शा ( ) U। इस नए एरे को संक्षेप में असाइन करें U।[2,1,3,2,0]
Urw
वर्तमान मान और वर्तमान तत्व के अधिक होने से rसरणी Uको कम करें ( ) ।3
b
पहला इंडेक्स प्राप्त करें Uजिसमें तत्व उस मान के बराबर होता है और परिणाम को अनुमानित करता है।2
Āबजाय का उपयोग करेंÄ0›।