pengantar

Mari kita amati array berikut:

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

Sebuah kelompok terdiri dari angka yang sama di samping satu sama lain. Dalam array di atas, ada 5 grup berbeda:

[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

Kelompok terkecil ini [2, 2], jadi kami mengeluarkan [2, 2].

Mari kita ambil contoh lain:

[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

Anda dapat melihat bahwa ada beberapa grup dengan panjang yang sama. Kelompok terkecil adalah:

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

Jadi kami hanya menampilkan [3, 3], [4, 4], [4, 4], [5, 5]dalam format yang masuk akal. Anda dapat menampilkan ini dalam urutan apa pun.

Tugas

Diberikan array yang hanya terdiri dari bilangan bulat positif, mengeluarkan grup terkecil dari array. Anda dapat mengasumsikan bahwa array akan mengandung setidaknya 1 integer.

Uji kasus

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]

Ini adalah kode-golf , jadi pengiriman dengan jumlah byte paling sedikit menang!

Pyth, 14 12 11

mM_MmhbrQ8

Test Suite

2 byte berkat Jakube! Dan 1 byte terima kasih kepada isaacg!

Sayangnya, run length decoding tidak cukup melakukan apa yang kita inginkan, tetapi itu akan bekerja dengan solusi kecil, tetapi itu membuatnya sedikit lebih lama daripada implementasi manual:

mr]d9.mhbrQ8

Kredit ke Jakube untuk mengetahui hal ini.

Mathematica, 24 byte

MinimalBy[Length]@*Split

Ini adalah komposisi dua fungsi yang dapat diterapkan ke daftar. Splitmengambil semua grup angka berurutan, dan MinimalBy[Length]memilih mereka dengan panjang minimal.

Haskell, 38 byte

import Data.Lists
argmins length.group

Contoh penggunaan: 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]].

Bangun grup dengan elemen yang sama dan temukan yang memiliki panjang minimal.

Python 2, 120 byte

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

Mengambil input sebagai string bilangan bulat yang dipisahkan spasi dengan spasi tambahan, dan menampilkan daftar daftar string. Strateginya adalah untuk menemukan grup menggunakan regex (\d+ )\1*(yang cocok dengan satu atau lebih bilangan bulat yang dipisahkan ruang, dengan spasi tambahan), kemudian membaginya dalam ruang menjadi daftar bilangan bulat, dan mencetak grup tersebut yang panjangnya sama dengan panjang grup minimum.

Cobalah online

C #, 204 byte

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

Saya tidak tahu apakah menggunakan string itu wajar mengingat semua esolang golf mendapatkan input mereka dengan cara yang sama tetapi ia meminta input array.

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


    }

Saya perlu cara untuk mendapatkan kecocokan terkecil untuk array pertandingan, sebagian besar byte saya terbuang di sana, membantu dihargai. Saya mencoba untuk masuk ke hal-hal LINQ dan lambda.

Python 2.x, 303 byte

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)

Paling buruk. Kode. Pernah.

Input: Array dalam format r'\[(\d,)*(\d,?)?\]'
Dengan kata lain, array python angka

Output: Array array (grup terkecil), dalam urutan yang mereka muncul di array input

Fitur Kebetulan Tambahan (Fitur yang tidak ingin saya buat):

• Input dapat berupa array kosong; output akan berupa array kosong.
• Dengan mengubah minke max, itu akan mengembalikan array grup terbesar.
• Jika Anda melakukannya print r, itu akan mencetak semua grup secara berurutan.

MATL, 15 byte

Y'tX<tb=bw)wTX"

Cobalah online

Input adalah vektor, seperti [1 2 3 4], dan output adalah matriks di mana setiap kolom adalah salah satu kelompok terkecil, misalnya:

1 100
1 100

untuk kasus uji ketiga.

Penjelasan:

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

Jelly, 22 17 16 byte

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

Cobalah online!

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

Uji

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 byte

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 byte

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

Cobalah online!

Penjelasan

Inputnya adalah 1,1,10,10,10,100,100.

Baris pertama cocok dengan grup dengan istilah yang sama:

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

Masukan menjadi:

1,1
10,10,10
100,100

Dua baris berikut menambahkan jumlah koma ke baris:

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

Masukan menjadi:

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

Kemudian mereka diurutkan berdasarkan baris ini, yang mencari angka pertama sebagai indeks:

O#`.+

Masukan menjadi:

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

Kemudian kedua garis ini menemukan tempat di mana panjangnya berbeda, dan menghapus semuanya ke depan:

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

Masukan menjadi:

1:1,1
1:100,100

Kemudian angkanya dihapus oleh dua baris ini:

.+:
<empty-line>

Di mana input menjadi:

1,1
100,100

APL, 25 karakter

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

Dalam Bahasa Inggris:

• letakkan di z pemisahan argumen di mana angka berbeda dari yang sebelumnya;
• hitung panjang masing-masing subarray
• bandingkan minimum dengan masing-masing panjang yang menghasilkan ...
• ... yang digunakan untuk mengurangi z

J , 31 byte

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

Input adalah array nilai. Output adalah array array kotak.

Pemakaian

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

Penjelasan

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

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

Gunakan +sebagai identityfungsi seperti (+ 5)5 :) Sisanya harus jelas, Gadalah peta-hash yang digunakan sebagai fungsi dan diberi kunci itu mengembalikan nilai yang sesuai.

Brachylog , 6 byte

ḅlᵒlᵍh

Cobalah online!

Input melalui variabel input dan output melalui variabel output.

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

Meskipun, tidak seperti ḅ, ᵍkelompok elemen yang tidak berurutan sama, lᵒmasih diperlukan untuk menemukan grup dengan panjang terpendek, dan itu berfungsi karena urutan kelompok dalam output dari ᵍditentukan oleh posisi elemen pertama dari setiap kelompok, sehingga yang ᵍhᵐdapat berfungsi sebagai semacam deduplicate oleh pseudo-metapredicate.

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

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

Cobalah online!