मेरा मालिक अब चाहता है कि मैं एक ऐसे तंत्र को लागू करूं जो उसे किसी एरे में किसी वस्तु की खोज करने दे, और उसे वह इंडेक्स / इंडेक्स दे, जहां वह मूल्य होता है।

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सरणी और एक मान प्राप्त करता है (स्ट्रिंग, इंटेगर, फ्लोट, या बूलियन), और उस सरणी के सूचकांकों को लौटाता है जिस पर मान होता है (या तो 0 या 1 अनुक्रमित, जो भी आप चाहें)। यदि मान सरणी में नहीं है, तो खाली सरणी लौटाएं।

इनपुट:

एक सरणी A और मान V, जो A में मौजूद हो भी सकता है और नहीं भी।

आउटपुट:

एक सरणी जिसमें इंडिस (एस) होते हैं, जिस पर V ए में होता है, या, यदि वी ए में नहीं होता है, तो एक खाली सरणी।

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

कृपया ध्यान दें कि परीक्षण के मामले 0 आधारित हैं।

12, [12,14,14,2,"Hello World!",3,12,12]         -> [0,6,7]
"Hello World", ["Hi", "Hi World!", 12,2,3,True] -> []
"a", ["A",True,False,"aa","a"]                  -> [4]
12, [12,"12",12]                                -> [0,2]

स्कोरिंग:

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम स्कोर जीतता है।

code-golf array-manipulation

— ग्रीफॉन - मोनिका को बहाल करना
स्रोत

1

क्या हम मान सकते हैं कि दी गई सारणी में केवल एक ही प्रकार है (अर्थात मिश्रित प्रकारों के साथ कोई सरणियाँ नहीं) क्योंकि कई भाषाएं एक से अधिक प्रकारों के साथ सरणियों या सूचियों का समर्थन नहीं करती हैं।

— दोष

1

ज़रूर, @flawr आप मान सकते हैं कि सरणी में केवल उसी प्रकार के मान शामिल होंगे जिनकी जाँच करने के लिए मान है, यदि आपकी भाषा को इसकी आवश्यकता है।

— ग्रिएफॉन -

2

आपकी सभी सरणियाँ 1D हैं। कल्पना?

— अड्म

1

@ केविनक्रूजसेन का मतलब है कि खोजा जाने वाला सरणी। यह मल्टी-डी हो सकता है।

— एडम

1

ठीक है। और मुझे आश्चर्य है कि अभी तक कोई भाषा नहीं आई है जो इसे 1 बाइट में कर सकती है!

— ज़ाचारि

10

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

0 अनुक्रमित।

xE

इसे ऑनलाइन आज़माएं! या सभी टेस्ट मामलों की जाँच करें

व्याख्या

xEQ  - Full Program. Takes Input from standard input. Q means evaluated input and is implicit at the end of the program.

x   - Get all the indexes of x in y
 E  - Evaluated Input #2 - The value
  Q - The list - Evaluated Input #1

— श्री Xcoder
स्रोत

आप सभी घटनाओं को वापस करने के लिए पहले नहीं हैं।

— आउटगॉल्फ

@EriktheOutgolfer फिक्स्ड। बस उन्हें उल्टे क्रम में ले जाएं।

— श्री Xcoder

1

पायथ निश्चित रूप से नौकरी के लिए सबसे अच्छा साधन है: पी

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

7

MATL , 2 बाइट्स

mf

mदो तर्कों का उपभोग करता है, और सरणी में प्रत्येक तत्व की जांच करता है कि क्या अन्य तर्क के बराबर है, fकिसी सरणी के सत्य प्रविष्टियों के सूचकांकों को लौटाता है।

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

— flawr
स्रोत

यह ऑक्टेव समाधान के लिए प्रस्तावित परीक्षण मामलों के लिए काम नहीं करता है।

— सिनेस्की

आपको स्ट्रिंग्स के सरणियों को ठीक से संभालने के ismemberबजाय उपयोग करना चाहिए =। mf

— स्वेवर

@LuisMendo हमें मिश्रित इनपुट पर विचार करने की आवश्यकता नहीं है, ओपी से स्पष्टीकरण देखें!

— 18:

@flawr ओह, यह केवल एक टिप्पणी में क्यों है, और चुनौती पाठ में नहीं? : - /

— लुइस मेंडो

आपको ओपी से पूछना होगा, मुझसे नहीं :)

— त्रुटिपूर्ण

7

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

-3 बाइट्स @EriktheOutgolfer और @Chris_Rands को धन्यवाद

