チャレンジの説明

アイテムのリスト/配列を指定して、連続する繰り返しアイテムのすべてのグループを表示します。

入力/出力の説明

入力は、アイテムのリスト/配列です（すべてが同じタイプであると想定できます）。言語が持つすべてのタイプをサポートする必要はありませんが、少なくとも1つをサポートする必要intがあります（できれば、のようなタイプbooleanも非常に興味深いものではありませんが、問題ありません）。出力例：

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

空のリストに関しては、出力は未定義です-それは何もない、空のリスト、または例外である可能性があります-あなたのゴルフの目的に最も適したものは何でも。リストの個別のリストを作成する必要もないため、これも完全に有効な出力です。

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

1 1 1
2 2
3 3 3
4
9

重要なことは、グループを何らかの方法で分離しておくことです。

Mathematica、5バイト

Split

...そのための組み込み機能があります。

ゼリー、5 バイト

I0;œṗ

すべての数値タイプで機能します。オンラインでお試しください！または、すべての数値テストケースを確認します。

使い方

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.

Retina、15 8バイト

よりシンプルなI / Oフォーマットを提案してくれたLynnに感謝します。

!`(.)\1*

入力を文字のリストとして扱います（ラインフィードを使用してグループを区切ります）。

オンラインでお試しください！

これは単にグループを一致させてすべてを印刷することで機能します（これは自動的に改行分離を使用します）。

JavaScript（ES6）、39 37バイト

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

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

スペースで区切られた単語のようなトークンで動作します。@ MartinEnder♦のおかげで2バイト節約されました。配列の入力と戻りに対して私ができる最善の方法は68です。

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

MATL、9バイト

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

入力は、セパレータとしてスペースまたはコンマを使用した数値の行配列です。

オンラインでお試しください！整数以外の数値でテストします。

MATL、11バイト

lidgvYsG7XQ

入力は、セパレータとして使用する数値または文字の列配列です;。

オンラインでお試しください！任意の数値でテストします。文字でテストします。

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バイト

c-

オンラインでお試しください！

cこれはまさにこれを行うグループ化組み込みなので、STDIN（文字列、つまり文字のリスト）で呼び出し、文字列のリストを取得します。残念ながら、結果は入力と区別がつかないため、セパレータを追加する必要があります。-（スペースで結合）トリックを行います。

別の答えはcα（CP437の2バイト）で、これは単にc無名関数にラップされます。

Brachylog、13バイト

:{s.dl1}fs.c?

警告：これは非常に非効率的であり、説明で理由を理解できます。

これは[1:1:2:2:2]入力としてリスト（例えば）を期待します。リスト内の要素はほとんど何でもかまいません。

説明

:{     }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

これは、s - Subset統一方法によってのみ機能します。最小セットが最後にあります。したがって、入力への連結が最初に検出するのは、たとえば[[1:1]:[2:2:2]]でなく、などの最長の実行[[1:1]:[2:2]:[2]]です。

J、13バイト

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

Jは不規則な配列をサポートしないため、等しい要素の実行ごとにボックス化されます。入力は値の配列であり、出力はボックス配列の配列です。

使用法

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

説明

<;.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 バイト

⊢⊂⍨1,2≠/⊢

⊢最初の要素で
⊂⍨分割さ
1れた引数
,と
2≠/、その後のペア
⊢で引数が異なる場合

Python 2、43バイト

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

ブール値のリストで機能します。例：

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

入力リストを反復処理し、最後に表示された要素を格納します。前とは異なる各要素の前に区切りバーが印刷され、ビット単位のxor ^が0であることが確認されますp=-1。初期化すると、最初の要素の前の区切りが回避されます。

CJam、9バイト

2つのソリューション：

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

ここでテストしてください。

説明

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.

または

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バイト

import Data.List
group

ビルトインがあります。同等性をサポートするすべての型で機能します。

MATL、8 7バイト

@Sueverのおかげで1バイトを削除

ly&Y'Y{

整数/浮動小数点数/文字/ブール値/ユニコーンポイント/その他の虚数入力で動作します。
ブール値の場合、入力はT/F、出力は1/0です。

オンラインでお試しください！

グループ化および繰り返し

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バイト

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

ない（本当にではない）

    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バイト

mr9]dr8

2バイトの@LeakyNunへのクレジット！

説明：

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

古い回答、12バイト

hf.Am!t{dT./

組み込みのランレングスを忘れていましたが、これは大丈夫なアプローチだと思うので、そのままにしました。

説明：

                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バイト

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

テストリンク

編集：説明：

                                      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)

網膜、24 22バイト

Martin Enderのおかげで2バイト。

15バイトの答えはすでに存在しているので、これは複数のバイトのコストだけで、別のアプローチです。

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

オンラインでお試しください！

先行する番号が手続きと異なるスペースで分割されます。

これはルックアラウンドのデモンストレーションです。

05AB1E、13バイト

¬svyÊi¶}yðJ?y

説明しました

¬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

どのリストでも機能するはずです。
intとcharでテストされています。

オンラインでお試しください

Swift、43バイト

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

iを赤道オブジェクトの配列と仮定します。intから文字列、カスタムオブジェクトまで何でも機能します。出力には多くの改行が含まれるという点で生意気ですが、よりきれいにすることはバイトを消費します。

きれいな、ゴルフではないバージョン：

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
}

このバージョンでは、コードが増える代わりに、すべてのグループが新しい行に印刷されます。

改善のためのアイデア

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

このバージョンは47バイトですが、アプローチが異なるため、そこに最適化する何かがあるのでしょうか？最大の問題はreturnステートメントです。

C、88 77バイト

11バイト節約のstrmcmp 内側に 移動printf

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

使用法：

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

入力例：

（コマンドラインパラメーター）

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

出力例：

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

テスト済み：

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

5.3.0 Segmetation Faultを修正しようとしています。

88バージョン

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

Java 134バイト

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

反復し、改行で区切るかスペースで区切るかを決定します。

ListSharp、134バイト

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は関数をサポートしていないため、配列は次のローカルファイルに保存されます。 l.txt

Ruby、24バイト

Ruby Arrayインスタンスには組み込みメソッドがありますgroup_by

したがって、ソリューションは次のようになります。

a.group_by{|x| x}.values

TSQL、132バイト

これは他の回答とは少し異なります-SQLには配列がありません。SQLの明らかな入力はテーブルです。

ゴルフ：

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)

非ゴルフ：

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)

フィドル

Perl 5-39バイト

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

Pyke、2バイト（非競合）

整数のみをサポート

$f

ここでお試しください！

split_at(input, delta(input))

split_atノードを追加し、2番目の引数が真の場合に入力を分割

sed、33 23 + 1 = 24バイト

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

-rオプションが必要です。

使用例：

$ 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

入力：数値または文字列の配列

出力：配列の配列

ゴルフされたコードで正確な比較を初めて使用する

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

Clojure、19バイト

#(partition-by + %)

組み込みですが、マッピング関数を使用します。この場合、+アイデンティティ関数として機能します。

JavaScript（外部ライブラリを使用）（178バイト）

(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:[]})

免責事項：C＃からJSにLINQを実装するために書いたライブラリを使用しています。それは私が勝つことを正確には助けませんでしたが、まあ