Iteración de matriz a partir del medio

Question

En una entrevista reciente se ha formulado una pregunta peculiar

a[]= { 1,2,3,4,5,6,7,8,9,10}

Cuando se da una matriz con un índice de inicio especificado, tengo que iterarlo hasta atravesar todos los elementos.

Supongo que el índice de inicio es " 5 " Debo comenzar desde 6,7,8,9,10,5,4,3,2,1 . Observe detenidamente la secuencia, ¿cómo se puede crear Reset ()? Actual, bla, bla ...?.

Pero el entrevistador ejecutó la secuencia cuando le preguntó. No mostró el código.

¿Podemos realmente desarrollar una lógica para un requisito tan extraño?

Answer 1

Solo usa dos bucles.

IEnumerable<int> ForwardsBackwards(int[] a, int start) {
    for(int i=start; i<a.Length; i++) 
        yield return a[i];
    for(int i=start-1; i>=0; i--) 
        yield return a[i];
}

Editar: Aún mejor con linq:

IEnumerable<int> ForwardBackward(int[] a, int start) {
    return a.Skip(start).Concat(a.Take(start).Reverse());
}

Answer 2

Más fácil de mantener (?):

        int[] a= {1,2,3,4,5,6,7,8,9,10};

        int StartIndex=5;

        for (int iCount = StartIndex; iCount < a.Count() + StartIndex; iCount++)
        {
            Debug.WriteLine(a[(iCount + a.Count()) % a.Count()]);
        }

La salida es:

6 7 8 9 10 1 2 3 4 5

Editar: acaba de detectar su secuencia, se invierte cuando alcanza el límite superior. Eso es desagradable si esa era la pregunta especificada.

Answer 3

Es un hilo viejo, pero necesitaba el mismo algoritmo y encontré una buena solución. Solución

1. Puede comenzar desde CUALQUIER elemento de la matriz
2. Puede comenzar iterar en CUALQUIER dirección
3. Pasará todos los elementos, comenzando desde el SIGUIENTE en la dirección del movimiento
4. Se superpondrá a la primera / última, cuando se alcance el elemento de borde

Toda la magia está en una sola línea con para operador de bucle, otro código es para conveniencia de vista previa.

// Example program
#include <iostream>
#include <string>

int a[] = {0,1,2,3,4,5};
int Count = sizeof(a)/sizeof(int);

void LoopFromMidWithDirection ( int curIdx , int motion )
{
    std::cout << "\nNextFrom=" << curIdx << " motion =" << motion << "\n";
    curIdx +=motion;
    for (int i = curIdx; (i - curIdx) * motion < Count ; i += motion)
        std::cout << a[(i + Count) % Count] << " ";

    std::cout << "\n";
}

int main()
{
    LoopFromMidWithDirection(4, +1);
    LoopFromMidWithDirection(6, +1);
    LoopFromMidWithDirection(0, -1);
}

Salida

NextFrom=4 motion =1
5 0 1 2 3 4 

NextFrom=6 motion =1
1 2 3 4 5 0 

NextFrom=0 motion =-1
5 4 3 2 1 0 

La solución está inspirada en @Neil Kimber

Answer 4

Sí, debe implementar el IEnumerator interfaz en una clase personalizada. Escriba la lógica en el método MoveNext que detecta el final de la matriz y luego comienza al principio de la matriz, recordando el punto de inicio a mitad de camino.

Siga estos ejemplos de código por Microsoft como una plantilla.

Answer 5

(DEFINE (traverse length start call) 
  (DEFINE (flow index motion)
    (cond ((> index length) 
              (flow (- start 1) -1))
          ((> index -1) 
              ((call index) (flow (+ index motion) motion)))))
  (flow start +1))

(traverse 9 5 job)

Me gusta el aspecto 9 a 5 de la pregunta. Me pregunto si estaban aludiendo a algo. Suponiendo que trabajo imprima el índice de matriz, esto generaría 678954321.

En C estaría tentado de usar un bucle for (no un bucle while como lo tenía antes de la edición);

int a[]= { 1,2,3,4,5,6,7,8,9,10};
int length = 10;
int start = 5;
int motion = 1; //increment

for( int index = start; index >= 0; index += motion ) {
  if(index > (length-1)) {
    motion = -1; //decrement
    index = start -1;
  else {
    printf("%d", a[index]);
  }
}

El proceso solo finaliza después de imprimir el índice cero. La única vez que no está atravesando la matriz es cuando la ha superado. Cuando eso sucede, regresa al índice de inicio (-1) e invierte el movimiento.