Mensajes

Podria evitarse el overflow al convertir el angulo gigante en el pequeno equivalente, por ejemplo

Código (cpp) [Seleccionar] Expandir


float G2R(float g) {
    while(g > 360) {
        g -= 360;
    }
    return g*PI/180;
}

2 mejoras a esto:
- En vez de iterar restando 360, dividir por 360, y luego restar directamente la cantidad de veces que cabe 360 en el numero gigante.
- Algo similar hay que hacer para angulos negativos gigantes

Solo puedo decir una cosa : GENIAL.

No creo que sea un defecto por el posible overflow, (de hecho me parece que no hay overflow, como dije antes...) El algoritmo mismo exige 0 <= r <= 2pi

Propongo, para simplificar tantos positivos como negativos grandes, la macro

Código (c) [Seleccionar] Expandir


#define G2R(g) ((g%360)*PI/180)


Aunque el operador (%) solo admite int, y ni podamos meter "floats".

Código (c) [Seleccionar] Expandir

int g;
  for ( ; cin >> g ; )


Ahora, tnemeos

Código [Seleccionar] Expandir


0 90 180 270 360
          0 0.0000 0.0000
         90 1.5708 1.0000
        180 3.1416 0.0000
        270 4.7124 -1.0000
        360 0.0000 0.0000
0 -90 -180 -270 -360
          0 0.0000 0.0000
        -90 -1.5708 -1.0000
       -180 -3.1416 -0.0000
       -270 -4.7124 1.0000
       -360 0.0000 0.0000
0 1170 1260 1350 1440  # I.e  [0,90,180,270,360] + 360x3
          0 0.0000 0.0000
       1170 1.5708 1.0000
       1260 3.1416 0.0000
       1350 4.7124 -1.0000
       1440 0.0000 0.0000
0 -1170 -1260 -1350 -1440
          0 0.0000 0.0000
      -1170 -1.5708 -1.0000
      -1260 -3.1416 -0.0000
      -1350 -4.7124 1.0000
      -1440 0.0000 0.0000

Como Dios manda....

Como dices, tu solución carece de "valor" en tanto que utilizas la librería <math.h>, que resuelve el problema que se te pide.

El cálculo de funciones trigonométricas se puede abordar desde muchos puntos de vista (calculo numérico, teoremas de trigonometría), pero todos ellos serán imprecisos en sus resultados en la medida que el sistema de tipos de C, (float) esta limitado en su capacidad para representar, no digamos ya cualquier número real, si no muchos números racionales, por ejemplo (1/3).

El clásico método para aproximar la función seno ( el resto, coseno y tangente, investigalos por tu cuenta) se basa en el Teorema de Taylor que permite el cómputo del valor de sen en términos de operraciones elementales, productos, sumas, potencias y divisiones:

Código [Seleccionar] Expandir

sinus(x) = sum i : 0<= i : (((-1)^i)/(2i+1)!)*x^(2i+1)

Como no es posible extenderme puesto que no es un curso de análisis numérico, baste decir que en toda implementación hay que tener en cuenta la precisión con la que abordamos el problema, en nuestro caso, hasta las diezmilésimas (10^-4)

Allá va el código. La línea central, la más compleja de elaborar, es la 28. Expplicar de donde se saca es un poco complejo sin entrar en manipulaciones algebraicas. Baste decir que t es el sumando correspondeinte al valor n. Lo que hace 28 es actualizar t para la siguiente vuelta, y esto se puede hacer en función del valor que tiene actualmente t.

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <iomanip> // To format floats into screen

/* Uses Taylor formula to compute sin(x), x in gradiants
 
  sinus(x) = sum i : 0<= i : (((-1)^i)/(2i+1)!)*x^(2i+1)

  Any computer program makes a finite computation, hence
  we only add summands up to epsilon (in our case, 10^-4)

*/

#define PI 3.1416
#define G2R(g) (g*PI/180)
#define EPSILON 0.0001
#define ABS(x) ((x>=0)?x:-x)

using namespace std;

/* P: r given in radians */
float sinus(const float r)
{
 int n;
 float s,t;
 for(n=s=0,t=r; ABS(t) >= EPSILON ; n++)
   {
     s+=t;
     t = ((-1)*r*r*t)/((2*n+3.0)*(2*n+2.0));
   }
 return s;
}


