Mục tiêu của thách thức này là lấy một loạt các số nguyên dương và liệt kê các chỉ số của nó, nhóm lại như các phần tử.

Việc liệt kê mà không có bất kỳ sự trùng lặp nào được thực hiện bằng cách chỉ xuất ra một mảng các cặp (value, index), ví dụ, [3, 4, 13, 9, 2]=> [[3,1],[4,2],[13,3],[9,4],[2,5]].

Tuy nhiên, nếu một yếu tố nhất định xuất hiện lần thứ hai, thì nó không được cung cấp cặp riêng của nó, mà thay vào đó được thêm vào nhóm lần xuất hiện đầu tiên. Nếu trong ví dụ trên của chúng tôi, chúng tôi đã thay thế 9 bằng 3, thì trong đầu ra, chúng tôi sẽ loại bỏ [9,4]và thay thế [3,1]bằng [3,1,4].

Trong đầu ra, các nhóm phải được sắp xếp theo lần xuất hiện đầu tiên của chúng và các chỉ số phải theo thứ tự tăng dần. Phần tử phải là đầu tiên trong một nhóm, trước các chỉ số của nó. Đầu ra có thể là 0 hoặc 1 được lập chỉ mục. Bạn có thể giả sử mảng có ít nhất một phần tử.

Các trường hợp thử nghiệm:

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

Đây là mã golf , ít byte thắng nhất!

APL Dyalog, 5 byte

(⊂,)⌸

Hãy thử trực tuyến!

,⌸cho 2 byte gần như hoạt động, nhưng có các số 0 ở cuối: /

J , 12 byte

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

Không có chỉ mục.

Hãy thử trực tuyến!

Nếu bạn có thể loại bỏ tất cả các công việc tôi đang làm với các hộp, có lẽ bạn có thể giảm bớt bytecount một chút. Tôi sẽ xem nếu tôi có thể tìm ra điều đó.

Giải trình

Điều này có lẽ là quá sớm để giải thích (nên có nhiều golf hơn).

~. ,&.> <@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 byte

ÙεDIQƶ0K)˜

Hãy thử trực tuyến!

Giải trình

Ù             # 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 byte

^{-1 byte nhờ Mego}

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

Hãy thử trực tuyến!

Haskell , 48 byte

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

Hãy thử trực tuyến!

Tùy viên , 15 byte

Flat=>Positions

Hãy thử trực tuyến!

Đây là một trường hợp thú vị của =>, hình thức vận hành Map. Khi được đưa ra hai đối số chức năng fvà g, Maptrả về một hàm f => g[x]trên x. Nghĩa là, RHS được áp dụng cho đầu vào, sau đó LHS được ánh xạ.

Nội dung Positionstạo ra một mảng đại diện cho nhóm các mục nhập theo chỉ mục. Theo mặc định, khi không được cung cấp đối số thứ hai, Positionssẽ sử dụng đối số thứ nhất. Flatsau đó được ánh xạ qua từng mục, vì đó là những gì câu hỏi yêu cầu.

Các giải pháp thay thế

31 byte

