introduction

Observons le tableau suivant:

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

Un groupe est composé des mêmes chiffres côte à côte. Dans le tableau ci-dessus, il existe 5 groupes différents:

[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

Le plus petit groupe d'entre eux est [2, 2]donc nous sortons [2, 2].

Prenons un autre exemple:

[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

Vous pouvez voir qu'il existe plusieurs groupes de même longueur. Les plus petits groupes sont:

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

Nous sortons donc simplement [3, 3], [4, 4], [4, 4], [5, 5]dans un format raisonnable. Vous pouvez les afficher dans n'importe quel ordre.

La tâche

Étant donné un tableau composé uniquement d'entiers positifs, affichez le ou les plus petits groupes du tableau. Vous pouvez supposer que le tableau contiendra au moins 1 entier.

Cas de test

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]

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Pyth, 14 12 11

mM_MmhbrQ8

Suite de tests

2 octets grâce à Jakube! Et 1 octet grâce à isaacg!

Malheureusement, le décodage de la longueur d'exécution ne fait pas tout à fait ce que nous voulons qu'il fasse, mais il fonctionnera avec une solution de contournement mineure, mais cela le rend légèrement plus long que l'implémentation manuelle:

mr]d9.mhbrQ8

Nous remercions Jakube de l'avoir découvert.

Mathematica, 24 octets

MinimalBy[Length]@*Split

Il s'agit d'une composition de deux fonctions qui peuvent être appliquées à une liste. Splitprend tous les groupes de nombres consécutifs et MinimalBy[Length]sélectionne ceux de longueur minimale.

Haskell, 38 octets

import Data.Lists
argmins length.group

Exemple d'utilisation: 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]].

Construisez des groupes d'éléments égaux et trouvez ceux de longueur minimale.

Python 2, 120 octets

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

Prend l'entrée sous la forme d'une chaîne d'entiers séparés par un espace avec un espace de fin et génère une liste de listes de chaînes. La stratégie consiste à rechercher des groupes à l'aide de l'expression régulière (\d+ )\1*(qui correspond à un ou plusieurs entiers séparés par un espace, avec un espace de fin), puis à les diviser sur des espaces en listes d'entiers et à imprimer les groupes dont la longueur est égale à la longueur minimale du groupe.

Essayez-le en ligne

C #, 204 octets

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

Je ne sais pas si l'utilisation d'une chaîne est juste compte tenu du fait que tous les esolangs de golf obtiennent leur entrée de la même manière, mais il a demandé une entrée de tableau.

non golfé:

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


    }

J'ai besoin d'un moyen d'obtenir les plus petites correspondances pour le tableau de correspondance, la plupart de mes octets y sont gaspillés, aide appréciée. J'essaie d'entrer dans LINQ et les trucs lambda.

Python 2.x, 303 octets

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)

Le plus laid. Code. Déjà.

Entrée: un tableau au format r'\[(\d,)*(\d,?)?\]'
En d'autres termes, un tableau python de nombres

Sortie: un tableau de tableaux (les plus petits groupes), dans l'ordre dans lequel ils apparaissent dans le tableau d'entrée

Fonctionnalités coïncidentes supplémentaires (fonctionnalités que je n'avais pas l'intention de créer):

• L'entrée peut être un tableau vide; la sortie sera un tableau vide.
• En changeant minen max, il renverra un tableau des plus grands groupes.
• Si vous le faites print r, il imprimera tous les groupes dans l'ordre.

MATL, 15 octets

Y'tX<tb=bw)wTX"

Essayez-le en ligne

L'entrée est un vecteur, comme [1 2 3 4], et la sortie est une matrice où chaque colonne est l'un des plus petits groupes, par exemple:

1 100
1 100

pour le troisième cas de test.

Explication:

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

Gelée, 22 17 16 octets

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

Essayez-le en ligne!

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

Tester

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 octets

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

Rétine, 91 85 80 79 77 76 75 74 octets

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

Essayez-le en ligne!

Explication

L'entrée est 1,1,10,10,10,100,100.

La première ligne correspond aux groupes ayant les mêmes termes:

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

L'entrée devient:

1,1
10,10,10
100,100

Les deux lignes suivantes ajoutent le nombre de virgules à la ligne:

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

L'entrée devient:

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

Ensuite, ils sont triés par cette ligne, qui recherche le premier nombre comme index:

O#`.+

L'entrée devient:

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

Ensuite, ces deux lignes trouvent l'endroit où la longueur est différente et supprimez tout ce qui suit:

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

L'entrée devient:

1:1,1
1:100,100

Ensuite, les nombres sont supprimés par ces deux lignes:

.+:
<empty-line>

Où l'entrée devient:

1,1
100,100

APL, 25 caractères

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

En anglais:

• mettre en z l'argument split où un nombre est différent du précédent;
• calculer la longueur de chaque sous-tableau
• comparer le minimum avec chacune des longueurs produisant un booléen ...
• ... qui est utilisé pour réduire z

J , 31 octets

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

L'entrée est un tableau de valeurs. La sortie est un tableau de tableaux encadrés.

Usage

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

Explication

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

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

Utilise +la identityfonction telle qu'elle (+ 5)est 5 :) Le reste doit être évident, Gc'est une carte de hachage utilisée comme fonction et étant donné une clé, elle renvoie la valeur correspondante.

Brachylog , 6 octets

ḅlᵒlᵍh

Essayez-le en ligne!

Entrée via la variable d'entrée et sortie via la variable de sortie.

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

Bien que, à la différence ḅ, des ᵍgroupes d' éléments égaux non consécutifs, l' lᵒest encore nécessaire de trouver le groupe avec les longueurs les plus courtes, et il fonctionne parce que l'ordre des groupes dans la sortie de ᵍest déterminée par la position du premier élément de chaque groupe, de sorte que qui ᵍhᵐpourrait fonctionner comme une sorte de déduplication par pseudo-métaprédicat.

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

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

Essayez-le en ligne!