কোনও উপাদান অনুসন্ধান করার দক্ষ উপায়

Question 1

সম্প্রতি আমার একটি সাক্ষাত্কার হয়েছিল, যেখানে তারা আমাকে একটি " অনুসন্ধান " প্রশ্ন জিজ্ঞাসা করেছিলেন।
প্রশ্নটি ছিল:

ধরুন এখানে (ধনাত্মক) পূর্ণসংখ্যার একটি অ্যারে রয়েছে যার মধ্যে প্রতিটি উপাদান হয় +1বা -1তার সাথে সংলগ্ন উপাদানগুলির সাথে তুলনা করা হয় ।

উদাহরণ:
array = [4,5,6,5,4,3,2,3,4,5,6,7,8];
এখন অনুসন্ধান করুন 7এবং এর অবস্থানটি ফিরে আসুন ।

আমি এই উত্তরটি দিয়েছি:

অস্থায়ী অ্যারেতে মানগুলি সঞ্চয় করুন, সেগুলি সাজান এবং তারপরে বাইনারি অনুসন্ধান প্রয়োগ করুন।

যদি উপাদানটি পাওয়া যায়, অস্থায়ী অ্যারেতে এর অবস্থানটি ফিরে আসুন।
(যদি সংখ্যাটি দু'বার হয়ে থাকে তবে তার প্রথম উপস্থিতিটি ফিরিয়ে দিন)

তবে তারা এই উত্তরটি নিয়ে সন্তুষ্ট বলে মনে হয় নি।

সঠিক উত্তর কি?

Question 2

আপনি প্রায় 1 টিরও বেশি বারের ধাপগুলির সাথে লিনিয়ার সন্ধান করতে পারেন ob গুরুত্বপূর্ণ পর্যবেক্ষণটি হ'ল যদি উদাহরণস্বরূপ array[i] == 4এবং 7 এখনও উপস্থিত না হয় তবে পরবর্তী প্রার্থীর জন্য 7 সূচীতে রয়েছে i+3। কিছুক্ষণের লুপটি ব্যবহার করুন যা বার বার সরাসরি পরবর্তী সম্ভাব্য প্রার্থীর কাছে যায়।

এখানে একটি বাস্তবায়ন, কিছুটা সাধারণীকরণ করা হল। এটি kঅ্যারেতে প্রথম ঘটনাটি আবিষ্কার করে (+ = 1 টি বিধিনিষেধ সাপেক্ষে) বা -1যদি এটি না ঘটে:

#include <stdio.h>
#include <stdlib.h>

int first_occurence(int k, int array[], int n);

int main(void){
    int a[] = {4,3,2,3,2,3,4,5,4,5,6,7,8,7,8};
    printf("7 first occurs at index %d\n",first_occurence(7,a,15));
    printf("but 9 first \"occurs\" at index %d\n",first_occurence(9,a,15));
    return 0;
}

int first_occurence(int k, int array[], int n){
    int i = 0;
    while(i < n){
        if(array[i] == k) return i;
        i += abs(k-array[i]);
    }
    return -1;
}

আউটপুট:

7 first occurs at index 11
but 9 first "occurs" at index -1

Question 3

আপনার পদ্ধতিটি খুব জটিল। আপনার প্রতিটি অ্যারে উপাদান পরীক্ষা করার দরকার নেই। প্রথম মান 4তাই হয়, 7হয় অন্তত 7-4 উপাদান দূরে, এবং আপনাকে সেই এড়িয়ে যেতে পারেন।

#include <stdio.h>
#include <stdlib.h>

int main (void)
{
    int array[] = {4,5,6,5,4,3,2,3,4,5,6,7,8};
    int len = sizeof array / sizeof array[0];
    int i = 0;
    int steps = 0;
    while (i < len && array[i] != 7) {
        i += abs(7 - array[i]);
        steps++;
    }

    printf("Steps %d, index %d\n", steps, i);
    return 0;
}

প্রোগ্রাম আউটপুট:

Steps 4, index 11

সম্পাদনা: @ রাফেল মিডেল এবং @ মার্টিন জ্যাবেলের মন্তব্যের পরে উন্নতি হয়েছে।

Question 4

প্রচলিত রৈখিক অনুসন্ধানের একটি ভিন্নতা যাওয়ার ভাল উপায় হতে পারে। আমাদের একটি উপাদান চয়ন করুন array[i] = 2। এখন, array[i + 1]হয় হয় 1 বা 3 (বিজোড়) array[i + 2]হবে , (কেবল ধনাত্মক পূর্ণসংখ্যাগুলি) 2 বা 4 (এমনকি সংখ্যা) হবে।

এভাবে চলতে থাকলে, একটি প্যাটার্নটি পর্যবেক্ষণযোগ্য - সমান array[i + 2*n]সংখ্যক ধারণ করবে এবং তাই এই সমস্ত সূচকগুলি উপেক্ষা করা যেতে পারে।

এছাড়াও, আমরা এটি দেখতে পারি

array[i + 3] = 1 or 3 or 5
array[i + 5] = 1 or 3 or 5 or 7

সুতরাং, সূচকটি i + 5পরবর্তী পরীক্ষা করা উচিত এবং কিছুক্ষণের মধ্যে লুপটি সূচীতে প্রাপ্ত মানের উপর নির্ভর করে চেক করার জন্য পরবর্তী সূচকটি নির্ধারণ করতে ব্যবহার করা যেতে পারে i + 5।

যদিও এর জটিলতা রয়েছে O(n)(অ্যাসিপটোটিক জটিলতার ক্ষেত্রে লিনিয়ার সময়), সমস্ত সূচকগুলি পরিদর্শন করা না হওয়ায় এটি ব্যবহারিক দিক থেকে স্বাভাবিক রৈখিক অনুসন্ধানের চেয়ে ভাল।

স্পষ্টতই, array[i](আমাদের প্রারম্ভিক বিন্দু) বিজোড় হলে এই সমস্তটি বিপরীত হবে ।

Question 5

জন কোলেম্যান উপস্থাপিত পদ্ধতিটি সমস্ত সম্ভাবনার ক্ষেত্রে সাক্ষাত্কারকারীর প্রত্যাশা ছিল।
আপনি যদি আরও কিছুটা জটিল হতে ইচ্ছুক হন তবে আপনি প্রত্যাশিত এড়িয়ে যাওয়ার দৈর্ঘ্য বাড়িয়ে তুলতে পারেন:
টার্গেট মান কে । প্রথম উপাদনের মান দিয়ে শুরু করুন বনাম অবস্থানে পি এবং পার্থক্য কেভি কল DV পরম মান Av । গতি নেতিবাচক অনুসন্ধানে, অন্যান্য মান হিসাবে শেষ উপাদান একটি উঁকি আছে তোমার দর্শন লগ করা অবস্থানে ণ: যদি ডিভি negative ড নেগেটিভ থাকে, কে উপস্থিত থাকে (কে-এর কোনও ঘটনা যদি গ্রহণযোগ্য হয় তবে আপনি বাইনারি অনুসন্ধানের পদ্ধতি অনুসারে সূচি পরিসরটি এখানে সংক্ষিপ্ত করতে পারেন)। যদি av + au অ্যারের দৈর্ঘ্যের চেয়ে বড় হয় তবে k অনুপস্থিত। (যদি DV × ডু শূন্য, বনাম অথবা U ট সমান।)
( "পরবর্তী") অবস্থান যেখানে ক্রম মাঝখানে ট সঙ্গে বনাম ফিরে আসতে পারে প্রোব: সূচক বৈধতা ছেড়ে যাওয়া হচ্ছে: o = p + 2*av।
যদি ডিভি × ড negativeণাত্মক হয় তবে পি + অ্যাভ থেকে ও-অউ-তে কে (পুনরাবৃত্তভাবে?) সন্ধান করুন;
যদি এটি শূন্য হয় তবে আপনি কে তে সমান হন।
ডু DV সমান যদি মাঝখানে মান k করা হয় না, বা অ Av অতিক্রম করে
অথবা আপনি ব্যর্থ পি থেকে ট এটি + + Av হে-অ,
দিন p=o; dv=du; av=au;এবং অনুসন্ধান রাখা।
('60 এর পাঠ্যগুলির পুরো ফ্ল্যাশ-ব্যাকের জন্য, কুরিয়ারের সাথে দেখুন My আমার "1 ম দ্বিতীয় চিন্তা") ব্যবহার করা উচিতo = p + 2*av - 1, যা du সমান ডিভির সমাপ্ত হয় ))

Question 6

ধাপ 1

প্রথম উপাদানটি দিয়ে শুরু করুন এবং এটি check রয়েছে কিনা তা যাচাই করে দেখি cবর্তমান অবস্থানের সূচি of সুতরাং, প্রাথমিকভাবে c = 0,।

ধাপ ২

যদি এটি 7 হয় তবে আপনি সূচকটি খুঁজে পেয়েছেন। এটা c। আপনি যদি অ্যারের শেষ প্রান্তে পৌঁছে গেছেন তবে ব্রেক আউট করুন।

ধাপ 3

যদি এটি না হয়, তবে 7 অবশ্যই ন্যূনতম |array[c]-7|অবস্থানের দূরে থাকতে হবে কারণ আপনি কেবলমাত্র সূচক প্রতি ইউনিট যুক্ত করতে পারেন। অতএব, |array[c]-7|আপনার বর্তমান সূচীতে যুক্ত করুন, সি, এবং চেক করতে আবার স্টেপ 2 এ যান।

সবচেয়ে খারাপ ক্ষেত্রে, যখন বিকল্প 1 এবং -1 হয়, সময় জটিলতা ও (এন) এ পৌঁছতে পারে, তবে গড় কেসগুলি দ্রুত সরবরাহ করা হবে।

Question 7

এখানে আমি জাভাতে বাস্তবায়ন দিচ্ছি ...

public static void main(String[] args) 
{       
    int arr[]={4,5,6,5,4,3,2,3,4,5,6,7,8};
    int pos=searchArray(arr,7);

    if(pos==-1)
        System.out.println("not found");
    else
        System.out.println("position="+pos);            
}

public static int searchArray(int[] array,int value)
{
    int i=0;
    int strtValue=0;
    int pos=-1;

    while(i<array.length)
    {
        strtValue=array[i];

        if(strtValue<value)
        {
            i+=value-strtValue;
        }
        else if (strtValue==value)
        {
            pos=i;
            break;
        }
        else
        {
            i=i+(strtValue-value);
        }       
    }

    return pos;
}

Question 8

এখানে একটি বিভাজন এবং বিজয়ী শৈলী সমাধান। আরও অনেক হিসাবরক্ষণের ব্যয়ে, আমরা আরও উপাদান এড়িয়ে যেতে পারি; বাম-থেকে-ডান স্ক্যান না করে মাঝখানে পরীক্ষা করুন এবং উভয় দিক ছেড়ে যান ।

#include <stdio.h>                                                               
#include <math.h>                                                                

int could_contain(int k, int left, int right, int width);                        
int find(int k, int array[], int lower, int upper);   

int main(void){                                                                  
    int a[] = {4,3,2,3,2,3,4,5,4,5,6,7,8,7,8};                                   
    printf("7 first occurs at index %d\n",find(7,a,0,14));                       
    printf("but 9 first \"occurs\" at index %d\n",find(9,a,0,14));               
    return 0;                                                                    
}                                                                                

int could_contain(int k, int left, int right, int width){                        
  return (width >= 0) &&                                                         
         (left <= k && k <= right) ||                                            
         (right <= k && k <= left) ||                                            
         (abs(k - left) + abs(k - right) < width);                               
}                                                                                

int find(int k, int array[], int lower, int upper){                              
  //printf("%d\t%d\n", lower, upper);                                            

  if( !could_contain(k, array[lower], array[upper], upper - lower )) return -1;  

  int mid = (upper + lower) / 2;                                                 

  if(array[mid] == k) return mid;                                                

  lower = find(k, array, lower + abs(k - array[lower]), mid - abs(k - array[mid]));
  if(lower >= 0 ) return lower;                                                    

  upper = find(k, array, mid + abs(k - array[mid]), upper - abs(k - array[upper]));
  if(upper >= 0 ) return upper;                                                  

  return -1;                                                                     

}

Question 9


const findMeAnElementsFunkyArray = (arr, ele, i) => {
  const elementAtCurrentIndex = arr[i];

  const differenceBetweenEleAndEleAtIndex = Math.abs(
    ele - elementAtCurrentIndex
  );

  const hop = i + differenceBetweenEleAndEleAtIndex;

  if (i >= arr.length) {
    return;
  }
  if (arr[i] === ele) {
    return i;
  }

  const result = findMeAnElementsFunkyArray(arr, ele, hop);

  return result;
};

const array = [4,5,6,5,4,3,2,3,4,5,6,7,8];

const answer = findMeAnElementsFunkyArray(array, 7, 0);

console.log(answer);

সমস্যার পুনরাবৃত্ত সমাধান সমাধান করতে চেয়েছিলেন an উপভোগ করুন