सूचकांकों और मूल्यों को स्वैप करें

Question

काम

एक कार्यक्रम या समारोह जिसका इनपुट एक सूची / सरणी है लिखें एक्स पूर्णांकों का, और जिसका उत्पादन पूर्णांकों का सेट की एक सूची है Y , ऐसी है कि प्रत्येक तत्व के लिए ई प्रत्येक सेट में वाई [ मैं ], एक्स [ ई ] = मैं , और ऐसा है कि वाई में सेट में तत्वों की कुल संख्या एक्स में तत्वों की संख्या के बराबर है ।

(यह मूल रूप से हैशटेबल / शब्दकोश को उलटने जैसा ही ऑपरेशन है, इसके बजाय सरणियों पर लागू किया गया है।)

उदाहरण

ये उदाहरण 1-आधारित अनुक्रमण को मानते हैं, लेकिन यदि आप चाहें तो आप 0-आधारित अनुक्रमणिका का उपयोग कर सकते हैं।

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

स्पष्टीकरण

• यदि आप चाहें तो आप एक सूची के रूप में एक सेट का प्रतिनिधित्व कर सकते हैं। यदि आप ऐसा करते हैं, तो इसके तत्वों का क्रम मायने नहीं रखता है, लेकिन आप तत्वों को नहीं दोहरा सकते हैं।
• आप किसी भी उचित अस्पष्ट I / O प्रारूप का उपयोग कर सकते हैं; उदाहरण के लिए, आप रिक्त स्थान के साथ एक सेट के तत्वों को अलग कर सकते हैं, और खुद को newlines के साथ सेट कर सकते हैं।
• Y अंतिम रूप से लंबा होना चाहिए, और एक्स इंडेक्स के सभी तत्वों को कम से कम लंबे समय तक रखना चाहिए । हालांकि, यह एक्स के अधिकतम तत्व से अधिक हो सकता है (अतिरिक्त तत्व खाली सेट होंगे)।
• यदि आप 1-आधारित अनुक्रमणिका का उपयोग करते हैं या यदि आप 1-आधारित अनुक्रमणिका का उपयोग करते हैं, तो X के तत्व सभी मान्य सरणी सूचक, यानी गैर-नकारात्मक पूर्णांक होंगे।

विजय की स्थिति

एक के रूप में कोड गोल्फ चुनौती, छोटे बेहतर है।

Comments

संबंधित । में सैंडबॉक्स पोस्ट (अब नष्ट कर दिया है, लेकिन आप इसे देख सकते हैं अगर आप प्रतिष्ठा है), हम फैसला किया कि यह शायद एक नकली नहीं था, लेकिन करीब वोट करने के लिए अगर आप असहमत संकोच न करें।

क्या "इसके तत्वों का क्रम मायने नहीं रखता है" का मतलब है कि के आउटपुट [5,5,6,6]और [6,6,5,5]समान हो सकते हैं?

— लीक नून

@LeakyNun आउटपुट सूची में सेट के तत्वों का क्रम मायने नहीं रखता। इसलिए [5,5,6,6]और [6,6,5,5]समान आउटपुट नहीं हो सकता है, लेकिन इसके लिए आउटपुट [5,5,6,6]भी हो सकता है, जैसे, उदा [{},{},{},{},{2,1},{4,3}]।

— ngenisis

क्या X में एक सूचकांक का एक अधिकतम मूल्य है? इसके अलावा खाली सेट वास्तव में खाली होने के बजाय उनमें 0 है? उदाहरण के लिए [{0},{0},{0},{0},{1,2},{3,4}]मान्य आउटपुट होगा [5,5,6,6]?

— स्काइड्सदेव