int main(int argc, char *args[])
{
 float g;
 for ( ; cin >> g ; )
   {
     const float r = G2R(g);
     std::cout << std::fixed << std::setw( 11 ) << std::setprecision(4)
<< g << " " <<  r << " " << sinus(r) << endl;
   }

}

Y a continuación, la salida a algunos casos de angulos conocidos, como son  aquellos de seno 0,1,-1 y 0.5.
La primera columna marca el ánglo en grados, la segunda en radianes (aproximado) y la tercera la función seno del mismo....Se aprecia como en el caso de 360 grados cuyo seno es 0, arroja una aproximaci'on de 0,0001

Código [Seleccionar] Expandir

0 90 180 270 360
    0.0000 0.0000 0.0000
   90.0000 1.5708 1.0000
  180.0000 3.1416 0.0000
  270.0000 4.7124 -1.0000
  360.0000 6.2832 0.0001
30 150 210 330
   30.0000 0.5236 0.5000
  150.0000 2.6180 0.5000
  210.0000 3.6652 -0.5000
  330.0000 5.7596 -0.5000
1200
 1200.0000 20.9440 5.4417

El último caso es llamativo, pues da un error incoherente...El seno sólo puede ser entre -1 y 1. Nuevamente, se debe a la imprecisión para representar numeros grandes, y ciertamente, si te fijas en el producto del código de la línea 28, esta incluye un valor "relativamente grande", que float es incapaz de representar. Ojo a los errores en el cálculo numérico!

No es posible. Un programa tan simple....
El error debe estar en las otras cosas...las que no son de sockets

Código (c) [Seleccionar] Expandir

#include <sys/types.h>        
#include <sys/socket.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
 int packet_socket;
 if ((packet_socket = socket(AF_INET, SOCK_STREAM, 0))==-1)
   {
     perror("socket");
     exit(1);
   }
 
 if (close(packet_socket)==-1)
   {
     perror("close");
     exit(1);
   }
 exit(0);
}


Probando esto en UNIX

Código [Seleccionar] Expandir

(./main && echo "OK") || echo "NOK"

Da la salida

Código [Seleccionar] Expandir


OK

Hola,  
He ido a iniciar un pequeño socket en C++, me ha dado un mensaje de error en el que decía:.
La línea en la que me da el error pone lo siguiente:Gracias,  
fox459

Repasa el prototipo de la llamada socket.

Código [Seleccionar] Expandir


NAME
      socket - create an endpoint for communication

SYNOPSIS
      #include <sys/types.h>          /* See NOTES */
      #include <sys/socket.h>

      int socket(int domain, int type, int protocol);


basta con que declares

Código (c) [Seleccionar] Expandir


int packet_socket;
packet_socket = socket(AF_INET, SOCK_STREAM, 0);

Probablemente tengas mal declarado packet_socket y esté apuntando a alguna dirección sin sentido como por ejemplo;

Código (c) [Seleccionar] Expandir


int *packet_socket; // uninitialized pointer
packet_socket = socket(AF_INET, SOCK_STREAM, 0);

[RETURNS :]

Tengo una duda. De la función

Código (cpp) [Seleccionar] Expandir

iterator erase (iterator position);
la documentación dice:

RETURNS : An iterator pointing to the element that followed the last element erased by the function call. This is the container end if the operation erased the last element in the sequence.

Mi pregunta es: se deve asumir algún valor "util" en el iterador, como parametro de entrada salida?

El siguiente programa invierte el sugsegmento L[i..i+k) del vector corresponidente a la lista L[0..N), con 0 <=i < N , 0 <= k

Código (c) [Seleccionar] Expandir

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

// P : length(l) >= 0 , 0 <= i < length(l)  ,k >= 0
void invertSegment(list<char>& l, const int i, const int k){
 list<char>::const_iterator it1,it2;
 it1 = next(l.begin(),i);  //O(l)
 it2 = next(l.begin(),min(i+k,(int)l.size())); // O(i+k)
 for(it2--;it2!=it1 ;it2-- ) // O(k))
   {
     l.insert(it1,*it2);  // O(1)
     it2=l.erase(it2);
   }
 return;    
}



int main() {
 list<char> l;
 int N, i, k;
 char c;
 for ( ; cin >> N >> i >> k; )
   {
     l.clear();
     for (int n = 0; n < N; n++)
{
cin >> c ; l.push_back(c);
}
     invertSegment(l,i,k);
     for (list<char>::const_iterator it=l.begin(); it!=l.end(); it++) cout << *it << " ";
     cout << endl;
   }
 return true;
}


