14

आपकी चुनौती आज एक कार्यक्रम या समारोह लिखना है जो एक सूची लेता है lऔर उन पदों को देता है lजिनमें lक्रमबद्ध रूप से प्रत्येक क्रमिक तत्व दिखाई देता है।

दूसरे शब्दों में, सबसे छोटे मूल्य के सूचकांक का उत्पादन करते हैं, इसके बाद दूसरे सबसे छोटे मूल्य के सूचकांक का, आदि।

आप मान सकते हैं कि इनपुट सरणी में केवल धनात्मक पूर्णांक होंगे, और इसमें कम से कम एक तत्व होगा।

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

Input                  | Output (1-indexed)
[7, 4, 5]              | [2, 3, 1]
[1, 2, 3]              | [1, 2, 3]
[2, 6, 1, 9, 1, 2, 3]  | [3, 5, 1, 6, 7, 2, 4]
[4]                    | [1]

जब समान मूल्य वाले दो या अधिक तत्व दिखाई देते हैं, तो उनके सूचक एक दूसरे से छोटे से लेकर सबसे बड़े तक दिखाई देते हैं।

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है!

code-golf array-manipulation

— पावेल
स्रोत

16

-1 एक तुच्छ चुनौती के लिए जिसे आम गोल्फ भाषाओं में बिल्ट-इन के साथ हल किया जा सकता है, और 24 घंटे से कम समय में जवाब स्वीकार करने के लिए। यह न तो एक उचित चुनौती थी, न ही एक दिलचस्प।

— कोडी ग्रे

3

खैर, मुझे लगता है कि उसने 24 घंटे के भीतर जवाब क्यों स्वीकार कर लिया, इसे हरा पाना असंभव है।

— जकार्इ

3

जब मैंने 1-2 बाइट्स का उत्तर देखा, तो @CodyGray ने मुझे नीचा दिखाया, लेकिन वास्तव में, मुझे नहीं लगता कि यह अधिक मानक प्रोग्रामिंग भाषाओं के लिए एक बुरी चुनौती है। बेशक, यह एक कठिन चुनौती नहीं है , लेकिन फिर भी, निश्चित रूप से कुछ गोल्फ की संभावनाएं हैं। बेशक, यह 1-बाइट बिल्ट-इन को देखने के लिए अप्रिय है, लेकिन मुझे नहीं लगता कि इसके लिए चुनौती को दोष देना उचित है।

— दादा

1

1 वर्ण निर्मित का उपयोग करना शायद ही अभ्यास है। केवल जरूरी नहीं कि आसान का मतलब केवल बिल्डिंस का उपयोग करना है।

— JAD

2

ऐसे मामलों में सबसे अच्छा समाधान यह है कि आप टी फ़ीचर सुविधा के बारे में भूल जाएं, जो वास्तव में वैसे भी प्रासंगिक नहीं है।

— मिस्टर एक्सकोडर

9

जेली , 1 बाइट

Ụ

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

— डेनिस
स्रोत

हेह जो बहुत स्पष्ट था ...

— एरिक द आउटग्राफर जूल

2

APL ने आपकी गति के लिए इसे +1 का हकदार बनाया।

— जकार्इ

@ Zacharý मुझे यकीन है कि जेली ने इसे जे से उठाया था, जो बदले में इसे एपीएल से विरासत में मिला था।

— 12

11

दिल्लोग एपीएल, 1 बाइट

⍋

Dyalog APL ने इसे करने के लिए एक बिल्ट इन ~~ऑपरेटर~~ फंक्शन (शुक्रिया ज़ाचारि को धन्यवाद) दिया है।

उदाहरण

⍋11 2 4 15
    2 3 1 4  
{⍵[⍋⍵]}11 4 2 15
    2 4 11 15

यहाँ मैं सूची में अनुक्रमित सूचकांकों द्वारा सूची को आरोही क्रम में वापस करने के लिए सूचीबद्ध कर रहा हूँ।

— जेम्स हेस्लिप
स्रोत

ओह, बस आपको कुछ भ्रामक शब्दावली के प्रति सचेत करने के लिए, एपीएल में, बिल्डिंस जैसे ⍋कार्यों को माना जाता है, जबकि चीजें जैसे ¨⍨⍣.∘/\⌿⍀⌸⍤ऑपरेटर हैं।

— ज़ाचरी जूल

9

हास्केल , 43 42 बाइट्स

1-indexed:

import Data.List
map snd.sort.(`zip`[1..])

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

-1 @ janrjanJohansen को धन्यवाद!

— ბიმო
स्रोत

2

