介绍

让我们观察以下数组：

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

这是代码高尔夫球，因此字节数最少的提交将获胜！

Pyth， 14 12 11

mM_MmhbrQ8

测试套件

感谢Jakube 2个字节！还有1个字节，感谢isaacg！

不幸的是，游程长度解码并不能完全完成我们想要的工作，但是可以通过较小的解决方法来工作，但是这比手动实现要长一些：

mr]d9.mhbrQ8

感谢Jakube找出了这一点。

Mathematica，24个字节

MinimalBy[Length]@*Split

这是可以应用于列表的两个功能的组合。Split取所有连续数字组，并MinimalBy[Length]选择长度最小的数字。

Haskell，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]]。

建立相等元素的组，并找到长度最小的元素。

Python 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*（与一个或多个用空格分隔的整数匹配，并带有尾随空格）查找组，然后将它们在空格上拆分为整数列表，并打印长度等于最小组长度的组。

在线尝试

C＃，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);}}

考虑到所有打高尔夫球的依索兰人都以相同的方式获取输入，我不知道使用字符串是否公平，但他要求输入数组。

松开

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


    }

我需要一种方法来为match数组获取最小的匹配项，我的大部分字节都在那里浪费了，不胜感激。我正在尝试使用LINQ和lambda的东西。

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

最丑。码。曾经

输入：采用以下格式的数组：r'\[(\d,)*(\d,?)?\]'
换句话说，就是python的数字数组

输出：一个数组数组（最小的组），按照它们在输入数组中出现的顺序

其他巧合功能（我不打算做的功能）：

• 输入可以是一个空数组；输出将是一个空数组。
• 通过更改min为max，它将返回最大组的数组。
• 如果您只是这样做print r，它将按顺序打印所有组。

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

果冻，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)

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

测试

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个字节

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字节

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

APL，25个字符

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

用英语：

• 在参数z中放入一个数字，该数字不同于前面的数字；
• 计算每个子数组的长度
• 将最小值与产生布尔值的每个长度进行比较...
• ...用于减少z

J，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

Clojure，65个字节

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

+按identity原样使用(+ 5)5 :)其余的应该很明显，G是用作函数的哈希映射，并给定一个键，它返回相应的值。

Brachylog，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ᵐ可以作为一个排序的功能通过重复数据删除伪metapredicate。

Perl -MList::Util=pairkeys,min -a 5，69个字节

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

在线尝试！