void PonerExpresion (std::string c)
{
    int i, j;
    std::string x, y;
    std::vector<std::string> infija;
 
    i=0;
    while (i < c.length()) {
 
  		x = "";  
  		while (isdigit(c[i])) {
   			x += c[i];
   			std::cout << x << " while isdigit " << '\n';
   			i++;
  			}
		infija.push_back(x);  			
 
  		y = c[i];	
    	if(y == "+" || y == "-" || y == "*" || y == "/" || y == "(" || y == ")") {
   			infija.push_back(y);
   			std::cout << y << " Signos " << '\n';
  			} 
 
  		i++;	
 
     	for (j = 0; j < infija.size(); j++) //muestra el vector para verificar el resultado.
  		{
   			std::cout << infija[j];
    	}  
 	}
    return;
}
 
 
 
 
 
 

#include 
 
int main(void)
{
        const char *const verde = "\033[0;40;32m";
        const char *const subrayado_fazul_verde = "\033[4;44;32m";
        const char *const normal = "\033[0m";
 
        printf("Mostrando %scolores%s !!!\n", verde, normal);
        printf("Mostrando %scolores%s !!!\n", subrayado_fazul_verde, normal);
 
        return 0;
}
 

    include <stdio.h>
#include <stdlib.h>	
 
/*
	Eliminar elementos basura de un array en C
« en: 30 Enero 2017, 18:46 »
Hola, hace mucho que no entro en esta web y me da gusto volver a formar parte de esta comunidad. Bueno, dicho esto, expreso mi inquietud. Tengo una función que lo que tiene que hacer es "Emitir el valor máximo e indicar la cantidad de veces que apareció y el número de orden en que fue ingresado."
He aquí el código:
*/
 
void funcion(int v[],int tam){
    int max=0,i,j,acumulador=0;
    int nro_orden[]={0, 0, 0, 0, 0, 0};
 
 
    for(i=0;i<tam;i++){
    	nro_orden[i]=0;
        }
 
    for(i=0;i<tam;i++){
        if(v[i]>max){
          max=v[i];         //establecemos el maximo
        }
    }
 
    for(i=0;i<tam;i++){
        if(v[i]==max){
          acumulador++;     //contamos la cantidad de veces que aparece el maximo
        }
    }
 
    i=0;
    j=0;
    while(i<tam){
         if(max==v[i]){
            nro_orden[j]=i+1;
            j++;
         }
         i++;
 
    }
 
    printf("\nEl valor maximo es: %d",max);
    printf("\nLa cantidad de veces que aparecio el maximo es: %d",acumulador);
 
    printf("\nEl numero de orden en que fue ingresado es: ");
 
    for(i=0;i<tam;i++){
       if (nro_orden[i]) printf("[%d] ", nro_orden[i]);
    }
}
 
int main() {
	int vector[]={2, 9, 8, 4, 9, 5};
	funcion(vector, 6);
 
	return 0;
}
 [ /code]

#include<stdlib.h>
#include<time.h>
#include<stdio.h>
 
 
int usado(char, char*);
 
int main()
{
    int i;
    char vector[26]={0};
    char newChar;
 
 
    srand((unsigned)time(NULL));
 
 
    for(i=0; i<26; i++)
    {
        do {
        newChar = 'A'+rand()%26;
        	} while(usado(newChar, vector));
        vector[i] = newChar;
 	}
 
    for(i=0; i<10; i++)
    {
        if (vector[i*2] < vector[i*2+1]) {
      	  printf("%c%c ",vector[i*2],vector[i*2+1]);
      	  } else printf("%c%c ",vector[i*2+1],vector[i*2]);
    }
 
 
    return 0;
 
}
 
int usado(char ch, char* array)
{
	int i;
 
	while (*(array+i) && ch != *(array+i) ) i++;
 
	if (*(array+i)) return 1;
	return 0;
}
 

 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
 
//creacion de la estructura
typedef struct Pila {
    int dato;
    struct Pila *sgte; 
} Pila;
 
//asignacion de memoria
Pila *asignarMemoria(){
 return (Pila *)malloc(sizeof(Pila));
}
 
//apilado
Pila *apilar(Pila *p, int dato){
 
 Pila *q = asignarMemoria(); //Pila auxiliar
 q->dato=dato;
 q->sgte=NULL;
 
 if(p==NULL){
  return q;
 }
 q->sgte = p;
 p = q;
 return p;
}
 