पॉइंटफ्री संस्करण एक बाइट बचाता है map snd.sort.(`zip`[1..]):।

— अर्जन जोहान्सन

9

पायथन 2 , 56 बाइट्स

यह समाधान 0-अनुक्रमित है। यह इस तथ्य का दुरुपयोग करता है जो sorted()मूल सूची की एक प्रति बनाता है।

l=input()
for k in sorted(l):a=l.index(k);print a;l[a]=0

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

— मिस्टर एक्सकोडर
स्रोत

आपने यह क्यों अनसुना किया?

— आउटगोल्फ जूल

@EriktheOutgolfer फिक्स्ड, रोलबैक।

— श्री एक्सकोडर

9

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

-2 बाइट्स @ पावेल्स के लिए धन्यवाद

यह केवल उन ब्राउज़रों में काम करता है जहां Array.prototype.sortस्थिर है।

a=>[...a.keys()].sort((b,c)=>a[b]-a[c])

1-अनुक्रमित संस्करण (47 बाइट्स):

a=>a.map((_,i)=>i+1).sort((b,c)=>a[b-1]-a[c-1])

उदाहरण कोड स्निपेट:

f=
a=>[...a.keys()].sort((b,c)=>a[b]-a[c])
console.log("7,4,5 => "+f([7,4,5]))
console.log("1,2,3 => "+f([1,2,3]))
console.log("2,6,1,9,1,2,3 => "+f([2,6,1,9,1,2,3]))
console.log("4 -> "+f([4]))

स्निपेट का विस्तार करें

— हरमन एल
स्रोत

[...a.keys()]इसके बजाय a.map((_,i)=>i)आप बाइट्स के एक जोड़े को बचाएगा।

— पावेल्स

7

पायथन 2 , 48 बाइट्स

lambda x:sorted(range(len(x)),key=x.__getitem__)

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

— आउटगोल्फ को एरिक करें
स्रोत

अच्छा लगा, मैं आउट हो गया> _ <। मैंने पायथन 3 को अपना उत्तर इस तरह दिया कि मुझे यह बुरा नहीं लगता

— श्री एक्सकोडर

4

@ Mr.Xcoder खैर, यह उनका काम है ...

— नील

@ Mr.Xcoder आओ, तुम उसके लिए बुरा महसूस नहीं करना चाहिए! आपने एक पूर्ण कार्यक्रम बनाया, मैंने एक समारोह बनाया, और मेरा दृष्टिकोण थोड़ा अलग है।

— एर्ग आउटफोलर जूल

मुझे बुरा नहीं लगता, मुझे पता था कि यह दिखाई देगा (मुझे व्यक्तिगत रूप से __<blahblah>__वाक्य रचना से नफरत है )। मैं कुछ जेली करूँगा, मैं अपना प्रशिक्षण नहीं खोना चाहता हूँ :)

— श्री एक्सकोडर

1

@ Mr.Xcoder कोडगॉल्फ का मतलब सुंदर वाक्य रचना और प्रारूपण नहीं है। ;)

— एरिक आउटगोल्फ जूल

5

पर्ल 6 , 27 21 बाइट्स

*.pairs.sort(*.value)».key

झसे आज़माओ

->\x{sort {x[$_]},^x}

झसे आज़माओ

पायथन जवाब से प्रेरित है

विस्तारित:

