सारांश

पूर्णांकों की सूची को देखते हुए, अनुक्रमित करें कि प्रत्येक पूर्णांक क्रमबद्ध होने पर समाप्त हो जाएगा।

उदाहरण के लिए, यदि सूची थी [0,8,-1,5,8], तो आपको वापस आ जाना चाहिए [1,3,0,2,4]। ध्यान दें कि दोनों 8एक दूसरे के सापेक्ष अपना क्रम बनाए रखते हैं (क्रम स्थिर है)।

दूसरा तरीका रखो: सूची में प्रत्येक तत्व के लिए, सूची में मौजूद तत्वों की संख्या लौटाओ: चुने हुए तत्व से छोटा या (तत्व के बराबर) और चुने हुए तत्व से पहले प्रकट होता है)

~~इंडेक्स 0 (~~ नॉट ~~1) से शुरू होना चाहिए~~ : बड़े पुशबैक को देखते हुए, मैं 1-आधारित संकेतों की अनुमति दूंगा।

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

0                -> 0
23               -> 0
2,3              -> 0,1
3,2              -> 1,0
2,2              -> 0,1
8,10,4,-1,-1,8   -> 3,5,2,0,1,4
0,1,2,3,4,5,6,7  -> 0,1,2,3,4,5,6,7
7,6,5,4,3,2,1,0  -> 7,6,5,4,3,2,1,0
4,4,0,1,1,2,0,1  -> 6,7,0,2,3,5,1,4
1,1,1,1,1,1,1,1  -> 0,1,2,3,4,5,6,7
1,1,1,1,1,1,1,0  -> 1,2,3,4,5,6,7,0

code-golf array-manipulation sorting

— नाथन मेरिल
स्रोत

इस चुनौती की सरलता के बावजूद, मुझे इस चुनौती का कोई डुप्लिकेट नहीं मिला।

— नाथन मेरिल

1

यह इस प्रश्न की एक विशेषता है जहां दो सरणियों को लेने के बजाय यह एक सरणी लेता है और दूसरा एक है [0 1 ... n-1]।

— पीटर टेलर

@PeterTaylor: उस चुनौती में, सरणी का कोई दोहराव नहीं है।

— लिन

2

सॉल्वरों पर ध्यान दें: वह 8,10,4,-1,-1परीक्षण मामला बहुत ही भ्रामक है। 4,4,0,1,1,2,0,1पहले एक कोशिश करो ।

— लिन

@ लियन ने देखा कि "ग्रेड अप" क्या करता है, और मुझे पता चला कि परीक्षण का मामला कितना भ्रामक है। फिक्स्ड।

— नाथन मेरिल

21

एपीएल, 2 बाइट्स

⍋⍋

"ग्रेड अप" बिल्ट-इन, दो बार लागू किया गया। यदि अनुक्रमण 0 पर शुरू होता है, जो एपीएल के सभी स्वादों के लिए डिफ़ॉल्ट नहीं है। यहाँ कोशिश करो!

यह काम क्यों करता है?

⍋xऐसे सूचकांकों की सूचीx लौटाता है जो निश्चित रूप से क्रमबद्ध होंगे । उदाहरण के लिए:

    x ← 4 4 0 1 1 2 0 1
    ⍋x
2 6 3 4 7 5 0 1

क्योंकि यदि आप तत्व लेते हैं 2, तो 6, तब 3... आपको एक समान रूप से क्रमबद्ध सूची मिलती है:

    x[⍋x]
0 0 1 1 1 2 4 4

लेकिन इस प्रश्न का उत्तर देने वाली अनुक्रमणिका सूची सबसे अलग है: पहले हम सबसे छोटे तत्व का सूचकांक चाहते हैं, फिर दूसरा सबसे छोटा, आदि - फिर से, मूल क्रम रखते हुए।