//desapilado
Pila *desapilar(Pila *p){
 
 if(p == NULL){
  return p;
 }
 Pila *q = p->sgte;
 p->sgte = NULL;
// free(p); //liberar memoria
 return q;
}
 
//listar la pila
void mostrarPila (Pila *p){
	while(p) {
		printf("%d, ", p->dato);
		p = p->sgte;
		}
}
 
 /*
 if(p!=NULL){
  Pila *q = p; //pila auxiliar
  while(q!=NULL){
   printf("%d ", q->dato);
   q = desapilar(q);
   }
  return;
 }
 printf("No hay elementos en la Pila\n"); 
}
*/
 
//buscar un elemento en la pila
int buscarPila(Pila *p, int dato){
 if(p!=NULL){
  Pila *q = p; //pila auxiliar
  while(q!=NULL){
   if(q->dato==dato){
    return 1; //verdadero si lo encuentra.
   }
   q = desapilar(q);
  }
  return 0; //falso, si no lo encuentra.
 }
 return 0; //falso, si no lo encuentra.
}
 
int main(int argc, char *argv[]) {
 
 //Menu Principal.
 int opcionMenu, volverIntentar, scanfValidador;
 srand(time(NULL));  //Semilla del creador de numeros Randoms
 
do{
 do{
 
 printf("Seleccione una opcion\n");
 printf("[1] Ejercicio 1\n[2] Ejercicio 2\n[3] Ejercicio 3\n[4] Salir\n");
 scanfValidador = scanf("%d", &opcionMenu);
 fflush(stdin);
  if(scanfValidador!=1){
   printf("\nOpcion no valida, ingrese un valor numererico positivo.\n");
   puts("");
  } 
 }while(scanfValidador!=1); //Validador
 
     if(opcionMenu == 1){ 
      // Crear y listar una pila con n elementos. Ingresar un dato y consultar cuantas veces se repite y en que posiciones.
   Pila *pila;
   int n, i; //tamaño n de la pila
   int numRand;
   int scanfValidador3;
 
   do{
        puts("Ingrese tamaño de la Pila la cual tendra numeros random del [0-10]");
        scanfValidador3 = scanf("%d", &n);
        fflush(stdin);
        if(scanfValidador3!=1){
       		  printf("\nOpcion no valida, ingrese un valor numererico positivo.\n");
      		  puts("");
 			  }
        }while(scanfValidador3!=1); //Validador
        i=n;
 
        while(n!=0){ //Recorrer Pila
         numRand = rand() % 11; // genera un numero Random entre el 0 y el 10
         //pila->sgte=NULL;
         pila = apilar(pila, numRand);
    	n--;
 	  	} 
 
  	// while(i!=0) {
   		 mostrarPila(pila);
 	//	  i--;
 	//	  }  
 
  }
 
  else if(opcionMenu == 2){
   printf("Opcion 2\n");
  }
 
  else if(opcionMenu == 3){
   printf("Opcion 3\n");
  }
 
  else if(opcionMenu == 4){
   exit(0);
  }
  else{
   puts("");
   printf("Opcion invalida\n");
   puts("");
  }
  int scanfValidador2;
 do{
  printf("\nPara volver a intentar preciona [1] y da enter.\nPara salir use cualquier otro numero y precione enter.\n");
  puts("");
  scanfValidador2 = scanf("%d", &volverIntentar);
  fflush(stdin);
  if(scanfValidador2!=1){
   printf("\nOpcion no valida, ingrese un valor numererico positivo.\n");
   puts("");
  }
 }while(scanfValidador2!=1); //Validador
}while(volverIntentar==1);
 return 0;
}
 

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "time.h"
 
enum bool {false, true}
 
int main () 
 
