एक सरणी में सबसे छोटे समूह

Question

परिचय

चलो निम्नलिखित सरणी का निरीक्षण करते हैं:

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

एक समूह में एक दूसरे के बगल में समान अंक होते हैं। उपरोक्त सरणी में, 5 अलग-अलग समूह हैं:

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

 1, 1, 1 
          2, 2
                1, 1, 1, 1
                            2, 2, 2
                                     1, 1, 1

इनमें से सबसे छोटा समूह है [2, 2], इसलिए हम आउटपुट करते हैं [2, 2]।

आइए एक और उदाहरण लेते हैं:

[3, 3, 3, 4, 4, 4, 4, 5, 5, 4, 4, 3, 3, 4, 4]

 3, 3, 3
          4, 4, 4, 4
                      5, 5
                            4, 4
                                  3, 3
                                        4, 4

आप देख सकते हैं कि समान लंबाई वाले कई समूह हैं। सबसे छोटे समूह हैं:

[3, 3], [4, 4], [4, 4] and [5, 5].

तो हम [3, 3], [4, 4], [4, 4], [5, 5]किसी भी उचित प्रारूप में उत्पादन करते हैं । आप किसी भी क्रम में इनका उत्पादन कर सकते हैं।

काम

केवल सकारात्मक पूर्णांक से मिलकर एक सरणी को देखते हुए, सरणी से सबसे छोटे समूह (ओं) को आउटपुट करें। आप मान सकते हैं कि सरणी में कम से कम 1 पूर्णांक होगा।

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

Input: [1, 1, 2, 2, 3, 3, 4]
Output: [4]

Input: [1]
Output: [1]

Input: [1, 1, 10, 10, 10, 100, 100]
Output: [1, 1], [100, 100]

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!

Comments

संबंधित ।

— लीक नून

क्या इनपुट एक स्ट्रिंग हो सकता है?

— downrep_nation

@downrep_nation हम्म, फिर आप ऐसा कैसे करना चाहेंगे? यदि आप इसे मल्टीडिजिट पूर्णांक के साथ कर सकते हैं, तो यह ठीक है।

— अदनान

ints आकार द्वारा बहुत सीमित हैं और तार नहीं हैं। Thats क्यों पूछ im

— downrep_nation

@downrep_nation ठीक है, तो आप अंतिम परीक्षण मामले के लिए इनपुट कैसे प्रदान करना चाहते हैं? 11101010100100इनपुट के लिए सही नहीं लगता: p

— अदनान

Answer 1

Pyth, 14 12 1 1

mM_MmhbrQ8

परीक्षण सूट

2 बाइट्स Jakube के लिए धन्यवाद! और 1 बाइट isaacg के लिए धन्यवाद!

दुर्भाग्य से, रन लंबाई डिकोडिंग काफी कुछ नहीं करती है जो हम इसे करना चाहते हैं, लेकिन यह एक मामूली वर्कअराउंड के साथ काम करेगा, लेकिन यह मैनुअल कार्यान्वयन की तुलना में थोड़ा लंबा बनाता है:

mr]d9.mhbrQ8

इसे खोजने के लिए जकुबे को श्रेय।

Comments

Btw, Rld काम करता है, लेकिन आपको जोड़े की एक सूची प्रदान करनी होगी:mr]d9.mhbrQ8

— Jakube 21

रन लेंथ डिकोडिंग के बारे में अधिक जानकारी: रन लेंथ डिकोडिंग जोड़े की एक सूची की अपेक्षा करता है, जैसे कि लंबाई एन्कोडिंग रिटर्न क्या होती है, व्यक्तिगत जोड़ी नहीं।

— ईसैक

.bmYN==mM_M

— ईसैक

@isaacg आह, सही है कि समझ में आता है, मुझे लगता है कि मैं उस के माध्यम से नहीं सोच रहा था। इसके अलावा, नक्शा चाल साफ है, धन्यवाद!

— FryAmTheEggman

Answer 2

गणितज्ञ, 24 बाइट्स

MinimalBy[Length]@*Split

यह दो कार्यों की एक रचना है जिसे एक सूची में लागू किया जा सकता है। Splitलगातार संख्याओं के सभी समूहों को लेता है, और MinimalBy[Length]न्यूनतम लंबाई वाले लोगों का चयन करता है।

Comments