@ माय्यूब: पहले उत्तर के लिए नहीं (हालाँकि यदि आप किसी ऐसी भाषा का उपयोग कर रहे हैं जिसमें पूर्णांक पर सीमित सीमा है, तो आप प्रोग्राम को ऐसे लिख सकते हैं जैसे कि पूर्णांक अनबाउंड रूप से बड़ा हो सकता है, और इसे तोड़ने की चिंता न करें यदि कोई आपको आउट देता है- इनपुट के रूप में रेंज पूर्णांक)। दूसरे प्रश्न के संबंध में, यह 1-आधारित अनुक्रमणिका का उपयोग करते समय एक अस्पष्ट (यदि अजीब) वाक्यविन्यास है, तो उस स्थिति में हाँ (जाहिर है, यदि आप 0-आधारित अनुक्रमणिका का उपयोग नहीं कर रहे हैं क्योंकि तब 0 का अर्थ होगा कुछ और।)

Answer 1

MATL , 8 बाइट्स

tn:IXQ&D

इनपुट एक कॉलम वेक्टर है, जिसमें ;विभाजक (उदाहरण के लिए [2;2;2]) है। आउटपुट पंक्ति वैक्टर के सेल सरणी (उदाहरण के लिए {[]; [1 2 3]}) का स्ट्रिंग प्रतिनिधित्व है । एकल तत्व की एक पंक्ति वेक्टर एक संख्या के समान होती है (इसलिए {1; 2; 3}इसके बजाय आउटपुट होगा {[1]; [2]; [3]})।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

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