{
        int v_original [4];
        int b_original [4];
        int final[8]=0;
        int usados[8];
        int i, j, k=0, l=0;
        bool repetido;
        int  contUsados=0;
 
        printf("Programa union de vectores \n\n");
 
        for (i=0; i<4; i++) 
		{
                printf("Introduce el valor a[%d]:", i);
                scanf("%d",&v_original[i]);
        } 
         printf("\n");
 
        for (i=0; i<4; i++)
		 {
                printf("Introduce el valor b[%d]: ", i);
                scanf("%d",&b_original[i]);
        }
 
        for (i=0;i<4;i++)  {																				//exploramos uno a uno el vector inicial
        	repetido = false;																			//suponemos que no está repetido
        	for (j=0; j<contUsados;j++)   {													//pero lo verificamos comprobando el vector de usados
        	    if (v_original[i] == usados[j]) repetido = true;				
        	    }
                if (repetido == false) {																//si no ha sido usado
                	final[k]= v_original[i];															//lo añadimos al vector final y
                	usados[l]= v_original[i];													   //anotamos que ha sido usado
                	contUsados++;																	   //incrementamos el numero de elementos en el vector de usados	
                	k++;
                	l++;
                	}											  //si ya ha sido usado, no hacemos nada: ni lo anotamos como usado, ni lo copiamos en el vector final
               }
 
        for (i=0;i<4;i++)  {					
        	repetido = false;																				    //hacemos lo mismo con el segundo vector
        	for (j=0; j<contUsados;j++)  {
        	    if (b_original[i] == usados[j]) repetido = true;				
        	    }
                if (repetido == false) {																				               				
                	final[k]= b_original[i];																						
                	usados[l]= b_original[i];																						
                	contUsados++;
                	k++;
                	l++;
                	}
         	}
 
 
		printf("\n");
		printf("La union de los vectores a y b sera:");
		for(i=0;i<k;i++)
		printf(" %d ",final[i]);
}
 
 

#include <stdio.h>
#include <stdlib.h>
 
typedef struct nodo{ 
	int valor; 
	struct nodo *siguiente; 
} tiponodo; 
 
typedef tiponodo* pPila; 																//En pPila se guardará la dirección del primer elemento de la lista (pila)
typedef tiponodo* pNodo;															//Se define un nuevo tipo de dato, pNodo, que es un Puntero a una struct nodo (tiponodo)
 
void push(pPila *ptr, int v); 
int  pop(pPila *ptr);
 
int main() { 
 
	pPila *pila = NULL; 																	 	//Se pone a cero la dirección contenida en pila. Es decir, lista vacía.
 
	push(&pila, 5); 																				//Se pasa la dirección de la pila
	push(&pila, 8); 
	push(&pila, 10); 
	printf("\n%d", pop(&pila));
	printf("\n%d", pop(&pila));
	printf("\n%d", pop(&pila));
 
 
	return 0 
} 
 
void push(pPila *ptr, int v){															//Pasamos a la función la dirección de un elemento tipo pila.
 
	pNodo nuevo = (pNodo ) malloc(sizeof(tiponodo)); 		//Se crea un nuevo nodo
	if (nuevo == NULL) exit(1);
	nuevo->valor = v; 
	nuevo->siguiente = *ptr; 															//Se guarda la dirección del hasta ahora primer elemento de la lista
	*ptr = nuevo; 																					//Se anota en pila la dirección de este nuevo nodo, que pasa a ser el primero
}
 
int  pop(pPila *ptr){																			//Pasamos a la función la dirección de un elemento tipo pila.
 
   pNodo ptrTemp;																			//Se crea una direccion a tiponodo para poder luego liberar memoria
   int num;
 
	if (*ptr == NULL) printf ("\nPila vacía.");
	   else {
 			ptrTemp = *ptr;																		//Se guarda la dirección del primer elemento de la pila
 			num =  ptrTemp->valor;
 			*ptr = ptrTemp->siguiente;												//Pila coge la dirección del siguiente elemento al primero, con lo que primero está listo para eliminar
			free(ptrTemp);
	       }
 
	  return num;     
}
 
 

#include <stdio.h>
#include <stdlib.h>
#define MAX 20
 
typedef struct _Mazmorra {																			//Este struct tiene un tamaño de 2*int + 1*char
    int x;
    int y;
    char c;
 
}Mazmorra;
 
typedef struct _Punto{																					//Este struct tiene un tamaño de 4*Mazmorra
    Mazmorra *P_final;
    Mazmorra *P_principio;
    Mazmorra *p_tamanyo;
    Mazmorra *tamanyo_mazmorra[MAX][MAX];
}Punto;
 