अरे, यह परीक्षण करने के लिए सिर्फ गणितज्ञ को निकाल दिया ... +1 :)

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

अब मैं सोच रहा हूं कि क्या मैंने यह बहुत तुच्छ नहीं बनाया है: /।

— अदनान

Answer 3

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

import Data.Lists
argmins length.group

प्रयोग उदाहरण: argmins length.group $ [3,3,3,4,4,4,4,5,5,4,4,3,3,4,4]-> [[4,4],[3,3],[4,4],[5,5]]।

समान तत्वों के समूह बनाएं और कम से कम लंबाई वाले पाएं।

Comments

प्रलेखन कहाँ के लिए है Data.Lists?

— लिन

@ लियन: डेटा.लिस्ट । इस पृष्ठ पर पुन: निर्यात किए गए मॉड्यूल के लिंक भी देखें। argminsउदाहरण के लिए Data.List.Extras.Agrmax से है ।

— नीमी

Answer 4

पायथन 2, 120 बाइट्स

import re
r=[x.group().split()for x in re.finditer(r'(\d+ )\1*',input())]
print[x for x in r if len(x)==min(map(len,r))]

एक अनुगामी अंतरिक्ष के साथ अंतरिक्ष-पृथक पूर्णांकों की एक स्ट्रिंग के रूप में इनपुट लेता है, और स्ट्रिंग की सूची की एक सूची आउटपुट करता है। रीजेक्स का उपयोग करने वाले समूहों को खोजने के लिए रणनीति है (\d+ )\1*(जो एक या एक से अधिक अंतरिक्ष से अलग हुए पूर्णांक से मेल खाता है, एक अनुगामी स्थान के साथ), फिर उन्हें रिक्त स्थान की सूची में पूर्णांक से विभाजित करें, और उन समूहों को प्रिंट करें जिनकी लंबाई न्यूनतम समूह की लंबाई के बराबर है।

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

Answer 5

सी #, 204 बाइट्स

void f(string o){var r=Regex.Matches(o,@"([0-9])\1{0,}").Cast<Match>().OrderBy(x=>x.Groups[0].Value.Length);foreach(var s in r){foreach(var z in r)if(s.Length>z.Length)return;Console.WriteLine(s.Value);}}

मुझे नहीं पता कि अगर स्ट्रिंग का उपयोग करना उचित है, तो सभी गोल्फिंग एलांगों को उसी तरह से इनपुट मिलता है, लेकिन उन्होंने सरणी इनपुट का अनुरोध किया है।

ungolfed:

    public static void f(string inp)
    {

        var r = Regex.Matches(inp, @"([0-9])\1{0,}").Cast<Match>().OrderBy(x => x.Groups[0].Value.Length);

        foreach (Match s in r)
        {
            foreach (Match z in r)
                if (s.Length > z.Length)
                    return;

        Console.WriteLine(s.Value);
        }


    }

मुझे मैच सरणी के लिए सबसे छोटे मैच प्राप्त करने का एक तरीका चाहिए, मेरी अधिकांश बाइट्स वहां बर्बाद हो जाती हैं, सराहना की जाती है। मैं LINQ और लैम्ब्डा सामान में जाने की कोशिश कर रहा हूँ।

Comments

तकनीकी रूप से एक स्ट्रिंग एक सरणी है।

— लीक नून

Answer 6

पायथन 2.x, 303 बाइट्स

x=input()
r=[q[2]for q in filter(lambda l:(len(l[2])>0)&((l[0]<1)or(x[l[0]-1]!=x[l[0]]))&((l[1]>len(x)-1)or(x[l[1]]!=x[l[1]-1]))&(len(filter(lambda k:k==l[2][0],l[2]))==len(l[2])),[(a,b,x[a:b])for a in range(0,len(x))for b in range(0,len(x)+1)])]
print filter(lambda k:len(k)==min([len(s)for s in r]),r)

Ugliest। कोड। कभी।

इनपुट: प्रारूप में एक सरणी r'\[(\d,)*(\d,?)?\]'
दूसरे शब्दों में, संख्याओं का एक अजगर सरणी

आउटपुट: एरे का एक सरणी (सबसे छोटा समूह), इस क्रम में कि वे इनपुट ऐरे में दिखाई देते हैं

