Nhiệm vụ

Viết chương trình hoặc hàm có đầu vào là danh sách / mảng X các số nguyên và đầu ra của nó là danh sách các bộ số nguyên Y , sao cho mỗi phần tử e trong mỗi bộ Y [ i ], X [ e ] = i và sao cho tổng số phần tử trong các tập hợp trong Y bằng với số phần tử trong X .

(Về cơ bản, đây là thao tác tương tự như đảo ngược hashtable / dictionary, ngoại trừ áp dụng cho mảng thay thế.)

Ví dụ

Các ví dụ này giả định lập chỉ mục dựa trên 1, nhưng bạn có thể sử dụng lập chỉ mục dựa trên 0 thay vì nếu bạn thích.

X             Y
[4]           [{},{},{},{1}]
[1,2,3]       [{1},{2},{3}]
[2,2,2]       [{},{1,2,3}]
[5,5,6,6]     [{},{},{},{},{1,2},{3,4}]
[6,6,5,5]     [{},{},{},{},{3,4},{1,2}]

Làm rõ

• Bạn có thể đại diện cho một tập hợp như một danh sách, nếu bạn muốn. Nếu bạn làm như vậy, thứ tự các yếu tố của nó không quan trọng, nhưng bạn có thể không lặp lại các yếu tố.
• Bạn có thể sử dụng bất kỳ định dạng I / O rõ ràng hợp lý nào; ví dụ: bạn có thể tách các thành phần của một tập hợp bằng dấu cách và chính các tập hợp với dòng mới.
• Y nên có độ dài chính xác và ít nhất đủ dài để có tất cả các phần tử của X là các chỉ mục mảng. Tuy nhiên, nó có thể dài hơn phần tử tối đa của X (các phần tử phụ sẽ là các tập hợp trống).
• Tất cả các phần tử của X sẽ là các chỉ số mảng hợp lệ, tức là các số nguyên không âm nếu bạn sử dụng lập chỉ mục dựa trên 0 hoặc các số nguyên dương nếu bạn sử dụng lập chỉ mục dựa trên 1.

Điều kiện chiến thắng

Là một thách thức mã golf , ngắn hơn là tốt hơn.

MATL , 8 byte

tn:IXQ&D

Đầu vào là một vectơ cột, với ;dấu phân cách (ví dụ [2;2;2]). Đầu ra là biểu diễn chuỗi của một mảng ô của vectơ hàng (ví dụ {[]; [1 2 3]}). Một vectơ hàng của một phần tử giống như một số (vì vậy {1; 2; 3}sẽ là đầu ra thay vì {[1]; [2]; [3]}).

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

