आपको इनपुट के रूप में पॉजिटिव पूर्णांकों की दो सूचियां लेनी चाहिए, आइए इन n और m को कॉल करें ।

आप मान सकते हैं कि:

N में सभी पूर्णांक मी का हिस्सा हैं
मी में सभी पूर्णांक अद्वितीय हैं
सूची गैर-रिक्त हैं

चुनौती: जहाँ आप n में , m में मान पाते हैं, उसके सूचकांकों को लौटाएँ ।

यह भ्रामक हो सकता है, लेकिन मुझे लगता है कि परीक्षण के मामले कार्य को बहुत स्पष्ट कर देंगे। उदाहरण 1-अनुक्रमित हैं, यदि आप (कृपया निर्दिष्ट करें) आप 0-अनुक्रमित चुन सकते हैं।

n = 5 3 4 1
m = 6 8 4 1 2 5 3 100
output: 6 7 3 4    // 5 is in the 6th position of m 
                   // 3 is in the 7th position of m
                   // 4 is in the 3rd position of m
                   // 1 is in the 4th position of m

n = 5 3 4 9 7 5 7
m = 3 4 5 7 9
output: 3 1 2 5 4 3 4

n = 1 2 3 4 5 6
m = 1 2 3 4 5 6
output: 1 2 3 4 5 6

n = 16 27 18 12 6 26 11 24 26 20 2 8 7 12 5 22 22 2 17 4
m = 15 18 11 16 14 20 37 38 6 36 8 32 21 2 31 22 33 4 1 35 3 25 9 30 26 39 5 23 29 10 13 12 7 19 24 17 34 27 40 28
output: 4 38 2 32 9 25 3 35 25 6 14 11 33 32 27 16 16 14 36 18

n = 54
m = 54
output: 1

विजेता प्रत्येक भाषा में सबसे छोटा समाधान होगा।

_{यह एक बहुत अच्छा मेटा-पोस्ट तरीका है!}

code-golf number

— स्टीवी ग्रिफिन
स्रोत

यह एक विचित्र प्रश्न हो सकता है, लेकिन क्या यह मान लेना ठीक होगा कि इनपुट में अनुगामी स्थान होगा?

— DJMcMayhem

जिज्ञासु आप क्यों पूछते हैं, लेकिन हाँ, निश्चित ...

— स्टिव ग्रिफिन

13

वी , 26 बाइट्स

jòdf kÄ/-
DÓÓ
ÒC1@"Gòdk

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

यह एक बहुत ही अजीब और हिकी समाधान है, क्योंकि वी की संख्या की कोई अवधारणा नहीं है। इनपुट इस प्रारूप में आता है:

6 8 4 1 2 5 3 100 
5 3 4 1

प्रत्येक पंक्ति पर एक अनुगामी स्थान के साथ।

Hexdump:

00000000: 6af2 6466 206b c42f 122d 0a44 d3d3 0ad2  j.df k./.-.D....
00000010: 0143 311b 4022 47f2 646b                 .C1.@"G.dk

स्पष्टीकरण:

j                   " Move down one line (to N) (1)
 ò                  " Recursively:
  df                "   (d)elete until you (f)ind a space. This will be saved into
                    "   register '-' (2)
     k              "   Move up one line (to M)
      Ä             "   Duplicate line M (3)
       /<C-r>-      "   Move the cursor forward until the next occurence of register '-' 
                    "   (the number we deleted from N)
                    "   (4)
D                   "   Delete every character *after* the cursor (5)
 ÓÓ                 "   Remove everything on this line except for whitespace
Ò<C-a>              "   Replace every character on this line with `<C-a>`, which is the 
                    "   command for incrementing a number (6)
      C             "   Delete this line into register '"', and enter insert mode
       1<esc>       "   Enter a '1' and return to normal mode
             @"     "   Run register '"' as V code (7)
               G    "   Go to the last line (1)
                ò   " End recursion
                 dk " Delete the last two lines (m and n)