lambda y,x:[i for i,j in enumerate(x)if j==y]

परीक्षण सूट।

आज मैंने सीखा enumerate(x) == zip(range(len(x)),x)।

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

lambda n,l:[x for x in range(len(l))if l[x]==n]

इसे ऑनलाइन आज़माएं! या सभी टेस्ट मामलों की जाँच करें

— श्री Xcoder
स्रोत

enumerate()इसे बाइट्स के एक जोड़े को नीचे लाने के लिए उपयोग करें

— Chris_Rands

@Chris_Rands समाप्त होने में अधिक समय लग रहा है।

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

3

lambda n,l:[x for x,y in enumerate(l)if y==n]

— आउटगॉल्फ

मेरा मतलब था कि @EriktheOutgolfer ने क्या कहा

— क्रिस_रैंड्स

1

@JonathanAllan फिक्स्ड।

— श्री Xcoder

6

आर (+ प्रायर), 20 बाइट्स

pryr::f(which(a==b))

जो फ़ंक्शन का मूल्यांकन करता है

function (a, b) 
which(a == b)

जहां या तो सदिश aको देखने का मूल्य हो सकता है b, या आसपास का रास्ता। जब असमान लंबाई के दो वैक्टर (आर में एक लंबाई -1 वेक्टर के रूप में गिना जाता है) के साथ प्रस्तुत किया जाता है, तो आर लंबे समय तक मैच करने के लिए छोटे को लपेट देगा। फिर समानता की जाँच की जाती है। यह एक तार्किक वेक्टर उत्पन्न करता है। whichयह सदिश सत्य है, जहां सूचकांकों को प्रदान करता है।

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

— JAD
स्रोत

6

जावास्क्रिप्ट, 39 बाइट्स

e=>a=>[...a.keys()].filter(i=>a[i]===e)

f=
e=>a=>[...a.keys()].filter(i=>a[i]===e)

console.log(f(12)([12,14,14,2,"Hello World!",3,12,12]));
console.log(f("Hello World")(["Hi", "Hi World!", 12,2,3,true]));
console.log(f("a")(["A",true,false,"aa","a"])); 
console.log(f(12)([12,14,14,2,"Hello World!",3,12,'12']));

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

उपरोक्त स्निपेट सभी ब्राउज़रों पर काम नहीं कर सकता है, इसलिए यहां एक TIO लिंक है ।

— क्रिस्टियन लुपस्कू
स्रोत

6

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

^{पार किया 44 अभी भी नियमित है 44 ;;}

v=>a=>a.map((x,i)=>x===v&&++i).filter(x=>x)

सहेजे गए 1 बाइट @Arnauld के लिए धन्यवाद

let f=
v=>a=>a.map((x,i)=>x===v&&++i).filter(x=>x)
;

console.log(f(12)([12,14,14,2,"Hello World!",3,12,12]));         // => [1,7,8]
console.log(f("Hello World")(["Hi", "Hi World!", 12,2,3,true])); // => []
console.log(f("a")(["A",true,false,"aa","a"]));                  // => [5]

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

— जोहान कार्लसन
स्रोत

क्या आप एक बाइट कम के लिए एक ===सामान्य कर सकते हैं ==? मैं शाब्दिक रूप से एक ही चीज़, चर नाम और सभी हाहा के साथ आया था।

— kamoroso94

4

===भेद करने के लिए आवश्यक है 12से"12"

— क्रिस्टोफ

1

@ kamoroso94 नहीं, यहाँ क्यों है।

— प्योरफेरेट

5

05AB1E , 4 बाइट्स

QāsÏ

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

1 अनुक्रमित।

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

मुझे लगता है कि हमारे दोनों इनपुट्स पर गड़बड़ करते हैं: 12और [12,'12'], जब तक उन्होंने कहा कि यह उन भाषाओं के लिए सर्द है जो वास्तव में ठोस प्रकार के बारे में परवाह नहीं करते हैं।

— मैजिक ऑक्टोपस Urn

मैं वास्तव में है कि लगता है 12≠ '12'05AB1E में क्योंकि कभी कभी वे अलग तरीके से व्यवहार ... नहीं यकीन है कि किसी भी समानता परीक्षण जो हालांकि ऐसी बात का समर्थन कर सकते हो, तो।

— आउटगॉल्फ

