이 과제의 목표는 양의 정수 배열을 가져 와서 요소처럼 그룹화하여 해당 인덱스를 열거하는 것입니다.

중복되지 않은 열거는 쌍 배열을 출력하여 수행됩니다 ( (value, index)예 : [3, 4, 13, 9, 2]=>) [[3,1],[4,2],[13,3],[9,4],[2,5]].

그러나 주어진 요소가 두 번째로 나타나면 자체 쌍이 제공되지 않고 대신 첫 번째 그룹에 추가됩니다. 우리가 3 9를 대체 우리 위의 예 경우, 출력에 우리는 제거 할 [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]]

이것은 code-golf 이며 가장 적은 바이트 수입니다!

Dyalog APL, 5 바이트

(⊂,)⌸

온라인으로 사용해보십시오!

,⌸2 바이트 동안 거의 작동하지만 후행 0이 있습니다.

J , 12 바이트

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

인덱스가 0입니다.

온라인으로 사용해보십시오!

상자로하고있는 모든 작업을 제거 할 수 있다면 바이트 수를 상당히 줄일 수 있습니다. 나는 그것을 알아낼 수 있는지 볼 것입니다.

설명

이것은 설명하기에는 너무 이르다 (더 많은 골프가 있어야한다).

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

파이썬 3 , 83 82 바이트

^{Mego 덕분에 -1 바이트}

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

온라인으로 사용해보십시오!

하스켈 , 48 바이트

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

온라인으로 사용해보십시오!

첨부 , 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와 짝을 이룹니다 ( 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 – 각 요소마다 ...
    x – 모든 지수를 구합니다.
 + 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)))

온라인으로 사용해보십시오!

이것은 codegolf에서의 첫 시도이므로 모든 의견을 환영합니다!

Wolfram Language (Mathematica) , 40 바이트

Martin Ender 덕분에 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (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 자

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

Adam 테스트 덕분에 -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- 프롤로그 , 165117 바이트

프롤로그 골프 팁 덕분에 -48 바이트 .

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)

노트:

• x, 선언하지 않고 14 바이트(,/)'+(!;.)@'= 는이 접근법을 포기했습니다 ...

줄리아 0.6 , 37 바이트

1 바이트 할인 된 Pavel에게 감사합니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (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));

이것은 사람이 읽을 수있는 방식으로 배열을 나타냅니다.
키 "A"내부에서 POST, GET 및 COOKIE를 통해 값을 전달할 수 있습니다.

최신 버전의 경우 (90 바이트)를 사용할 수 있습니다.

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

모든 값이 키 "A"내의 GET 매개 변수를 통해 전달되어야한다는 점을 제외하면 결과는 동일합니다.

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

apt , 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]);

담당자를 바탕으로, 나는 가정 IsmaelMiguel은 내가에서 건물입니다 있도록이 지역 사회에서 포스트 PHP 코드에 가장 좋은 방법을 알고 자신의 재단 . 내 스 니펫에 포함 / 계산 되는지 명확하지 않습니다.<? . 이것은 내 처녀 게시물이므로 불필요한 구문이 있는지 설명해 주시면 감사하겠습니다. 추신 : 나는 또한 읽을 수 PHP에서 골프에 대한 팁을 메타 마이그레이션을위한 훌륭한 후보처럼 날 것으로 보인다 .

Ismael의 스 니펫 개선 사항은 다음과 같습니다.

1. 각 하위 배열의 첫 번째 요소에 무조건 할당 (값 덮어 쓰기)
2. 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}")
        }
    }
}

TIO

TryItOnline

스위프트 4, 107 바이트

... 이크 스.

{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은 예쁘지 않습니다.

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

이 버전은 nil (53 바이트)을 허용합니다.

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

온라인으로 사용해보십시오!