यदि यह इसे स्पष्ट नहीं करता है, तो यहां विभिन्न चरणों के दौरान बफर के उदाहरण दिए गए हैं जो लूप से गुजरता है:

चरण 1 ( |कर्सर है)

6 8 4 1 2 5 3 100
|5 3 4 1

चरण 2:

6 8 4 1 2 5 3 100
|3 4 1

स्टेज 3:

|6 8 4 1 2 5 3 100
6 8 4 1 2 5 3 100
3 4 1

स्टेज 4:

6 8 4 1 2 |5 3 100
6 8 4 1 2 5 3 100
3 4 1

चरण 5:

6 8 4 1 2 |
6 8 4 1 2 5 3 100
3 4 1

स्टेज 6:

|<C-a><C-a><C-a><C-a><C-a>
6 8 4 1 2 5 3 100
3 4 1

स्टेज 7:

|6
6 8 4 1 2 5 3 100
3 4 1

चरण 1 पर वापस:

6
6 8 4 1 2 5 3 100
|3 4 1

— DJMcMayhem
स्रोत

9

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

lambda a,b:map(a.index,b)

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

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

— लीक नन
स्रोत

8

एपीएल (डायलॉग) , 1 बाइट

⍳

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

नोट: ⍳समारोह है नहीं अपनी बाईं तर्क के रूप में scalars लेते हैं, तो यह एक छोड़ दिया तर्क देने के लिए की तरह 54है, आप इसे एक सरणी का उपयोग कर में करना है ,तो तरह (,54)।

— क्रिक्टी लिथोस
स्रोत

7

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

#&@@@PositionIndex@#/@#2&

दो आदानों लेता है mऔर n, और 1 आधारित सूचकांक रिटर्न nमें m।

— मार्टिन एंडर
स्रोत

6

रेटिना , 32 31 30 बाइट्स

1 बाइट ने क्रिक्टी लिथोस को धन्यवाद और मार्टिन एंडर को 1 बाइट धन्यवाद दिया

(\d+)(?=.*¶(\d+ )*\1 )
$#2
G1`

0-इंडेक्सिंग का उपयोग करता है। इनपुट में प्रत्येक पंक्ति पर एक अनुगामी स्थान होता है।

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

व्याख्या

(\d+)(?=.*¶(\d+ )*\1 )
$#2

यहां हम प्रत्येक संख्या को पहली पंक्ति पर दूसरी संख्या पर समान संख्या से पहले संख्या के आधार पर बदलते हैं।

G1`

फिर, हम दूसरी पंक्ति को हटाते हैं, केवल नई पहली पंक्ति को आउटपुट के रूप में छोड़ते हैं।

— बिजनेस कैट
स्रोत

5

जावा , 104 81 बाइट्स

बिजनेस कैट को 1 बाइट धन्यवाद।

void f(int[]a,int[]b){for(int i=0,j=0;i<b.length;)j=a[j++]==b[i]?0*(b[i++]=j):j;}

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

— लीक नन
स्रोत

5

सी #, 32 बाइट्स

(n,m)=>n.Select(i=>m.IndexOf(i))

यह लैम्बडा अभिव्यक्ति के रूप में कोड है, इसलिए यह मान्य होना चाहिए।

समाधान 0 आधारित सूचकांक के साथ है। मुझे लगता है कि यह आगे काम करता है कि यह कैसे काम करता है - यह केवल n की वस्तुओं को लेता है और मी में वस्तुओं के सूचकांक का चयन करता है।

— MetaColon
स्रोत

4

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