यदि हम पूर्णांक वैधता के लिए उनका परीक्षण करना चाहते थे, तो हमारे उत्तर 60-बाइट्स का उपयोग करने की तरह होंगे is_alpha (a)और is_number (d)मुझे लगता है कि हम मान सकते हैं कि हमारे मान्य हैं जब तक कि अन्यथा न कहा जाए।

— मैजिक ऑक्टोपस Urn

5

सी #, 88 72 बाइट्स

using System.Linq;a=>o=>a.Select((i,n)=>o.Equals(i)?n:-1).Where(n=>n>=0)

16 बाइट्स का धन्यवाद @LiefdeWen को दिया गया।

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

— TheLethalCoder
स्रोत

कमाल है, मैं अभी भी यह पता लगाने की कोशिश कर रहा था कि i==oकाम क्यों नहीं करता है।

— LiefdeWen

3

@ LiefdeWen बॉक्सिंग मूल्य प्रकार।

— द लीथल कोडर

72 बाइट्सusing System.Linq;a=>b=>a.Select((x,i)=>x.Equals(b)?i:-1).Where(x=>x>=0)

— LiefdeWen

@ LiefdeWen अच्छा एक, मैं इसे चारों ओर स्विच करने के बारे में सोचा नहीं होगा।

— TheLethalCoder

आप बहुत कुछ बचा सकते हैं :): tio.run/…

— digEmAll

5

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

⁼€T

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

-1 श्री एक्सकोडर का धन्यवाद । (रंगाई श्रृंखला)

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

1

अच्छा है। मुझे आश्चर्य है कि जैली के पास शुद्ध अंतर्निहित नहीं है, जैसे कि पायथ करता है।

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

@ Mr.Xcoder मुझे लगता है कि सबसे ज्यादा नहीं है।

— आउटगॉल्फ

— राग

3

हास्केल , 41 39 बाइट्स

v!l=fst<$>(filter((==v).snd)$zip[1..]l)

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

@Flawr के लिए धन्यवाद दो बाइट्स सहेजे गए

हास्केल सांख्यिकीय रूप से टाइप किया गया है, इसलिए मुझे परीक्षण मामलों को चलाने के लिए थोड़ा सा वर्कअराउंड का उपयोग करना पड़ा।

— jferard
स्रोत

अब आपको अपने वर्कअराउंड की आवश्यकता नहीं है, ओपी की टिप्पणी देखें।

— 12

1

इसके v#l=...बजाय एक ऑपरेटर को परिभाषित करें f v l=..., आपको दो बाइट्स

— बचाएगी

@flawr मुझे इसका विचार था v!l=..., लेकिन अगर इसे स्वीकार नहीं किया गया तो मैंने इसे नहीं लिया। मैं उत्तर संपादित करूँगा। धन्यवाद!

— 12

1

mapकुछ filterअभिव्यक्ति का उपयोग करना अक्सर एक संकेतक होता है कि एक सूची समझ कम हो सकती है v!l=[i|(i,x)<-zip[1..]l,x==v]:।

— लैकोनी

एक बिलिन भी है, लेकिन दुर्भाग्य से यह लाईकियोनिस सुझाव से अधिक लंबा है :)

— त्रुटी

3

भूसी , 5 बाइट्स

`fNm=

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

व्याख्या

       -- implicitly input a value v and a list L
   m=  -- map "equals v" over the list L, resulting in a list of truthy and falsy values
`fN    -- filter the natural numbers N by discarding the numbers at falsy positions 
          and keeping the ones at truthy positions

— Laikoni
स्रोत

क्या यह स्ट्रिंग्स के साथ सरणियों के लिए काम करता है, हालांकि?

— आधिकारिक

1

@officialaimm यह केवल स्ट्रिंग्स युक्त सूचियों के लिए काम करता है: इसे ऑनलाइन आज़माएं! मिश्रित प्रकार की सूचियाँ हास्केल द्वारा समर्थित नहीं हैं और इस प्रकार हस्क द्वारा, लेकिन ओपी ने टिप्पणियों में स्पष्ट रूप से इसकी अनुमति दी।

— लकोनी

क्या हस्क का एक दस्तावेज है?

— दोष

@flawr हाँ, यह github पृष्ठ पर विकि में है: github.com/barbuz/Husk/wiki

— Laikoni

@flawr यदि आपके पास सामान्य रूप से भूसी के डॉक्स के बारे में प्रश्न हैं, तो हमें चैट रूम में शामिल करें !

— जर्गर्ब

3

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

->e,a{i=-1;a.map{|x|i+=1;x==e&&i}-[!1]}

