Мета цього завдання - взяти масив натуральних чисел та перерахувати його індекси, згрупуючи подібні елементи.

Перерахування без жодних дублікатів здійснюється просто виведенням масиву пар (value, index), наприклад, [3, 4, 13, 9, 2]=> [[3,1],[4,2],[13,3],[9,4],[2,5]].

Однак якщо даний елемент з’являється вдруге, він не надає власної пари, а замість цього додається до групи його першого появи. Якщо в нашому вище прикладі ми замінили 9 на 3, то у висновку ми видалимо [9,4]і замінимо [3,1]на [3,1,4].

На виході групи повинні бути впорядковані за першим їх виникненням, а індекси повинні бути у порядку зростання. Елемент повинен бути першим у групі перед його індексами. Вихід може бути індексованим 0 або 1. Ви можете припустити, що масив містить принаймні один елемент.

Тестові приклади:

Input           | Output (One-indexed)
[3, 2, 2, 3]    | [[3, 1, 4], [2, 2, 3]]
[17]            | [[17, 1]]
[1, 1]          | [[1, 1, 2]]
[1, 1, 2]       | [[1, 1, 2], [2, 3]]
[1, 2, 3, 4]    | [[1, 1], [2, 2], [3, 3], [4, 4]]
[1, 1, 1, 1]    | [[1, 1, 2, 3, 4]]

Це кодовий гольф , найменше виграш байтів!

Діалог APL, 5 байт

(⊂,)⌸

Спробуйте в Інтернеті!

,⌸2 байти майже працює, але має зворотні нулі: /

J , 12 байт

~.,&.><@I.@=

Нульова індексація.

Спробуйте в Інтернеті!

Якщо ви зможете видалити всю роботу, яку я роблю з ящиками, ви, ймовірно, можете зовсім скоротити кількість рахунків. Я подивлюсь, чи зможу це зрозуміти.

Пояснення

Це, мабуть, занадто рано, щоб пояснити (повинно бути більше гольфів).

~. ,&.> <@I.@=
             =  Self-classify (comparison of each unique element to array)
            @   Composed with
          I.    Indices of ones (where it's equal)
         @      Composed with
        <       Boxed (how we deal with arrays of unequal length)
   ,&.>         Joined with
      >          Unbox each
   ,             Concatenate
    &.           Box again
~.              Unique elements

05AB1E , 10 байт

ÙεDIQƶ0K)˜

Спробуйте в Інтернеті!

Пояснення

Ù             # remove duplicates
 ε            # apply to each element
  D           # duplicate
   IQ         # compare for equality with input
     ƶ        # multiply each element by its index (1-based)
      0K      # remove zeroes
        )˜    # wrap in a flattened list

Python 3 , 83 82 байт

^{-1 байт завдяки Мего}

lambda x:[[n]+[j for j,m in enumerate(x)if m==n]for n in sorted({*x},key=x.index)]

Спробуйте в Інтернеті!

Haskell , 48 байт

import Data.List
f l=nub[k:elemIndices k l|k<-l]

Спробуйте в Інтернеті!

Attache , 15 байт

Flat=>Positions

Спробуйте в Інтернеті!

Це цікавий випадок =>операторської форми Map. При введенні двох функціональних аргументів fі g, Mapповертає функцію f => g[x]над x. Тобто RHS застосовується до входу, потім LHS відображається.

Вбудований Positionsстворює масив, що представляє групування записів за індексами. За замовчуванням, якщо не постачається другий аргумент, Positionsбуде використаний перший аргумент. Flatпотім відображається над кожним елементом, тому що саме цього питання потрібно.

Альтернативні рішення

31 байт