अधिकांश कार्य मैटलैब के उच्च-क्रम फ़ंक्शन द्वारा किया जाता है accumarray, जो पहले में मिलान मूल्यों के अनुसार दूसरे इनपुट में तत्वों को समूह करता है, और प्रत्येक समूह को एक निर्दिष्ट फ़ंक्शन लागू करता है। इस मामले में फ़ंक्शन है @(x){sort(x).'}, जो प्रत्येक समूह में छंटनी किए गए तत्वों को आउटपुट करता है और सभी समूहों के परिणाम को सेल सरणी में पैक करने का कारण बनता है।

Answer 2

पायथन, 69 बाइट्स

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

0-आधारित अनुक्रमण का उपयोग करता है।

Answer 3

जेली , 7 5 बाइट्स

=þṀT€

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Answer 4

जेली , 8 बाइट्स

Jẋ"Ṭ€;"/

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Answer 5

गणितज्ञ, 36 बाइट्स

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

व्याख्या

प्रत्येक के लिए nमें {1, 2, ..., Max@#}है, जहां Max@#इनपुट सूची में सबसे बड़ा पूर्णांक है, गणना करता Positionरों जहां nइनपुट सूची में दिखाई देता #। चूंकि Position[{6,6,5,5},5](उदाहरण के लिए) वापस आता है {{3},{4}}, हम तब परिणाम के Apply Joinस्तर पर सभी तत्वों {1}के लिए।

Answer 6

हास्केल , 45 बाइट्स

sपूर्णांकों की एक सूची लेता है और सूचियों की एक सूची देता है। 1-अनुक्रमित परीक्षण मामले के आदान-प्रदान को अनमॉडिफ़ाइड रखने के लिए (हालाँकि आउटपुट को कुछ अतिरिक्त खाली सूची मिलती है)।

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

इसे ऑनलाइन आज़माएं!

ये बहुत सीधी नेस्टेड सूची की समझ हैं। केवल मामूली ट्वीक के sumबजाय का उपयोग करके एक लंबी सूची बनाने के विकल्प का लाभ ले रहा है maximum।

Answer 7

PHP, 55 बाइट्स

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

0 अनुक्रमित।

Answer 8

आर, 68 49 47 बाइट्स

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

हैरानी की बात है, लंबे समाधान की तुलना में बहुत अधिक सीधा। एक वेक्टर ले जाता है x, stdin से से एक सदिश बनाता 1करने के लिए max(x), परोक्ष लंबाई की एक सूची बनाता max(x)है, और चेक जो सूचकांक xनई सूची में उन लोगों के साथ अनुरूप हैं। अनुमानित रूप से आउटपुट प्रिंट करता है।

पुराना संस्करण:

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

अन्य आर उत्तर के लिए थोड़ा अलग दृष्टिकोण। एक वेक्टर को STDIN में ले जाता है, इनपुट में अधिकतम मान के बराबर लंबाई के साथ एक सूची बनाता है। इनपुट पर लूप्स और इंडेक्स को सही जगह जोड़ता है।

1-आधारित अनुक्रमण का उपयोग करता है।

Answer 9

पायथन 2 , 91 86 85 बाइट्स

मैं अपने फोन पर प्रोग्रामिंग कर रहा हूं लेकिन मुझे वास्तव में यह चुनौती पसंद आई। मैं निश्चित रूप से इसे और अधिक गोल्फ कर सकता हूं।

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

इसे ऑनलाइन आज़माएं!

Comments

एक नेस्टेड सूची समझ से फिर से बाहर निकाला गया। : डी

— बमुश्किल

Answer 10

जेली , 9 बाइट्स

Ṭ+\ịĠȧ@"Ṭ

1-अनुक्रमित, खाली सेट के रूप में प्रतिनिधित्व किया 0, एक आइटम के Nसेट के रूप में प्रतिनिधित्व कई मदों के सेट के रूप में प्रतिनिधित्व किया[M,N,...]

इसे ऑनलाइन आज़माएं!

कैसे?

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

Answer 11

जावास्क्रिप्ट (ईएस 6), 64 62 बाइट्स

सहेजे गए 2 बाइट @SteveBennett की बदौलत

---

0-अनुक्रमित इनपुट लेता है। सेट की अल्पविराम से अलग सूची देता है।

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

परीक्षण के मामलों

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

---

वैकल्पिक संस्करण, 53 बाइट्स

अगर एक सरलीकृत उत्पादन जैसे '||||3,2|1,0'स्वीकार्य है, हम बस कर सकते हैं:

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

Comments

वाह। मैं बहुत उलझन में हूँ कि `{${o.join`},{`}}`कानूनी ES2015 कैसा है।

— स्टीव बेनेट

@SteveBennett, यह एक टेम्पलेट शाब्दिक है । जेएस के पुराने संस्करणों में यह होगा "{" + o.join("},{") + "}", अगर यह किसी भी स्पष्ट करता है।

— झबरा

नहीं, मैं उन लोगों के बारे में जानता हूं - यह शब्द जुड़ने के बाद का बैकक्वॉट है जो मुझे भ्रमित करता है। क्या वह स्ट्रिंग बंद कर रहा है (किस स्थिति में wtf) या यह कि आप एक करीबी ब्रेस से कैसे बच सकते हैं?

— स्टीव बेनेट

हम्म, ठीक है, इसलिए इस संदर्भ join`में इसके बराबर है join('। नहीं पता था कि आप ऐसा कर सकते हैं।

— स्टीव बेनेट

आह, अब मैं देख रहा हूं। यह एक टैगेड टेम्प्लेट शाब्दिक है। जब आप किसी फ़ंक्शन को कॉल करने के लिए दुरुपयोग कर सकते हैं जब भी कोई फ़ंक्शन एक स्ट्रिंग तर्क लेता है (और दूसरों की उपेक्षा करता है) array.join` `:। यहाँ सुपर भ्रामक क्योंकि आप एक टेम्पलेट स्ट्रिंग के भीतर एम्बेड कर रहे हैं, और इससे भी अधिक भ्रामक रूप से, जुड़ने वाला स्ट्रिंग है },{, जो संयोग से टेम्पलेट स्ट्रिंग के भाग की तरह दिखता है ... और वैसे भी अजीब और बदसूरत है। :)

— स्टीव बेनेट

Answer 12

बैश , 109 बाइट्स

बहुत बुरा है, कोई अधिकतम सरणी के लिए अंतर्निहित नहीं है।

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

इसे ऑनलाइन आज़माएं!

Answer 13

गणितज्ञ 62 बाइट्स

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

मैं इसे आपके लिए चलाऊंगा

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

इसे ऑनलाइन आज़माएं (बस ctrl-v और प्रेस शिफ्ट + एंटर के साथ कोड पेस्ट करें)
इनपुट सूची को अंत में ऊपर दिए गए उदाहरण की तरह चिपकाना न भूलें

Comments

PPCG में आपका स्वागत है! आप के लिए infix संकेतन का उपयोग करके एक बाइट बचा सकते हैं AppendTo। इसके अलावा, {j,1,Length[#1]}बस हो सकता है {j,Length@#}, या उससे भी कम {j,Tr[1^#]},। उपयोग करने के लिए एक बाइट को बचाने के लिए Tr[1^#]एक बहुत ही सामान्य चाल है Length।

— ngenisis

Answer 14

पर्ल 6 ,  36 32  29 बाइट्स

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

कोशिश करो

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

कोशिश करो

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

कोशिश करो

---

विस्तारित:

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

}

---

शून्य आधारित अनुक्रमितों को लौटाता है, 1 आधारित उपयोग क्रॉस ऑपरेटर ( X) को +op के साथ संयुक्त करने के लिए । (33 बाइट्स)

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

इसे वापस लाने के लिए सेट सेट को बस वहां जोड़ेंset (कुल 37 बाइट्स)

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

Answer 15

आर, 80 72 बाइट्स

1-अनुक्रमित, Xस्टड से लेता है। NULLखाली सेट के साथ सूचकांकों के वैक्टर की सूची लौटाता है ।

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

इसे ऑनलाइन आज़माएं!

पुराना संस्करण:

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

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि यह ठीक Y=list();काम करता है

— rturnbull

fewमेरे जवाब में बाइट्स दाढ़ी बनाने का प्रबंधन :) codegolf.stackexchange.com/a/120024/59530

— JAD

Answer 16

05AB1E , 10 बाइट्स

ZFā¹N-ψ}¯

इसे ऑनलाइन आज़माएं!

Answer 17

रोड़ा , 51 बाइट्स

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

यह यूरिल द्वारा पायथन उत्तर का एक बंदरगाह है ।

एक और संस्करण (88 बाइट्स):

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

इसे ऑनलाइन आज़माएं!

दोनों 1-अनुक्रमित।

Answer 18

पॉवरशेल, 81 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित।

Answer 19

जीएनयू मेक , 214 213 208 204 बाइट्स

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: तर्कों के माध्यम से इनपुट सरणी, स्टैडआउट के लिए आउटपुट, प्रति पंक्ति, रिक्त स्थान से अलग।

$ make -f swap.mk 2 2 2

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

व्याख्या

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

सेटों में सूचकांकों का क्रम उलटा है क्योंकि Pअपडेट करने से पहले खुद को पुनरावर्ती कॉल करता है A$2(राइट-हैंड साइड के मूल्यांकन में निष्पादित कॉल)।

Comments

क्या makeखुद को अंकगणित करने का कोई तरीका है? इसे करने के लिए बाहरी कार्यक्रमों में कॉल करना थोड़ा धोखा देने जैसा लगता है, क्योंकि आप शायद उन कार्यक्रमों में बहुत अधिक एल्गोरिथ्म डाल सकते हैं और एक छोटे कार्यक्रम के साथ समाप्त हो सकते हैं।

@ ais523 यह नहीं है। पिछले संस्करण का इस्तेमाल किया bcऔर grep। मैं भी इस्तेमाल कर सकते हैं testऔर $?। dcएक terser वाक्यविन्यास है, लेकिन स्पष्ट रूप से इन सभी को समान लगता है।

— eush77

Answer 20

आम लिस्प, 91 बाइट्स

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

1-आधारित अनुक्रमण, सूची के रूप में सेट लौटाता है।

इसे ऑनलाइन आज़माएं!

Answer 21

k , 13 बाइट्स

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

यह 0-अनुक्रमित है।

इसे ऑनलाइन आज़माएं!

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