introduzione

Osserviamo il seguente array:

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

Un gruppo è composto dalle stesse cifre una accanto all'altra. Nell'array sopra, ci sono 5 diversi gruppi:

[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

Il gruppo più piccolo di questi è [2, 2], quindi produciamo [2, 2].

Facciamo un altro esempio:

[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

Puoi vedere che ci sono più gruppi con la stessa lunghezza. I gruppi più piccoli sono:

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

Quindi abbiamo appena prodotto [3, 3], [4, 4], [4, 4], [5, 5]in qualsiasi formato ragionevole. Puoi produrli in qualsiasi ordine.

L'obiettivo

Dato un array composto solo da numeri interi positivi, emette i gruppi più piccoli dall'array. Si può presumere che l'array conterrà almeno 1 numero intero.

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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Pyth, 14 12 11

mM_MmhbrQ8

Test Suite

2 byte grazie a Jakube! E 1 byte grazie a isaacg!

Sfortunatamente, la decodifica della lunghezza di esecuzione non fa esattamente quello che vogliamo che faccia, ma funzionerà con una soluzione alternativa minore, ma questo lo rende leggermente più lungo dell'implementazione manuale:

mr]d9.mhbrQ8

Ringraziamo Jakube per averlo scoperto.

Mathematica, 24 byte

MinimalBy[Length]@*Split

Questa è una composizione di due funzioni che possono essere applicate a un elenco. Splitaccetta tutti i gruppi di numeri consecutivi e MinimalBy[Length]seleziona quelli con lunghezza minima.

Haskell, 38 byte

import Data.Lists
argmins length.group

Esempio di utilizzo: 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]].

Costruisci gruppi di elementi uguali e trova quelli con lunghezza minima.

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

Prende l'input come una stringa di numeri interi separati da spazio con uno spazio finale e genera un elenco di elenchi di stringhe. La strategia è quella di trovare gruppi usando la regex (\d+ )\1*(che corrisponde a uno o più numeri interi separati da spazio, con uno spazio finale), quindi dividerli sugli spazi in elenchi di numeri interi e stampare quei gruppi la cui lunghezza è uguale alla lunghezza minima del gruppo.

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

Non so se usare una stringa sia giusto considerando che tutti gli esolang del golf ottengono il loro input allo stesso modo, ma ha richiesto l'input dell'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);
        }


    }

Ho bisogno di un modo per ottenere le corrispondenze più piccole per l'array delle partite, la maggior parte dei miei byte vengono sprecati lì, aiuto apprezzato. Sto cercando di entrare in LINQ e roba 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)

Ugliest. Codice. Mai.

Input: un array nel formato r'\[(\d,)*(\d,?)?\]'
In altre parole, un array di numeri Python

Output: una matrice di matrici (i gruppi più piccoli), nell'ordine in cui compaiono nella matrice di input

Funzionalità aggiuntive aggiuntive (funzionalità che non intendevo creare):

• L'input può essere un array vuoto; l'output sarà un array vuoto.
• Cambiando min a max, restituirà una matrice dei gruppi più grandi.
• Se lo fai print r, stampa tutti i gruppi in ordine.

MATL, 15 byte

Y'tX<tb=bw)wTX"

Provalo online

L'input è un vettore, come [1 2 3 4], e l'output è una matrice in cui ogni colonna è uno dei gruppi più piccoli, ad esempio:

1 100
1 100

per il terzo caso di test.

Spiegazione:

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

Gelatina, 22 17 16 byte

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

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

Test

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>

Provalo online!

Spiegazione

L'input è 1,1,10,10,10,100,100.

La prima riga corrisponde ai gruppi con gli stessi termini:

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

L'input diventa:

1,1
10,10,10
100,100

Le due righe seguenti antepongono il numero di virgole alla riga:

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

L'input diventa:

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

Quindi vengono ordinati in base a questa riga, che cerca il primo numero come indice:

O#`.+

L'input diventa:

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

Quindi queste due linee trovano il punto in cui la lunghezza è diversa e rimuovono tutto in seguito:

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

L'input diventa:

1:1,1
1:100,100

Quindi i numeri vengono rimossi da queste due righe:

.+:
<empty-line>

Dove diventa l'input:

1,1
100,100

APL, 25 caratteri

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

In inglese:

• metti in z l'argomento split in cui un numero è diverso da quello precedente;
• calcola la lunghezza di ciascun subarray
• confrontare il minimo con ciascuna delle lunghezze che producono un valore booleano ...
• ... utilizzato per ridurre z

J , 31 byte

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

L'input è una matrice di valori. L'output è un array di array in box.

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

Spiegazione

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

Usa +come identityfunzione come (+ 5)è 5 :) Il resto dovrebbe essere ovvio, Gè una mappa hash utilizzata come funzione e, dato un tasto, restituisce il valore corrispondente.

Brachylog , 6 byte

ḅlᵒlᵍh

Provalo online!

Input attraverso la variabile input e output attraverso la variabile 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.

Anche se, a differenza ḅ, ᵍraggruppa elementi uguali non consecutive, il lᵒè ancora necessario trovare il gruppo con le lunghezze più brevi, e funziona perché l'ordine dei gruppi nell'output ᵍviene determinata dalla posizione del primo elemento di ciascun gruppo, in modo che ᵍhᵐpotrebbe funzionare come una specie di deduplicato dallo pseudo-metapredicato.

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

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

Provalo online!