यदि हम देखो ⍋x, हालांकि, हम देखते हैं यह हमें इस सूची को आसानी से दे सकते हैं: स्थिति एक की 0में ⍋xहमें बताता है जहां सबसे छोटा तत्व छँटाई करने के बाद अंततः होता है, और स्थिति एक की 1में ⍋xहमें बताता है जहां दूसरा सबसे छोटा तत्व खत्म हो जाएगा , आदि।

लेकिन हम जानते ⍋xहैं कि वास्तव में संख्या [0, 1… n । 1] है । हम इसे ग्रेड तो फिर , हम बस के सूचकांक मिलेगा 0में ⍋xहै, तो के सूचकांक 1में ⍋x, आदि, जो ठीक है कि हम क्या में रुचि रखते हैं।

तो इसका जवाब है ⍋⍋x।

— लिन
स्रोत

वाह, यह श्रमसाध्य गोल्फ होना चाहिए: पी

— डाउनगोट

ngn -pl केवल UTF-8 का समर्थन करता है, लेकिन यह बहुत अधिक हर स्वाद में काम करता है बशर्ते कि सूचकांक मूल 0. पर सेट हो

— Dennis

यह मुझे आश्चर्यचकित करता है: क्या क्लासिक एपीएल जायके के लिए कोई प्रयास है?

— लिन

नहीं है TryAPL Dyalog के लिए, लेकिन 1. करने के लिए आईओ चूक हालांकि यह आसानी से बदला जा सकता है। पर्मलिंक

— डेनिस

1-आधारित की अब अनुमति है।

— नाथन मेरिल

12

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

ỤỤ

दो बार ग्रेड। 1 अनुक्रमित। इसे ऑनलाइन आज़माएं!

— लिन
स्रोत

कौन सी एन्कोडिंग योजना में दो बाइट्स?

— WGroleau

5

आह! में जेली कोड पेज । मैंने हेडर में एक लिंक जोड़ा। :)

— लिन

6

जावास्क्रिप्ट ईएस 6, 87 82 79 74 70 बाइट्स

(a,b={})=>a.map(l=>[...a].sort((a,b)=>a-b).indexOf(l)+(b[l]=b[l]+1|0))

किसी वस्तु का उपयोग करना पसंद नहीं है लेकिन यह डुप्लिकेट का ट्रैक रखने का सबसे छोटा तरीका है

व्याख्या

