Beschreibung der Herausforderung

Zeigen Sie bei einer Liste / einem Array von Elementen alle Gruppen aufeinanderfolgender sich wiederholender Elemente an.

Eingabe / Ausgabe Beschreibung

Ihre Eingabe ist eine Liste / ein Array von Elementen (Sie können davon ausgehen, dass alle vom gleichen Typ sind). Sie müssen nicht jeden Typ unterstützen, den Ihre Sprache hat, sondern mindestens einen (vorzugsweise int, aber Typen wie boolean, obwohl nicht sehr interessant, sind auch in Ordnung). Beispielausgaben:

[4, 4, 2, 2, 9, 9] -> [[4, 4], [2, 2], [9, 9]]
[1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4] -> [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
[1, 1, 1, 3, 3, 1, 1, 2, 2, 2, 1, 1, 3] -> [[1, 1, 1], [3, 3], [1, 1], [2, 2, 2], [1, 1], [3]]
[9, 7, 8, 6, 5] -> [[9], [7], [8], [6], [5]]
[5, 5, 5] -> [[5, 5, 5]]
['A', 'B', 'B', 'B', 'C', 'D', 'X', 'Y', 'Y', 'Z'] -> [['A'], ['B', 'B', 'B'], ['C'], ['D'], ['X'], ['Y', 'Y'], ['Z']]
[True, True, True, False, False, True, False, False, True, True, True] -> [[True, True, True], [False, False], [True], [False, False], [True, True, True]]
[0] -> [[0]]

Bei leeren Listen ist die Ausgabe undefiniert - es kann sich um nichts, eine leere Liste oder eine Ausnahme handeln - was auch immer für Ihre Golfzwecke am besten geeignet ist. Sie müssen auch keine separate Liste von Listen erstellen, daher ist dies auch eine absolut gültige Ausgabe:

[1, 1, 1, 2, 2, 3, 3, 3, 4, 9] ->

1 1 1
2 2
3 3 3
4
9

Das Wichtigste ist, die Gruppen auf irgendeine Weise getrennt zu halten.

Mathematica, 5 Bytes

Split

... dafür ist etwas eingebaut.

Gelee , 5 Bytes

I0;œṗ

Funktioniert für alle numerischen Typen. Probieren Sie es online aus! oder überprüfen Sie alle numerischen Testfälle .

Wie es funktioniert

I0;œṗ  Main link. Argument: A (array)

I      Increments; compute the differences of consecutive elements.
 0;    Prepend a zero.
   œṗ  Partition; split A at truthy values in the result to the left.

Netzhaut , 15 8 Bytes

Vielen Dank an Lynn für den Vorschlag eines einfacheren E / A-Formats.

!`(.)\1*

Behandelt die Eingabe als Liste von Zeichen (und verwendet Zeilenvorschübe, um Gruppen zu trennen).

Probieren Sie es online aus!

Dies funktioniert einfach, indem Gruppen abgeglichen und alle gedruckt werden (wobei die Zeilenvorschubtrennung automatisch verwendet wird).

JavaScript (ES6), 39 37 Byte

f=
s=>s.replace(/(\w+) (?!\1\b)/g,`$1
`)
;

<input oninput=o.textContent=f(this.value);><pre id=o>

Funktioniert mit durch Leerzeichen getrennten wortähnlichen Token. 2 Bytes dank @ MartinEnder ♦ gespeichert. Das Beste, was ich für die Eingabe und Rückgabe von Arrays tun kann, ist 68:

a=>a.reduce((l,r)=>(l==r?c.push(r):b.push(c=[r]),r),b=[c=[a[0]]])&&b

MATL , 9 Bytes

Y'v"@Z}Y"

Y'     % Take input. Run-length encoding. Gives two row arrays: values and run lengths
v      % Concatenate vertically   
"      % For each column
  @Z}  %   Push column and split into its two elements
  Y"   %   Run-length decoding
       % End for. Implicitly display

Die Eingabe ist ein Zeilenarray von Zahlen mit Leerzeichen oder Kommas als Trennzeichen.

Probieren Sie es online aus! Test mit nicht ganzzahligen Zahlen .

MATL, 11 Bytes

lidgvYsG7XQ

Die Eingabe ist ein Spaltenarray aus Zahlen oder Zeichen , das ;als Trennzeichen verwendet wird.

Probieren Sie es online aus! Test mit beliebigen Zahlen . Teste mit Charakteren .

l     % Push 1
i     % Take input, say [4;4;2;2;9;9]
d     % Consecutive differences of input: [0;-2;0;7;0]
g     % Convert to logical: gives 1 if consecutive entries were different: [0;1;0;1;0]
v     % Concatenate vertically with the initial 1: [1;0;1;0;1;0]
Ys    % Cumulative sum. Each value is a group label: [1;1;2;2;3;3]
G     % Push input again
7XQ   % Split into horizontal arrays as indicated by group labels: {[4 4];[2 2];[9 9]}
      % Implicitly display

gs2, 2 Bytes

c-

Probieren Sie es online aus!

cist eine integrierte Gruppierung, die genau dies tut. Wir nennen sie also STDIN (eine Zeichenfolge, dh eine Liste von Zeichen) und erhalten eine Liste von Zeichenfolgen. Leider ist das Ergebnis nicht von der Eingabe zu unterscheiden, daher müssen wir Trennzeichen hinzufügen! -(durch Leerzeichen verbinden) macht den Trick.

Eine alternative Antwort ist cα(2 Bytes CP437), die einfach cin eine anonyme Funktion eingebunden wird.

Brachylog , 13 Bytes

:{s.dl1}fs.c?

Warnung: Dies ist äußerst ineffizient, und Sie werden in der Erklärung verstehen, warum.

Dies erwartet eine Liste (zB [1:1:2:2:2]) als Eingabe. Die Elemente in der Liste können so ziemlich alles sein.

Erläuterung

:{     }f       Find all ordered subsets of the Input with a unique element in them
  s.                Output is a subset of the input
    dl1             Output minus all duplicates has a length of 1 (i.e. one unique value)
         s.     Output is an ordered subset of those subsets
           c?   The concatenation of those subsets is the Input

Dies funktioniert nur aufgrund der Art und Weise, wie sich s - Subsetvereinheitlicht: Die kleinsten Sätze sind am Ende. Daher stellt sich als erstes heraus, dass Verkettungen mit dem Eingang die längsten Läufe sind, z. B. [[1:1]:[2:2:2]]und nicht zum Beispiel [[1:1]:[2:2]:[2]].

J , 13 Bytes

<;.1~1,2~:/\]

Da J keine zerlumpten Arrays unterstützt, wird jeder Lauf gleicher Elemente eingerahmt. Die Eingabe ist ein Array von Werten und die Ausgabe ist ein Array von Boxed Arrays.

Verwendungszweck

   f =: <;.1~1,2~:/\]
   f 4 4 2 2 9 9
┌───┬───┬───┐
│4 4│2 2│9 9│
└───┴───┴───┘
   f 1 1 1 3 3 1 1 2 2 2 1 1 3
┌─────┬───┬───┬─────┬───┬─┐
│1 1 1│3 3│1 1│2 2 2│1 1│3│
└─────┴───┴───┴─────┴───┴─┘
   f 'ABBBCDXYYZ'
┌─┬───┬─┬─┬─┬──┬─┐
│A│BBB│C│D│X│YY│Z│
└─┴───┴─┴─┴─┴──┴─┘
   f 0
┌─┐
│0│
└─┘

Erläuterung

<;.1~1,2~:/\]  Input: s
            ]  Identify function to get s
       2       The constant 2
           \   Operate on each overlapping sublist of size 2
        ~:/      Are the two values unequal, 1 if true else 0
     1,        Prepend a 1 to it
<;.1~          Using the list just made, chop s at each index equal to 1 and box it
               Return this as the result

Dyalog APL , 9 Bytes

⊢⊂⍨1,2≠/⊢

⊢das Argument
⊂⍨, das am
1ersten Element partitioniert wurde
,und
2≠/bei dem sich nachfolgende Paare
⊢im Argument unterscheiden

Python 2, 43 Bytes

p=-1
for x in input():print"|"[:x^p],x,;p=x

Funktioniert mit Listen von Booleschen Werten. Beispiel:

>> [True,True,False,False,False,True,False,True,False]
 True  True | False  False  False | True | False | True | False

Durchläuft die Eingabeliste und speichert das zuletzt gesehene Element. Vor jedem Element, das sich vom vorherigen unterscheidet, wird eine Trennleiste gedruckt, die als bitweise x oder ^0 markiert ist. Beim Initialisieren wird p=-1ein Trennzeichen vor dem ersten Element vermieden.

CJam, 9 Bytes

Zwei Lösungen:

{e`:a:e~}
{e`{(*}%}

Testen Sie es hier.

Erläuterung

e`   e# Run-length encode (gives a list of pairs [run-length value]).
:a   e# Wrap each pair in a singleton list.
:e~  e# Run-length decode each list.

Oder

e`   e# Run-length encode.
{    e# Map this block over each pair...
  (  e#   Pull out the run length.
  *  e#   Repeat the list containing only the value that many times.
}%

Haskell, 22 Bytes

import Data.List
group

Es ist ein eingebauter. Funktioniert mit jedem Typ, der Gleichheit unterstützt.

MATL, 8 7 Bytes

1 Byte dank @Suever entfernt

ly&Y'Y{

Funktioniert mit ganzen Zahlen / Floats / Zeichen / Booleschen Werten / Einhornpunkten / anderen imaginären Eingaben.
Für Boolesche Werte sind Eingaben T/F, Ausgaben 1/0.

Probieren Sie es online aus!

Gruppiert und wiederholt

ly&Y'Y{
l          % push 1 onto the stack
 y         % duplicate the input
  &Y'      % run-length encoding (secondary output only)
     Y{    % break up array into cell array of subarrays

C #, 117 Bytes

void f(List<String>m){Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));}

ungolfed (nicht wirklich)

    public static void f(List<String>m)
    {
        Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));
    }

Pyth, 9 7 Bytes

mr9]dr8

Gutschrift an @LeakyNun für 2 Byte!

Erläuterung:

             input
     r8      run-length decode
m            for each...
   ]d        ...treat each run as standalone encoded form...
 r9          ...decode 
             print

Alte Antwort, 12 Bytes

hf.Am!t{dT./

Ich habe die eingebaute Lauflänge vergessen, aber ich denke, das ist ein guter Ansatz, also habe ich ihn beibehalten.

Erläuterung:

                input
          ./    all possible partitions
 f       T      filter by...
  .A            ...whether all groups of integers...
    m!t{d       ...have length one after deduplication
h               get the first element (first one has no adjacent [1,1] and [1])
                print

Pyth , 36 35 Bytes

VQIqNk=hZ).?=+Y]*]kZ=Z1=kN;t+Y]*]kZ

Testlink

Edit: Erklärung:

                                      standard variables: Y=[], Z=0, k='', Q=input
VQ                                    iterate over input
  IqNk                                if the current entity is equal to k:
      =hZ)                            increase Z.
          .?                          else:
               ]*]kZ                  list of length Z filled with k
            =+Y                       add it to Y
                    =Z1               set Z to 1
                       =kN            set k to the current entity
                          ;           end loop
                              ]*]kZ   list of length Z filled with k
                            +Y        add it to Y
                           t          implicitly print the tail of Y (removing the first element)

Netzhaut , 24 22 Bytes

2 Bytes dank Martin Ender.

Es gibt bereits eine 15-Byte-Antwort , daher ist dies nur ein weiterer Ansatz, der mehr Bytes kostet.

S-`(?<=(\d+)) (?!\1\b)

Probieren Sie es online aus!

Es teilt sich in Leerzeichen auf, deren vorhergehende Nummer vom Verfahren abweicht.

Dies ist eine Demonstration von Lookarounds.

05AB1E, 13 Bytes

¬svyÊi¶}yðJ?y

