Maneira eficiente de pesquisar um elemento

Recentemente, tive uma entrevista, onde me fizeram uma pergunta " investigativa ".
A questão era:

Assuma que existe uma matriz de números inteiros (positivos), dos quais cada elemento é ou +1ou -1em relação aos seus elementos adjacentes.

Exemplo:

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

Agora procure 7e retorne sua posição.

Eu dei esta resposta:

Armazene os valores em uma matriz temporária, classifique-os e aplique a pesquisa binária.

Se o elemento for encontrado, retorne sua posição na matriz temporária.
(Se o número estiver ocorrendo duas vezes, retorne a primeira ocorrência)

Mas eles não pareciam satisfeitos com esta resposta.

Qual é a resposta certa?

Você pode fazer uma pesquisa linear com etapas que geralmente são maiores do que 1. A observação crucial é que, se eg array[i] == 4e 7 ainda não apareceram, o próximo candidato para 7 está no índice i+3. Use um loop while que repetidamente vai diretamente para o próximo candidato viável.

Aqui está uma implementação, ligeiramente generalizada. Encontra a primeira ocorrência de kna matriz (sujeito à restrição + = 1) ou -1se não ocorrer:

#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;
}

resultado:

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

Sua abordagem é muito complicada. Você não precisa examinar todos os elementos da matriz. O primeiro valor é 4, portanto 7está, pelo menos, 7-4 elementos ausentes, e você pode pular esses.

#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;
}

Resultado do programa:

Steps 4, index 11

Editar: melhorado após comentários de @Raphael Miedl e @Martin Zabel.

Uma variação da pesquisa linear convencional pode ser um bom caminho a percorrer. Vamos escolher um elemento, digamos array[i] = 2. Agora, array[i + 1]será 1 ou 3 (ímpar), array[i + 2]será (somente números inteiros positivos) 2 ou 4 (número par).

Ao continuar assim, um padrão é observável - array[i + 2*n]manterá números pares e, portanto, todos esses índices podem ser ignorados.

Além disso, podemos ver que

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

portanto, o índice i + 5deve ser verificado em seguida e um loop while pode ser usado para determinar o próximo índice a ser verificado, dependendo do valor encontrado no índice i + 5.

Embora isso tenha complexidade O(n)(tempo linear em termos de complexidade assintótica), é melhor do que uma pesquisa linear normal em termos práticos, pois todos os índices não são visitados.

Obviamente, tudo isso será revertido se array[i](nosso ponto de partida) for estranho.

A abordagem apresentada por John Coleman é o que o entrevistador esperava, com toda a probabilidade.
Se você estiver disposto a ir um pouco mais complicado, pode aumentar a duração esperada do salto:
Chame o valor alvo k . Comece com o valor do primeiro elemento v na posição p e chame a diferença kv dv com o valor absoluto av . Para acelerar pesquisas negativas, dê uma olhada no último elemento como o outro valor u na posição o: se dv × du for negativo, k está presente (se qualquer ocorrência de k for aceitável, você pode restringir o intervalo do índice aqui da forma como a pesquisa binária faz). Se av + au for maior que o comprimento da matriz, k estará ausente. (Se dv × du é zero, V ou L é igual a k.)
Omitindo validade índice: Sonda o ( "Avançar") posição onde a sequência pode voltar a v com k no meio: o = p + 2*av.
Se dv × du for negativo, encontre k (recursivamente?) De p + av para o-au;
se for zero, u é igual a k em o.
Se du é igual a dv e o valor no meio não é k, ou au excede av,
ou você não consegue encontrar k de p + av para o-au,
deixe p=o; dv=du; av=au;e continue sondando.
(Para um flashback completo dos textos dos anos 60, veja com o Courier. Meu "primeiro segundo pensamento" foi usaro = p + 2*av - 1, o que exclui du equals dv .)

PASSO 1

Comece com o primeiro elemento e verifique se é 7. Digamos que cseja o índice da posição atual. Portanto, inicialmente c = 0,.

PASSO 2

Se for 7, você encontrou o índice. É c. Se você alcançou o final do array, saia.

ETAPA 3

Se não for, então 7 devem estar pelo menos |array[c]-7|posições de distância, porque você só pode adicionar uma unidade por índice. Portanto, adicione |array[c]-7|ao seu índice atual, c, e vá para o PASSO 2 novamente para verificar.

No pior caso, quando há alternativos 1 e -1s, a complexidade do tempo pode chegar a O (n), mas os casos médios seriam entregues rapidamente.

Aqui estou dando a implementação em java ...

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

Aqui está uma solução de estilo dividir e conquistar. À custa de (muito) mais contabilidade, podemos pular mais elementos; em vez de digitalizar da esquerda para a direita, teste no meio e pule nas duas direções.

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

}

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

Queria incluir uma solução recursiva para o problema. Aproveitar