(a,b={})=>          `a` is input
                    `b` stores the occurrences of each number
  a.map(l =>        Loop over the array, `l` is item
  [...a]            Copy `a`
    .sort(...)       Sort in ascending numerical order
    .indexOf(l)      Index of input in that array
  +                 Add the following to account for dupes
   (b[l]=            set and return the item `l` in hashmap `b` to...
     b[l]+1           Increase the counter by one if it exists yet
     |0               default is zero
   )

— Downgoat
स्रोत

61 बाइट्स

— अरनॉल्ड

6

के , 5 2 बाइट्स

<<

<दो बार ग्रेड ( )। JohnE ने K में मौजूद tacit अभिव्यक्तियों को इंगित करके तीन बाइट्स बचाए! बेहद कूल। कोशिश करके देखो।

— लिन
स्रोत

लैम्ब्डा आवरण स्पष्ट रूप से आवश्यक नहीं है - आप इसे केवल एक मौन अभिव्यक्ति के रूप में लिख सकते हैं <<। इसे यहाँ आज़माएँ ।

— 22E पर जॉन जूल

5

हास्केल, 50 48 बाइट्स

import Data.List
m x=map snd$sort$zip x[0..]
m.m

प्रयोग उदाहरण: m.m $ [4,4,0,1,1,2,0,1]-> [6,7,0,2,3,5,1,4]।

इसे map snd.sort.zip x [0..]इनपुट पर दो बार लागू किया जाता है, अर्थात प्रत्येक तत्व e को इसके साथ index करें i ( (e,i)), पहले तत्वों को हटा दें। एक बार दोहराएं।

@ लियन के साथ आया था m=map snd.sort.(`zip`[0..])जिसके पास एक ही बाइट है।

— nimi
स्रोत

5

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

def f(x):x=zip(x,range(len(x)));print map(sorted(x).index,x)

7 बाइट बंद करने के लिए @xnor को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

फ़्लिप enumerateको a zip: के साथ छोटा किया जा सकता है l=input();x=zip(l,range(len(l)))।

— xnor

उस स्थिति में, एक फ़ंक्शन और भी छोटा होता है। धन्यवाद!

— डेनिस

4

PowerShell v2 +, 63 बाइट्स

param($n)$n|%{($n|sort).IndexOf($_)+($n[0..$i++]-eq$_).count-1}

$nहर तत्व पर एक लूप के माध्यम से इनपुट , पाइप लेता है |%{...}। प्रत्येक पुनरावृत्ति, हम sort $nऔर IndexOfहमारे वर्तमान तत्व को प्राप्त करते हैं $_। यह मायने रखता है कि मौजूदा तत्व की तुलना में कितने आइटम छोटे हैं। हम इसमें उस स्लाइस को जोड़ते हैं $n, जो हर लूप पुनरावृत्ति का विस्तार करती है, उन तत्वों का जो वर्तमान तत्व के बराबर हैं $_और उसी .Countका लेते हैं । हम तब घटाते हैं -1ताकि हम अपने वर्तमान तत्व को न गिनें, और वह संख्या पाइपलाइन पर छोड़ दी जाती है। अंत में आउटपुट निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\ordering-a-list.ps1 @(4,4,0,1,1,2,0,1)
6
7
0
2
3
5
1
4

PS C:\Tools\Scripts\golfing> .\ordering-a-list.ps1 @(8,10,4,-1,-1)
3
4
2
0
1

— AdmBorkBork
स्रोत

4

सीजेएम, 15 बाइट्स

{{eeWf%$1f=}2*}

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

व्याख्या

{             }       Delimits an anonymous block.
 {         }2*        Run this block on the argument twice:
  ee                  Enumerate ([A B C] → [[0 A] [1 B] [2 C]])
    Wf%               Reverse each ([[A 0] [B 1] [C 2]])
       $              Sort the pairs lexicographically;
                        i.e. first by value, then by index.
        1f=           Keep the indices.

— लिन
स्रोत

4

जे, 5 बाइट्स

/:^:2

ग्रेड ( /:दो बार ^:2)। 0 अनुक्रमित।

इसे आज़माने के लिए, टाइप करें f =: /:^:2और फिर tryj.tkf 4 4 0 1 1 2 0 1 में टाइप करें ।

— लिन
स्रोत

या /:@/:बराबर बाइट-काउंट के साथ।

— लीक

4

MATL, 10 9 4 बाइट्स

4 बाइट्स @Luis की बदौलत बच गए

&S&S

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

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

— Suever
स्रोत

@DrGreenEggsandIronMan मैं मेटा खोजता हूं, और मुझे कुछ भी संकेत नहीं मिल रहा है। उस ने कहा, मैंने प्रतिबंध वापस कर दिया है।

— नाथन मेरिल

4

05AB1E, 12 बाइट्स

2FvyN‚}){€¦˜

व्याख्या की

2F            # 2 times do
  vyN‚})      # create list of [n, index]-pairs
        {€¦   # sort and remove first element leaving the index
           ˜  # deep flatten
              # implicit output

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

— Emigna
स्रोत

4

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

a=input()
p=[]
for x in a:print sorted(a).index(x)+p.count(x);p+=x,

xnor ने दो बाइट्स बचाए।

— लिन
स्रोत

जब आप जाते हैं तो पहले से देखे गए तत्वों की सूची को फिर से बनाना कम होता है:a=input();p=[]\nfor x in a:print sorted(a).index(x)+p.count(x);p+=x,

— xnor

आह, मुझे यह पसंद है! धन्यवाद।

— लिन

4

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

f l|z<-zip l[0..]=[sum[1|y<-z,y<x]|x<-z]

प्रत्येक तत्व को अपने सूचकांक के साथ एनोटेट करें, फिर प्रत्येक तत्व को छोटे तत्वों की गिनती के लिए मैप करें, सूचकांक पर टाईब्रेकिंग। कोई छँटाई नहीं।

— XNOR
स्रोत

3

जूलिया, 17 बाइट्स

~=sortperm;!x=~~x

1 अनुक्रमित। sortpermदो बार ग्रेड ( )। इसे यहाँ आज़माएँ।

EDIT: डेनिस ने सामान संचालक-y नाम देकर चार बाइट्स बचाए ! जूलिया अजीब है।

— लिन
स्रोत

3

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

a=>(g=a=>[...a.keys()].sort((n,m)=>a[n]-a[m]))(g(a))

gग्रेड फ़ंक्शन के रूप में परिभाषित करता है , जो सूचकांकों की एक सरणी देता है, जिसमें क्रमबद्ध सरणी के सभी तत्व मूल सरणी में से आए होंगे। दुर्भाग्य से हम जो चाहते हैं वह सूचकांक है जो सभी तत्वों को जाएगा। सौभाग्य से यह ग्रेड से वापस सूचकांकों की मूल सूची में मैपिंग के रूप में निकलता है, जिसे स्वयं ग्रेड को छाँटने का परिणाम माना जा सकता है, इस प्रकार हमें वांछित परिणाम प्राप्त करने के लिए ग्रेड के ग्रेड को लेने की अनुमति मिलती है।

— नील
स्रोत

3

अजगर, 10 9 बाइट्स

1 बाइट जेक्यूब के लिए धन्यवाद।

xLo@QNUQU

परीक्षण सूट।

वहाँ चाहिए एक छोटी तरीका हो ...

— लीक नन
स्रोत

xLके बजाय sxR। या मैं कुछ देख रहा हूँ?

— जकुबे

@Jakube धन्यवाद!

— लीके नन

2

रैकेट, 117 बाइट्स

(λ(x)(build-list(length x)(λ(h)((λ(y)(+(count(λ(z)(< z y))x)(count(λ(z)(eq? z y))(take x h))))(list-ref x h)))))

मैं इसके लिए एक बेसिन की कमी से हमेशा से निराश हूं।

— स्टीवन एच।
स्रोत

क्या प्रत्येक तत्व को एक (संख्या, सूचकांक) जोड़ी में रखना कम होगा, फिर उसे क्रमबद्ध करें?

— नाथन मेरिल

मैंने कोशिश की है, लेकिन यह मुझे उस सूची का उलटा देता है जो मैं चाहता हूं, और दुर्भाग्य से सूची के भीतर किसी वस्तु का सूचकांक प्राप्त कर रहा है ताकि वह उल्टा हो जाए, यह बहुत ही अयोग्य है।

— स्टीवन एच।

2

रूबी, 54 53 बाइट्स

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

-1 बाइट को अपग्रेड करने से @ डुपोगैट के दृष्टिकोण का उपयोग करके हर बार डुप्लिकेट की गिनती करने के बजाय मूल्यों को स्टोर करने के लिए।

->a{b={};a.map{|e|a.sort.index(e)+b[e]=(b[e]||-1)+1}}

— मूल्य स्याही
स्रोत

रूबी की तरह अस्थिर है , जिसका अर्थ है कि यह संबंधों पर गलत काम कर सकता है।

— नाथन मेरिल

1

@NathaMerrill यह सटीक विधि के कारण नहीं है कि मैं संख्याओं को उत्पन्न करने के लिए उपयोग कर रहा हूं। अगर मैं सूचकांकों की सूची को हल करता हूं, तो यह गलत परिणाम देगा। लिंक की कोशिश करो! यह 60% समय, हर बार काम करेगा। मैं बाद में इस पर एक स्पष्टीकरण पोस्ट करूँगा।

— वैल्यू इंक।

आह अच्छा। मुझे यकीन नहीं था कि बाकी कोड क्या कर रहे हैं (मैं रूबी को नहीं जानता)

— नाथन मेरिल

? यह संबंधों पर गलत काम नहीं करता है, लेकिन यह 40% समय में कुछ और गलत करता है?

— WGroleau

@Groleau यह एक Anchorman उद्धरण है। मेरा कोड हर समय काम करता है, हालांकि।

— मूल्य इंक

2

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

(fn[a](nth(iterate #(->> %(map-indexed(comp vec rseq vector))sort(map second))a)2))

मैं एक अनाम फ़ंक्शन बनाता हूं जो इनपुट सरणी को ग्रेड करता है और इनपुट पर इसे दो बार पुन: व्यवस्थित करता है। पहला कॉल ग्रेड वापस करेगा। दूसरा कॉल ग्रेड पर संचालित होता है और रैंक लौटाता है।

— मील की दूरी पर
स्रोत

2

ब्रेकीलॉग , 27 बाइट्स

lL-M,?og:MjO,L~l.#d:Orz:ma?

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

व्याख्या

यह निम्नलिखित संबंधों का एक सीधा कार्यान्वयन है: इनपुट के एक तत्व के अनुरूप आउटपुट का प्रत्येक पूर्णांक सॉर्ट किए गए इनपुट में उस तत्व का सूचकांक है।

Example input: [3:2]

lL               L is the length of the input (e.g L=2)
  -M,            M = L-1 (e.g. M=1)
?o               Sort the input...
  g:MjO,         ... and create a list O with L copies of the input (e.g. O=[[2:3]:[2:3]])
L~l.             Output is a list of length L (e.g. [I:J])
    #d           All elements of the output must be distinct (e.g. I≠J)
      :Orz       Zip O with the output (e.g. [[[2:3]:I]:[[2:3]:J]])
          :ma?   Apply predicate Member with that zip as input and the input as output
                 (e.g. 3 is the Ith element of [2:3] and 2 is the Jth element of [2:3])

— Fatalize
स्रोत

2

मैथेमेटिका, 15 बाइट्स

(o=Ordering)@*o

— alephalpha
स्रोत

2

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

Function[{list}, SortBy[MapIndexed[Join[{#1}, #2]&, Sort@MapIndexed[Join[{#1}, #2] &, list]], #[[1, 2]] &][[All, 2]] - 1]

— navigaid
स्रोत

1

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

(flet((i(Z)(mapcar'cdr(stable-sort(loop for e in Z for x from 0 collect(cons e x))'< :key'car))))(lambda(L)(i(i L))))

दो बार एक श्वार्टजियन परिवर्तन लागू करें ।

;; FIRST TIME

(0 8 -1 5 8)
;; add indexes
((0 . 0) (8 . 1) (-1 . 2) (5 . 3) (8 . 4))
;; sort by first element
((-1 . 2) (0 . 0) (5 . 3) (8 . 1) (8 . 4))
;; extract second elements
(2 0 3 1 4)

;; SECOND TIME

(2 0 3 1 4)
;; indexes
((2 . 0) (0 . 1) (3 . 2) (1 . 3) (4 . 4))
;; sort by first element
((0 . 1) (1 . 3) (2 . 0) (3 . 2) (4 . 4))
;; extract second elements
(1 3 0 2 4)

परीक्षा

(let ((fn (flet((i(Z)(mapcar'cdr(stable-sort(loop for e in Z for x from 0 collect(cons e x))'< :key'car))))(lambda(L)(i(i L))))))
  (every
   (lambda (test expected)
     (equal (funcall fn test) expected))

   '((0) (23) (2 3) (3 2) (2 2) (8 10 4 -1 -1 8) (0 1 2 3 4 5 6 7)
     (7 6 5 4 3 2 1 0) (4 4 0 1 1 2 0 1) (1 1 1 1 1 1 1 1) (1 1 1 1 1 1 1 0))

   '((0) (0) (0 1) (1 0) (0 1) (3 5 2 0 1 4) (0 1 2 3 4 5 6 7) (7 6 5 4 3 2 1 0)
     (6 7 0 2 3 5 1 4) (0 1 2 3 4 5 6 7) (1 2 3 4 5 6 7 0))))
=> T

— कोर निपात
स्रोत

1

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (105 बाइट्स)

(n)=>{var a=_.From(n).Select((v,i)=>v+""+i);return a.Select(x=>a.OrderBy(y=>(y|0)).IndexOf(x)).ToArray()}

Lib से लिंक करें: https://github.com/mvegh1/Enumerable कोड का स्पष्टीकरण: अनाम विधि बनाएँ जो पूर्णांकों की सूची को स्वीकार करता है। _.From लाइब्रेरी का एक उदाहरण बनाता है जो विशेष तरीकों के साथ एक सरणी लपेटता है। "V" alue लेकर, किसी स्ट्रिंग में पार्स करके, फिर उस आइटम के "i" ndex को समेट कर (यह डुप्लिकेट वैल्यू केस हल करता है) प्रत्येक आइटम को एक नए आइटम के लिए चुनें। चर 'a' में संग्रहीत। फिर हम निम्नलिखित का परिणाम लौटाते हैं: प्रत्येक आइटम को 'ए' में उस आइटम के सूचकांक में एक (जैसे पूर्णांकों) के सॉर्ट किए गए संस्करण में मैप करते हैं, और एक मूल जेएस सरणी में वापस डालते हैं

ध्यान दें कि नकारात्मक डुप्लिकेट संख्याएं रिवर्स ऑर्डर में प्रिंट होती हैं। मुझे यकीन नहीं है कि अगर यह समाधान अमान्य है? तकनीकी रूप से 8,10,4, -1, -1,8 ओपी के अनुसार 3,5,2,0,1,4 होना चाहिए, लेकिन मेरा कोड 3,5,2,1,0,4 प्रिंट कर रहा है, जो मुझे विश्वास है अभी भी तकनीकी रूप से मान्य है?

— applejacks01
स्रोत

1

जीएनयू कोर यूटिल्स, 39 33 बाइट्स

nl|sort -nk2|nl|sort -nk2|cut -f1

1-आधारित उत्पादन का उत्पादन करता है। 0-आधारित आउटपुट प्राप्त करने के लिए -v0दूसरे के बाद जोड़ें nl। (+1 बाइट्स)

जिन कमांड का हम उपयोग कर रहे हैं:

nl इनपुट की प्रत्येक पंक्ति में लाइन नंबर जोड़ता है।
sort -n -k 2 स्तम्भ 2 के आधार पर संख्या।
cut -f 1 पहला टैब-सीमांकित कॉलम लेता है, बाकी को छोड़ देता है।

इसके अतिरिक्त, -sविकल्प को sortएक स्थिर प्रकार का अनुरोध करने के लिए पारित किया जा सकता है , लेकिन हमें यहां इसकी आवश्यकता नहीं है। यदि दो आइटम समान हैं, sortतो दूसरे स्तंभों पर वापस गिरकर उनके आदेश का निर्धारण करेंगे, जो इस मामले में नीरस रूप से बढ़ते उत्पादन से है nl। तो इनपुट के आधार पर इसे निर्दिष्ट करने की आवश्यकता के बिना क्रम स्थिर होगा।

— joeytwiddle
स्रोत

1

जावा 149 140 बाइट्स

public int[] indexArray(int[] index){
  int[] out=new int[index.length];
  for(int i=-1;++i<index.length;){
    for(int j=-1;++i<index.length;){
      if(index[i]==Arrays.sort(index.clone())[j]){
        out[i]=j;
      }
    }
  }
  return out;
}

golfed

int[]a(int[]b){int l=b.length;int[]o=new int[l];for(int i=-1;++i<l;)for(int j=-1;++i<l;)if(b[i]==Arrays.sort(b.clone())[j])o[i]=j;return o;}

9 बाइट के शेविंग के लिए @ केविन क्रूज़जेन को धन्यवाद।

— रोमन ग्रैफ़
स्रोत

@ नातान मेरिल ने देखा कि जब मैंने इसे गॉल्फ़ किया था, लेकिन जब मैंने गोल्फ का जवाब चिपकाया तो इसे भूल गया।

— रोमन ग्रैफ़

1

आप इसे कुछ और गोल्फ कर सकते हैं। आप के बीच int[] aऔर रिक्त स्थान की जरूरत नहीं है int[] b। आप intछोरों से बाहर ले जा सकते हैं । और चूंकि आप b.lengthशुरू में दो बार उपयोग करते हैं इसलिए आप इसे एक अलग क्षेत्र में रख सकते हैं। तो कुल कुछ इस तरह से:

int[]a(int[]b){int l=b.length,o[]=new int[l],i,j;for(i=-1;++i<l;)for(j=-1;++i<b.length;)if(b[i]==Arrays.sort(b.clone())[j])o[i]=j;return o;}

( 140 बाइट्स ) हम्म, भी, यह काम नहीं लगता है .. Arrays.sort(...)कुछ भी वापस नहीं करता है (यह एक voidविधि है), इसलिए आप इसकी तुलना कैसे कर सकते हैं b[i]? ..

— केविन क्रूज़सेन

1

PHP, 88 बाइट्स

unset($argv[0]);$a=$argv;sort($a);foreach($argv as$e)echo$h[$e]+++array_search($e,$a),_;

कमांड लाइन तर्कों पर काम करता है; प्रिंट 0-अनुक्रमित, अंडरस्कोर-अलग सूची। साथ चलाना -nr।

टूट - फूट

unset($argv[0]);        // remove file name from arguments
$a=$argv;               // create copy
sort($a);               // sort copy (includes reindexing, starting with 0)
foreach($argv as$e)     // loop $e through original
    echo                    // print:
        $h[$e]++            // number of previous occurences
        +array_search($e,$a)// plus position in copy 
        ,_                  // followed by underscore
    ;

— टाइटस
स्रोत

0

MATLAB, 29 बाइट्स

function j=f(s);[~,j]=sort(s)

MATLAB की अधिकांश छँटाई बिल्ट-इन एक वैकल्पिक दूसरी सरणी को छाँटे गए सूचकांकों के साथ लौटाएगा। j=अगर सूचकांक मुद्रण स्वीकार्य है, बजाय उन्हें लौटने से हटाया जा सकता है।

— MattWH
स्रोत

0

CJam , 19 बाइट्स

_$:A;{A#_AWt:A;1+}%

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

स्पष्टीकरण:

_ duplicate array
 $ sort array
  :A store in variable A
    ; discard top item in stack
     {A#_AWt:A;1+} block that finds index of item and removes it from sorted array to prevent duplicates
      % map block onto every item in array

— lolad
स्रोत

सूची तैयार करना

सारांश

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

एपीएल, 2 बाइट्स

यह काम क्यों करता है?

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

जावास्क्रिप्ट ईएस 6, 87 82 79 74 70 बाइट्स

व्याख्या

के , 5 2 बाइट्स

हास्केल, 50 48 बाइट्स

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

PowerShell v2 +, 63 बाइट्स

उदाहरण

सीजेएम, 15 बाइट्स

व्याख्या

जे, 5 बाइट्स

MATL, 10 9 4 बाइट्स

05AB1E, 12 बाइट्स

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

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

जूलिया, 17 बाइट्स

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

अजगर, 10 9 बाइट्स

रैकेट, 117 बाइट्स

रूबी, 54 53 बाइट्स

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

ब्रेकीलॉग , 27 बाइट्स

व्याख्या

मैथेमेटिका, 15 बाइट्स

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

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

परीक्षा

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (105 बाइट्स)

जीएनयू कोर यूटिल्स, 39 33 बाइट्स

जावा 149 140 बाइट्स

PHP, 88 बाइट्स

MATLAB, 29 बाइट्स

CJam , 19 बाइट्स