Einführung

Betrachten wir das folgende Array:

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

Eine Gruppe besteht aus den gleichen Ziffern nebeneinander. Im obigen Array gibt es 5 verschiedene Gruppen:

[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

Die kleinste Gruppe davon ist [2, 2], also geben wir aus [2, 2].

Nehmen wir ein anderes Beispiel:

[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

Sie können sehen, dass es mehrere Gruppen mit derselben Länge gibt. Die kleinsten Gruppen sind:

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

Wir geben also nur [3, 3], [4, 4], [4, 4], [5, 5]in einem vernünftigen Format aus. Sie können diese in beliebiger Reihenfolge ausgeben.

Die Aufgabe

Bei einem Array, das nur aus positiven ganzen Zahlen besteht, geben Sie die kleinste (n) Gruppe (n) aus dem Array aus. Sie können davon ausgehen, dass das Array mindestens eine Ganzzahl enthält.

Testfälle

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]

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Pyth, 14 12 11

mM_MmhbrQ8

Test Suite

2 Bytes dank Jakube! Und 1 Byte dank isaacg!

Leider entspricht die Lauflängendekodierung nicht genau unseren Wünschen, sie funktioniert jedoch mit einer geringfügigen Problemumgehung, die jedoch etwas länger dauert als die manuelle Implementierung:

mr]d9.mhbrQ8

Wir danken Jakube, dass er das herausgefunden hat.

Mathematica, 24 Bytes

MinimalBy[Length]@*Split

Dies ist eine Zusammenstellung von zwei Funktionen, die auf eine Liste angewendet werden können. SplitNimmt alle Gruppen von fortlaufenden Nummern und MinimalBy[Length]wählt diejenigen mit minimaler Länge aus.

Haskell, 38 Bytes

import Data.Lists
argmins length.group

Anwendungsbeispiel: 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]].

Bilde Gruppen gleicher Elemente und finde solche mit minimaler Länge.

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

Nimmt Eingaben als eine Zeichenfolge von durch Leerzeichen getrennten Ganzzahlen mit einem nachgestellten Leerzeichen und gibt eine Liste von Zeichenfolgenlisten aus. Die Strategie besteht darin, Gruppen mithilfe des regulären Ausdrucks zu finden(\d+ )\1* (der einer oder mehreren durch Leerzeichen getrennten Ganzzahlen mit einem nachgestellten Leerzeichen entspricht) zu finden, sie dann auf Leerzeichen in Listen mit Ganzzahlen aufzuteilen und die Gruppen zu drucken, deren Länge der minimalen Gruppenlänge entspricht.

Probieren Sie es online aus

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

Ich weiß nicht, ob es fair ist, eine Saite zu verwenden, wenn man bedenkt, dass alle Golf-Esolangs ihre Eingabe auf die gleiche Weise erhalten, aber er forderte eine Array-Eingabe an.

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


    }

Ich brauche einen Weg, um die kleinsten Übereinstimmungen für das Übereinstimmungsarray zu erhalten. Die meisten meiner Bytes werden dort verschwendet. Ich versuche, mich mit LINQ und Lambda zu beschäftigen.

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)

Hässlichste. Code. Je.

Eingabe: Ein Array im Format r'\[(\d,)*(\d,?)?\]'
Mit anderen Worten, ein Python-Array von Zahlen

Ausgabe: Ein Array von Arrays (die kleinsten Gruppen) in der Reihenfolge, in der sie im Eingabearray angezeigt werden

Zusätzliche zufällige Funktionen (Funktionen, die ich nicht machen wollte):

• Die Eingabe kann ein leeres Array sein. Die Ausgabe ist ein leeres Array.
• Durch die Änderung minan max, wird es eine Reihe der größten Gruppen zurück.
• Wenn Sie dies nur tun print r, werden alle Gruppen der Reihe nach gedruckt.

MATL, 15 Bytes

Y'tX<tb=bw)wTX"

Probieren Sie es online aus

Die Eingabe ist wie ein Vektor [1 2 3 4]und die Ausgabe ist eine Matrix, in der jede Spalte eine der kleinsten Gruppen ist, z.

1 100
1 100

für den dritten Testfall.

Erläuterung:

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 Bytes

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

Probieren Sie es 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))]))

Prüfung

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 Bytes

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

Probieren Sie es online!

Erläuterung

Die Eingabe ist 1,1,10,10,10,100,100.

Die erste Zeile entspricht Gruppen mit denselben Begriffen:

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

Die Eingabe wird:

1,1
10,10,10
100,100

Die folgenden zwei Zeilen stellen die Anzahl der Kommas vor die Zeile:

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

Die Eingabe wird:

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

Dann werden sie nach dieser Zeile sortiert, die nach der ersten Zahl als Index sucht:

O#`.+

Die Eingabe wird:

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

Dann finden diese beiden Zeilen die Stelle, an der die Länge unterschiedlich ist, und entfernen alles weiter:

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

Die Eingabe wird:

1:1,1
1:100,100

Dann werden die Zahlen durch diese beiden Zeilen entfernt:

.+:
<empty-line>

Wo die Eingabe wird:

1,1
100,100

APL, 25 Zeichen

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

Auf Englisch:

• Setzen Sie in z das Argument split, wenn sich eine Zahl von der vorhergehenden unterscheidet.
• Berechnen Sie die Länge jedes Subarrays
• Vergleiche das Minimum mit jeder der Längen, die einen Booleschen Wert erzeugen ...
• ... das verwendet wird, um z

J , 31 Bytes

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

Die Eingabe ist ein Array von Werten. Die Ausgabe ist ein Array von Boxed Arrays.

Verwendung

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

Erläuterung

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

Verwendet +als identityFunktion wie (+ 5)5 :) Der Rest sollte offensichtlich sein, Gist eine Hash-Map, die als Funktion verwendet wird und mit einem Schlüssel den entsprechenden Wert zurückgibt.

Brachylog , 6 Bytes

ḅlᵒlᵍh

Probieren Sie es online!

Eingabe über die Eingabevariable und Ausgabe über die Ausgabevariable.

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

Obwohl, anders als ḅ, ᵍGruppen nicht aufeinanderfolgenden gleiche Elemente, die lᵒsind immer noch notwendig , die Gruppe mit den kürzesten Längen zu finden, und es funktioniert , weil die Reihenfolge der Gruppen in der Ausgabe von ᵍdurch die Position des ersten Elements jeder Gruppe bestimmt wird, so das ᵍhᵐkönnte als eine Art funktionieren Deduplikat von Pseudo-Metapredikat funktionieren.

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

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

Probieren Sie es online!