সারাংশ

পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে, প্রতিটি পূর্ণসংখ্য অনুসারে বাছাইয়ের পরে সূচকটি শেষ হবে।

উদাহরণস্বরূপ, তালিকাটি থাকলে আপনার [0,8,-1,5,8]ফিরে আসা উচিত [1,3,0,2,4]। লক্ষ্য করুন যে দু'জন 8একে অপরের সাথে সম্পর্কিত তাদের অর্ডার বজায় রাখছেন (সাজান স্থিতিশীল)।

অন্য উপায় রাখুন: তালিকার প্রতিটি উপাদানগুলির জন্য, তালিকার যে উপাদানগুলির সংখ্যা রয়েছে তা ফিরিয়ে দিন: নির্বাচিত উপাদানের চেয়ে ছোট বা OR (উপাদানটির সমান এবং নির্বাচিত উপাদানটির আগে প্রদর্শিত হবে)

~~সূচকগুলি অবশ্যই 0 (1 না)~~ EDIT ~~দিয়ে শুরু করা উচিত~~ : বড় পুশব্যাকের পরে আমি 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]।

— পিটার টেলর

@ পিটারটেলর: সেই চ্যালেঞ্জটিতে অ্যারের কোনও পুনরাবৃত্তি হয়নি।

— লিন

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

তবে সূচক তালিকা যা এই প্রশ্নের উত্তর দেয় তা যথাযথভাবে পৃথক: প্রথমে আমরা ক্ষুদ্রতম উপাদানটির সূচি চাই, দ্বিতীয় দ্বিতীয় ছোট ইত্যাদি again আবার, মূল ক্রমটি রেখে।

আমরা যদি তাকান ⍋x, যদিও, আমরা দেখতে এটা আমাদের এই তালিকায় সহজে দিতে পারেন: অবস্থান একটি এর 0মধ্যে ⍋xআমাদের বলে যেখানে ক্ষুদ্রতম উপাদান বাছাই পর শেষ পর্যন্ত হবে, এবং অবস্থান একটি এর 1মধ্যে ⍋xআমাদের বলে যেখানে দ্বিতীয় ক্ষুদ্রতম উপাদান শেষ পর্যন্ত হবে ইত্যাদি

তবে আমরা জানি ⍋xঠিক সংখ্যা [0, 1… n − 1] রয়েছে । আমরা এটা গ্রেড তাহলে আবার , আমরা শুধু সূচী পাবেন 0মধ্যে ⍋x, তারপর সূচক 1মধ্যে ⍋x, ইত্যাদি, যা অবিকল কি আমরা করতে আগ্রহী হন।

সুতরাং উত্তর হয় ⍋⍋x।

— লিন
সূত্র

বাহ, এই অবশ্যই শ্রমসাধ্যভাবে গল্ফ করা হয়েছিল: পি

— ডাউনগোট

এনএনজি-এপিএল কেবল ইউটিএফ -8 সমর্থন করে তবে সূচি উত্সটি 0 তে নির্ধারিত হয় এমন প্রতিটি গন্ধে এটি কাজ করে

— ডেনিস

এটি আমাকে অবাক করে তোলে: ক্লাসিক এপিএল স্বাদগুলির জন্য কি কোনও চেষ্টা-অন-লাইন রয়েছে?

— লিন

আছে TryAPL Dyalog জন্য, কিন্তু 1. আই অক্ষমতা এটা যদিও সহজে পরিবর্তনশীল নয়। মাহবুব

— ডেনিস

1-ভিত্তিক এখন অনুমোদিত।

— নাথান মেরিল

12

জেলি, 2 বাইট

ỤỤ

দুইবার গ্রেড আপ। 1-ইন্ডেক্স। এটি অনলাইন চেষ্টা করুন!

— লিন
সূত্র

কোন এনকোডিং প্রকল্পে দুটি বাইট?

— ডাব্লুগ্রোলাও

5

আহ! ইন জেলি কোড পৃষ্ঠা । আমি হেডারে একটি লিঙ্ক যুক্ত করেছি। :)

— লিন

6

জাভাস্ক্রিপ্ট ES6, 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 বাইট

<<

গ্রেড আপ ( <) দুইবার। জনে কেতে ট্য্যাসিট এক্সপ্রেশন উপস্থিত রয়েছে তা দেখিয়ে তিনটি বাইট সংরক্ষণ করেছেন! দুর্দান্ত শীতল। চেষ্টা কর.

— লিন
সূত্র

