• la terminación de un programa
• la corrección parcial, que nos dice que si acaba, (notese la cursiva) entonces el programa computa lo que se espera de él.  

• Según el estandar ANSI-C, asssert solo falla cuando la evaluación del parámetro da 0 (false). En nuestro caso, assert(1), cuando 1==0, lo que es un absurdo  
• Según el estandar ANSI-C, el bucle acaba cuando la parte del discriminante da 0 (false) . En nuestro for( ; 1; ), caso, cuando 1==0 , (en terminos prácticos, nunca)  
• O sea, que cuando el bucle acabe, (no dice que acabe, dice que cuando acabe, esto es importante!) se cumplirá   1==0, lo que es la condición para que assert(1) falle.  

(Short proof)
     1=0 |= 1=0  q.e.d   

(Full proof)

Let Post Q:1=0 .

Then we have to proof that

  { I } for( ; 1 ; ) { Q } (Partial correctness, no matter I)

  1. { I } skip {I}  SKIP
  2. I and 1=1 -> I (Logic, stronger antecedent )
  3. { I and 1=1 } skip { I } STREN(1,2)
  4. I and 1=0 -> 1=0 (Logic, false (or stronger) antecedent)
  5. { I } for( ; 1 ; ) { 1=0 }  WHILE(3,4)

  q.e.d

Remark: ANSI-C states
     * assert(1) call does fail when 1=0 ("never")
     * loop for( ;1;) does end when 1=0 ("never" ;-D)
     * empty loop's body is skip.

(Short proof)

   0!=0 |= 0 < 0   q.e.d. 

(Full proof)

Let C()=0 >= 0 positively defined, i.e.

      I -> 0 >= 0  (no matter I)
      
Then we have to proof

     { I and 0!=0 and 0=0 } skip { 0 < 0} (Quota indeed decreases)

    1. { 0 < 0 } skip { 0 < 0 } (SKIP)
    2. I and 0!=0 and 0=0 -> 0 < 0  (Logic, false antecedent)
    3. { I and 0!=0 and 0=0 } skip { 0 < 0 } (STRENG(2,1))

    q.e.d

Remark :   * ANSI-C states the loop is entered
           when 0!=0, i.e. "never" ;-D
	   * empty loop's body is "skip"

for < variable-name > := < initial_value > to [down to] < final_value > do 
   S;

while (0) ; 

• Es un absurdo esperar a que acabe un programa que no acaba. Todo el mundo está de acuerdo en que el bucle es infinito.
• Es un absurdo esperar que assert falle cuando el parámetro sea 1, ya que sólo falla cuando vale 0, según el ANSI-C/ISO-C

#include <stdio.h>
#include <string.h>
 
#define __FILENAME__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
 
#define assert(expression) (void)((!(expression)) || (mostrar(#expression, __FILENAME__, (unsigned)(__LINE__), __func__), 0))
 
#define for(a) while(0)
...
 

• El primer problema pide demostrar que el programa dado acaba
• El segundo dice que cuando acabe, el sistema sacará la llamada correspondiente al assert.  

No me habia dado cuenta de la fecha como salto al principio dije "a ver tiene una hermana y si lo ayudamos?"  

#include <stdio.h> // scanf, printf
#include <stdlib.h> // abs
 
/* 
   Note: Arrays and loops forbidden! 8-O
 
   P : True
   fun min5(a0,a1,a2,a3,a4) dev <p,d>:(int,int)
   Q : p=min i : 1 <= i < 5 : |ai-a0|=d and
       d=min i : 1<=i<N : |ai-a0| 
 
   (Not sure about legitimate use of ai at object language)
 
*/
 
 
void min5(const int a0,const int a1,const int a2,const int a3,const int a4,
          int *p, int *d)
{
  *p=1; *d=abs(a0-a1);
  if (*d>abs(a0-a2))
    { *p=2; *d=abs(a0-a2);}
  if (*d>abs(a0-a3))
    { *p=3; *d=abs(a0-a3);}
  if (*d>abs(a0-a3))
    { *p=3; *d=abs(a0-a3);}
  if (*d>abs(a0-a4))
    { *p=4; *d=abs(a0-a4);}
  return;
}
 
int main(int argc, char *args[])
{
  int a0,a1,a2,a3,a4;
  int p,d;
  for( ;scanf("%d%d%d%d%d",&a0,&a1,&a2,&a3,&a4)==5 ; )
    {
      min5(a0,a1,a2,a3,a4,&p,&d);
      printf("%d %d\n",p,d);
    }
  return 0;
}
 
 
 

• La línea impar es la entrada de cinco variables(a0,a1,a2,a3,a4).
• La línea par saca el ordinal de la variable que esta más cerca (4 -> a4) y la distancia |a4-a0|. En caso de varías a la misma distancia, escoge la de ordinal más baja

1001 1002 2 3 4
1 1
1001 2 1002 3 4
2 1
1001 2 3 1002 4
3 1
1001 2 3 4 1002
4 1
1001 1001 1001 1001 1001
1 0

void Agenda::ordenaListas(){
    Contacto auxiliar;
    for(list<Contacto>::iterator it1 = listapal.begin(); it1 != --listapal.end(); it1++)
        for(list<Contacto>::iterator it2 = (++it1)--; it2 != listapal.end(); it2++)
            if(it1->comparar(it2->getNombre()))
			{
                auxiliar = *it1;
                *it1 = *it2;
                *it2 = auxiliar;
            }
}

#include <string>
#include <utility> //swap
#include <list> //list
 
