किसी तत्व को खोजने का कुशल तरीका

Question 1

हाल ही में मेरा एक साक्षात्कार था, जहां उन्होंने मुझसे " खोज " की " प्रश्न पूछा था।
सवाल यह था:

मान लें कि (सकारात्मक) पूर्णांकों की एक सरणी है, जिनमें से प्रत्येक तत्व +1या तो है-1 अपने आसन्न तत्वों की तुलना में ।

उदाहरण:
array = [4,5,6,5,4,3,2,3,4,5,6,7,8];
अब खोजते हैं 7 और अपनी स्थिति वापस करें।

मैंने इसका उत्तर दिया:

मूल्यों को एक अस्थायी सरणी में संग्रहीत करें, उन्हें सॉर्ट करें, और फिर बाइनरी खोज लागू करें।

यदि तत्व पाया जाता है, तो अस्थायी सरणी में अपनी स्थिति लौटाएं।
(यदि संख्या दो बार हो रही है तो इसकी पहली घटना लौटाएं)

लेकिन, वे इस जवाब से संतुष्ट नहीं दिखे।

सही उत्तर क्या है?

Question 2

आप उन चरणों के साथ एक रेखीय खोज कर सकते हैं जो अक्सर 1 से अधिक होते हैं। महत्वपूर्ण अवलोकन यह है कि अगर उदाहरण के लिए 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

संपादित करें: @Raphael Miedl और @Martin Zabel की टिप्पणियों के बाद सुधार हुआ।

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

जॉन कोलमैन द्वारा प्रस्तुत दृष्टिकोण वह है जो साक्षात्कारकर्ता उम्मीद कर रहा था, सभी संभावना में।
आप बहुत-सी जटिल जाने के इच्छुक हैं, तो आप उम्मीद छोड़ लंबाई में वृद्धि कर सकते हैं:
कॉल लक्ष्य मान कश्मीर । पहले तत्व के मूल्य v से स्थिति p पर शुरू करें और अंतर kv DV को निरपेक्ष मान av के साथ कहें । नकारात्मक खोजों को गति देने के लिए, अंतिम तत्व पर स्थिति o पर अन्य मान u के रूप में एक तिरछी नज़र रखें: यदि DV × du ऋणात्मक है, तो k मौजूद है (यदि k की कोई भी घटना स्वीकार्य है, तो आप यहां अनुक्रमणिका सीमा को संकीर्ण कर सकते हैं, जिस तरह से बाइनरी खोज करता है)। यदि av + au सरणी की लंबाई से अधिक है, तो k अनुपस्थित है। (यदि DV × du शून्य है, v या u बराबर k है।)
सूचकांक की वैधता को छोड़ते हुए: जांच करें ("अगला") स्थिति जहां अनुक्रम बीच में k के साथ v पर वापस आ सकता है o = p + 2*av:।
यदि DV × डु ऋणात्मक है, तो p + av से o-au तक k (पुनरावर्ती) खोजें;
यदि यह शून्य है, तो यू ओ के बराबर है।
यदि डु DV के बराबर है और बीच में मान k नहीं है, या au av से अधिक है,
या आप p + av से o-au तक k को खोजने में असफल हैं,
तो p=o; dv=du; av=au;रहने दें और जांच करते रहें।
(60 के दशक के ग्रंथों के लिए एक पूर्ण फ्लैश-बैक के लिए, कूरियर के साथ देखें। मेरा "1 दूसरा विचार" का उपयोग करना थाo = p + 2*av - 1, जो डु के बराबर है DV ।

Question 6

चरण 1

पहले तत्व से शुरू करें और जांचें कि क्या यह 7. चलो कहते cहैं कि वर्तमान स्थिति का सूचकांक है। तो, शुरू में, c = 0।

चरण 2

यदि यह 7 है, तो आपने सूचकांक पाया। यह है c। यदि आप सरणी के अंत तक पहुँच चुके हैं, तो विराम लें।

चरण 3

यदि यह नहीं है, तो 7 को कम से कम |array[c]-7|स्थिति में होना चाहिए क्योंकि आप केवल प्रति यूनिट एक इकाई जोड़ सकते हैं। इसलिए, |array[c]-7|अपने वर्तमान सूचकांक में जोड़ें , ग, और जांच के लिए फिर से STEP 2 पर जाएं।

सबसे खराब स्थिति में, जब वैकल्पिक 1 और 1s होते हैं, तो समय जटिलता O (n) तक पहुंच सकती है, लेकिन औसत मामलों को शीघ्रता से वितरित किया जाएगा।

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);

समस्या के पुनरावर्ती समाधान को शामिल करना चाहता था। का आनंद लें