7 बाइट्स बचाए !!! एरिक डुमिनील को धन्यवाद।

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

— क्रिस्टियन लुपस्कू
स्रोत

-1 बाइट के !1लिए false।

— एरिक डुमिनील

3

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

->e,a{a.each_index.select{|x|a[x]==e}}

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

— Idva
स्रोत

2

PPCG में आपका स्वागत है!

— मार्टिन एंडर

3

Google शीट, 101 बाइट्स

=IfError(Join(",",Filter(Column(Offset(A1,0,0,1,Counta(Split(B1,",")))),Exact(Split(B1,","),A1))),"")

मूल्य Vमें A1और सरणी Aमें B1प्रत्येक प्रविष्टि के साथ एक अल्पविराम के द्वारा अलग। अशक्त एंट्रेस की अनुमति नहीं है (नीचे पंक्ति 5 से पता चलता है कि क्या होता है)।

स्पष्टीकरण:

Offset(A1,0,0,1,Counta(Split(B1,","))) एक ऐसी सीमा देता है जो एक पंक्ति लंबी होती है और जितने कॉलम चौड़े होते हैं उतने ही प्रविष्टियाँ होती हैं A1 ।

=IfError(Join(",",Filter(Column(~),Exact(Split(B1,","),A1))),"")उस मान के स्तंभ संख्या को फ़िल्टर करता है या नहीं, इसके आधार पर मान A1प्रत्येक मान में होता है B1और उन सभी को अल्पविराम वाली सूची में सम्मिलित करता है।

— इंजीनियर टोस्ट
स्रोत

3

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

कोड गोल्फ में पहला प्रयास।

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