Erklärt

¬s             # push first element of list to stack and swap with input
  v            # for each X in input
   yÊi¶}       # if X is different from last iteration, push a newline
        yðJ?   # push X followed by a space to stack and join stack to string
            y  # push X to stack for next iterations comparison

Sollte für jede Liste funktionieren.
Getestet auf int und char.

Probieren Sie es online aus

Schnell, 43 Bytes

var p=0;i.map{print($0==p ?"":",",$0);p=$0}

Nimmt an, dass i ein Array von gleichwertigen Objekten ist; funktioniert für alles von Ints über Strings bis hin zu benutzerdefinierten Objekten. Ein bisschen frech, da die Ausgabe viele Zeilenumbrüche enthält, aber diese hübscher zu machen würde Bytes kosten.

Schönere, ungolfed Version:

var prev = Int.max // unlikely to be the first element, but not the end of the world if it happens to be.
i.map { n in
    print(n == prev ? " " : "\n•", n, terminator: "")
    prev = n
}

Diese Version druckt jede Gruppe in einer neuen Zeile auf Kosten von mehr Code.

Ideen zur Verbesserung

i.reduce(0){print($0==$1 ?"":"•",$1);return $1}

Diese Version hat 47 Bytes, aber es ist ein anderer Ansatz. Vielleicht gibt es dort etwas zu optimieren? Das größte Problem ist die Rückgabeerklärung.