Punto* inicializar_mazmorra(){
 
    Punto *punto;
    int x,y;
 
   punto=(Punto*)malloc(sizeof(Punto));														//Se crea espacio para un struct _Punto
   if(punto==NULL){
       printf ("error al reservar memoria");
   }
 
   punto->P_final = (Mazmorra *) malloc(sizeof(Mazmorra));				//Se crea espacio para un struct Mazmorra
   if(punto->P_final ==NULL){
       printf ("error al reservar memoria");
   }
   punto->P_final=NULL;
 
   punto->P_principio = (Mazmorra *) malloc(sizeof(Mazmorra));		//Se crea espacio para un struct Mazmorra
   if(punto->P_principio ==NULL){
       printf ("error al reservar memoria");
   }
   punto->P_principio=NULL;
 
   punto->p_tamanyo = (Mazmorra *) malloc(sizeof(Mazmorra));		//Se crea espacio para un struct Mazmorra
   if(punto->p_tamanyo ==NULL){
       printf ("error al reservar memoria");
   } 
   punto->p_tamanyo=NULL;
 
   for(x=0;x<MAX;x++){
       for(y=0;y<MAX;y++){
       	    punto->tamanyo_mazmorra[x][y] = (Mazmorra *) malloc(sizeof(Mazmorra));		//Se crea espacio para un struct Mazmorra
       	       if(punto->tamanyo_mazmorra[x][y] ==NULL){
    		   printf ("error al reservar memoria");
   				} 
            punto->tamanyo_mazmorra[x][y]=NULL;
       }
   }
 
   return punto;
}
 
void Liberarmemoria(Punto *punto) {
 
    int x,y;
 
    free(punto->P_final);
    free(punto->P_principio);
    free(punto->p_tamanyo);
       for(x=0;x<MAX;x++){
       for(y=0;y<MAX;y++){
            free(punto->tamanyo_mazmorra[x][y]);
       }
   }
 
}
 
int main(){
    FILE *archivo;
    Punto *punto;
    int x;    
 
    punto = inicializar_mazmorra();
 
    punto->tamanyo_mazmorra[1][1]->x = 5;
    archivo = fopen("prueba.dat","r");
    if(archivo==NULL){
        printf ("error");
    }
 
    printf ("%c",punto->tamanyo_mazmorra[1][1]->x);
 
    //x = leer_archivo_mazmorra(archivo,punto);
    Liberarmemoria(punto);
    fclose(archivo);
 
 
}
 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 10
 
typedef struct asignaturas{
	char nombre[MAX];
	int nota[4];
}asignatura;
 
typedef struct estudiantes{
	char nombre[MAX];
	char apellido[MAX];
	asignatura materia[3];
}escolar;
 
void DatosAlum(escolar *alumno);
void IntroNota(asignatura *materia, int indice);
 
 
int main(){
 
	int cant_alum, i,j;
	char nom_mate[3][MAX];
	escolar *alumno;
 
 
	printf("Introduzca cantidad de alumnos: \n");
	scanf("%d",&cant_alum);
 
    alumno = (escolar *) malloc(sizeof(escolar) *cant_alum);       //Declarando variable tipo struct "escolar"
 
	for(i=0;i<cant_alum;i++) {
		printf("Alumno nro %d: \n", i+1);    
		DatosAlum(&alumno[i]);               //Introduciendo nombres y apellidos de alumnos
     	}
 
	printf("Introduzca nombre de materias: \n");
		for(i=0;i<3;i++){
			printf("Materia nro %d: ",i+1);
			fflush(stdin);
			gets(nom_mate[i]);
	}
 
	for(i=0;i<cant_alum;i++) {
		for(j=0;j<3;j++) {
			strcpy(alumno[i].materia[j].nombre,nom_mate[j]);     //Aca copìo y pego los nombres en  las estructuras.
	        }
     	}
 
 
	printf("Introduzca notas: \n");
		for( i=0; i<cant_alum; i++){
			printf("Alumno: %s %s\n", alumno[i].nombre, alumno[i].apellido);
				for( j=0; j<3; j++) {
					printf("Materia: %s \n",alumno[i].materia[j].nombre);  
					IntroNota( alumno[i].materia[i].nota, j);
				    printf("\nvalor de j= %d", j);
	}	
	}
 
 
getchar();
return 0;
}
 
void DatosAlum(escolar *alumno){
 
	printf("Nombre: ");
	fflush(stdin);
	gets(alumno->nombre);
 
	printf("Apellido: ");
	fflush(stdin);
	gets(alumno->apellido);
 
}
 
void  IntroNota(asignatura *materia, int indice) 
{
	int i;
 
		for( i=0; i<4; i++) {
			printf("Nota %d: \n",i+1);
			scanf("%d", &(materia[indice].nota[i]) );
	}
 
}