@(n,m)([x,~]=find(n==m'))

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

— rahnema1
स्रोत

4

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

a%b=[length$fst$span(/=x)b|x<-a]

इसे ऑनलाइन आज़माएं! एक-अनुक्रमित।

अन्य प्रयास:

q(h:t)x|x==h=0|1>0=1+q t x;map.q
f b=map$length.fst.($b).span.(/=)
a%b=[until((==x).(b!!))(+1)0|x<-a]
a%b=[until(\y->x==b!!y)(+1)0|x<-a]
import Data.List;map.flip elemIndex

— XNOR
स्रोत

3

के, १

यह एक अंतर्निहित ऑपरेटर है kऔर शून्य-आधारित अनुक्रमण का उपयोग करता है।

उदाहरण:

k)6 8 4 1 2 5 3 100 ? 5 3 4 1
5 6 2 3

— skeevey
स्रोत

2

05AB1E , 5 बाइट्स

v²yk,

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

v     # For each value in n (call it y)
 ²    # Push m
  y   # Push y
   k, # Print the 0-indexed index of y in m

— रिले
स्रोत

2

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

iÐ€

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

चश्मा

इनपुट: दो तर्क, पहला एम किया जा रहा है , और दूसरा जा रहा है एन ।
आउटपुट: एक सरणी

— लीक नन
स्रोत

2

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

सिंटैक्स को करीने में ले जाता है (n)(m)। 0 अनुक्रमित।

let f =

n=>m=>n.map(v=>m.indexOf(v))

console.log(JSON.stringify(f([5,3,4,1])([6,8,4,1,2,5,3,100])))
console.log(JSON.stringify(f([5,3,4,9,7,5,7])([3,4,5,7,9])))
console.log(JSON.stringify(f([1,2,3,4,5,6])([1,2,3,4,5,6])))
console.log(JSON.stringify(f([16,27,18,12,6,26,11,24,26,20,2,8,7,12,5,22,22,2,17,4])([15,18,11,16,14,20,37,38,6,36,8,32,21,2,31,22,33,4,1,35,3,25,9,30,26,39,5,23,29,10,13,12,7,19,24,17,34,27,40,28])))
console.log(JSON.stringify(f([54])([54])))

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

— Arnauld
स्रोत

2

पर्ल 6 , 31 बाइट्स

->\n,\m{n.map:{m.first($_,:k)}}

कोशिश करो

विस्तारित:

-> \n, \m {  # pointy block lambda

  n.map: {            # map over the values in ｢n｣
    m.first( $_, :k ) # return the key ｢:k｣ of the first occurrence
  }
}

0 अनुक्रमित

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

2

जाप , 4 बाइट्स

m!bV

इसे ऑनलाइन टेस्ट करें!

व्याख्या

यहाँ समझाने के लिए बहुत कुछ नहीं है, लेकिन यह जाप की एक दिलचस्प विशेषता को दर्शाता है। आम तौर पर, आप एक फंक्शन पास करेंगे m, जैसे:

mX{VbX}

यह मूल रूप से U.map(X => V.indexOf(X))( Uनिहित है)। हालाँकि, जब आप केवल दो मानों ( bयहाँ, पर Vऔर X) के बीच एक ऑपरेशन कर रहे होते हैं, तो आप बस ऑपरेटर को दे सकते हैं और दूसरा मान और Japt इसमें से एक फंक्शन बनाएगा। इसका मतलब है कीmX{X+2} गोल्फ हो सकता है m+2।

हालाँकि, यह तब काम नहीं करता है जब मान गलत क्रम में हों ( mbVइसके लिए कम होगा mX{XbV})। इसके चारों ओर जाने के लिए, आप ऑपरेटर को एक विस्मयादिबोधक चिह्न प्रस्तुत कर सकते हैं, जो जैप को ऑपरेंड स्वैप करने के लिए कहता है। यह एक अतिरिक्त बाइट खर्च करता है, लेकिन यह अभी भी वैकल्पिक की तुलना में कम युगल है। और अब आप जाप के बारे में थोड़ा और जानते हैं।

— ETHproductions
स्रोत

2

MATL , 2 बाइट्स

&m

यह 1-इंडेक्सिंग का उपयोग करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

मेटा-फ़ंक्शन &इंगित करता है कि अगला फ़ंक्शन एक (फ़ंक्शन-विशिष्ट) द्वितीयक डिफ़ॉल्ट / इन-आउट विनिर्देश का उपयोग करेगा। फ़ंक्शन के लिए m( ismember), &निर्दिष्ट करता है कि इसका दूसरा आउटपुट तैयार किया जाएगा। इसमें दूसरे इनपुट में पहले इनपुट के प्रत्येक प्रविष्टि का सूचकांक (पहली घटना) शामिल है।

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

2

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

n#m=[i|a<-n,(i,e)<-zip[1..]m,e==a]

उपयोग उदाहरण: [5,3,4,9,7,5,7] # [3,4,5,7,9]->[3,1,2,5,4,3,4]

अंतर्निहित संस्करण ऊपर के संस्करण की तुलना elemIndexमें है Data.Listऔर इसलिए अधिक लंबा है। बाहरी लूप के माध्यम से जाता है nऔर आंतरिक लूप जोड़े के माध्यम से होता है (i,e)जहां iका सूचकांक eहै m। iजहां eके वर्तमान तत्व के बराबर है रखें n।

— nimi
स्रोत

2

आर, २० 5 बाइट्स

1 अनुक्रमित; matchबिलियन फ़ंक्शन है जो पहले के तत्वों के दूसरे इनपुट में सूचकांकों को पाता है, अर्थात, match(n,m)वांछित उत्तर देता है

match

@flodel के लिए धन्यवाद इंगित करने के लिए कि किसी फ़ंक्शन को वापस करना उत्तर के रूप में पूरी तरह से स्वीकार्य है!

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

— ग्यूसेप
स्रोत

2

मुझे लगता है कि match(5 बाइट्स) एक स्वीकार्य समाधान होगा।

— फ्लोडेल

आप सही हैं, अपडेट किए गए

— ग्यूसेप

1

अजगर , 4 बाइट्स

xLQE

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

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

— लीक नन
स्रोत

1

जे , 2 बाइट्स

i.

यह एक पूर्ण कार्यक्रम नहीं है, बल्कि एक अंतर्निहित कार्य है।

इसे इस तरह उपयोग करें:

echo 6 8 4 1 2 5 3 100 i. 5 3 4 1

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

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

— लीक नन
स्रोत

1

CJam , 4 बाइट्स

{f#}

बेनामी ब्लॉक जो स्टैक पर तर्कों की अपेक्षा करता है और स्टैक पर परिणाम छोड़ता है।

0-इंडेक्सिंग का उपयोग करता है।

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

— बिजनेस कैट
स्रोत

1

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

a*b=[[fst x|x<-zip[0..]b,y==snd x]!!0|y<-a]

a*b=                                         -- define function * with 2 args
    [                                |y<-a]  -- for each elt in first arg
               zip[0..]b                     -- match elts in second arg w/ idxs
                                             -- [a,b,c] -> [[0,a],[1,b],[2,c]]
     [fst x|x<-                  ]           -- take first element in each pair
                        ,y==snd x            -- if the index matches
                                  !!0        -- first element (always only 1)

— Doorknob
स्रोत

1

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

#(map(zipmap %2(range))%)

0 अनुक्रमित।

— NikoNyrh
स्रोत

1

पर्ल 5, 38 34 बाइट्स

4 बाइट्स ने दादा को धन्यवाद दिया

sub{map$x{$_}//($x{$_}=++$x)x0,@_}

1 अनुक्रमित। सूचियों m और n को एकल सूची के रूप में लेता है , जैसे f(@m,@n)। x0बस के साथ शुरू से उत्पादन रखना है 1,2,3,4,5, आदि

— क्रिस
स्रोत

अच्छा जवाब। ध्यान दें कि अनाम फ़ंक्शंस की अनुमति है, इसलिए sub{...}आप 2 बाइट्स बचा सकते हैं। इसके अलावा, आप दो बाइट्स को सहेजने के x0बजाय उपयोग कर सकते हैं &&()।

— दादा

1

PHP, 56 बाइट्स

ऑनलाइन संस्करण

0 अनुक्रमण

स्ट्रिंग के रूप में आउटपुट

<?foreach($_GET[0]as$v)echo" ".array_flip($_GET[1])[$v];

PHP, 65 बाइट्स

सरणी के रूप में आउटपुट

<?foreach($_GET[0]as$v)$r[]=array_flip($_GET[1])[$v];print_r($r);

PHP, 78 बाइट्स

के साथ समाधान array_map

<?print_r(array_map(function($v){return array_flip($_GET[1])[$v];},$_GET[0]));

अद्वितीय सरणियों के साथ की जगह नहीं है array_flip($_GET[1])[$v] array_search($v,$_GET[1])

— जार्ग हुल्सरमन
स्रोत

0

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

for n in $1
do grep -wn $n <<<"$2"
done|cut -d: -f1

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

पिछला उत्तर:

s()(sort -$1k2)
nl|s|join -j2 - <(nl<<<"$1"|s)|s n|cut -d\  -f3

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

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

0

जावा 7, 80 बाइट्स

void c(int[]a,java.util.List b){for(int i=0;i<a.length;a[i]=b.indexOf(a[i++]));}

0 अनुक्रमित

स्पष्टीकरण:

void c(int[]a,java.util.List b){  // Method with integer-array and List parameters
  for(int i=0;i<a.length;         //  Loop over the integer-array
    a[i]=b.indexOf(a[i++])        //   And change every value to the index of the List
  );                              //  End of loop (no body)
}                                 // End of method

टेस्ट कोड:

इसे यहाँ आज़माएँ।

import java.util.Arrays;
class M{
  static void c(int[]a,java.util.List b){for(int i=0;i<a.length;a[i]=b.indexOf(a[i++]));}

  public static void main(String[] a){
    int[] x = new int[]{ 5, 3, 4, 1 };
    c(x, Arrays.asList(6, 8, 4, 1, 2, 5, 3, 100));
    System.out.println(Arrays.toString(x));

    x = new int[]{ 5, 3, 4, 9, 7, 5, 7 };
    c(x, Arrays.asList(3, 4, 5, 7, 9));
    System.out.println(Arrays.toString(x));

    x = new int[]{ 1, 2, 3, 4, 5, 6 };
    c(x, Arrays.asList(1, 2, 3, 4, 5, 6));
    System.out.println(Arrays.toString(x));


    x = new int[]{ 16, 27, 18, 12, 6, 26, 11, 24, 26, 20, 2, 8, 7, 12, 5, 22, 22, 2, 17, 4 };
    c(x, Arrays.asList(15, 18, 11, 16, 14, 20, 37, 38, 6, 36, 8, 32, 21, 2, 31, 22, 33, 4, 1, 35, 3, 25, 9, 30, 26, 39, 5, 23, 29, 10, 13, 12, 7, 19, 24, 17, 34, 27, 40, 28));
    System.out.println(Arrays.toString(x));


    x = new int[]{ 54 };
    c(x, Arrays.asList(54));
    System.out.println(Arrays.toString(x));
  }
}

आउटपुट:

[5, 6, 2, 3]
[2, 0, 1, 4, 3, 2, 3]
[0, 1, 2, 3, 4, 5]
[3, 37, 1, 31, 8, 24, 2, 34, 24, 5, 13, 10, 32, 31, 26, 15, 15, 13, 35, 17]
[0]

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

एक सूची में दूसरे में मूल्यों के सूचकांकों का पता लगाएं

चुनौती: जहाँ आप n में , m में मान पाते हैं, उसके सूचकांकों को लौटाएँ ।

वी , 26 बाइट्स

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

एपीएल (डायलॉग) , 1 बाइट

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

रेटिना , 32 31 30 बाइट्स

जावा , 104 81 बाइट्स

सी #, 32 बाइट्स

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

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

के, १

05AB1E , 5 बाइट्स

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

चश्मा

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

पर्ल 6 , 31 बाइट्स

विस्तारित:

जाप , 4 बाइट्स

व्याख्या

MATL , 2 बाइट्स

व्याख्या

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

आर, २० 5 बाइट्स

अजगर , 4 बाइट्स

जे , 2 बाइट्स

CJam , 4 बाइट्स

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

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

पर्ल 5, 38 34 बाइट्स

PHP, 56 बाइट्स

PHP, 65 बाइट्स

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

जावा 7, 80 बाइट्स