अतिरिक्त संयोगात्मक विशेषताएं (वे सुविधाएँ जिन्हें मैंने बनाने का इरादा नहीं किया था):

• इनपुट एक खाली सरणी हो सकती है; आउटपुट एक खाली सरणी होगी।
• परिवर्तित करने से minकरने के लिए max, यह सबसे बड़ा समूह की एक सरणी वापस आ जाएगी।
• यदि आप बस करते हैं print r, तो यह सभी समूहों को क्रम में प्रिंट करेगा।

Answer 7

MATL, 15 बाइट्स

Y'tX<tb=bw)wTX"

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

इनपुट एक वेक्टर है, जैसे [1 2 3 4], और आउटपुट एक मैट्रिक्स है जहां प्रत्येक कॉलम सबसे छोटे समूहों में से एक है, जैसे:

1 100
1 100

तीसरे टेस्ट केस के लिए।

स्पष्टीकरण:

Y'    %// Run length encoding, gives 2 vectors of group-lengths and values
t     %// Duplicate group lengths
X<    %// Minimum group length
tb    %// Duplicate and get vector of group lengths to the top
=     %// Find which group lengths are equal to the minimum
bw)   %// And get the values of those groups
wTX"  %// Repeats the matrix of minimum-length-group values by the minimum group length

Answer 8

जेली, 22 17 16 बाइट्स

I0;œṗ¹L=¥ÐfL€Ṃ$$

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

I0;œṗ¹L=¥ÐfL€Ṃ$$     Main link. List: z = [a,b,c,...]

I                    Compute [b-a, c-b, d-c, ...]
 0;                  Concatenate 0 in front: [0, b-a, c-b, d-c, ...]
   œṗ                Split z where the corresponding item in the above array is not zero.
      L=¥Ðf          Filter sublists whose length equal:
           L€Ṃ$      the minimum length throughout the list.

     ¹         $     (grammar stuffs)

Answer 9

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

a=>(a.map((v,i)=>v==a[i-1]?g.push(v):h.push(g=[v]),h=[]),h.filter(x=>!x[Math.min(...h.map(x=>x.length))]))

परीक्षा

f=a=>(a.map((v,i)=>v==a[i-1]?g.push(v):h.push(g=[v]),h=[]),h.filter(x=>!x[Math.min(...h.map(x=>x.length))]))

console.log=x=>O.textContent+=x+'\n'

;[[1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1]
, [3, 3, 3, 4, 4, 4, 4, 5, 5, 4, 4, 3, 3, 4, 4]
, [1, 1, 2, 2, 3, 3, 4]
, [1]
, [1, 1, 10, 10, 10, 100, 100]]
.forEach(t=>console.log(t+' -> '+f(t).join` `))

<pre id=O></pre>

Comments

करता है h.map(length)काम नहीं?

— लीक नून

@ केनीलाउ नहीं, इसके लिए काम करने lengthके लिए स्ट्रिंग के साथ एक फ़ंक्शन होना चाहिए तर्क के रूप में, स्ट्रिंग की एक विधि नहीं

— edc65

@ edc65 दरअसल, स्ट्रिंग की एक संपत्ति। विधि नहीं।

— नहीं कि चार्ल्स

Answer 10

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

a=>a.map(n=>n==c[0]?c.push(n):b.push(c=[n]),c=b=[])&&b.sort((a,b)=>a[l]-b[l],l='length').filter(e=>e[l]==b[0][l])

Answer 11

रेटिना, 91 85 80 79 77 76 75 74 बाइट्स

M!`\b(\d+)(,\1\b)*
(,()|.)+
$#2:$&
O#`.+
s`^(.*\b(.+:).*)¶(?!\2).+
$1
.+:
<empty-line>

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

व्याख्या

इनपुट है 1,1,10,10,10,100,100।

पहली पंक्ति समान शब्दों वाले समूहों से मेल खाती है:

M!`\b(\d+)(,\1\b)*

इनपुट बन जाता है:

1,1
10,10,10
100,100

निम्नलिखित दो पंक्तियाँ लाइन पर अल्पविराम की संख्या को प्रस्तुत करती हैं:

(,()|.)+
$#2:$&

इनपुट बन जाता है:

1:1,1
2:10,10,10
1:100,100

फिर उन्हें इस पंक्ति द्वारा क्रमबद्ध किया जाता है, जो पहले नंबर को सूचकांक के रूप में देखता है:

