এটি একটি সহজ: ইনপুট হিসাবে পূর্ণসংখ্যার একটি ম্যাট্রিক্স নিন এবং সর্বাধিক অ-শূন্য উপাদানগুলির সাথে সারির সূচকটি আউটপুট করুন। আপনি ধরে নিতে পারেন যে সর্বাধিক শূন্য উপাদানগুলির সাথে কেবল একটি সারি থাকবে।
এগুলি 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
-২ বাইটস এরিক দি আউটগলফারকে ধন্যবাদ
ΣĀ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!m0 থেকে 1 এবং অন্য কিছুর 0. তে রূপান্তর করে সারিগুলির which.minযোগফল দেয়, প্রথম সারির 1-ভিত্তিক সূচকটি প্রদান করে যার মধ্যে ন্যূনতম যোগফল থাকে (অর্থাত্, কোন সারিতে স্বল্পতম শূন্য রয়েছে)।
which.min()যেহেতু অ-শূন্য উপাদানগুলি মিথ্যা হয়ে উঠবে !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
নোট:
সমস্যাটি মোটামুটি সোজা, এই সমাধানটি অত্যধিক জটিল বোধ করে। সাবমিট হিট করার সাথে সাথে আমি আমার উপায়গুলির ত্রুটিটি বুঝতে পারি।
বোনাস:
এখানে 16 ম 9 9 বাইটের মধ্যে ওজনের আক এর সমাধান রয়েছে - কে বিল্ট-ইনগুলি ব্যবহার করার সময় আমাদের বন্ধনী প্রয়োজন না হওয়ার কারণে প্রায় একই কিন্তু 7 বাইট ছোট হয় এবং ফলস্বরূপ কিছু কিউ কীওয়ার্ডের চেয়ে সংক্ষিপ্ত হয়ে যায় ( যেমন +/জন্য sum(হবে (+/)কুই মধ্যে))।
*<+/+0=/:
{0fe=_:e>#}
>হওয়া উচিত <... যাইহোক ধন্যবাদ। :)
òø0
jòÚDuu/"
dGؾ
বেশিরভাগ ভি উত্তরগুলির বিপরীতে, এটি 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: Element উপাদানটির 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)
যেখানে mএকটি 2 ডি অ্যারে এবং সূচকটি 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;}
আমরা আমাদের তালিকাগুলির তালিকাগুলি (প্রশ্নের ম্যাট্রিক্স) একটি স্ট্রিমে পরিণত করি এবং প্রতিটি উপ-তালিকা থেকে p সমস্ত অতিস্বল্প জিরোগুলি সরিয়ে প্রতিটি উপাদান দিয়ে যাই। আমাদের এখানে প্রতিবার সুস্পষ্টভাবে সাবলিস্টটি ফিরিয়ে আনতে হবে, কারণ 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))এই সংস্করণটি অ্যারেগুলির মাধ্যমে 0s অগ্রগতিতে সরিয়ে দেয়, বর্তমান সূচকটি মুদ্রণ করে এবং যখন অপসারণের জন্য আরও কোনও শূন্য নেই তখন ক্র্যাশ হয়। শেষ মুদ্রিত সূচক উত্তর।
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›।