ল্যাম্বদা র‌্যাপার কঠোরভাবে প্রয়োজনীয় নয় - আপনি কেবল এটিকে একটি স্বচ্ছ প্রকাশ হিসাবে লিখতে পারেন <<। এখানে চেষ্টা করুন ।

— জন

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..]ইনপুটটিতে দু'বার প্রয়োগ করা হয়েছে, অর্থাত প্রতিটি উপাদানকে যুক্ত করুন এবং এর সূচক 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 বাইট বন্ধ করে দেওয়ার জন্য ধন্যবাদ!

আইডিয়নে এটি পরীক্ষা করুন ।

— ডেনিস
সূত্র

ফ্লিপ enumerateএকটি সঙ্গে খাটো করা যাবে zip: l=input();x=zip(l,range(len(l)))।

— xnor

সেক্ষেত্রে একটি ফাংশন আরও ছোট হয়। ধন্যবাদ!

— ডেনিস

4

পাওয়ারশেল ভি 2+, 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এবং তারপর f 4 4 0 1 1 2 0 1মধ্যে tryj.tk ।

— লিন
সূত্র

বা /:@/:সমান বাইট-কাউন্ট সহ।

— লিকি নুন

4

এমএটিএল, 10 9 4 বাইট

4 বাইটস @ লুইসকে ধন্যবাদ রক্ষা করেছে

&S&S

এই সমাধানটিতে 1-ভিত্তিক সূচক ব্যবহার করা হয়

অনলাইনে চেষ্টা করুন

— Suever
সূত্র

@DrGreenEggsandIronMan আমি মেটা অনুসন্ধান করেছি এবং কোনও উপায়ই ইঙ্গিত করে কিছু পাইনি। বলেছিল, আমি সীমাবদ্ধতাটি ফিরিয়ে দিয়েছি।

— নাথান মেরিল

4

05 এ বি 1 ই, 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) দুইবার। এখানে চেষ্টা করুন।

সম্পাদনা: ডেনিস স্টাফ অপারেটর-ওয়াই নাম দিয়ে চারটি বাইট সংরক্ষণ করলেন ! জুলিয়া অদ্ভুত।

— লিন
সূত্র

3

জাভাস্ক্রিপ্ট (ES6), 52 বাইট

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

gগ্রেড ফাংশন হিসাবে সংজ্ঞায়িত করে, যা সূচকের একটি অ্যারে প্রদান করে যাতে সাজানো অ্যারেতে থাকা সমস্ত উপাদান আসল অ্যারে থেকে এসেছিল। দুর্ভাগ্যক্রমে আমরা যা চাই তা হ'ল সূচকগুলি যা সমস্ত উপাদানগুলিতে যাবে। ভাগ্যক্রমে এটি গ্রেড থেকে সূচকের মূল তালিকায় ফিরে ম্যাপিং হিসাবে দেখা যাচ্ছে, যা নিজেই গ্রেডকে বাছাইয়ের ফলাফল হিসাবে বিবেচনা করা যেতে পারে, এইভাবে আমাদের পছন্দসই ফলাফল অর্জনের জন্য গ্রেডের গ্রেড গ্রহণের অনুমতি দেয়।

— নিল
সূত্র

3

পাইথ, 10 9 বাইট

জাকুবে 1 বাইট ধন্যবাদ।

xLo@QNUQU

পরীক্ষা স্যুট.

আরও একটি ছোট উপায় থাকতে হবে ...

— ফুটো নুন
সূত্র

xLপরিবর্তে sxR। নাকি আমি কিছু উপেক্ষা করছি?

— জাকুব

@ জাকুব ধন্যবাদ!

— ফাঁস নুন

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 বাইট প্রতিটি ডুপ্লিকেট গণনা না করে মান সংরক্ষণ করার জন্য একটি হ্যাশ ব্যবহার করার জন্য @ ডাউনগোটের পদ্ধতির আপগ্রেড করা থেকে from

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

— মান কালি
সূত্র

রুবির বাছাই অস্থিতিশীল , যার অর্থ এটি সম্পর্কের ক্ষেত্রে ভুল কাজটি করতে পারে।

— নাথান মেরিল

1

@ নাথামারিল এই সংখ্যাটি উত্পন্ন করার জন্য সঠিক পদ্ধতিটি ব্যবহার করছি বলেই নয়। যদি আমি সূচকগুলির তালিকায় বাছাই করে থাকি তবে এটির ভুল ফলাফল হতে পারে। লিঙ্কটি চেষ্টা করে দেখুন! এটি প্রতিবার, 60% সময় কাজ করবে। আমি এটি পরে একটি ব্যাখ্যা পোস্ট করব।