O#`.+

इनपुट बन जाता है:

1:1,1
1:100,100
2:10,10,10

फिर ये दो रेखाएं उस स्थान को ढूंढती हैं जहां लंबाई अलग है, और बाद में सब कुछ हटा दें:

s`^(.*\b(.+:).*)¶(?!\2).+
$1

इनपुट बन जाता है:

1:1,1
1:100,100

फिर इन दो पंक्तियों द्वारा नंबर हटा दिए जाते हैं:

.+:
<empty-line>

इनपुट कहां बनता है:

1,1
100,100

Comments

@ अदनान धन्यवाद, तय।

— लीक नून

Answer 12

एपीएल, 25 चार्ट

{z/⍨(⊢=⌊/)≢¨z←(1,2≠/⍵)⊂⍵}

अंग्रेजी में:

• z को तर्क में विभाजित करें जहां एक संख्या एक पूर्ववर्ती से अलग है;
• प्रत्येक सबर्रे की लंबाई की गणना करें
• बूलियन का निर्माण करने वाली प्रत्येक लंबाई के साथ न्यूनतम की तुलना करें ...
• ... कि z को कम करने के लिए उपयोग किया जाता है

Comments

आवागमन। आवागमन। आवागमन! ⍵⊂⍨1,2≠/⍵

— ज़ाचरी

Answer 13

जे , 31 बाइट्स

[:(#~[:(=<./)#@>)]<;.1~1,2~:/\]

इनपुट मूल्यों की एक सरणी है। आउटपुट बॉक्सिंग ऐरे की एक सरणी है।

प्रयोग

   f =: [:(#~[:(=<./)#@>)]<;.1~1,2~:/\]
   f 1 1 2 2 3 3 4
┌─┐
│4│
└─┘
   f 3 3 3 4 4 4 4 5 5 4 4 3 3 4 4
┌───┬───┬───┬───┐
│5 5│4 4│3 3│4 4│
└───┴───┴───┴───┘

व्याख्या

[:(#~[:(=<./)#@>)]<;.1~1,2~:/\]  Input: s
                              ]  Identity function, get s
                         2       The constant 2
                             \   Operate on each overlapping sublist of size 2
                          ~:/      Check if each pair is unequal, 1 if true else 0
                       1,        Prepend a 1 to that list
                 ]               Identity function, get s
                  <;.1~          Using the list above, chop s at each true index
[:(             )                Operate on the sublists
             #@>                 Get the length of each sublist
     [:(    )                    Operate on the length of each sublist
         <./                     Get the minimum length
        =                        Mark each index as 1 if equal to the min length else 0
   #~                            Copy only the sublists with min length and return

Answer 14

क्लोजर, 65 बाइट्स

#(let[G(group-by count(partition-by + %))](G(apply min(keys G))))

उपयोग +के रूप में identityसमारोह के रूप में (+ 5)5 :) बाकी स्पष्ट होना चाहिए, Gएक हैश-नक्शा एक समारोह के रूप में इस्तेमाल किया और एक महत्वपूर्ण यह रिटर्न इसी मूल्य दिया जाता है।

Answer 15

ब्रेकीलॉग , 6 बाइट्स

ḅlᵒlᵍh

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

इनपुट वेरिएबल के माध्यम से इनपुट और आउटपुट चर के माध्यम से आउटपुट।

ḅ         The list of runs of consecutive equal elements of
          the input
 lᵒ       sorted by length
   lᵍ     and grouped by length
          has the output variable
     h    as its first element.

हालांकि, इसके विपरीत ḅ, ᵍसमूह गैर-निरंतर समान तत्व, lᵒअभी भी सबसे कम लंबाई वाले समूह को खोजने के लिए आवश्यक है, और यह काम करता है क्योंकि उत्पादन में समूहों का क्रम ᵍप्रत्येक समूह के पहले तत्व की स्थिति से निर्धारित होता है, इसलिए कि छद्म रूपक द्वाराᵍhᵐ एक घटा के रूप में कार्य कर सकता है ।

Answer 16

पर्ल 5 -MList::Util=pairkeys,min -a , 69 बाइट्स

map$r{y/ //}.="[ $_]",pairkeys"@F "=~/((\d+ )\2*)/g;say$r{min keys%r}

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