(fn[a b](keep-indexed #(if(= %2 a)%1)b))

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

— देवो
स्रोत

3

एपीएल (Dyalog यूनिकोड) , 2 बाइट्स ^SBCS

बाएँ तर्क के रूप में देखने के लिए आइटम लेता है ( एक सबर्रे के बजाय लुकअप सरणी का एक आइटम खोजने के लिए स्केलर होना चाहिए ) और सही तर्क के रूप में लुकअप सरणी (जिसमें 15 आयाम हो सकते हैं)। सूचकांकों की सूची लौटाता है, जिनमें से प्रत्येक में लुकअप सरणी में आयामों की संख्या के रूप में कई तत्व हो सकते हैं।

⍸⍷

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

⍸ ɩ ndices जहाँ

⍷ मिल गया

— एडम
स्रोत

मैं कहने वाला था कि यह पाइथ को बाँधता है, लेकिन आप जानते हैं ... यूनिकोड। APL Dyalog Classic में यह 2 बाइट्स नहीं होगा (क्योंकि यह SBCS का उपयोग करता है)?

— श्री Xcoder

@Mr.Xcoder ⍸ isn't in the character set. Still, since Dyalog uses way less than 256 unique chars, it could have been a single byte. When we add new glyphs, we refrain from changing the character set so that backwards compatibility is maintained.

— Adám

Ah, Thanks! (I have no idea how APL / Dyalog works)

— Mr. Xcoder

@Mr.Xcoder APL is a commercial language (not a golfing language), so Dyalog have certain obligations to existing subscribers.

— Adám

APL isn't a golfing language, but there do exist open-source APL implementations (ngn and GNU).

— Zacharý

2

Batch, 86 bytes

@set i=0
:g
@if "%~2"=="" exit/b
@if %1==%2 echo %i%
@set/ai+=1
@shift/2
@goto g

Takes input as command line parameters (value then the array elements as separate parameters). Note: String quoting is considered part of the match e.g. "1" won't equal 1 (would cost 6 bytes).

— Neil
स्रोत

2

Python 2, 49 bytes

lambda l,v:filter(lambda i:l[i]==v,range(len(l)))

Try it online!

Not short enough, but I thought it was cool. ¯\_(ツ)_/¯

— totallyhuman
स्रोत

2

Perl 5, 28 bytes

sub{grep$_[$_]eq$_[0],1..@_}

Try it online!

The output is 1-indexed.
An anonymous function is quite unusual for Perl, but it happens to be the shortest I could think of. grep ..., 1 .. @_ iterates over the indexes of the input array (actually it goes one cell beyond the last, but it doesn't matter), keeping only the index that satisfy $_[$_]eq$_[0], ie. the ones where the value of the element ($_[$_]) is the same as the value we need to keep ($_[0]).

Slightly longer (31 bytes (30 + -l flag)), but as a full program:

$@=<>;$@eq$_&&print$.-1while<>

Try it online!

— Dada
स्रोत

2

Haskell, 37 33 bytes

import Data.List
findIndices.(==)

Thanks @Laikoni for -4 bytes!

Try it online!

— flawr
स्रोत

Pointfree is shorter: findIndices.(==)

— Laikoni

Oh right, that is even more pointfree, thanks=)

— flawr

1

Why not elemIndices?

— nimi

2

Java 8, 146 113 112 111 110 108 bytes

import java.util.*;l->o->{List r=new Stack();for(int i;(i=l.indexOf(o))>-1;l.set(i,null))r.add(i);return r;}

-2 bytes thanks to @TAsk by using Vector instead of ArrayList.
-1 byte by using Stack instead of Vector.
-2 bytes thanks to @Jakob by inputting a ArrayList instead of an array.

0-indexed

Explanation:

Try it here.

import java.util.*;    // Required import for Vector and Vector
l->o->{                // Method with List and Object parameters
  List r=new Stack();  //  Result-list
  for(int i;(i=l.indexOf(o))>=-1;
                       //  Loop as long as we can find the object in the list
    l.set(i,null))     //   After every iteration, remove the found item from the list
      r.add(i);        //    Add the index to the result-list
                       //  End of loop (implicit / single-line body)
  return r;            //  Return the result-List
}                      // End of method

— Kevin Cruijssen
स्रोत

1

Cool! If I am not wrong Vector may save few bytes. :)

— CoderCroc

1

@TAsk Thanks! Need to remember that one. I use List+ArrayList pretty often.

— Kevin Cruijssen

1

List r=new Vector(); will work, too.

— CoderCroc

1

You can save 1 byte by taking a list instead: TIO. Seems like a small enough change not to merit a separate answer.

— Jakob

The change breaks searching for null, but that's fine.

— Jakob

1

05AB1E, 4 bytes

Qƶ0K

Try it online!

It is 1-indexed, as shown below:

IN A-#------------------------> [2,3,3,3,4]
IN B-#------------------------> 3
-----#------------------------+-----------------
Q    # Vectorized equivalence | [0,1,1,1,0]
 ƶ   # Lift by index          | [0,2,3,4,0]
  0K # Remove zeros           | [2,3,4]

— Magic Octopus Urn
स्रोत

1

Mathematica, 12 bytes

Position@##&

1-Indexed

input [Array,Value]

[{12, 14, 14, 2, "Hello World!", 3, 12, 12}, 12]

output

{{1}, {7}, {8}}

— J42161217
स्रोत

Why not just Position?

— hftf

1

Haskell, 29 bytes

e#l=[i|(i,h)<-zip[0..]l,h==e]

Try it online!

— nimi
स्रोत

Does that work with the heterogeneous input cases? (Mixtures of integers, strings, a "true" value, etc).

— Kaz

@Kaz: no, it doesn't. It's polymorphic and works for every type where equality is defined for, but all list elements have to be of the same type. According to a comment in the OP that's enough.

— nimi

1

Japt, 9 bytes

mÈ¶V©YÄÃf

1-indexed.

Japt input doesn't support booleans, so they have been replaced with 0 and 1 in the test cases.

Try it online! with the -Q flag to format the array output.

0-indexed Solution, 11 bytes

l o f@gX ¶V

Try it online!

— Justin Mariner
स्रोत

One of the few times ¶ rather than ¥ comes in handy :P I was thinking of doing something along the lines of m@Y*(X¶V} f, but I hadn't realized that wouldn't work for index 0. 1-indexing is clever...

— ETHproductions

1

Perl 6, 21 bytes

{grep :k,*===$^v,@^z}

Try it online!

The :k adverb to grep tells it to return the matching keys (indices) of the input sequence that match the predicate * === $^v.

If strings and numbers were considered equivalent, one could use a grep predicate of just $^v instead of * === $^v.

— Sean
स्रोत

eqv might be better than === depending on what you want to consider equivalent values.

— Brad Gilbert b2gills

1

Common Lisp, 66 bytes

(lambda(x s)(loop as i in s as j from 0 when(equal i x)collect j))

Try it online!

— Renzo
स्रोत

1

TXR Lisp, 26 bytes

(op where(op equal @@1)@2)

In other words, "Where is argument 2 equal to argument 1?"

Run:

1> (op where(op equal @@1) @2)
#<interpreted fun: lambda (#:arg-01-0166 #:arg-02-0167 . #:rest-0165)>
2> [*1 12 #(12 14 14 2 "Hello world!" 3 12 12)]
(0 6 7)
3> [*1 "Hello World" #("Hi" "Hi world!" 12 2 3 t)]
nil

— Kaz
स्रोत

1

Clojure, 39 38 bytes

#(filter(comp #{%2}%)(range(count %)))

A bit obscure :) The first input argument is a vec of values and the second one is the searched value. % maps indexes to values, and the set #{%2} returns truthy (the input argument %2) or falsy nil for that value. comp composes these together.

— NikoNyrh
स्रोत

1

C 340 362 166 115 Bytes

Hello all. My first time here. I figured since I enjoy (attempting) to write optimized code I may as well give this a try.

@Rodney - ~39 bytes from the includes

@Zacharý - 7 bytes with implicit typing

0-indexed.

How to Run:

As per @Arnolds suggestion, the program takes arguments in a much more C friendly manner. This let me reduce the size of the file by a little more than half.

The arguments should be passed in the following order value [element1 ...] where braces indicate optional arguments

You may or may not have to add escaped quotes to any strings that are provided in order to satisfy the condition of 12 != "12". On my system the this can be done in the following manner

prog-name.exe 12 3 "Hello" 12 4 "12"
Returns [2,4]     < This is incorrect

prog-name.exe 12 3 "\"Hello\"" 12 4 "\"12\""
Returns [2]       < Correct

golfed

#define P printf(
b=0;main(int c,char**v){P"[");for(--c;c-1;c--)b|=strcmp(v[1],v[c])?0:P b?",%i":"%i",c-2);P"]");}