->    # pointy block lambda
  \x  # declare sigilless parameter
{
  sort
    { x[$_] },  # sort by the value in ｢x｣ at the given position
    ^x          # Range up-to the number of elements in ｢x｣
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

5

बैश + कोरुटिल्स, 20

nl|sort -nk2|cut -f1

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

— डिजिटल आघात
स्रोत

4

स्विफ्ट 4 , 82 बाइट्स

func f(l:[Int]){var l=l;for k in l.sorted(){let a=l.index(of:k)!;print(a);l[a]=0}}

परीक्षण सूट।

व्याख्या

स्विफ्ट में, l.sorted()मूल ऐरे की एक सॉर्ट की गई कॉपी बनाता है। हम सूची में क्रमबद्ध तत्वों के माध्यम से लूप करते हैं और मूल ऐरे में प्रत्येक आइटम के इंडेक्स को प्रिंट करने के बाद let a=l.index(of:k)!;print(a), और फिर, एरे में सही इंडेक्स रखने के लिए, हम असाइन l[a]करते हैं 0, क्योंकि यह हमारे सामान्य आउटपुट को प्रभावित नहीं करता है।

ध्यान दें कि यह 0-अनुक्रमित है, क्योंकि यह मेरे पायथन समाधान का एक बंदरगाह है। आप इसे 1-सूचीबद्ध होना चाहते हैं, की जगह print(a)के साथ print(a+1)या यह ऑनलाइन कोशिश करो! ।

— मिस्टर एक्सकोडर
स्रोत

4

आर , 5 बाइट्स

इसके लिए बिल्टइन फंक्शन है।

order

— djhurio
स्रोत

3

मानक नियम फ़ंक्शन का एक कार्यक्रम प्रदान करना है। orderपहले से ही एक फ़ंक्शन है, इसलिए आपको इनपुट का उपयोग करने की आवश्यकता नहीं है scan()। यह 5 बाइट्स होगा।

— JAD

rank()एक बाइट बचा सकता है

— gstats

1

मुझे यकीन है कि rank@JarkoDubbeldam द्वारा एक उत्तर था , लेकिन मैं इसे अब नहीं देखता।

— djhurio 16

1

सही है, यह कल्पना का पालन नहीं करता है इसलिए मैंने इसे हटा दिया।

— JAD

4

रूबी , 40 बाइट्स

->a{a.zip([*1..a.size]).sort.map &:last}

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

— जीबी
स्रोत

3

MATL , 2 बाइट्स

&S

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

इनपुट और आउटपुट निहित हैं।

— Sanchises
स्रोत

3

जे , 2 बाइट्स

/:

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

शून्य-आधारित अनुक्रमण।

— Tikkanz
स्रोत

इस पोस्ट करने जा रहा था ...

— Cyoce

3

ऑक्टेव , 17 बाइट्स

@(i)[~,y]=sort(i)

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

ऑक्टेव MATLAB की तरह है, लेकिन इनलाइन असाइनमेंट के साथ, उन चीजों को संभव बनाता है जो लोगों को Mathworks HQ सिरदर्द में देता है। इससे कोई फर्क नहीं पड़ता कि आप क्या कहते हैं y, लेकिन आप उस डमी वैरिएबल के बिना नहीं कर सकते, जहां तक मुझे पता है।

— Sanchises
स्रोत

3

MY , 3 बाइट्स

MY के पास इसके लिए एक बेसिन भी है!

⎕⍋↵

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

कैसे?

अनुमानित इनपुट, ग्रेड अप, फिर एक नई रेखा के साथ आउटपुट।

अनुक्रमित हालांकि आप ⌶/ के साथ सूचकांक निर्धारित करते हैं 0x48। (जैसे कुछ अजीब पूर्णांक भी हो सकते हैं -1या 2, डिफ़ॉल्ट है 1)।

— जाकारी
स्रोत

3

जावा 8, 128 + 19 = 147 बाइट्स

श्री Xcoder के समाधान पर आधारित है । 0-आधारित। लैम्ब्डा एक Integer[]और रिटर्न के रूप में इनपुट लेता है Integer[]। बाइट काउंट में लंबोदर अभिव्यक्ति और आवश्यक आयात शामिल हैं।

import java.util.*;

l->{Integer o[]=l.clone(),s[]=l.clone(),i=0;for(Arrays.sort(s);i<l.length;)l[o[i]=Arrays.asList(l).indexOf(s[i++])]=0;return o;}

यह ऑनलाइन की कोशिश करो

अघोषित लंबोदर

l -> {
    Integer
        o[] = l.clone(),
        s[] = l.clone(),
        i = 0
    ;
    for (Arrays.sort(s); i < l.length; )
        l[o[i] = Arrays.asList(l).indexOf(s[i++])] = 0;
    return o;
}

मैं उपयोग Integer[]करने की int[]अनुमति देने के बजाय उपयोग करता हूं Arrays.asList, जिसका कोई आदिम संस्करण नहीं है। Integerकरने के लिए पसंद किया जाता है Longक्योंकि मूल्यों सरणी सूचकांक के रूप में उपयोग किया जाता है और कास्टिंग की आवश्यकता होगी।

यह Listवर्ग और विधि के नाम की लागत के कारण मेरे सबसे अच्छे प्रक्रिया-शैली समाधान से छोटा हो गया ।

इसने एक ऐसे समाधान को भी हराया, जिसमें मैंने कोशिश की थी कि इनपुट्स को स्ट्रीम किया जाए, (वैल्यू, इंडेक्स) जोड़ियों को मैप किया जाए, वैल्यूज़ पर सॉर्ट किया जाए, और इंडेक्स को मैप किया जाए, क्योंकि ज्यादातर सामान स्ट्रीम को इकट्ठा करने के लिए आवश्यक थे।

स्वीकृतियाँ

-5 बाइट्स नेवे के लिए धन्यवाद

— जेकब
स्रोत

1

आपको जरूरत नहीं है j:

l->{Integer o[]=l.clone(),s[]=l.clone(),i=0;for(Arrays.sort(s);i<l.length;l[o[i]=Arrays.asList(l).indexOf(s[i++])]=0);return o;}

(19 + 128 बाइट्स)।

— नेवई

2

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

(lambda(l)(loop as i in(sort(copy-seq l)'<)do(setf(elt l(print(position i l)))0)))

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

— रेंज़ो
स्रोत

2

क्लोजर, 39 बाइट्स

#(map key(sort-by val(zipmap(range)%)))

— NikoNyrh
स्रोत

पर्ल 6 में अनुवाद{map *.key,(sort *.value,(0..* Z=> @_))}

— ब्रैड गिल्बर्ट b2gills

2

CJam , 12 बाइट्स

{ee{1=}$0f=}

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

— आउटगोल्फ को एरिक करें
स्रोत

2

MATLAB / ऑक्टेव , 29 बाइट्स

[~,y]=sort(input(''));disp(y)

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

— लुइस मेंडो
स्रोत

जबकि आपका जवाब सही MATLAB है, आप वास्तव में ऑक्टेव में अनाम कार्यों में इनलाइन असाइनमेंट कर सकते हैं ।

— जुलुस

अच्छा था! मैं इन-लाइन असाइनमेंट के बारे में जानता था, लेकिन मुझे नहीं पता था कि आप सीधे उस तरह से आउटपुट कर सकते हैं

— लुइस मेंडो

1

सच कहूं तो, मैं भी नहीं। मैंने कुछ के साथ शुरुआत की @(X)([~,y]=sort(X)), और जब मैं इससे प्राप्त करने का एक रास्ता देख रहा था y, मुझे एहसास हुआ yकि वास्तव में असाइनमेंट से वापसी मूल्य था, और करीब निरीक्षण से पता चला कि कोष्ठक की आवश्यकता भी नहीं थी। MATLAB सब कुछ स्पष्ट पसंद करता है; जब यह असंदिग्ध है तो ऑक्टेव खुश है।

— Sanchises

2

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

0 अनुक्रमित। 65,536 तत्वों तक की सूचियों के लिए काम करता है।

a=>[...a=a.map((n,i)=>n<<16|i)].sort((a,b)=>a-b).map(n=>a.indexOf(n))

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

कोड स्निपेट दिखाएं

let f =

a=>[...a=a.map((n,i)=>n<<16|i)].sort((a,b)=>a-b).map(n=>a.indexOf(n))

console.log(JSON.stringify(f([7, 4, 5])))
console.log(JSON.stringify(f([1, 2, 3])))
console.log(JSON.stringify(f([2, 6, 1, 9, 1, 2, 3])))
console.log(JSON.stringify(f([4])))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

क्या आप n=>a.indexOf(n)सिर्फ बदल सकते हैं a.indexOf?

— ज़ाचरी जूल

@ Zacharý दुर्भाग्य से नहीं। इंस्टेंट ऑब्जेक्ट का एक तरीका कॉलबैक के रूप में उपयोग नहीं किया जा सकता है।

— Arnauld

@ Zacharý इससे भी बदतर है कि Array#mapकॉलबैक फ़ंक्शन के लिए 3 तर्क पारित करता है, और Array#indexOf2 की उम्मीद करता है, इसलिए यह अवांछनीय परिणाम देगा।

— kamoroso94

2

पायथन 3 , 52 बाइट्स

0 अनुक्रमित। ब्रूस फोर्ट के हास्केल उत्तर के आधार पर और जीबी के रूबी के उत्तर यहां दिए गए हैं ।

lambda l:list(zip(*sorted(zip(l,range(len(l))))))[1]

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

— Sherlock9
स्रोत

2

भूसी , 10 7 बाइट्स

यह मेरे हास्केल उत्तर का प्रत्यक्ष पोर्ट है , भी 1-indexed:

m→O`z,N

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

Ungolfed / समझाया

Code        Description               Example
         -- implicit input            [2,6,1]
      N  -- natural numbers           [1,2,3,..]
   `z,   -- zip, but keep input left  [(2,1),(6,2),(1,3)]
  O      -- sort                      [(1,3),(2,1),(6,2)]
m→       -- keep only indices         [3,1,2]

— ბიმო
स्रोत

2

जावा (ओपनजेडके 8) , 72 बाइट्स

l->l.stream().sorted().map(i->{int j=l.indexOf(i);l.set(j,0);return j;})

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

एक लेता है List<Integer>, एक Stream<Integer>परिणाम देता है।

हमें प्रारंभिक सूची के आधार पर एक स्ट्रीम मिलती है, इसे क्रमबद्ध करें, फिर प्रत्येक संख्या को सूची में सूचीबद्ध करें। डुप्लिकेट तत्वों को समायोजित करने के लिए, हम सूची में मूल तत्व को सेट करते हैं 0।

— Xanderhall
स्रोत

2

स्माइलबासिक, 67 बाइट्स

DEF I(A)DIM B[0]FOR I=1TO LEN(A)PUSH B,I
NEXT
SORT A,B
RETURN B
END

बहुत ही सरल, यह सब 1 से संख्या की सूची (सरणी की लंबाई) उत्पन्न करता है और इसे इनपुट के समान क्रम से क्रमबद्ध करता है।

— 12Me21
स्रोत

2

पम्प्न 3 के साथ नम्पी , 38 26 बाइट्स

12 बाइट्स ने जो किंग को धन्यवाद दिया (फंक्शन को कोई नाम नहीं दिया गया)

import numpy
numpy.argsort

आउटपुट 0-आधारित है।

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

— लुइस मेंडो
स्रोत

समारोह सिर्फ numpy.argsortलैम्ब्डा भाग के बिना हो सकता है

— जो किंग

@ जोकिंग सुझाव के लिए धन्यवाद। मैंने इसे इस तरह लिखा था क्योंकि बस के साथ numpy.argsort;import numpyमुझे एक त्रुटि मिलती है ( numpyअभी तक आयात नहीं किया गया है), और इसके साथ import numpy;numpy.argsortमुझे f=कोड भाग में जाने की आवश्यकता है । क्या आप जानते हैं कि इन मामलों में मानक प्रक्रिया क्या है? स्थानांतरित करें f=और इसे गिनें नहीं?

— लुइस मेंडो

हाँ, मुझे लगता है कि। हो सकता f=numpy.argsortहै कि पाद में केवल फिर से परिभाषित करें

— जो किंग

@JoKing अच्छा विचार है। किया हुआ। धन्यवाद!

— लुइस मेंडू

1

05AB1E , 4 बाइट्स

ā<Σè

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

— आउटगोल्फ को एरिक करें
स्रोत

1

परी / जीपी , 16 बाइट्स

a->vecsort(a,,1)

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

— alephalpha
स्रोत

1

PHP , 54 बाइट्स

<?php function i($a){asort($a);return array_keys($a);}

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

यह शून्य-अनुक्रमित है। बस सरणी को सॉर्ट करें और चाबियाँ लौटाएं।

— WebSmithery
स्रोत

1

<?phpटैग एक समारोह के लिए अनावश्यक है। 48 बाइट्स।

— टाइटस

1

Tcl , 21 बाइट्स

(0 अनुक्रमित)

puts [lsort -indi $L]

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

— sergiol
स्रोत

परीक्षण मामलों में केवल 1 अंकों की संख्या होती है; मेरा समाधान केवल 1 अंकों की संख्या पर अच्छा काम करता है।

— सर्जियोल

छँटाई के बाद एक सरणी के सूचकांक प्राप्त करें

जेली , 1 बाइट

दिल्लोग एपीएल, 1 बाइट

उदाहरण

हास्केल , 43 42 बाइट्स

पायथन 2 , 56 बाइट्स

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

पायथन 2 , 48 बाइट्स

पर्ल 6 , 27 21 बाइट्स

विस्तारित:

बैश + कोरुटिल्स, 20

स्विफ्ट 4 , 82 बाइट्स

व्याख्या

आर , 5 बाइट्स

रूबी , 40 बाइट्स

MATL , 2 बाइट्स

जे , 2 बाइट्स

ऑक्टेव , 17 बाइट्स

MY , 3 बाइट्स

कैसे?

जावा 8, 128 + 19 = 147 बाइट्स

अघोषित लंबोदर

टिप्पणियाँ

स्वीकृतियाँ

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

क्लोजर, 39 बाइट्स

CJam , 12 बाइट्स

MATLAB / ऑक्टेव , 29 बाइट्स

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

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

पायथन 3 , 52 बाइट्स

भूसी , 10 7 बाइट्स

Ungolfed / समझाया

जावा (ओपनजेडके 8) , 72 बाइट्स

स्माइलबासिक, 67 बाइट्स

पम्प्न 3 के साथ नम्पी , 38 26 बाइट्स

05AB1E , 4 बाइट्स

परी / जीपी , 16 बाइट्स

PHP , 54 बाइट्स

Tcl , 21 बाइट्स