using namespace std;
...
// BubleSort
// P : listapal=A[0..N) N>=0
// Q : \forall i : 0 <= i < N-1: V[i] < V[i+1] and permut(listapal,A,N)
void  Agenda::ordenaListas()
{
  list<Contacto>::iterator it1, it2;
  for( it1 = listapal.begin(); it1 != prev(listapal.end()); it1++)
    for(it2 = next(it1); it2 != listapal.end(); it2++)
      if (it1->getNombre() > it2->getNombre()) swap(*it1,*it2);
}
 

for (i=0; i<n-1; i++)
   for (j=i+1; j<n; j++)
    if(V[i]>V[j])
       V[i],V[j]=V[j],V[i]; // Esto no existe en C
 

Tiene razón, me siento estupida, pero de todas formas no quiero pasar dos parametros solo el arbol  nada mas y si no se puede pues ni modo.  

• O planteas tu structura con un campo "padre", que apunte al nodo padre, en el caso de la raiz null (Recomendable)
• Usas un viejo truco de C, el cualificador "static", que como efecto lateral irá grabado siempre el nivel de descenso

 
#include <stdlib.h>
#include <stdio.h>
 
/*    Binary search tree
 
                        10
		       /  \
		      5	   14
		     / 	  / \
		    3  	 13  15
 
   Adding non-leaf and non-root nodes, i.e. 19
 
   Warning: This solution may be not portable to other languages than C
*/
 
typedef struct nodo {
  struct nodo *izq;
  struct nodo *der;
  int dato;
}  *pnodo;
 
int sumar(const pnodo a)
{
  static int level = 0 ; // <== An eye to static qualifier (side effect!)
  int suma=0;
 
  if(a!=NULL){
    level++;  // <=== An eye.
    suma=sumar(a->izq)+sumar(a->der);
    level--; // <== An eye.
    if ((a->izq!=NULL || a->der!=NULL) && level)  //  <=== An eye
	suma+=a->dato;
  }
  return suma;
}
 
 
 
int main(int argc, char *args[])
{
  pnodo a=NULL;
 
 /* Raw building of tree. More abstraction might be needed here */
  if ((a = (struct nodo* )malloc(sizeof(struct nodo)))==NULL)
    {
      perror("malloc");
      exit(1);
    }
  a->dato = 10;
  if ((a->izq = (struct nodo* )malloc(sizeof(struct nodo)))==NULL)
    {
      perror("malloc");
      exit(1);
    }
  a->izq->dato = 5;
  if ((a->izq->izq = (struct nodo* )malloc(sizeof(struct nodo)))==NULL)
    {
      perror("malloc");
      exit(1);
    }
  a->izq->izq->dato = 3;  
  if ((a->der = (pnodo )malloc(sizeof(struct nodo)))==NULL)
    {
      perror("malloc");
      exit(1);
    }
  a->der->dato = 14;
  if ((a->der->der = (pnodo )malloc(sizeof(struct nodo)))==NULL)
    {
      perror("malloc");
      exit(1);
    }
  a->der->der->dato = 15;
  if ((a->der->izq = (pnodo )malloc(sizeof(struct nodo)))==NULL)
    {
      perror("malloc");
      exit(1);
    }
  a->der->izq->dato = 13;
 
  printf("Adding internal nodes %d\n",sumar(a));
 
}
 
 

Adding internal nodes 19

int sumar(const pnodo a, const pnodo root)
{
  int suma=0;
  if(a!=NULL){
    suma=sumar(a->izq,root)+sumar(a->der,root);
    if ((a->izq!=NULL || a->der!=NULL) && a!=root) // neither leaf nor root
      suma+=a->dato;
  }
  return suma;
}
 
// Initial call
pnode a ;
// populate tree a with subtrees
sumar(a,a);
 

• La solución de Ana es correcta pero ineficiente, se dice que está en O(n^3) (3 bucles)
• La solucion de NEBIRE tiene ideas aprovechables, porque se requiere ordenar el vector, pero el paso 2 es díficil de seguir con 7 variables, algunas sin inicializar, y _creo_ que está en O(n^2), por los dos bucles. Además creo que se pide eliminar los elementos del vector de entrada, no una opia

/*
   P : V=A[0..N)   N>= 0
   fun dropRedundant(V=A[0..N) of int) return M:int
   Q : \forall i : 0 <=  i < N : \exists j :0 <= j < M : A[i]=V[j]
       and
       M = #i : 0 <= i < N : frec(A,0,N,A[i])= 1 
 
   I : Q[N/n] and  0 <= M <= n <= N and
       StrictSorted(V,0,M) and Sorted(V,n,N)
 
   where 
 
   frec(A,i,j,v) ::= # p : i<= p < j : A[p]=v
 
 
   I and B |- Q  (trivial, since n=N)
 
 
Snapshot invariant: (Hard)
-------------------
 
0     1     2    m=3    4     5     6    n=7    8           N
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|  1  |  2  |  3  |  3  |   3 |  3  |  3  |  4  |     |     |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 
 
*/
 
#include <iostream>
#include <algorithm> // sort
 
using namespace std;
// O(n)
int dropRedundant(int V[], const int N)
{
  int m,n;
  sort(V,V+N); // O(nlog(n)
  // V sorted.
  for(n=m=0;n<N;n++) // O(n)
    if (m==0 || V[n]>V[m-1]) V[m++]=V[n];
  return m;
}
 
#define MAX 10000
 
int main(int argc, char *args[])
{
  int N,M;
  int V[MAX];
  for ( ; cin >> N; )
    {
      for(int n=0 ; n < N ;  n++ ) cin >> V[n];
      M=dropRedundant(V,N);
      cout << M << endl;
      for(int m=0;m<M;m++) cout << V[m] << " ";
      cout << endl;
    }
}
 

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

3
1 2 3 
5
1 2 3 4 5 
3
1 2 3