Görev

, Girişi bir liste / dizisi olan bir program ya da işlev Yazın X, çıkış tamsayılar ve tam sayıların setlerinin bir listesi , Y , örneğin, her bir eleman için , e her bir set , Y [ I ], X, [ E ] = I , ve bu setler toplam eleman sayısı o Y eleman sayısına eşit X .

(Bu, temelde dizilere uygulanması dışında bir karmaşanın / sözlüğün tersine çevrilmesiyle aynı işlemdir.)

Örnekler

Bu örnekler 1 tabanlı dizinlemeyi varsaymaktadır, ancak tercih ederseniz bunun yerine 0 tabanlı dizinlemeyi kullanabilirsiniz.

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

Açıklamalar

• İsterseniz bir seti bir liste olarak temsil edebilirsiniz. Bunu yaparsanız, elemanlarının sırası önemli değildir, ancak elemanları tekrar etmeyebilirsiniz.
• Herhangi bir makul belirgin G / Ç formatı kullanabilirsiniz; örneğin, bir kümenin öğelerini boşluklarla ve kümelerin kendilerini yeni çizgilerle ayırabilirsiniz.
• Y , son derece uzun ve en azından X'in tüm öğelerini dizi dizinleri olarak alacak kadar uzun olmalıdır . Bununla birlikte, X'in maksimum elemanından daha uzun olabilir (ekstra elemanlar boş kümeler olur).
• X öğelerinin tümü geçerli dizi indisleri, yani 0 tabanlı indeksleme kullanıyorsanız negatif tamsayılar veya 1 tabanlı indeksleme kullanıyorsanız pozitif tamsayılar olacaktır.

Zafer durumu

Bir As kod golf meydan, kısa olması daha iyidir.

MATL , 8 bayt

tn:IXQ&D

Giriş, ;ayırıcı olarak bir sütun vektörüdür (örneğin [2;2;2]). Çıktı, satır vektörlerinin (örneğin {[]; [1 2 3]}) bir hücre dizisinin dize gösterimidir . Tek bir elemanın satır vektörü sayı ile aynıdır ( {1; 2; 3}bunun yerine çıkış olacaktır {[1]; [2]; [3]}).

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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

Çalışmanın çoğu, Matlab'ın accumarrayikinci girişteki elemanları ilk önce eşleşen değerlere göre gruplayan ve her gruba belirli bir işlevi uygulayan üst düzey işlevi tarafından yapılır . Bu durumda, @(x){sort(x).'}her gruptaki sıralı elemanları çıkaran ve tüm grupların sonuçlarının bir hücre dizisine paketlenmesine neden olan fonksiyondur.

Python, 69 bayt

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

0 tabanlı endeksleme kullanır.

Jöle , 7 5 bayt

=þṀT€

Çevrimiçi deneyin!

Nasıl çalışır

=þṀ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.

Jöle , 8 bayt

Jẋ"Ṭ€;"/

Çevrimiçi deneyin!

Nasıl çalışır

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

Mathematica, 36 bayt

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

açıklama

