Giriş

Aşağıdaki diziyi inceleyelim:

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

Bir grup yan yana aynı rakamlardan oluşur. Yukarıdaki dizide 5 farklı grup vardır:

[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

Bunların en küçük grubu bu [2, 2]yüzden çıktı alıyoruz [2, 2].

Bir örnek daha alalım:

[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

Aynı uzunlukta birden çok grup olduğunu görebilirsiniz. En küçük gruplar:

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

Bu nedenle [3, 3], [4, 4], [4, 4], [5, 5], herhangi bir makul formatta çıktı veriyoruz . Bunları herhangi bir sırayla çıktılayabilirsiniz.

Görev

Yalnızca pozitif tamsayılardan oluşan bir dizi verildiğinde, diziden en küçük grupları çıktılar. Dizinin en az 1 tamsayı içereceğini varsayabilirsiniz.

Test senaryoları

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]

Bu kod golf , yani en az bayt ile gönderme kazanır!

Pyth, 14 12 11

mM_MmhbrQ8

Test odası

Jakube sayesinde 2 bayt! Veaagg sayesinde 1 bayt!

Ne yazık ki, çalışma uzunluğu kod çözme yapmak istediğimizi yapmıyor, ancak küçük bir çözümle çalışacak, ancak bu, manuel uygulamadan biraz daha uzun sürüyor:

mr]d9.mhbrQ8

Bunu bulmak için Jakube'e teşekkür ederiz.

Mathematica, 24 bayt

MinimalBy[Length]@*Split

Bu, bir listeye uygulanabilen iki işlevin bir bileşimidir. Splittüm ardışık sayı gruplarını alır ve MinimalBy[Length]minimum uzunlukta olanları seçer.

Haskell, 38 bayt

import Data.Lists
argmins length.group

Kullanım örneği: 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]].

Eşit eleman grupları oluşturun ve minimum uzunlukta olanları bulun.

Python 2, 120 bayt

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))]

Girdiyi, boşluk içeren bir boşlukla ayrılmış tamsayı dizesi olarak alır ve dizelerin listelerinin bir listesini çıkarır. Strateji, düzenli ifadeyi (\d+ )\1*(bir boşlukla ayrılmış bir veya daha fazla boşlukla ayrılmış tamsayı ile eşleşen) kullanarak grupları bulmak , daha sonra bunları boşluklarda tamsayılar listesine bölmek ve uzunluğu minimum grup uzunluğuna eşit olan grupları yazdırmaktır.

Çevrimiçi deneyin

C #, 204 bayt

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);}}

Bir dize kullanarak tüm golf esolangs aynı şekilde kendi giriş olsun düşünüyor adil olduğunu bilmiyorum ama o dizi girişi istedi.

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);
        }


    }

Ben maç dizisi için en küçük maçlar almak için bir yol gerekir, benim bayt çoğu orada boşa, takdir yardım. Ben LINQ ve lambda şeyler girmeye çalışıyorum.

Python 2.x, 303 bayt

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)

Çirkin. Kod. Hiç.

Girdi: Biçimdeki bir dizi r'\[(\d,)*(\d,?)?\]'
Başka bir deyişle, bir python sayı dizisi

Çıktı: Girdi dizisinde göründükleri sırayla bir dizi (en küçük gruplar) dizisi

Ek Tesadüfi Özellikler (yapmak istemediğim özellikler):

• Giriş boş bir dizi olabilir; çıktı boş bir dizi olacaktır.
• Değiştirerek miniçin max, bu büyük grupların bir dizi döndürür.
• Sadece yaparsanız print r, tüm grupları sırayla yazdıracaktır.

MATL, 15 bayt

Y'tX<tb=bw)wTX"

Çevrimiçi deneyin

Girdi, bir vektör gibidir [1 2 3 4]ve çıktı, her bir sütunun en küçük gruplardan biri olduğu bir matristir, örneğin:

1 100
1 100

üçüncü test durumu için.

Açıklama:

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

Jöle, 22 17 16 bayt

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

Çevrimiçi deneyin!

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)

JavaScript (ES6), 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))]))

Ölçek

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>

JavaScript (ES6), 113 bayt

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])

Retina, 91 85 80 79 77 76 75 74 bayt

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

Çevrimiçi deneyin!

açıklama

Girdi 1,1,10,10,10,100,100.

İlk satır aynı terime sahip gruplarla eşleşir:

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

Girdi şu şekilde olur:

1,1
10,10,10
100,100

Aşağıdaki iki satır, satıra virgül sayısını ekler:

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

Girdi şu şekilde olur:

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

Ardından, ilk sayıyı dizin olarak arayan bu satıra göre sıralanırlar:

O#`.+

Girdi şu şekilde olur:

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

Sonra bu iki çizgi, uzunluğun farklı olduğu yeri bulur ve her şeyi ileriye doğru kaldırır:

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

Girdi şu şekilde olur:

1:1,1
1:100,100

Sonra sayılar bu iki satır tarafından kaldırılır:

.+:
<empty-line>

Girdi nerede olur:

1,1
100,100

APL, 25 karakter

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

İngilizcede:

• z'ye, bir sayının öncekinden farklı olduğu argümanı böl;
• her alt dizinin uzunluğunu hesaplayın
• Minimum değeri bir boole üreten uzunlukların her biri ile karşılaştırın ...
• ... bu z'yi azaltmak için kullanılır

J , 31 bayt

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

Girdi bir değerler dizisidir. Çıktı kutulu diziler dizisidir.

kullanım

   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│
└───┴───┴───┴───┘

açıklama

[:(#~[:(=<./)#@>)]<;.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

Clojure, 65 bayt

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

5 +gibi identityişlev olarak kullanır (+ 5):) Gerisi açık olmalı, Gbir işlev olarak kullanılan bir karma harita ve bir anahtar verilen karşılık gelen değeri döndürür.

Brachylog , 6 bayt

ḅlᵒlᵍh

Çevrimiçi deneyin!

Giriş değişkeni üzerinden giriş ve çıkış değişkeni üzerinden çıkış.

ḅ         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.

Her ne kadar birbirini takip etmeyen eşit elemanların aksine ḅ, en kısa uzunluklara sahip grubu bulmak yine de gereklidir ve çalışır, çünkü çıktıdaki grupların sırası her grubun ilk elemanının konumuna göre belirlenir, bu nedenle bu sahte metaforikle bir tür tekilleştirme işlevi görebilir.ᵍlᵒᵍᵍhᵐ

Perl 5 -MList::Util=pairkeys,min -a , 69 bayt

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

Çevrimiçi deneyin!