আমার মান কোথায়?

20

আমার বস এখন আমাকে এমন একটি প্রক্রিয়া প্রয়োগ করতে চান যা তাকে অ্যারেতে কোনও আইটেম সন্ধান করতে দেয় এবং যেখানে সেই মানটি ঘটে তাকে সূচক / সূচক দেয়।

তোমার কাজ:

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা একটি অ্যারে এবং একটি মান (স্ট্রিং, ইন্টিজার, ফ্লোট, বা বুলিয়ান) গ্রহণ করে এবং অ্যারের সূচকগুলি দেয় যেখানে মানটি হয় (হয় 0 বা 1 সূচকযুক্ত, আপনি যেটিকে পছন্দ করুন)। মানটি অ্যারেতে না থাকলে একটি খালি অ্যারে ফিরিয়ে দেয়।

ইনপুট:

একটি অ্যারে এবং একটি মান ভি, যা এ-তে উপস্থিত থাকতে পারে বা নাও থাকতে পারে

আউটপুট:

ইনডিস (গুলি) সমন্বিত একটি অ্যারে যেখানে ভি এ হয় এবং যদি ভি এ-তে ঘটে না যায় তবে একটি ফাঁকা অ্যারে থাকে।

পরীক্ষার কেস:

দয়া করে মনে রাখবেন পরীক্ষার কেসগুলি 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
আমরা কী ধরে নিতে পারি যে প্রদত্ত অ্যারেতে কেবল সেগুলির মধ্যে একটি রয়েছে (যেমন মিশ্র প্রকারযুক্ত কোনও অ্যারে নেই) কারণ অনেকগুলি ভাষা একাধিক প্রকারের অ্যারে বা তালিকাকে সমর্থন করে না।
— flawr
1
অবশ্যই, @ ফ্লোয়ার আপনি ধরে নিতে পারেন যে অ্যারেতে কেবল একই ধরণের মানগুলি যাচাই করার জন্য যাচাই করতে হবে, যদি আপনার ভাষার প্রয়োজন হয় ist
— গ্রিফন - মনিকা
2
আপনার সমস্ত অ্যারে 1 ডি। ধৃষ্টতা?
— অ্যাডম
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
— মিঃ এক্সকোডার
সূত্র
আপনি সমস্ত ঘটনা কেবল প্রথমটিই নয় ফেরত দেওয়ার কথা।
— এরিক দ্য আউটগল্ফার
পছন্দ করেছেন এগুলি কেবল বিপরীত ক্রমে নিয়ে যান।
— মিঃ এক্সকোডার
1
পাইথ অবশ্যই কাজের জন্য সর্বোত্তম হাতিয়ার: পি
— মিঃ এক্সকোডার
7

এমএটিএল , 2 বাইট

mf

mহ্রাস দুটি আর্গুমেন্ট, এবং চেক অ্যারের মধ্যে প্রতিটি উপাদান কিনা অন্যান্য যুক্তি সমান, fএকটি অ্যারের truthy এন্ট্রি সূচকের ফেরৎ।

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

— flawr
সূত্র
এটি প্রস্তাবিত পরীক্ষাগুলির ক্ষেত্রে যেমন অষ্টাভ সমাধানের জন্য একই কাজ করবে বলে মনে হচ্ছে না।
— সিনাসকি
স্ট্রিংগুলির অ্যারেগুলি সঠিকভাবে পরিচালনা করার ismemberপরিবর্তে আপনার ব্যবহার করা উচিত =। mf
— স্যুভার
@ লুইসমেডো আমাদের মিশ্র ইনপুট বিবেচনা করার দরকার নেই, ওপি থেকে স্পষ্টতা দেখুন!
— flawr
@ ফ্লোয়ার ওহ, কেন এটি কেবল একটি মন্তব্যে, এবং চ্যালেঞ্জ পাঠ্যে নয়? : - /
— লুইস মেন্ডো
আপনাকে ওপিকে জিজ্ঞাসা করতে হবে, আমাকে নয় :)
— flawr
7

পাইথন 3 , 45 বাইট

-3 বাইটস @ এরিকথ আউটগল্ফার এবং @ ক্রিস_আর্যান্ডসকে ধন্যবাদ

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]

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেসগুলি পরীক্ষা করে দেখুন

— মিঃ এক্সকোডার
সূত্র
enumerate()এটিকে
— কয়েকটা
@ ক্রিস_আরেন্ডস দীর্ঘ হওয়ার পরে শেষ হয়েছে।
— মিঃ এক্সকোডার
3
lambda n,l:[x for x,y in enumerate(l)if y==n]
— এরিক দি আউটগল্ফার
আমি বোঝাই যাছিলাম এরিকথিউটগল্ফার যা বলেছিলেন
— ক্রিস_আরেন্ডস
1
@ জোনাথান অ্যালান ফিক্সড
— মিঃ এক্সকোডার
6

আর (+ পিএসআর), 20 বাইট

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

যা ফাংশন মূল্যায়ন

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

যেখানে হয় সন্ধানের aজন্য মূল্য এবং bভেক্টর, বা অন্য উপায়ে হতে পারে। অসম দৈর্ঘ্যের দুটি ভেক্টর (যখন একটি একক মানের দৈর্ঘ্য -১ ভেক্টর হিসাবে গণনা করা হয়) উপস্থাপিত হবে, আর আর এর দৈর্ঘ্যের দৈর্ঘ্যের সাথে মিলে সংক্ষিপ্ত একটিকে আবৃত করবে। তারপরে সমতা পরীক্ষা করা হয়। এটি একটি লজিকাল ভেক্টর উত্পন্ন করে। 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']));
স্নিপেট প্রসারিত করুন