ungolfed

#define P printf(

//Implicit only works in global(I totally knew this after almost 4 years of C :P)
b = 0;
main(int c,char**v)
{

    P"[");

    //match loop
    //b is used to determine if this is the first iteration. it can be assumed that printf will always return >0
    //subract two from c to get correct index number of match
    for(--c; c-1; c--)
        b |= strcmp(v[1], v[c]) ? 0 : P b ? ",%i" : "%i", c-2);

    P"]");

    return 0;
}

— Marcos
स्रोत

1

Welcome to the site. I notice you have a lot of extra whitespace. Particularly around operators i = 0. These can be removed. I suggest playing around with the whitespace a bit.

— Wheat Wizard

With the way you handle the list, a first argument of ,12 and second argument of [12,14,14,2,"Hello World!",3,12,12] prints [5,6] which is technically incorrect.

— Arnold Palmer

@ArnoldPalmer I updated the code to make it a little more verbose at detecting data types. However, since C doesn't have all the fancy type conversion such as JavaScript, it is still vulnerable to having a comma in a 'number' type. I pretty much just left it assuming correctly formatted input.

— Marcos

@Marcos There's a chance you may be able to take each value of the array as it's own command line argument. I don't golf in C ever, so not quite sure what the rules are, but it doesn't seem unreasonable to me that you'd be allowed to do that. Especially since accepting the array as a list leaves you vulnerable to this problem. Also, you still have a bit of white space in your golfed code. You don't need the spaces on the #include statements, strstr(h+i,n)-h ==i has an extra space, and you can do return-1 instead of return -1.

— Arnold Palmer

are implicit declarations allowed? I think you can ditch the #include statements

— Rodney

मेरा मूल्य कहाँ है?

आपका कार्य:

इनपुट:

आउटपुट:

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

स्कोरिंग:

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

व्याख्या

MATL , 2 बाइट्स

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

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

आर (+ प्रायर), 20 बाइट्स

जावास्क्रिप्ट, 39 बाइट्स

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

05AB1E , 4 बाइट्स

सी #, 88 72 बाइट्स

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

हास्केल , 41 39 बाइट्स

भूसी , 5 बाइट्स

व्याख्या

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

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

Google शीट, 101 बाइट्स

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

एपीएल (Dyalog यूनिकोड) , 2 बाइट्स SBCS

Batch, 86 bytes

Python 2, 49 bytes

Perl 5, 28 bytes

Haskell, 37 33 bytes

Java 8, 146 113 112 111 110 108 bytes

05AB1E, 4 bytes

Mathematica, 12 bytes

Haskell, 29 bytes

Japt, 9 bytes

0-indexed Solution, 11 bytes

Perl 6, 21 bytes

Common Lisp, 66 bytes

TXR Lisp, 26 bytes

Clojure, 39 38 bytes

C 340 362 166 115 Bytes

एपीएल (Dyalog यूनिकोड) , 2 बाइट्स ^SBCS