C 88 77 Bytes

Verschob das strmcmp Innere der printf 11 Bytes

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}

Verwendungszweck:

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}
main(c,v)char**v;{f(v);}

Beispieleingabe:

(Befehlszeilenparameter)

1 1 1 1 2 2 2 2 3 3 3 3 4 5 6 7777

Beispielausgabe:

1 1 1 1
2 2 2 2
3 3 3 3
4
5
6
7777

Getestet am:

gcc 4.4.7 (Red Hat 4.4.7-16)  - OK
gcc 5.3.0 (Cygwin)            - Segmetation Fault
gcc 4.8.1 (Windows)           - OK

Ich versuche, den 5.3.0-Segmetationsfehler zu beheben.

88 Version

f(char**a){*a++;char*x;for(;*a;x=*a++)strcmp(*a,x)?printf("\n%s ",*a):printf("%s ",*a);}

Java 134 Bytes

void a(String[]a){int i=0,l=a.length;for(;i<l-1;i++)System.out.print(a[i]+((a[i].equals(a[i+1]))?" ":"\n"));System.out.print(a[l-1]);}

iteriert durch und entscheidet, ob mit einer neuen Zeile oder einem Leerzeichen getrennt werden soll.

ListSharp , 134 Bytes

STRG l = READ[<here>+"\\l.txt"]
[FOREACH NUMB IN 1 TO l LENGTH-1 AS i]
{
[IF l[i] ISNOT l[i-1]]
STRG o=o+"\n"
STRG o=o+l[i]
}
SHOW = o