t     % Implicit input, say x. Duplicate
n     % Number of elements, say N
:     % Range: [1 2 ... N]
IXQ   % accumarray(x, [1 2 ... N], [], @(x){sort(x).'})
&D    % String representation

Hầu hết các công việc được thực hiện bởi hàm bậc cao hơn của Matlab accumarray, nhóm các thành phần trong đầu vào thứ hai theo các giá trị khớp trong đầu tiên và áp dụng một chức năng được chỉ định cho mỗi nhóm. Hàm trong trường hợp này là @(x){sort(x).'}, xuất ra các phần tử được sắp xếp trong mỗi nhóm và khiến kết quả cho tất cả các nhóm được đóng gói trong một mảng ô.

Python, 69 byte

lambda s:[[j for j,x in enumerate(s)if x==i]for i in range(max(s)+1)]

Sử dụng lập chỉ mục dựa trên 0.

Thạch , 7 5 byte

=þṀT€

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

Làm thế nào nó hoạt động

=þṀT€  Main link. Argument: A (array)

  Ṁ    Yield m, the maximum of A.
=þ     Equals table; for each t in [1, ..., m], compare all elemnts of A with t,
       yielding a 2D Boolean array.
   T€  Truth each; for each Boolean array, yield all indices of 1.

Thạch , 8 byte

Jẋ"Ṭ€;"/

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

Làm thế nào nó hoạt động

Jẋ"Ṭ€;"/  argument: z           eg. [6,6,4,4]
J         [1 .. len(z)]             [1,2,3,4]
   Ṭ€     untruth each of z         [[0,0,0,0,0,1],
                                     [0,0,0,0,0,1],
                                     [0,0,0,1],
                                     [0,0,0,1]]
 ẋ"       repeat each of ^^         [[[],[],[],[],[],[1]],
          as many times as           [[],[],[],[],[],[2]],
          each of ^                  [[],[],[],[3]],
                                     [[],[],[],[4]]]
       /  reduce by...
     ;"   vectorized concatenation  [[],[],[],[3,4],[],[1,2]]

Toán học, 36 byte

Join@@@#~Position~n~Table~{n,Max@#}&

Giải trình

Đối với mỗi ntrong {1, 2, ..., Max@#}, nơi Max@#là số nguyên lớn nhất trong danh sách đầu vào, hãy tính Positions nơi nxuất hiện trong danh sách đầu vào #. Vì Position[{6,6,5,5},5](ví dụ) trả về {{3},{4}}, sau đó chúng tôi Apply Joinđến tất cả các yếu tố ở cấp độ {1}của kết quả.

Haskell , 45 byte

slấy một danh sách các số nguyên và trả về một danh sách các danh sách. 1 - được lập chỉ mục để giữ cho các đầu vào trường hợp thử nghiệm không bị thay đổi (mặc dù đầu ra có thêm một số danh sách trống).

s l=[[i|(i,y)<-zip[1..]l,y==x]|x<-[1..sum l]]

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

Đây là những hiểu biết danh sách lồng nhau khá đơn giản. Điều chỉnh nhỏ duy nhất là tận dụng tùy chọn để tạo danh sách dài hơn bằng cách sử dụng sumthay vì maximum.

PHP, 55 byte

<?while($i<=max($_GET))print_r(array_keys($_GET,$i++));

Chỉ số 0.

R, 68 49 47 byte

lapply(1:max(x<-scan()),function(y)which(y==x)) 

Đáng ngạc nhiên, đơn giản hơn rất nhiều so với các giải pháp dài hơn. Lấy một vectơ xtừ STDIN, tạo một vectơ từ 1đến max(x), hoàn toàn tạo ra một danh sách độ dài max(x)và kiểm tra các chỉ số trongx tương ứng với các danh sách mới. Ngẫu nhiên in đầu ra.

Phiên bản cũ hơn:

o=vector('list',max(x<-scan()));for(i in x)o[[i]]=c(o[[i]],F<-F+1);o

Cách tiếp cận hơi khác với câu trả lời R khác. Đưa một vectơ thành STDIN, tạo một danh sách có độ dài bằng giá trị tối đa trong đầu vào. Vòng lặp trên đầu vào và thêm chỉ mục vào đúng nơi.

Sử dụng lập chỉ mục 1 dựa trên.

Python 2 , 91 86 85 byte

Tôi đang lập trình trên điện thoại của mình nhưng tôi thực sự thích thử thách này. Tôi chắc chắn có thể chơi golf này hơn nữa.

def f(a):
 r=[[]for i in range(max(a)+1)]
 for i,j in enumerate(a):r[j]+=[i]
 print r

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

Thạch , 9 byte

Ṭ+\ịĠȧ@"Ṭ

Các bộ trống được lập chỉ mục 1, được biểu thị dưới dạng 0, các bộ của một mục được biểu diễn dưới dạng Ncác bộ gồm nhiều mục được biểu diễn dưới dạng[M,N,...]

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

Làm sao?

Ṭ+\ịĠȧ@"Ṭ - Main link: list a        e.g. [6,6,4,4]
Ṭ         - untruth a                     [0,0,0,1,0,1]
  \       - cumulative reduce with:
 +        -   addition                    [0,0,0,1,1,2]
    Ġ     - group indices of a by value   [[3,4],[1,2]]
   ị      - index into                    [[1,2],[1,2],[1,2],[3,4],[3,4],[1,2]]
        Ṭ - untruth a                     [0,0,0,1,0,1]
       "  - zip with:
     ȧ@   -   and with reversed @rguments [0,0,0,[3,4],0,[1,2]]

JavaScript (ES6), 64 62 byte

Đã lưu 2 byte nhờ @SteveBennett

Có đầu vào 0 chỉ mục. Trả về một danh sách các bộ được phân tách bằng dấu phẩy.

a=>a.map((n,i)=>o[n]=[i,...o[n]||[]],o=[])&&`{${o.join`},{`}}`

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

let f =

a=>a.map((n,i)=>o[n]=[i,...o[n]||[]],o=[])&&`{${o.join`},{`}}`

console.log(f([3]))
console.log(f([0,1,2]))
console.log(f([1,1,1]))
console.log(f([4,4,5,5]))
console.log(f([5,5,4,4]))

Phiên bản thay thế, 53 byte

Nếu một đầu ra đơn giản hóa như '||||3,2|1,0'được chấp nhận, chúng ta có thể làm:

a=>a.map((n,i)=>o[n]=[i,...o[n]||[]],o=[])&&o.join`|`

Bash , 109 byte

Quá tệ, không có giá trị tích hợp cho mảng tối đa.

a=($@)
for((x=m=1;x<=m;x++)){ for((y=0;y<$#;)){((m<a[y]))&&((m=a[y]));((a[y++]==x))&&printf "%d " $y;};echo;}

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

Toán học 62 byte

(Y={}~Table~Max@#;Y[[#[[j]]]]~AppendTo~j~Table~{j,Tr[1^#]};Y)&

Tôi sẽ chạy nó cho bạn

(Y={}~Table~Max@#;Y[[#[[j]]]]~AppendTo~j~Table~{j,Tr[1^#]};Y)&[{4,5,2,3,3,8,6,3}]

{{}, {3}, {4, 5, 8}, {1}, {2}, {7}, {}, {6}}

Dùng thử trực tuyến (chỉ cần dán mã bằng ctrl-v và nhấn shift + enter)
đừng quên dán danh sách đầu vào ở cuối như trong ví dụ trên

Perl 6 ,  36 32  29 byte

->\a{map {a.grep(*==$_):k},1..a.max}

Thử nó

{map {.grep(*==$^a):k},1.. .max}

Thử nó

{map {.grep($^a):k},1.. .max}

Thử nó

Mở rộng:

{  # bare block lambda with implicit parameter ｢$_｣

  map

    {  # bare block lambda with placeholder parameter ｢$a｣

      .grep(  # grep for the values in ｢$_｣
        $^a   # that are equal to the currently tested value (and declare param)
      ) :k    # return the key (index) rather than the value
    },

    1 .. .max # Range from 1 to the maximum value in ｢$_｣

}

Trả về các chỉ mục dựa trên 0, để có được 1 toán tử sử dụng chéo ( X) kết hợp với +op . (33 byte)

{1 X+.grep($^a):k}

Để làm cho nó trở lại Đặt s chỉ cần thêmset vào đó (tổng cộng 37 byte)

{set 1 X+.grep($^a):k}

R, 80 72 byte

1 chỉ mục, lấy Xtừ stdin. Trả về một danh sách các vectơ của các chỉ mục, với NULLtập hợp trống.

X=scan();Y=vector('list',max(X));Y[X]=lapply(X,function(x)which(X==x));Y

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

phiên bản cũ:

X=scan();Y=vector('list',max(X));for(i in 1:length(X))Y[[X[i]]]=c(Y[[X[i]]],i);Y

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

05AB1E , 10 byte

ZFā¹N-ψ}¯

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

Röda , 51 byte

f s{seq(1,max(s))|[[s()|enum|[_2+1]if[_1=i]]]for i}

Đây là một cổng của câu trả lời Python của Uriel .

Một phiên bản khác (88 byte):

f a{I=indexOf;seq(1,max(a))|{|i|b=a[:]c=[]x=1{c+=x+I(i,b)b-=i;x++}until[I(i,b)<0];[c]}_}

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

Cả 1 chỉ số.

PowerShell, 81 byte

$args[0]|%{if($_-gt($c=$r.count)){$r+=@($t)*($_-$c)}$r[--$_]+=,++$i};$r|%{"{$_}"}

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

1 chỉ mục.

GNU Make , 214 213 208 204 byte

X=$(MAKECMDGOALS)
M=0
P=$(eval N=$(word $1,$X))$(if $N,$(if $(shell dc -e$Nd$Mds.\>.p),$(eval M=$N),)$(eval A$N+=$1$(call $0,$(shell expr $1 + 1))),)
$(call P,1)$(foreach K,$(shell seq $M),$(info $(A$K)))

I / O: mảng đầu vào thông qua các đối số, đầu ra đến thiết bị xuất chuẩn, một trên mỗi dòng, được phân tách bằng dấu cách.

$ make -f swap.mk 2 2 2

3 2 1
make: *** No rule to make target `2'.  Stop.

Giải trình

X=$(MAKECMDGOALS)     # Input array
M=0                   # Max value encountered in X
P=$(eval
    N=$(word $1,$X))  # Get next word from X
  $(if $N,$(if $(shell dc -e$Nd$Mds.\>.p),
    $(eval M=$N),)    # Update M
    $(eval A$N+=$1    # Append index to a variable named after value
      $(call $0,      # Recurse (call returns empty string)
        $(shell expr $1 + 1))),)
$(call P,1)           # Initial call to P. 1 is the first index
$(foreach K,          # Print all values of A* variables
  $(shell seq $M),
  $(info $(A$K)))     # Uninitialized ones default to empty strings

Thứ tự của các chỉ số trong các bộ được đảo ngược vì Pchính nó gọi đệ quy trước khi cập nhật A$2(cuộc gọi được thực hiện trong đánh giá của phía bên tay phải).

Lisp thông thường, 91 byte

(lambda(x &aux(l(make-list(eval`(max,@x))))(i 0))(dolist(y x l)(push(incf i)(nth(1- y)l))))

Lập chỉ mục dựa trên 1, trả về các bộ dưới dạng danh sách.

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

k , 13 byte

{(=x)@!1+|/x}

Đây là 0 chỉ mục.

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

{           } /function(x)
 (=x)         /make a map/dictionary of values to their indices
         |/x  /get maximum value in x
      !1+     /make a range from 0 to the value, inclusive
     @        /get map value at each of the values in the range
              /    0N is given where there is no result