Introducción

Observemos la siguiente matriz:

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

Un grupo consta de los mismos dígitos uno al lado del otro. En la matriz anterior, hay 5 grupos diferentes:

[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

El grupo más pequeño de estos es [2, 2], por lo que sacamos [2, 2].

Tomemos otro ejemplo:

[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

Puede ver que hay varios grupos con la misma longitud. Los grupos más pequeños son:

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

Así que simplemente imprimimos [3, 3], [4, 4], [4, 4], [5, 5]en cualquier formato razonable. Puede generarlos en cualquier orden.

La tarea

Dada una matriz que consta solo de enteros positivos, genera los grupos más pequeños de la matriz. Puede suponer que la matriz contendrá al menos 1 entero.

Casos de prueba

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]

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Pyth 14 12 11

mM_MmhbrQ8

Banco de pruebas

2 bytes gracias a Jakube! ¡Y 1 byte gracias a Isaac!

Desafortunadamente, la decodificación de longitud de ejecución no hace exactamente lo que queremos que haga, pero funcionará con una solución alternativa menor, pero eso lo hace un poco más largo que la implementación manual:

mr]d9.mhbrQ8

Gracias a Jakube por descubrir esto.

Mathematica, 24 bytes

MinimalBy[Length]@*Split

Esta es una composición de dos funciones que se pueden aplicar a una lista. Splittoma todos los grupos de números consecutivos y MinimalBy[Length]selecciona aquellos con longitud mínima.

Haskell, 38 bytes

import Data.Lists
argmins length.group

Ejemplo de uso: 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]].

Construya grupos de elementos iguales y encuentre aquellos con una longitud mínima.

Python 2, 120 bytes

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

Toma la entrada como una cadena de enteros separados por espacios con un espacio final, y genera una lista de listas de cadenas. La estrategia es encontrar grupos utilizando la expresión regular (\d+ )\1*(que coincide con uno o más enteros separados por espacios, con un espacio final), luego dividirlos en espacios en listas de enteros e imprimir esos grupos cuya longitud es igual a la longitud mínima del grupo.

Pruébalo en línea

C #, 204 bytes

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

No sé si usar una cadena es justo teniendo en cuenta que todos los esolangs de golf obtienen su entrada de la misma manera, pero solicitó la entrada de la matriz.

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


    }

Necesito una forma de obtener las coincidencias más pequeñas para la matriz de coincidencias, la mayoría de mis bytes se desperdician allí, se agradece la ayuda. Estoy tratando de entrar en LINQ y cosas lambda.

Python 2.x, 303 bytes

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)

Más feo Código. Nunca.

Entrada: una matriz en el formato r'\[(\d,)*(\d,?)?\]'
En otras palabras, una matriz de números de Python

Salida: una matriz de matrices (los grupos más pequeños), en el orden en que aparecen en la matriz de entrada

Características coincidentes adicionales (características que no tenía la intención de hacer):

• La entrada puede ser una matriz vacía; la salida será una matriz vacía.
• Al cambiar mina max, devolverá una serie de los grupos más grandes.
• Si lo hace print r, imprimirá todos los grupos en orden.

MATL, 15 bytes

Y'tX<tb=bw)wTX"

Pruébalo en línea

La entrada es un vector, como [1 2 3 4], y la salida es una matriz donde cada columna es uno de los grupos más pequeños, por ejemplo:

1 100
1 100

para el tercer caso de prueba.

Explicación:

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

Jalea, 22 17 16 bytes

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

Pruébalo en línea!

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

Prueba

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 bytes

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 bytes

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

Pruébalo en línea!

Explicación

La entrada es 1,1,10,10,10,100,100 .

La primera línea coincide con grupos con los mismos términos:

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

La entrada se convierte en:

1,1
10,10,10
100,100

Las siguientes dos líneas anteponen el número de comas a la línea:

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

La entrada se convierte en:

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

Luego se ordenan por esta línea, que busca el primer número como índice:

O#`.+

La entrada se convierte en:

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

Luego, estas dos líneas encuentran el lugar donde la longitud es diferente y eliminan todo en adelante:

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

La entrada se convierte en:

1:1,1
1:100,100

Luego, las dos líneas eliminan los números:

.+:
<empty-line>

Donde se convierte la entrada:

1,1
100,100

APL, 25 caracteres

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

En inglés:

• ponga en z el argumento dividido donde un número es diferente al anterior;
• calcular la longitud de cada submatriz
• compara el mínimo con cada una de las longitudes que producen un booleano ...
• ... que se usa para reducir z

J , 31 bytes

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

La entrada es una matriz de valores. La salida es una matriz de matrices en caja.

Uso

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

Explicación

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

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

Usos +como identityfunción que (+ 5)es 5 :) El resto debería ser obvio, Ges un hash-mapa utilizado como una función y dado una llave que devuelve el valor correspondiente.

Brachylog , 6 bytes

ḅlᵒlᵍh

Pruébalo en línea!

Entrada a través de la variable de entrada y salida a través de la variable de salida.

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

Aunque, a diferencia de ḅ, ᵍagrupa los elementos iguales no consecutivos, el lᵒtodavía es necesario para encontrar el grupo con las longitudes más cortas, y funciona debido a que el orden de los grupos en la salida de ᵍestá determinada por la posición del primer elemento de cada grupo, por lo eso ᵍhᵐpodría funcionar como una especie de deduplicado por pseudo-metapredicate.

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

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

Pruébalo en línea!