— মান কালি

আহ, ঠিক আছে. বাকি কোডটি কী করছে তা আমি নিশ্চিত ছিলাম না (আমি রুবিকে জানি না)

— নাথান মেরিল

? এটি সম্পর্কের ক্ষেত্রে ভুল কাজ করে না, তবে এটি 40% সময়কে অন্য কিছু করে?

— ডাব্লুগ্রোলাউ

@WGrolau এটি একটি অ্যাঙ্করম্যানের উক্তি। যদিও আমার কোডটি সর্বদা কাজ করে।

— মান কালি

2

Clojure, 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

— coredump
সূত্র

1

জাভাস্ক্রিপ্ট (বাহ্যিক গ্রন্থাগার ব্যবহার করে) (105 বাইট)

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

লিবের লিঙ্ক: https://github.com/mvegh1/ কোডের অগণিত ব্যাখ্যা: বেনামে পদ্ধতি তৈরি করুন যা পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে। _. থেকে গ্রন্থাগারের একটি উদাহরণ তৈরি করা হয় যা বিশেষ পদ্ধতিগুলির সাহায্যে একটি অ্যারেরকে আবৃত করে। প্রতিটি আইটেমকে একটি নতুন আইটেমের জন্য মানচিত্র নির্বাচন করুন, "ভি" লেবেলটিকে একটি স্ট্রিংয়ে পার্স করে, তারপরে সেই আইটেমটির "i" এনডেক্সকে সম্মতি জানাতে (এটি সদৃশ মান ক্ষেত্রে সমাধান করে)। চলকটি 'এ' তে সংরক্ষণ করা হয়। তারপরে আমরা নীচের ফলাফলটি ফিরিয়ে দেব: একটি (পূর্ণসংখ্যা হিসাবে) এর সাজানো সংস্করণে সেই আইটেমের সূচীতে 'ক' তে প্রতিটি আইটেম ম্যাপ করুন এবং একটি নেটিভ জেএস অ্যারেতে ফিরুন

মনে রাখবেন যে নেতিবাচক সদৃশ নম্বরগুলি বিপরীত ক্রমে মুদ্রণযোগ্য বলে মনে হচ্ছে। আমি নিশ্চিত না যে যদি এই সমাধানটি অবৈধ হয়? প্রযুক্তিগতভাবে 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-ভিত্তিক আউটপুট উত্পাদন করে। যোগ -v0দ্বিতীয় পর nl0 ভিত্তিক আউটপুট জন্য। (+4 বাইট)

কমান্ডগুলি আমরা ব্যবহার করছি:

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

পিএইচপি, 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

ম্যাটল্যাব, 29 বাইট

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

ম্যাটল্যাবের বেশিরভাগ বাছাই বিল্ট-ইনগুলি বাছাই করা সূচকগুলি সহ একটি optionচ্ছিক দ্বিতীয় অ্যারে প্রদান করবে। j=যদি সূচকের মুদ্রণ গ্রহণযোগ্য, বরং তাদের ফেরার চেয়ে মুছে যেতে পারে।

— MattWH
সূত্র

0

সিজেম , 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 বাইট

জাভাস্ক্রিপ্ট ES6, 87 82 79 74 70 বাইট

ব্যাখ্যা

কে , 5 2 বাইট

হাস্কেল, 50 48 বাইট

পাইথন 2, 67 60 বাইট

পাওয়ারশেল ভি 2+, 63 বাইট

উদাহরণ

সিজেম, 15 বাইট

ব্যাখ্যা

জে, 5 বাইট

এমএটিএল, 10 9 4 বাইট

05 এ বি 1 ই, 12 বাইট

পাইথন 2, 67 বাইট

হাস্কেল, 40 বাইট

জুলিয়া, 17 বাইট

জাভাস্ক্রিপ্ট (ES6), 52 বাইট

পাইথ, 10 9 বাইট

র‌্যাকেট, 117 বাইট

রুবি, 54 53 বাইট

Clojure, 83 বাইট

ব্র্যাচল্যাগ , 27 বাইট

ব্যাখ্যা

গণিত, 15 বাইট

গণিত, 135 বাইট

কমন লিস্প, 117 বাইট

পরীক্ষা

জাভাস্ক্রিপ্ট (বাহ্যিক গ্রন্থাগার ব্যবহার করে) (105 বাইট)

জিএনইউ কোর ইউটিলস, 39 33 বাইট

জাভা 149 140 বাইট

পিএইচপি, 88 বাইট

ম্যাটল্যাব, 29 বাইট

সিজেম , 19 বাইট