En la linea 14, debo asumir

Código (c) [Seleccionar] Expandir

it2=l.erase(it2);

como lo mismo que...

Código (c) [Seleccionar] Expandir

l.erase(it2);

Yo creo que NO, pese a que el programa parce funcionar.

Aquí algunas salidas: La primera linea leem, N, i, k , la segunda la lista de N elementos y la salida marca la lista con la sublista invertida

Código [Seleccionar] Expandir

6 1 2
1 2 3 4 5 6
1 3 2 4 5 6
6 1 4
1 2 3 4 5 6
1 5 4 3 2 6
6 1 5
1 2 3 4 5 6
1 6 5 4 3 2
6 0 6
1 2 3 4 5 6
6 5 4 3 2 1

Esta podría ser una solución elegante

Código (c) [Seleccionar] Expandir

#include <stdio.h>

void rombo(unsigned altura) {
...
    if(i<h) { // Mientras el reglón no ha llegado a la altura del rombo
        int j;
        for(j=0; j<=h/2-w/2; ++j) // Calculo los espacios por escalon
            putchar(' ');         //    y los imprimo
        for(j=0; j<w; ++j) // Imprimo
            putchar('*');  //    los asteriscos
        putchar('\n'); // Al siguiente reglón
...}

int main() {
    rombo(6);
}

hmmm... por lo general, si se meten bucles, se pierde la recursividad (caso base, caso recursivo, funcion de avance...

Mi propuesta

Código [Seleccionar] Expandir


height: 0
*
height: 2
*
***
*
height: 4
  * 
***
*****
***
  * 
height: 6
   *   
  *** 
*****
*******
*****
  *** 
   *   
height: 8
    *   
   ***   
  ***** 
*******
*********
*******
  ***** 
   ***   
    *   
height: 10
     *     
    ***   
   *****   
  ******* 
*********
***********
*********
  ******* 
   *****   
    ***   
     *     
height: 12
      *     
     ***     
    *****   
   *******   
  ********* 
***********
*************
***********
  ********* 
   *******   
    *****   
     ***     
      *     
height: 14
       *       
      ***     
     *****     
    *******   
   *********   
  *********** 
*************
***************
*************
  *********** 
   *********   
    *******   
     *****     
      ***     
       *       
height: 16
        *       
       ***       
      *****     
     *******     
    *********   
   ***********   
  ************* 
***************
*****************
***************
  ************* 
   ***********   
    *********   
     *******     
      *****     
       ***       
        *       
height: 18
         *         
        ***       
       *****       
      *******     
     *********     
    ***********   
   *************   
  *************** 
*****************
*******************
*****************
  *************** 
   *************   
    ***********   
     *********     
      *******     
       *****       
        ***       
         *         
height: 20
          *         
         ***         
        *****       
       *******       
      *********     
     ***********     
    *************   
   ***************   
  ***************** 
*******************
*********************
*******************
  ***************** 
   ***************   
    *************   
     ***********     
      *********     
       *******       
        *****       
         ***         
          *         
height: 22
           *           
          ***         
         *****         
        *******       
       *********       
      ***********     
     *************     
    ***************   
   *****************   
  ******************* 
*********************
***********************
*********************
  ******************* 
   *****************   
    ***************   
     *************     
      ***********     
       *********       
        *******       
         *****         
          ***         
           *           
height: 24
            *           
           ***           
          *****         
         *******         
        *********       
       ***********       
      *************     
     ***************     
    *****************   
   *******************   
  ********************* 
***********************
*************************
***********************
  ********************* 
   *******************   
    *****************   
     ***************     
      *************     
       ***********       
        *********       
         *******         
          *****         
           ***           
            *         




Código (c) [Seleccionar] Expandir


#include <stdio.h>

void printLineR(const int N, const int n,const int start)
{
  if (start==N+1) return;
  else
    {
      const int nn = n<=(N/2)?n:N-n;
      if (start < (N/2) - nn ) printf(" ");
      if ((((N/2) - nn)<=start) && (start <= (N/2 + nn))) printf("*");
      if ((start > (N/2 + nn))) printf(" ");
      printLineR(N,n<=(N/2)?n:N-n,start+1);
    }
}

void printLine(const int N,const int n)
{
  printLineR(N,n,0);
  printf("\n");
}


void diamondR(const int N, const int n)
{
  if (n == N+1)  return;
  else
    {
      printLine(N,n);
      diamondR(N,n+1);
    }

}
/* 0 <= N */
void diamond(const int N)
{
  diamondR(N,0);
}

int main()
{
  int N=25;
  for (int n=0; n<N ; n+=2 )
    {
      printf("height: %d\n",n);
      diamond(n);
    }
}




[implementar]

Al Gran Fibonacci le debemos todo

Muchas gracias @SrMcLister, entonces mi algoritmo quedaria asi:
//Aunque no me convence del todo ya que al ingresar 1 o 2 me devuelve el valor de la pila.cima y no es lo que busco pero funciona

Código (cpp) [Seleccionar] Expandir


int fibonacci(int n)
{
tpila pila;
init_stack(pila);
while(pila.cima<n-1){
push_stack(pila, pila.datos[pila.cima]+pila.datos[pila.cima-1]);
}
return top_stack(pila);
}

....

A ver: Independientemente de lo que devuelves, el errror más grande es que no "respetas" las operaciones del tad Pila... estás acceidiendo a su representación interna, cosa que el usuario que programa Fibonacci no tiene que ver....


Aquí hay dos problemas que separar

• implementar el TAD pila
• usar el TAD pila para resolver el problema de Fibonacci

Yo la primera, la doy por implementada en la STL, aunque es posbile que para tí sea necesario implementar la tuya propia.

Alla va mi propuesta ( tu puedes adatparla a la implementación de tu pila)

Código (c) [Seleccionar] Expandir


#include <stack> // from STL
#include <algorithm> // for min
#include <iostream>  // cout, cin
using namespace std;


/*

Starting on 0!

P : 0 <= N ...
I :
   0 <= n <= N
   top(stack) = fib(n)
   n > 1 -> top (pop(stack)) = fib(n-1)

*/
int Fibonacci(const int N)
{
  stack<int> s ;
  s.push(1);
  s.push(1);
  for(int n=min(N,1) ;  n<N ; n++)
    {
    int n1= s.top() ;
    s.pop();
    int n2 = s.top();
    s.pop();
    s.push(n1);
    s.push(n2+n1);
    }
  return s.top();
}


#define MAX 10000
int main(int argc, char **args)
{
  int N;
  for (; cin >> N  ; ) cout << Fibonacci(N) << endl;
  return 0;
}


Y algunos casos de prueba.

• Las lineas 2,4,6,8,10,12... revelan la secuencia de Fibonacci
  1,1,2,3,5,8,13,21,34
  
• Las lineas 1,3,5,7,9,11... revelan el orden de los términos de aquellas
  0,1,2,3,4,5,6,7,8
  

Código (c) [Seleccionar] Expandir

0
1
1
1
2
2
3
3
4
5
5
8
6
13
7
21
8
34

El problema es bonito.  Sucede que no se puede plantear como tú haces, ya que la función redondeo solo te puede dar -- el redondeo a la parte entera.

Te acuerdas cuando aprendiste a dividir con papel y lápiz a mano? Pues se trata de hacer lo mismo pero más rápido por computador.

Los números racionales, desde tiempos de la Grecia clásica, se conciben como "razón" entre dos números enteros (p y q ). Como los griegos no conocían el 0, cosa que lastró el desarrollo de matemáticas en Occidente, esta definición no plantea problemas.

Pero nosotros, desde tiempos de los arabes que los trajeron de la India (la de verdad, no la que creyó encontrar Colón en Santo Domingo  , saludos a los hermanos de Santo Domingo) , debemos completar esta definición exigiendo "q > 0"

Atendiendo a su representación decimal, se pueden dividir en dos

• enteros, los que no tienen parte decimal propiamente
• decimales, los que tienen parte decimal, ya sea finita o infinita periódica

En nuestro caso, vamos a considerar los enteros como un caso especial de los decimales, con una serie infinita de decimales con el dígito 0.   3 ~ 3.00000000000000000000000000000000......
O sea que el "primer decimal" , será el orden de unidades, el segundo de las décimas, el tercero de las centésimas...

Código (c) [Seleccionar] Expandir

#include <stdio.h>


/* Formal Spec
   P : N >= 0 , p>=0 , q > 0
   Q :
     rat(p/q) - (p/q + \sum i : 1 <= i <= N : pow(10,-i)*((r_{i-1}*10)/q)
      <= pow(10,-N)

   where r_{0} = p%q ;
         r_{n+1} = r_{n}*10 % q

   Informally, any rational number can be expressed with arbitrary precission
   just by operating its sucessive remainders.
*/
void exprDecUpToN(const int p, const int q,
                   int V[], const int N)
{
  int n,r;
  for(n=1, V[0]=(p/q), r=(p%q);n<N;n++)
    {
      V[n] = (10*r)/q;
      r = (10*r)%q;
    }
  return;
}

#define MAX 10000
int main(int argc, char **args)
{
  int N,p, q, V[MAX];
 
  for (; scanf("%d %d %d",&N,&p,&q)==3 ; )
    {
      exprDecUpToN(p,q,V,N+1);
      int n;
      printf("%d.",V[0]);
      for (n=1; n<N+1; n++) printf("%d",V[n]);
      printf("\n");
    }
  return 0;
}


Y ahora unos ejemplos de ejecución. El protocolo de entrada exige primerto meter el número de decimales deseado, el primer entero y el segundo (recuerda que debe ser mayor qie 0).
Llama la atención el último que es decimal infinito periódico.

Código [Seleccionar] Expandir



1 1 2
0.5
2 1 2
0.50
4 56 8
7.0000
18 1 3
0.333333333333333333
2 3 4
0.75
4 3 4
0.7500
40 56 8
7.0000000000000000000000000000000000000000
500 47 7
6.7142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857142857

Hola!
Ya lo tengo de nuevo, completo, con especificación algebraica, implementación, programa principal y todo! (no se pedía todo)



Como esto es un foro de C/C++ , empezamos por el final, la implementación...  Tened en cuenta que sólo se pedía el struct y la operación equals (Mismo Ciclo). Me ha salido más fácil que ayer!!

Código (c) [Seleccionar] Expandir


/*
CYCLE: Informally, a circular permutation, ie.

 [1,4,23,7]~[4,23,7,1]~[23,7,1,4]~[7,1,4,23]
*/
#define MAX 10000
#include <cassert>
#include <cstdlib>
#include <cstdio>

// Implementation on static memory.
typedef struct {
 int V[MAX];
 int N;
} CycleSeq, *pCycleSeq;

CycleSeq* cycle(const int V[],const int N)
{
 // Pre: assumed Def(canonical(V))
 CycleSeq *A;
 if (!(A = (pCycleSeq)malloc(sizeof(CycleSeq))))
   {
     perror("malloc");
     exit(1);
   };
 A->N = N ;
 for(int n=0; n<N ; n++) A->V[n]=V[n];
 return A;
}

int contains(const int i,const CycleSeq *A)
{
 // Pre: true O(n)
 int n;
 for (n=0 ; n<A->N && (A->V[n]!=i) ; n++);
 return (n<A->N);

}

int next(const int i,const CycleSeq *A)
{
 // Pre: contains(A,i) O(n)
 int n ;
 for ( n=0 ; A->V[n]!=i ; n++);
 return (A->V[(n+1)%A->N]);

}

/* Comment: Compare cannonical forms . (Was SameCycle)*/
int equals(const CycleSeq *A, const CycleSeq *B)
{

 if (A->N != B->N) return 0;

 if (A->N == 0 ) return 1 ;

 // e.o.c
 assert((A->N == B->N) && A->N );

 int n ;
 int mA, mB;
 for (mA=mB=0, n = 1 ; n < A->N ; n++)
   {
     if (A->V[mA]>A->V[n]) mA = n ;
     if (B->V[mB]>B->V[n]) mB = n ;
   };
 // mA mB holds minimum positions; count matches in cannonical form.
 for(n=0; (n < A->N) && (A->V[(mA+n)%A->N]==B->V[(mB+n)%A->N]); n++);
 return (n == A->N);
}

#include <iostream>
using namespace std;
#define MAX 10000

int main(int argc, char *args[])
{
 CycleSeq *B,*A;
 int V1[MAX],V2[MAX];
 int N1,N2;
 for( ; cin >> N1 && cin >>N2 ; )
   {
     for(int n=0; n<N1; n++) cin >> V1[n];
     for(int n=0; n<N2; n++) cin >> V2[n];
     A= cycle(V1,N1);
     B= cycle(V2,N2);
     cout << equals(A,B) << endl;
     free(A);
     free(B);
   }
}


Y algunos casos de prueba emepzando por los de la foto.

Protocolo de entrada.

• Linea que marca la longitud de las permutaciones ciclicas
• Componentes de la primera permucacion
• Componentes de la segunda permucacion
• Acaba cuando no se dan pares de longitudes

Protocolo de salida: 1 marca TRUE ( permutaciones ciclicas equivalentes) 0 marca FALSE

Código [Seleccionar] Expandir

5 5
6 23 4 71 9
71 9 6 23 4
1
5  5
71 9 6 23 4
6 23 4 71 9
1
5  5
6 23 4 71 9
6 23 71 4  9
0

Otros casos que no tienen que ver con esos.

Código [Seleccionar] Expandir

1 1
3 3
1
1 1
3 4
0
2 2
1 2
2 1
1
2 3
1 2
1 2 3
0
4 4
1 4 23 7
4 23 7 1
1
4  4
4 23 7 1
23 7 1 4
1
4  4
23 7 1 4
7 1 4 23
1
4  4
7 1 4 23
1 4 23 7
1
4  4
1 4 23 7
23 7 1 4
1
4 4
23 7 1 4
23 1 7 4
0

y Ahora.... Para los que busquen algo "pure mathematical", sin C... aquí os dejo la especifiación ecuacional del tipo Ciclic... No se si tiene fallos...

Código [Seleccionar] Expandir

CYCLE: Informally, a circular permutation, ie.

 [1,4,23,7]~[4,23,7,1]~[23,7,1,4]~[7,1,4,23]


 Algebraic Spec:
 ---------------

 TAD CYCLE is

 uses SEQ;

 carrier Cycle;

 ops
 ---

 cycle : Seq -> Cycle   [non free cons]

 partial next : Int Cycle -> Int   [ obs ]

 aux ops
 --------

 contains : Int Cycle -> Bool  [obs]

 partial canonical  : Seq -> Seq  // extends TAD SEQ, but safe

 var
 ---
 n:Int, c:Cycle , s: Seq

 axioms
 ------

 contains(n,c) -> Def(next(n,c))

 nonRepeated(s) -> Def(canonical(s))

 Def(canonical(s)) -> Def(cycle(s))

 contains(n,cycle(s)) = contains(n,s)

 // canonical form of a a seq.
length(s) = length(cannonical(s))

 let
   M = length(s)
 in
   (M==0 ||
          let
             ms,ms' = min(s) , min(canonical(s))
          in  
          \forall i : 0<= i < M : s.at[(ms+i)%M]=cannonical(s).at[(ms'+i)%M])

 cycle(seq) = cycle(cannonical(seq))  

Y unos breves apuntes  sobre la implementación, expresando el invariante de representación y la función de abstracción.

A lo mejor estas cosas no parecen imporantes, pero sirven para guiarme en como hago las cosas luego en C.

Código [Seleccionar] Expandir

 Impl:
 -----

   int V[MAX];
   int N;

 INV : N<=MAX && \forall : 0 <= i < N : frec(V[i],V)=1

 ABSTRACTION : (V1,N1) ~ (V2,N2)

    N1=N2 and
    (N1 = 0 ||
    let A = min i : 0 <= i < N1 : V1[i]
        B = min i : 0 <= i < N2 : V2[i]
    in
    \forall : 0 <= i < N1 : V1[(A+i) mod N1)] = V2[(B+i) mod N1)] )
       


...
Así conseguirás que funcione:

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
   
   int buscarMayor(int *p, int n);
   
   int main()
   {
       int vec[5] = {1, 4, 5, 2, 2},
           mayor;
       mayor = buscarMayor(vec,5);
       printf("El mayor es: %d", mayor);
       return 0;
   }
   
   int buscarMayor(int *p, int n)
   {
       int may = *p;
       while(--n){
           if (*p > may)
               may = *p;
           p++;
       }
       return may;
   }


Saludos.

Aún est mal. Valga el contraejemplo:

Código (c) [Seleccionar] Expandir

       int vec[5] = {1, 4, 2, 2, 5}

Devolverá 4, cuando el mayor es el 5.

Sólo hay que hacer un pequeño cambio,

Código (c) [Seleccionar] Expandir

      int may = *p++;  // mind the post-increment

O alternativamente, anticipar el incremento de p en el cuerpo

Código (c) [Seleccionar] Expandir


int buscarMayor( int *p, int n)
{
 int may = *p;
 while(--n){
   if (*++p > may) // mind the pre-increment
     may = *p;
 }
 return may;
}