espiral quadrada

[Rhiegen 0]

Pessoal,

 

Gostaria de uma ajuda para resolver o problema seguinte. Tenho uma espiral quadrada da forma parecida como no link http://legauss.blogspot.com/2009/03/espiral-de-ulam.html, mas no meu caso ela deve ser girada duas vezes para a esquerda, ficando os números na sequência

 

 

12 11 10 9

13 2 1 8

... 3 0 7

4 5 6.

A espiral também chamada de espiral de Ulam está centrada com seu ponto zero num plano cartesiano e vai se expandindo infinitamente.

Meu problema é percorrê-la com um algoritmo com ordem de complexidade de teta de raiz de n. Já fiz um algoritmo para achar as coordenadas x e y de um ponto em ordem de teta de 1 e também para ordem de teta de n.

Minha dificuldade é encontrar um encaminhamento ou ideia de como percorrê-la para achar, por exemplo, a coordenada do ponto 4 em duas passadas, ou calculando coordenadas de apenas 2 pontos. Do ponto 9 calculando de apenas 3 pontos, dos pontos 1, 2, 3 calculando apenas de um ponto, dos pontos 10, 11, 12, 13 calculando apenas 3 pontos, etc.

 

Se alguém tiver alguma ideia ficaria muito agradecido. Estou fazendo o algoritmo em Linguagem C ansi, obrigatoriamente.

[Renato Utsch 24]

Olá!

 

Que tal mostrar o que já fez?

 

 

Abraços :D

[Rhiegen 0]

Olá!

 

Que tal mostrar o que já fez?

 

 

Abraços :D

 

 

 

O código abaixo em C, percorre a espiral em Ordem de Teta de N e calcula a coordenada do ponto pedido. Lembre-se, a espiral não tem tamanho definido.

int* percorreTetadeN(int ponto)
{
   int x, y; // coordenadas cartesianas
   int * retorno;  // retorno das coordenadas
   int v;  // variavel de iteracao dos pontos
   retorno = (int *) malloc (3 * sizeof(int));
   int incOp = 1; // permissao de incrementar operacao
   x = y = 0;
   int op = 0; // operacao basica a ser executada
   int conta = 0;  // quantas vezes
   int laco = 2;  // numero de lacos de cada trajeto
   int vezes = 0;  // tamanho de caminhos de cada trajeto

   for (v = 0; v <= ponto; v++)
   {


       if (v > 2)  // se o ponto sendo percorrido for maior que 2
       {

           incOp = 0;  // trava incremento de operacao
           if (conta == laco)  // se o laco ja rodou laco vezes
           {
               conta = 0;  // zera contador
               vezes ++;
               ++op;  // proxima operacao
               if (vezes == 2)  // se um laco ja se repetiu 2 vezes
               {
                   laco++;  // increnta o numero de seus caminhos
                   vezes = 0;

               }
           }
           else if (ponto != 0) incOp = 1;
           conta ++;
           incOp = 0;

       }
       if (op > 4) op = 1; // garante a existencia de apenas 4 operacoes
       switch (op)
       {
       case 1:
           y = incY(&y);
           break;
       case 2:
           x = decX(&x);
           break;
       case 3:
           y = decY(&y);
           break;
       case 4:
           x = incX(&x);
           break;
       }


       if (incOp)
       {
           ++op;
       }
   }
   retorno[0] = x;
   retorno[1] = y;
   retorno[2] = v;  // passos

   return retorno;
}

int incX(int* x)
{
   return ++*x;
}


int incY(int* y)
{
   return ++*y;
}

int decX(int* x)
{
   return --*x;
}

int decY(int* y)
{
   return --*y;
}

 

Se alguém conseguir tornar o código acima para um em ordem de raiz de teta de n seria bom.

 

Para exibir o conteúdo ponto coordenada usei a função

void exibePontos(int x, int y , int ponto, int passos)
{
   printf("PONTO:%d   - COORD: (%d,%d)\n", ponto, x, y);

   if (passos != 0)
   {
       printf("PASSOS: %d \n", passos);

   }
   printf("--------------------\n");
}