MapArgs[Concat#~Indices,Unique]

Спробуйте в Інтернеті!

Досить коротка, не вбудована альтернатива. MapArgsтака функція, як Mapви можете виключати додаткові аргументи. Наприклад, MapArgs[{_1 + _2}, 1..3, 3]є [4, 5, 6]. Мовляв Map, він стає викривленим, коли постачається з двома функціональними аргументами. Відображається функція Concat#~Indices, яка є виделкою. Ця вилка застосовується до Uniqueелементів вводу та до самого вводу. Це призводить до Concat[_, Indices[_2, _]](з аргументами Indicesмісцями через ~), які пари елемента прив'язується ( _) з індексами зазначеного елемента _у вхідному масиві, який _2(як ffed через MapArgs).

43 байти

{Flat=>Zip[Unique[_],Indices[_,Unique[_]]]}

Спробуйте в Інтернеті!

Це насправді просто більш багатослівне (але при цьому зручніше для читання) поєднання рішень №1 та №2.

Желе , 6 байт

Q;"ĠṢ$

Спробуйте в Інтернеті!

Пояснення:

Q;"ĠṢ$
Q      Keep the first occurrence of each element
     $ Last two links as a monad
   Ġ    Group indices of equal elements, then sort the resulting list of groups by the element they point to
    Ṣ   Sort; used to re-order the list of groups based on first occurrence instead
  "    Vectorize link between two arguments (the first occurrences and the group list)
 ;      Concatenate

Pyth , 7 байт

0-індексований.

{+VQxRQ

Спробуйте тут! Альтернатива.

Як?

{+ VQxRQ - Повна програма.

     RQ - для кожного елемента ...
    х - Отримайте всі його показники.
 + V - І застосувати векторизовану конкатенацію.
   Q - З введенням.
{- Дублікат.

MATL , 8 байт

u"@tG=fh

Спробуйте в MATL Online

Пояснення

        # Implicitly get the input
u       # Compute the unique values
"       # For each unique value, N
  @     # Push the value N to the stack
  t     # Duplicate N
  G     # Grab the input
  =f    # Get the 1-based indices of the elements that equal N
  h     # Horizontally concatenate N with the indices
        # Implicitly display the result

Власне , 24 байти

;;╗⌠╝╜r⌠╜E╛=⌡░⌡M@Z⌠♂i⌡M╔

Спробуйте в Інтернеті!

Пояснення:

;;╗⌠╝╜r⌠╜E╛=⌡░⌡M@Z⌠♂i⌡M╔
;;                        make two copies of input
  ╗                       save a copy to register 0
   ⌠╝╜r⌠╜E╛=⌡░⌡M          map over input:
    ╝                       save the element in register 1
     ╜r                     indices for input
       ⌠╜E╛=⌡░              filter:
        ╜E                    element in input at index
          ╛=                  equals element for outer map (from register 1)
                @Z        swap, zip input with map result
                  ⌠♂i⌡M   flatten each element in zipped list
                       ╔  uniquify

R , 56 байт

function(x)lapply(unique(x),function(y)c(y,which(x==y)))

Спробуйте в Інтернеті!

Це моя перша спроба кодегольфа, тому будь-який відгук вітається!

Мова Вольфрама (Mathematica) , 40 байт

Збережено байт завдяки Мартіну Ендеру.

KeyValueMap[{#,##&@@#2}&]@*PositionIndex

Спробуйте в Інтернеті!

JavaScript (ES6), 64 байти

0 індексовано

a=>a.map((v,i)=>a[-v]?a[-v].push(i):a[-v]=[v,i]).filter(x=>x[0])

Зауважте, це передбачає, що вхідні числа є позитивними, тому v> 0

Тест злегка модифікований (1 індексований), щоб відповідати тестовим випадкам

var F=
a=>a.map((v,i)=>a[-v]?a[-v].push(i+1):a[-v]=[v,i+1]).filter(x=>x[0])

test = [ // output 1 indexed
  [3, 2, 2, 3],//    | [[3, 1, 4], [2, 2, 3]]
  [17], //           | [[17, 1]]
  [1, 1], //         | [[1, 1, 2]]
  [1, 1, 2], //      | [[1, 1, 2], [2, 3]]
  [1, 2, 3, 4], //   | [[1, 1], [2, 2], [3, 3], [4, 4]]
  [1, 1, 1, 1] //    | [[1, 1, 2, 3, 4]] 
]

test.forEach(t => {
  x = F(t)
  console.log(JSON.stringify(t)+ ' -> ' + JSON.stringify(x))
})

APL NARS, 24 байти, 12 символів

{∪⍵,¨⍸¨⍵=⊂⍵}

-4 байти завдяки тесту Адама:

  f←{∪⍵,¨⍸¨⍵=⊂⍵}

  ⎕fmt f 3 2 2 3
┌2────────────────┐
│┌3─────┐ ┌3─────┐│
││ 3 1 4│ │ 2 2 3││
│└~─────┘ └~─────┘2
└∊────────────────┘
  ⎕fmt f 17
┌1──────┐
│┌2────┐│
││ 17 1││
│└~────┘2
└∊──────┘
  ⎕fmt f 1 1
┌1───────┐
│┌3─────┐│
││ 1 1 2││
│└~─────┘2
└∊───────┘
  ⎕fmt f 1 2 3 4
┌4──────────────────────────┐
│┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐│
││ 1 1│ │ 2 2│ │ 3 3│ │ 4 4││
│└~───┘ └~───┘ └~───┘ └~───┘2
└∊──────────────────────────┘
  ⎕fmt f 1 1 1 1
┌1───────────┐
│┌5─────────┐│
││ 1 1 2 3 4││
│└~─────────┘2
└∊───────────┘

SWI-Prolog , 165 117 байт

-48 байт завдяки підказкам щодо гольфу Prolog .

h(I):-I+[]-1.
[H|T]+R-N:-(select([H|A],R,[H|L],S),!,append(A,[N],L);append(R,[[H,N]],S)),O is N+1,(T+S-O,!;write(S)).

Спробуйте в Інтернеті!

Пояснення

% The predicate that prints the grouped duplicates. It's a wrapper because we
% need some extra arguments to keep state:
enumerate_duplicates(Input) :- enumerate(Input, [], 1).

% In the golfed code, operators are used to represent this predicate.
% See /codegolf//a/153160
% Go through the input, build up the result on the way and print it.
enumerate([Head|Tail], Result, Index) :-
    (
        % If our current Result already contains a list that starts with the
        % current first element in our input, Head, NewIndexes will become the
        % new "tail" of that list in our next result list:
        select([Head|OldIndexes], Result, [Head|NewIndexes], NextResult),
        % Don't backtrack before this if goals below this fail:
        !,
        % The as-yet-unknown NewIndexes above should in fact be the same as
        % OldIndexes with our current Index appended:
        append(OldIndexes, [Index], NewIndexes)
    % Use ; instead of separate predicate rules.
    % See /codegolf//a/67032
    ;
        % If our current Result did not already contain Head, append a new list
        % for it with the current index:
        append(Result, [[Head, Index]], NextResult)
    ),
    % Increment our index counter:
    NextIndex is Index + 1,
    (
        % And continue with the rest of our input:
        enumerate(Tail, NextResult, NextIndex),
        % Don't backtrack if the above succeeded:
        !
    ;
        % If Tail is no longer a multi-element list, we're done. Print:
        write(NextResult)
    ).

K (oK) , 10 байт

Рішення:

(!x),'.x:=

Спробуйте в Інтернеті!

Приклади:

(!x),'.x:=,17
,17 0
(!x),'.x:=1 1
,1 1 2
(!x),'.x:=1 0 1
(1 1 2
2 3)
(!x),'.x:=1 2 3 4
(1 0
2 1
3 2
4 3)

Пояснення:

Оцінювання проводиться справа наліво. Я все ще думаю, що це можливість гольфу далі ...

(!x),'.x:= / the solution
         = / group input into dictionary, item!indices
       x:  / save as variable x
      .    / value of x (the indices)
    ,'     / concatenate (,) each-both (') with
(  )       / do this together
 !x        / the key of x (i.e. the items)

Примітки:

• 14 байт без оголошення x, (,/)'+(!;.)@'=, відмовився від цього підходу ...

Джулія 0,6 , 37 байт

Дякую Павлу за 1 байт.

y->[[x;findin(y,[x])]for x=unique(y)]

Спробуйте в Інтернеті!

JavaScript (ES6), 68 байт

0-індексований.

a=>a.map(p=(x,i)=>1/p[x]?b[p[x]].push(i):b.push([x,p[x]=i]),b=[])&&b

Тестові справи

let f =

a=>a.map(p=(x,i)=>1/p[x]?b[p[x]].push(i):b.push([x,p[x]=i]),b=[])&&b

console.log(JSON.stringify(f([3, 4, 13, 9, 2]))) // [[3,0],[4,1],[13,2],[9,3],[2,4]]
console.log(JSON.stringify(f([3, 4, 13, 3, 2]))) // [[3,0,3],[4,1],[13,2],[2,4]]
console.log(JSON.stringify(f([3, 2, 2, 3]    ))) // [[3,0,3],[2,1,2]]
console.log(JSON.stringify(f([17]            ))) // [[17,0]]
console.log(JSON.stringify(f([1, 1]          ))) // [[1,0,1]]
console.log(JSON.stringify(f([1, 1, 2]       ))) // [[1,0,1],[2,2]]
console.log(JSON.stringify(f([1, 2, 3, 4]    ))) // [[1,0],[2,1],[3,2],[4,3]]
console.log(JSON.stringify(f([1, 1, 1, 1]    ))) // [[1,0,1,2,3]]

PHP 4.1, 88 байт

Так, це досить довго.

Це передбачає файл за замовчуванням php.ini ( short_open_tag = Onі register_globals = On).

<?foreach($A as$k=>$v){!$b[$v]&&$b[$v]=array($v);$b[$v][]=$k;}print_r(array_values($b));

Це представляє масив у зрозумілому для людини вигляді.
Значення можуть передаватися POST, GET та COOKIE, всередині клавіші "A".

Для сучасної версії можна використовувати (90 байт):

<?foreach($_GET[A]as$k=>$v){if(!$b[$v])$b[$v]=[$v];$b[$v][]=$k;}print_r(array_values($b));

Результат такий самий, за винятком того, що всі значення повинні передаватися через параметри GET всередині клавіші "A".

Perl 6 ,  63  61 байт

*.pairs.classify(*.value).map({.key,|.value».key}).sort(*.[1])

Тестуйте його (на основі 0)

{sort *.[1],map {.key,|.value».key},classify *.value,.pairs}

Перевірте це (той же алгоритм на основі 0)

Розширено:

# WhateverCode lambda (this is the parameter) 
*\                                            # [3,2,2,3]

# get a list of Pairs (zero based index => value)
.pairs                                        # (0=>3,1=>2,2=>2,3=>3)

# classify based on the values (unordered result)
.classify(*.value)                            # {2=>[1=>2,2=>2],3=>[0=>3,3=>3]}

# simplify the structure
.map({
  .key,         # the value
  |.value».key  # slip in the indexes
})                                            # ((3,0,3),(2,1,2))

# sort based on first index
.sort(*.[1])

Japt , 14 9 байт

0-індексований.

â £ð¶X iX

Спробуй це

â £ð¶X iX
â             :Deduplicate
  £           :Map each X
   ð          :  Get 0-based indices of elements in the input
    ¶X        :    That are equal to X
       iX     :  Prepend X

PHP 7.4+ , 71 байт

* 73 байти для цитування $_GET ключ і уникати попереджень.

Фрагмент: ( демонстрація )

<?foreach($_GET[A]as$k=>$v){$b[$v][0]=$v;$b[$v][]=$k;}print_r([...$b]);

На основі реп, я припускаю, що Ісмаель Мігель знає найкращий спосіб розміщення PHP-коду в цій спільноті, тому я будую його основу . Мені незрозуміло, чи <?потрібно включати / рахувати в моєму фрагменті . Оскільки це мій дівочий пост, я радий будь-кому пояснити, чи є зайвий синтаксис. ps Я також читав Поради щодо гольфу в PHP, які мені здаються надзвичайними кандидатами на міграцію в Meta .

Покращення фрагменту Ісмаїла:

1. Безумовне присвоєння першого елемента в кожному підмножині (перезапис значення)
2. Splatpacking замість того,array_values() щоб повторно встановити результат.

Чистота , 61 60 байт

import StdEnv,StdLib
$l=removeDup[[e:elemIndices e l]\\e<-l]

Спробуйте в Інтернеті!

Вихід 0-індексований

Котлін , 83 байти

{it.mapIndexed{i,c->c to i}.groupBy({(a,b)->a},{(a,b)->b}).map{(a,b)->listOf(a)+b}}

Прикрасили

{
    it.mapIndexed { i, c -> c to i }
        .groupBy({ (a, b) -> a }, { (a, b) -> b })
        .map { (a, b) -> listOf(a) + b }
}

Тест

var f: (List<Int>) -> List<List<Int>> =
{it.mapIndexed{i,c->c to i}.groupBy({(a,b)->a},{(a,b)->b}).map{(a,b)->listOf(a)+b}}

data class Test(val input: List<Int>, val output: List<List<Int>>)

val tests = listOf(
        Test(listOf(3, 2, 2, 3), listOf(listOf(3, 0, 3), listOf(2, 1, 2))),
        Test(listOf(17), listOf(listOf(17, 0))),
        Test(listOf(1, 1), listOf(listOf(1, 0, 1))),
        Test(listOf(1, 1, 2), listOf(listOf(1, 0, 1), listOf(2, 2))),
        Test(listOf(1, 2, 3, 4), listOf(listOf(1, 0), listOf(2, 1), listOf(3, 2), listOf(4, 3))),
        Test(listOf(1, 1, 1, 1), listOf(listOf(1, 0, 1, 2, 3)))
)

fun main(args: Array<String>) {
    for (c in tests) {
        val o = f(c.input)
        if (o != c.output) {
            throw AssertionError("${c.input} -> $o != ${c.output}")
        }
    }
}

ТІО

TryItOnline

Швидкий 4, 107 байт

... Yikes.

{a in Dictionary(grouping:a.enumerated()){$0.1}.sorted{$0.1.first!.0<$1.1.first!.0}.map{[$0]+$1.flatMap{$0.0}}}

Безголівки:

let f = { (input: [Int]) -> [[Int]] in
    return Dictionary(grouping: input.enumerated(), by: { $0.element })
        .sorted { pairA, pairB in // Sort by order of first appearence (lowest offset)
            return pairA.value.first!.offset < pairB.value.first!.offset
        }.map { element, pairs in
            return [element] + pairs.map{ $0.offset /* +1 */} // add 1 here for 1 based indexing
        }
}

Дуже погано, що словник втрачає впорядкування, змушуючи мене знову витрачати стільки символів на сортування. Такого роду зловживання неявних аргументів закриття ( $0, $1, ...) і неявних членів кортежу ( .0, .1, ...) є uhhhhh не надто.

Perl 5 , 63 + 1 ( -a) = 64 байти

map$k{$_}.=$".++$i,@F;say$_.$k{$_}for sort{$k{$a}-$k{$b}}keys%k

Спробуйте в Інтернеті!

Рубі , 54 52 байти

->a{a.map{|i|[i]+(0..a.size).select{|j|a[j]==i}}|[]}

Ця версія дозволяє отримати нуль (53 байти):

->a{a.map{|i|[i]+(0...a.size).select{|j|a[j]==i}}|[]}

Спробуйте в Інтернеті!