Mensajes

Ligera modificación para que funcione.

Código (cpp) [Seleccionar] Expandir



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;
}







Puedes usar secuencias de escape ANSI. Te pongo un ejemplo. Sdos

Código (c) [Seleccionar] Expandir


#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;
}


No creo que te funcione. Mira a ver ahora.

Código (c) [Seleccionar] Expandir

    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]

Código (c) [Seleccionar] Expandir

#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;
}


Tiene muchas cosas mal o por lo menos, rarillas.
Te he corregido el mínimo necesario para que funcione.

Código (c) [Seleccionar] Expandir



#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;
}


Yo lo haría así. (Esta sin optimizar).
Sdos.

Código (c) [Seleccionar] Expandir


#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]);
}



Debería quedar así.

Código (c) [Seleccionar] Expandir


#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;     
}



Te falta crear espacio (reservar memoria) para los punteros a struct Mazmorra dentro de _Punto.
Un saludo.

Código (c) [Seleccionar] Expandir


#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);

   
}


Yo lo he resuelto así, pero tiene punteros, claro.

Código (c) [Seleccionar] Expandir

#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]) );
}

}

Te envío un código que sí funciona. Si solo quieres contar palabras en la primera línea, cambia el segundo if para que compruebe la condición (CP == 1).

#include <stdio.h>
#include <stdlib.h>
 

int main(int argc, char** argv)
{
    FILE *archivo;
    int ch, CL, CP,i;
    char arch[25];

 
    //printf("\nHoli! Dime el nombre archivo, incluyendo formato n.n:\n\n");
   // gets(arch);
   
//Para comprobar que exista el archivo :v
    if ((archivo = fopen("registroPersona.txt", "r")) == NULL){
      perror(arch);
      return EXIT_FAILURE;
      }
   
   CL = 0;
   CP = 0;
   while ((ch = fgetc(archivo)) != EOF) {
      if (ch == '\n')   CL++;
      if(ch == ' ' || ch == '\n')  CP++;
     }
   
   fclose(archivo);
   printf("Numero de lineas en: %d\n",CL);
    printf("Cantidad de palabras: %d\n", CP);
   return EXIT_SUCCESS;

}