ListSharp unterstützt keine Funktionen, daher wird das Array in einer lokalen Datei namens aufgerufen l.txt

Ruby , 24 Bytes

In Ruby haben ArrayInstanzen eine eingebaute Methodegroup_by

Die Lösung lautet also:

a.group_by{|x| x}.values

TSQL, 132 Bytes

Dies unterscheidet sich ein wenig von den anderen Antworten - SQL hat keine Arrays, die offensichtliche Eingabe für SQL ist eine Tabelle.

Golf:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT REPLICATE(v+' ',COUNT(*))FROM(SELECT i,i-row_number()over(partition
by v order by i)x,v FROM @)z GROUP BY x,v ORDER BY max(i)

Ungolfed:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT
  REPLICATE(v+' ',COUNT(*))
FROM 
  (
     SELECT
       i,
       i-row_number()over(partition by v order by i)x,
       v
     FROM @
  )z
GROUP BY
  x,v
ORDER BY
  max(i)

Geige

Perl 5 - 39 Bytes

print$_.($/)[$_ eq@a[++$-]]for@a=sort@a

Pyke, 2 Bytes (nicht wettbewerbsfähig)

Unterstützt nur Ganzzahlen

$f

Probieren Sie es hier aus!

split_at(input, delta(input))

Split_at-Knoten hinzugefügt, teilt die Eingabe auf, wenn das 2. Argument wahr ist

sed, 33 23 + 1 = 24 Bytes

s/([^ ]+)( \1)* */&\n/g

Es braucht die -rOption.

Anwendungsbeispiel:

$ echo '1 1 1 2 2 3 3 3 4 9 9' | sed -r 's/([^ ]+)( \1)* */&\n/g'
1 1 1 
2 2 
3 3 3 
4 
9 9

JavaScript (ES6), 56

Eingabe: Array von Zahlen oder Zeichenfolgen

Ausgabe: Array von Arrays

Zum ersten Mal mit genauem Vergleich im Golfcode

a=>a.map(x=>x!==p?o.push(g=[p=x]):g.push(x),p=o=g=[])&&o

Clojure, 19 Bytes

#(partition-by + %)

Es ist integriert, benötigt jedoch eine Zuordnungsfunktion. In diesem Fall +dient als Identitätsfunktion.

Javascript (mit externer Bibliothek) (178 Bytes)

(s)=>_.From(s).Aggregate((t,e)=>{if(0===t.Items.length)return t.Items.push([e]),t;var s=t.Items[t.Items.length-1];return s[0]===e?(s.push(e),t):(t.Items.push([e]),t)},{Items:[]})

Haftungsausschluss: Ich verwende eine Bibliothek, die ich geschrieben habe, um LINQ von C # in JS zu implementieren. Es hat mir nicht gerade geholfen zu gewinnen, aber na ja