উপরের স্নিপেটটি সমস্ত ব্রাউজারে কাজ না করতে পারে, তাই এখানে একটি টিআইও লিঙ্ক দেওয়া আছে ।

— ক্রিশ্চিয়ান লুপাস্কু
সূত্র
6

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

ক্রস করা হয়েছে 44 এখনও নিয়মিত 44; (

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

@ আরনাউল্ডকে ধন্যবাদ 1 বাইট সংরক্ষণ করা হয়েছে

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]
স্নিপেট প্রসারিত করুন

— জোহান কার্লসন
সূত্র
আপনি কি ===কোনও ==বাইট কম কমিয়ে স্বাভাবিক করতে পারেন ? আমি আক্ষরিক একই জিনিস, পরিবর্তনশীল নাম এবং সমস্ত haha ​​সঙ্গে এসেছি।
— কামোরোসো94
4
===এর থেকে আলাদা 12হওয়া দরকার"12"
— ক্রিস্টোফ
1
@ কামোরসো94 নং, এখানে কেন।
— পিওরফেরেট
5

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

QāsÏ

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

1-ইন্ডেক্স।

— এরিক দ্য আউটগল্ফার
সূত্র
আমি মনে করি আমাদের উভয়ই ইনপুটগুলিতে বিভ্রান্ত হয়: 12এবং [12,'12'], যদি না তিনি বলেন যে এটি এমন ভাষাগুলির জন্য ঠাণ্ডা যা প্রকৃত পক্ষে কংক্রিটের ধরণের নয় এবং প্রকারের বিষয়ে চিন্তা না করে।
— ম্যাজিক অক্টোপাস উরন
আমি আসলে মনে 12≠ '12'05AB1E কারণ কখনও কখনও তারা ভিন্নভাবে আচরণ ... না নিশ্চিত কোনো সমতা পরীক্ষা যা যদিও এই ধরনের একটি জিনিস সমর্থন করতে পারে না আছে কিনা।
— এরিক দি আউটগল্ফার
আমরা যদি তাদের পূর্ণসংখ্যার বৈধতার জন্য পরীক্ষা করতে চেয়েছিলাম তবে আমাদের উত্তরগুলি 60 বাইট ব্যবহারের মতো হবে is_alpha (a)এবং is_number (d)আমি মনে করি আমরা অন্যথায় না বলা পর্যন্ত আমাদের বৈধ বলে ধরে নিতে পারি।
— ম্যাজিক অক্টোপাস উরন
5

C#, 88 72 bytes

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

Saved 16 bytes thanks to @LiefdeWen.

Try it online!

— TheLethalCoder
সূত্র
Amazing, I was still trying to figure out why i==o doesn't work.
— LiefdeWen
3
@LiefdeWen Boxed value types.
— TheLethalCoder
72 bytes using System.Linq;a=>b=>a.Select((x,i)=>x.Equals(b)?i:-1).Where(x=>x>=0)
— LiefdeWen
@LiefdeWen Nice one, I wouldn't have thought of switching it around.
— TheLethalCoder
You can save a lot :) : tio.run/…
— digEmAll
3

Haskell, 41 39 bytes

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

Try it online!

Saved two bytes thanks to @flawr

Haskell is statically typed, so I had to use a little workaround to run the test cases.

— jferard
সূত্র
You don't need your workaround anymore, see the comment of the OP.
— flawr
1
Also define a operator v#l=... instead of f v l=..., will save you two bytes:)
— flawr
@flawr I had the idea of v!l=..., but didn't kow if it was accepted. I'll edit the answer. Thanks!
— jferard
1
Using map on some filter expression is often an indicator that a list comprehension might be shorter: v!l=[i|(i,x)<-zip[1..]l,x==v].
— Laikoni
There is also a builtin, but unfortunately it is longer than Laikionis suggestion:)
— flawr
3

Husk, 5 bytes

`fNm=

Try it online! 1-indexed.

Explanation

       -- 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
সূত্র
Does this work for arrays with strings, though?
— officialaimm
1
@officialaimm It works for lists containing only strings: Try it online! Lists of mixed types are not supported by Haskell and thus by Husk, but OP allowed this explicitly in the comments.
— Laikoni
Is there a documentation of Husk?
— flawr
@flawr Yes, it's in the wiki on the github page: github.com/barbuz/Husk/wiki
— Laikoni
@flawr If you have questions about the docs of Husk in general, join us in the chatroom!
— Zgarb
3

Google Sheets, 101 bytes

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

Value V in A1 and array A in B1 with each entry separated by a comma. Null entires are not allowed (row 5 below shows what happens).

Result

Explanation:

Offset(A1,0,0,1,Counta(Split(B1,","))) returns a range that is one row tall and as many columns wide as there are entries in A1.

=IfError(Join(",",Filter(Column(~),Exact(Split(B1,","),A1))),"") filters the column numbers of that range based on whether or not the value in A1 is exactly each of the values in B1 and concatenates them all in a comma-delineated list.

— Engineer Toast
সূত্র
3

Clojure, 40 bytes

First attempt at code golf.

keep-indexed maps a function over a collection here, passing the current index into the callback and yielding any non-nil return values.

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

Try it online!

— Devo
সূত্র
3

APL (Dyalog Unicode), 2 bytesSBCS

Takes item to look for as left argument (must be scalar to find an item of the lookup array rather than a subarray) and the lookup array (which may have up to 15 dimensions) as right argument. Returns list of indices, each of which may has as many elements as the number of dimensions in the lookup array.

⍸⍷

Try it online!

⍸ ɩndices where

⍷ found

— Adám
সূত্র
I was about to say it ties Pyth, but you know... Unicode. Wouldn't this be 2 bytes in APL Dyalog Classic (since it uses SBCS)?
— Mr. 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

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

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

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
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.