Her biri için nin {1, 2, ..., Max@#}, Max@#giriş listesindeki en büyük tamsayıdır, hesaplar Positions nereye ngirdi listesinde görünür #. Yana Position[{6,6,5,5},5](örneğin) dönüşleri {{3},{4}}, o zaman Apply Joinseviyede tüm elemanlara {1}sonucu.

Haskell , 45 bayt

stamsayıların listesini alır ve listelerin listesini döndürür. Test senaryosu girişlerini değiştirilmemiş halde tutmak için 1 indeksli (çıkış ekstra boş listeler alsa da).

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

Çevrimiçi deneyin!

Bunlar oldukça basit iç içe liste kavramalardır. Sadece hafif çimdik sumyerine kullanarak daha uzun bir liste yapma seçeneğinden yararlanıyor maximum.

PHP, 55 bayt

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

0 endeksli.

R, 68 49 47 bayt

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

Şaşırtıcı bir şekilde, uzun çözümlerden çok daha kolay. Bir vektör Alır x, STDIN'den bir vektör oluşturur 1için max(x)örtülü uzunlukta bir listesini oluşturur,max(x) hangi endekslerini ve çekler xyeni listede olanlarla tekabül. Örtük çıktılar yazdırır.

Eski versiyon:

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

Diğer R cevabına biraz farklı yaklaşım. STDIN'e bir vektör alır, girişteki maksimum değere eşit uzunlukta bir liste oluşturur. Girdi üzerinde dolaşır ve dizini doğru yere ekler.

1 tabanlı indeksleme kullanır.

Python 2 , 91 86 85 bayt

Telefonumda programlama yapıyorum ancak bu zorluğu gerçekten sevdim. Kesinlikle bundan daha fazla golf oynayabilirim.

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

Çevrimiçi deneyin!

Jöle , 9 bayt

Ṭ+\ịĠȧ@"Ṭ

1-indeksli, boş kümeler olarak temsil edildi 0, bir öğenin Nkümeleri olarak temsil edildi;[M,N,...]

Çevrimiçi deneyin!

Nasıl?

Ṭ+\ịĠȧ@"Ṭ - 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 bayt

@SteveBennett sayesinde 2 bayt kaydedildi

0 indeksli giriş alır. Virgülle ayrılmış bir takım listesi döndürür.

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

Test durumları

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

Alternatif sürüm, 53 bayt

Böyle bir basitleştirilmiş çıktı '||||3,2|1,0'kabul edilebilir ise, biz sadece yapabiliriz:

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

Bash , 109 bayt

Çok kötü dizi maksimum değer için yerleşik bir yoktur.

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

Çevrimiçi deneyin!

Mathematica 62 bayt

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

Senin için koşacağım

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

Çevrimiçi deneyin (yalnızca kodu ctrl-v ile yapıştırın ve shift + enter tuşuna basın)
giriş listesini yukarıdaki örnekteki gibi yapıştırmayı unutmayın

Perl 6 ,  36 32  29 bayt

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

Dene

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

Dene

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

Dene

Expanded:

{  # 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 ｢$_｣

}

Op ile birleştirilmiş 1 tabanlı kullanım çapraz operatörünü ( X)+ almak için sıfır tabanlı dizinleri döndürür . (33 bayt)

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

Döndürmek için Set s komutunu buraya ekleyinset (toplam 37 bayt)

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

R, 80 72 bayt

1 indeksli, Xstdin'den alır . NULLBoş küme olarak, dizinlerin vektörlerinin bir listesini döndürür .

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

Çevrimiçi deneyin!

eski versiyon:

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

Çevrimiçi deneyin!

05AB1E , 10 bayt

ZFā¹N-ψ}¯

Çevrimiçi deneyin!

Röda , 51 bayt

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

Uriel'in Python cevabının limanı .

Başka bir sürüm (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]}_}

Çevrimiçi deneyin!

Her ikisi de 1 indeksli.

PowerShell, 81 bayt

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

Çevrimiçi deneyin!

1 endeksli.

GNU Make , 214 213 208 204 bayt

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

G / Ç: bağımsız değişkenler yoluyla girdi dizisi, çıktı stdout, satır başına bir, boşluklarla ayrılmış.

$ make -f swap.mk 2 2 2

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

açıklama

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

Kümelerdeki endekslerin sırası ters çevrilmiştir çünkü Pgüncelleme yapmadan önce kendisini tekrar tekrar A$2çağırır (çağrı sağ tarafın değerlendirmesinde yapılır).

Ortak Lisp, 91 bayt

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

1 tabanlı indeksleme, setleri liste halinde döndürür.

Çevrimiçi deneyin!

k , 13 bayt

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

Bu 0 indeksli.

Çevrimiçi deneyin!

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