MapArgs[Concat#~Indices,Unique]

Hãy thử trực tuyến!

Một thay thế khá ngắn, tích hợp ít. MapArgslà một hàm như thế Map, ngoại trừ bạn có thể cung cấp thêm đối số vào nó. Ví dụ, MapArgs[{_1 + _2}, 1..3, 3]là [4, 5, 6]. Giống như Map, nó trở nên cộc lốc khi được cung cấp hai đối số chức năng. Các chức năng được ánh xạ là Concat#~Indices, một ngã ba. Ngã ba này được áp dụng cho các Uniquemục của đầu vào và đầu vào chính nó. Điều này chuyển thành Concat[_, Indices[_2, _]](với các đối số được Indiceshoán đổi qua ~), kết hợp phần tử được ánh xạ ( _) với các chỉ số của phần tử đã nói _trong mảng đầu vào, là _2(như ffed qua MapArgs).

43 byte

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

Hãy thử trực tuyến!

Đây thực sự chỉ là một sự kết hợp dài dòng hơn (nhưng vẫn dễ đọc hơn) của các giải pháp # 1 và # 2.

Thạch , 6 byte

Q;"ĠṢ$

Hãy thử trực tuyến!

Giải trình:

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

Bình thường , 7 byte

Chỉ số 0.

{+VQxRQ

Hãy thử nó ở đây! Thay thế.

Làm sao?

{+ VQxRQ - Chương trình đầy đủ.

     RQ - Đối với từng yếu tố ...
    x - Nhận tất cả các chỉ số của nó.
 + V - Và áp dụng phép nối vectơ.
   Q - Với đầu vào.
{- Khử trùng lặp.

MATL , 8 byte

u"@tG=fh

Hãy thử nó tại MATL Online

Giải trình

        # 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

Trên thực tế , 24 byte

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

Hãy thử trực tuyến!

Giải trình:

;;╗⌠╝╜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 byte

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

Hãy thử trực tuyến!

Đây là nỗ lực đầu tiên của tôi tại codegolf, vì vậy mọi phản hồi đều được chào đón!

Ngôn ngữ Wolfram (Mathicala) , 40 byte

Đã lưu một byte nhờ Martin Ender.

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

Hãy thử trực tuyến!

JavaScript (ES6), 64 byte

0 được lập chỉ mục

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

Lưu ý, điều này giả sử số đầu vào là dương, vì vậy v> 0

Kiểm tra sửa đổi một chút (1 chỉ mục) để phù hợp với các trường hợp thử nghiệm

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 byte, 12 ký tự

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

-4 byte nhờ kiểm tra Adam:

  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 byte

-48 byte nhờ các mẹo chơi gôn 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)).

Hãy thử trực tuyến!

Giải trình

% 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 byte

Dung dịch:

(!x),'.x:=

Hãy thử trực tuyến!

Ví dụ:

(!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)

Giải trình:

Đánh giá được thực hiện từ phải sang trái. Tôi vẫn nghĩ rằng đây là khả năng chơi gôn hơn nữa ...

(!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)

Ghi chú:

• 14 byte mà không khai báo x, (,/)'+(!;.)@'=đã từ bỏ với cách tiếp cận này ...

Julia 0,6 , 37 byte

Cảm ơn Pavel đã giảm 1 byte.

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

Hãy thử trực tuyến!

JavaScript (ES6), 68 byte

Chỉ số 0.

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

Các trường hợp thử nghiệm

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 byte

Vâng, nó khá dài.

Điều này giả sử một tập tin mặc định php.ini ( short_open_tag = Onvà register_globals = On).

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

Điều này trình bày các mảng theo một cách dễ đọc của con người.
Các giá trị có thể được truyền bằng POST, GET và COOKIE, bên trong khóa "A".

Đối với phiên bản hiện đại, người ta có thể sử dụng (90 byte):

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

Kết quả là như nhau, ngoại trừ tất cả các giá trị phải được chuyển qua tham số GET bên trong khóa "A".

Perl 6 ,  63  61 byte

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

Kiểm tra nó (dựa trên 0)

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

Kiểm tra nó (thuật toán tương tự dựa trên 0)

Mở rộng:

# 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 byte

Chỉ số 0.

â £ð¶X iX

Thử nó

â £ð¶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 trở lên , 71 byte

* 73 byte để trích dẫn $_GET khóa và tránh Cảnh báo.

Đoạn trích: ( Bản trình diễn )

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

Dựa trên đại diện, tôi giả sử IsmaelMiguel biết cách tốt nhất để đăng mã php trong cộng đồng này vì vậy tôi đang xây dựng từ nền tảng của anh ấy . Nó không rõ ràng với tôi nếu <?được bao gồm / tính trong đoạn trích của tôi . Vì đây là bài viết đầu tiên của tôi, tôi rất vui cho bất cứ ai giải thích nếu có bất kỳ cú pháp không cần thiết. ps Tôi cũng đọc Mẹo chơi golf trong PHP mà dường như là một ứng cử viên tuyệt vời cho việc di chuyển sang Meta .

Những cải tiến được thực hiện cho đoạn trích của Ismael là:

1. Việc gán vô điều kiện của phần tử đầu tiên trong mỗi phân đoạn (ghi đè giá trị)
2. Splatpacking thay vìarray_values() để reindex đầu ra.

Sạch , 61 60 byte

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

Hãy thử trực tuyến!

Đầu ra là 0 chỉ mục

Kotlin , 83 byte

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

Làm đẹp

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

Kiểm tra

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

TIO

Dùng thử

Swift 4, 107 byte

... Yike.

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

Ung dung:

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

Thật tệ khi từ điển mất trật tự, buộc tôi phải lãng phí quá nhiều ký tự để sắp xếp lại. Hình thức lạm dụng các đối số đóng cửa ngầm ( $0, $1, ...) và các thành viên tuple ngầm ( .0, .1, ...) là uhhhhh không đẹp.

Perl 5 , 63 + 1 ( -a) = 64 byte

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

Hãy thử trực tuyến!

Ruby , 54 52 byte

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

Phiên bản này cho phép không (53 byte):

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

Hãy thử trực tuyến!