hola verán tengo mi codigo que cuenta la cantidad de archivos que hay en un directorio y después devuelve el nombre de ese archivo junto a su md5sum , lo que sucede es que mi tarea dice lo siguiente:

La aplicacion debe examinar una vez cada cierto tiempo el contenido del directorio “/var/log”, para identificar los cambios que hayan ocurrido en los archivos de log del sistema desde la u´ltima revisi´on. Se deben omitir los subdirectorios y los archivos con extension “.gz”. Para verificar los archivos debe utilizar el comando de shell “md5sum” mediante las llamadas al sistema fork y exec. Por cada archivo a ser procesado su aplicaci´on debe crear un subproceso el cual se encargar de ejecutar el comando “md5sum”. El resultado del comando debe ser retornado

entonces encontre un codigo aqui en stackoverflow sobre como crear multiples procesos hijos: https://stackoverflow.com/questions/876605/multiple-child-process , lo cual supongo que es como lo piden en mi enunciado ya que dice "por cada archivo a prcesar se crea un subproceso" pero queria saber si es la manera correcta.

lo segundo es con las tuberias, yo tengo mi funcion piepe() y mi arreglo inf[2] y usando la funcion dup. redirigo la salida y entrada, pero tengo duda si tengo que crear una especie de arreglo dianmico o un arreglo de arreglo , ya que se deben crear N tuberias de acuerdo a mis N archivos leidos

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include<dirent.h> 
 
char buffer[100];
 
int s;
 
 
 
int path_is_dir(char *path) {   //valido si son subdirectorios 
    struct stat st_info;
 
    if (stat(path, &st_info) < 0) {
        return 0;
    }
 
    return S_ISDIR(st_info.st_mode);
}
 
 
void validar_folder(){
 
int carp;
 
DIR *dirp_p;
struct dirent *entry;
dirp_p = opendir("/home/jose/Escritorio/carpetaPrueba") ; //va "/var/log/PROYECTO_SO_1"
 
    if(dirp_p == NULL ){
        carp= mkdir("carpetaPrueba",0777);          //creo la carpeta
    }
 
}
 
 
int main(){
 
int cont_file=0;
int inf[2];
 
validar_folder();
 
pipe(inf);
 
DIR *dirp;
struct dirent * entry;
dirp = opendir("/home/jose/Escritorio");
 
while ((entry = readdir(dirp) )!=NULL) { //cuanto la cant de archivos
     if (entry->d_type == DT_REG) { 
       cont_file++;
    }
}
closedir(dirp);
 
 
const char * dir_name = "/home/jose/Escritorio";            
DIR * dir_ptr = NULL;
struct dirent * dirent_ptr;        
 
dir_ptr = opendir( dir_name );
 
//int f = open("prueba.txt", O_CREAT | O_WRONLY, S_IRWXU | S_IRWXG | S_IRWXO);
 
while ( (dirent_ptr = readdir( dir_ptr ) ) != NULL ){
 
if(!path_is_dir(dirent_ptr -> d_name)){
 
if(fork()==0){
 
close(1);
 
dup(inf[1]); // redirige la salida estandar
 
execl("/usr/bin/md5sum", "md5sum", dirent_ptr -> d_name, NULL);
 
}else{
 
read(inf[0], buffer, 100);
 
buffer[32] = '\0';
printf("%s :", dirent_ptr -> d_name);
printf("%s\n", buffer);
 
 
wait(&s);

vale gracias MAFUS, en seguida lo pruebo, supongo que cuando dices "todo debe estar del if (caracter!=\n)" hablas de todos los if y else if nada mas cierto?

Hola a todos, verán tengo un incoveninete, tengo que leer desde un archivo que se llama entrada.in donde me daran varios de diferentes cosas, tiempo de llegada, scanners, impresoras, etc... valores los cuales tengo que guardar en un registro y bueno, use un arreglo de structs para eso, el asunto es que primero leo con fgetc cada numero caracter sin comas ni espacios en blancos,

despues el problema surge que al imprimir esos mismo valores que guardo, ocurre un problema ... creo que me imprime valores negativos entre cada valor y que tambien pareciera que en el ultimo valor, no se tomara un valor, como si no estuviera:

ejemplo del archivo:

1, 0, 1, 0, 0, 0, 0
1, 1, 2, 1, 0, 0, 1
3, 3, 6, 1, 0, 1, 2

 
#include <stdio.h>
#include <stdlib.h>
 
struct list_entra {                       //registro con 7 campos
	int tiempo_llegada;
    int prioridad;
    int procesa;
    int scanner;
    int impresora;
    int modem;
    int dvd;
}proentra [7] ;
 
 
int main (int argc, char *argv[]) {
int contaproceso= 0, i;                   //contador para saber en cual celda del arreglo de struct se guardará
int contcanti =0;                            //contador que uso para ver los diferentes campos del struct
char carac;
 
    FILE *archivo;
    archivo= fopen("listaprocesos.in", "r");
 
    if (archivo == NULL){
        printf ("error al abrir archivo \n");
        exit (1);
    }
 
    while (carac != EOF){                                                            //imprimo para ver si lee bien los caracteres que necesito
		carac= fgetc (archivo);
        if (carac != '\n' && carac != ',' && carac != ' '){
			printf ("%c\n", carac);
        }
 
        if (contcanti==0){													//lleno el registro y resto -48 para pasar de caracter a entero
			proentra [contaproceso].tiempo_llegada= (int)(carac-48);
		}else if (contcanti==1){
			proentra[contaproceso].prioridad= (int)(carac-48);
		}else if (contcanti==2){
			proentra[contaproceso].procesa= (int)(carac-48);
		}else if (contcanti==3){
			proentra[contaproceso].scanner= (int)(carac-48);
		}else if (contcanti==4){
			proentra[contaproceso].impresora = (int)(carac-48);
		}else if (contcanti==5){
			proentra[contaproceso].modem= (int)(carac-48);
		}else if (contcanti==6){
			proentra[contaproceso].dvd= (int)(carac-48);
		}
			contcanti++;
 
		if (contcanti==7){
			contcanti=0;
			contaproceso++;
		}
    }
 
    for (i=0;i<contaproceso;i++){                                      //imprimo por pantalla
		printf ("\n%d", proentra[i].tiempo_llegada );
		printf ("\n%d", proentra[i].prioridad );
		printf ("\n%d", proentra[i].procesa);
		printf ("\n%d", proentra[i].scanner);
		printf ("\n%d", proentra[i].impresora);
		printf ("\n%d", proentra[i].modem);
		printf ("\n%d", proentra[i].dvd);
	}
 
    fclose (archivo);
 
    return 0;
}
 
 

y me muestra por consola esto:

1
0
1
0
0
0
0
1
1
2
1
0
0
1
3
3
6
1
0
1
2
�

1
-4
-16
0
-4
-16
1
-4
-16
0
-4
-16
0
-4
-16
0
-4
-16
0
-38
1
-4
-16
1
-4
-16
2
-4
-16
1
-4
-16
0
-4
-16
0
-4
-16
1
-38
3
-4
-16
3
-4
-16
6
-4
-16
1
-4
-16
0
-4
-16
1


podrían ayudarme, es una tarea que me mandaron, soy principiante en programación y he estado observando pero no lo logró ver el problema.

hola estoy teniendo problemas econ mi codigo de una tarea. este es el enunciado:

Inicialmente su código debe leer un archivo llamado “reglas.txt”, este contiene en cada
línea alguna letra del abecedario (solo trabajaremos con letras mayúsculas) y al lado
de cada letra estará su respectiva codificación en binario. Serán las letras de la A
hasta la Z y los números de 0 al 4, así tenemos 32 caracteres, 5 bits para cada uno. El
archivo tiene la siguiente estructura:
<Letra> <Binario de 5 bits>Ejemplo reglas.txt:
G 00000
Z 11001
K 00011
.
.
.
.
1 01110
Fíjese que las letras en el archivo no necesariamente están en orden alfabético,
igualmente los números tampoco están en orden. La idea es que las cadenas de
entrada tengan un significado diferente según el archivo de reglas. Todas las letras y
números mencionados anteriormente deben estar incluidos en las reglas con su
respectiva codificación en binario.
Si la entrada fuera 1 00000110010111000000, se tiene que escribir el mensaje
decodificado en un archivo de salida, cada entrada es una línea en la salida. Para el
ejemplo anterior, en el archivo salida se escribe GZ1G. Todo esto con las reglas
definidas antes.

bueno se que se imprime en un archivo salida pero primero imprimo en la terminal para ir probando mi codigo

ahora esta es la parte de opcion 1 la opcion ya la tengo hecha aparte no se preocupen por eso.

la cadena de 50 digitos sera mi bin y como tengo que ir cortando de esa cadena cada 5 digitos creen un for que guardare ese valor que va a ir del 0 al 4 despues cambie los iteradores por que al segundo termino de 5 digitos lo corto de 5 a 9

uso el fscanf para leer del archivo reglas ya que siempre leera un caracter y la cadena, luego uso el strncmp para comparar el arreglo con la cadena del archivo reglas si son iguales devolvera 0 y si es 0 guarda el caracter en el arreglo sol.

ahora el problema qu etengo es que este es mi archivo reglas:

K 00101
J 10111
A 00100
X 10010

y si coloco opcion 1 00101 me imprime k pero tambien me imprime algo de basura y por ejemplo si coloco opcion 1 10111 que seria j , el codigo no hace nada , me pueden ayudar con esto que no se por que el codigo genera estos problemas.

#include <stdlib.h>
#include <stdio.h>  
#include <string.h> 
 
int main (int argc, char *argv[]) {
	int i=0,j=0,k=0,l=0,m=0,n=0;
	char bin[50],str1[5],letra,op,ArrSol[10]; 
 
	int caracter,ret;
	int v=0, z=5;
	char array[5];
	FILE *reglas;
 
	scanf("%c %s",&op,bin);
 
if(op=='1'){ //Opción 1
	reglas=fopen(argv[1],"r"); //abriendo archivo reglas
 
	 if(reglas==NULL){
	 printf("Error en el archivo");
	 }else{
		while (!feof(reglas)){
			if((fscanf(reglas,"%c %s",&letra,str1))!=NULL){ 
						//printf("%c %s\n",letra,str1);//Probando que lee línea a línea					
 
				for (v=0;v<z;v++){
				 array[v]=bin[v];
				 l++; 
				}	
			 v=l;
			 z=z+5;
 
			    ret=strncmp(array,str1,5); 
			//printf("%d",ret);
				if (ret==0){     
				 ArrSol[k]=letra;
					}
				k++;
				printf ("%s" , ArrSol);	
			}
			}
		}  
}
}
 
 
fclose(reglas);
 
return 0;
}
 

se trata de que leo 3 valores el primero que es la cantidad de atracciones, el segudno que son las populares (maayor nivel de diversion) y h que son aristas con las que se conectan las atracciones.

primero asi seria la entrada:

6 2 3

noria 12
mon_rusa 20
carritosCHO 100
silla_voladora 15
gusanito 1
casa_terror 13
0 1
2 1
0 2

y la salida es:

CarritosCho Mon_rusa
POSIBLE
Entrada CarritosCho Mon_rusa Entrada
Entrada Mon_rusa CarritosCho Entrada

si es imposible solo devuelve imposible

pero aparte el programa no me compila y no se si el backtracking este bien, por favor podrian ayudarme .

hola podrian ayudarme con este codigo, es un backtracking que me tiene que devolver si es posible o es imposible que haya circuito hamiltoniano

#include <iostream>
#include <string>
using namespace std;
 
class atraccion {
	private:
	int x;
	string name;
	public:
 
	atraccion () {} 
	atraccion (int var, string nnombre){
		x=var;
		name = nnombre;
	}
	~atraccion() {}
 
	void set_x (int val) { 				//modifica el x
		x = val;
	}
 
	int get_x () {						//devuelve el x
		return x;
	}
 
	void set_name ( string nom) {			//modifica el nombre
		name =nom;
	}
 
	string get_name () {					//devuelve el nombre
		return name;
	}
};
 
 
void back (int i, int j, bool array[11][11],int camino[],int acum=0 , int arist){
 
	if((j==0) && (acum= arist-1)){
		cout<<"POSIBLE"<<endl;
	}else{
	 if (array[i][j] == true ){
		for (int x=0;x<11;x++){
			int p=j;
			camino[x]=j;
			array[i][j] = array[j][i]=false;
			acum=acum+1;
			back (i=p, j=0, array, camino, acum, arist);
 
			camino[x] = ' ';				//desmarco y deshago mu solucion 
			acum= acum-1;				//desmarco y deshago mi solucion
 
		}
 
	}else{
		back(i,j++,array,camino, acum,arist);			//busco otra solucion 
}
		cout<< "IMPOSIBLE"<<endl;	
}
}
 
 
int main (){
	int m, n, h,div;
	int posmayor,mayor;
	bool mat[11][11];
	int x,y;
	string nombre;
	atraccion intercambio;
	int r=0,s=0,t=0;
 
	cin>>m>>n>>h;
 
	int sol[h-1];
	atraccion ar [m];		//arreglo que almacena cada atraccion 
 
		for (int i=0;i<m;i++) {
			cin>>nombre;
			cin>>div;
			ar[i].set_name(nombre);
			ar[i].set_x (div);
		}
 
		for( int g=0;g<11;g++){				//matriz de adyacencia
			for (int f=0;f<11;f++){
			mat[g][f] =false;
		}
		}
 
		    for (int d=0;d<=h-1;d++){           // Coloco de par en par de vértices conexos hasta que no haya más aristas
            cin >> x >> y;     // Leo la pareja
            mat[x][y]=mat[y][x]=true; // Guardo el dato en la matriz de adyacencia
            }
 
		for (int w=0;w<=m-2;w++){               //ordenamiento //modelo 2
            posmayor = w;
            mayor = ar[w].get_x();
            for (int k=w+1; k<=m-1; k++){
				/*if ((ar[k].get_x() == mayor) && (ar[k].get_name () < ar[w].get_name())){
					mayor= ar[k];
					posmayor=k;
				}else{*/
                if (ar[k].get_x() > mayor) {
                    mayor = ar[k].get_x();
                    posmayor =k;
					}
				//}
            }
 
            intercambio = ar[posmayor];		//se encarga de cambiarlos 
            ar[posmayor] =ar[w];
            ar[w] = intercambio;
		}
 
		for (int j=0;j<n;j++) {				//imprime populares 
			cout<<ar[j].get_name()<<endl;
		}
 
		for (int u=0;u<11;u++) {				//imprime booleana
			for(int v=0;v<11;v++){
			cout<<mat[u][v];
		}
	}
		back(r, s, mat, sol, t , n);
 
	return 0;
}
 
 

Hola tengo un arreglo de objetos que se trata de un parque de diversiones en el cual cada atraccion tiene dos atributos su nombre (string) y su nivel de diversion (int).

yo leo 3 valores m que es la cantidad de atracciones, que es mayor a 1 y menor 100000; un n  n<=10 que son la cantidad de atracciones populares, osea, las atracciones que tienen un nivel de divesion mas alto y tambien leo un valor h que por ahora no lo estoy usando pero despues lo usare por que son para leer las aristas con las que se conectaran las atracciones,

por ahora mi problema es que tengo que ordenar ese arreglo de mayor a menor ya que las atracciones con mayor nivel de diversion van primero...

entrada:
5 3 3(este ultimo valor no hace nada todavia no es importante para el ordenar)
montaña_rusa 30
carritos_chocones 50
barco_pirata 40
tazas_locas 10
casa_terror 20

por lo tanto tendria que estar ordenado de:
carritos_chocones
barco_pirata
montaña_rusa
casa_terror
tazas_locas

y el programa deberia imprimir es:

carritos_chocones
barco_pirata
montaña_rusa


y bueno yo estaba usando el ordenamiento de seleccion (selection sort) que es de menor a mayor pero lo modifique como yo crei para poder ordenarlo ascendentemente, pero mi problema es que no me ordena, me da segmentation y nunca antes habia ordenado un arreglo de objetos y tengo dudas con eso, podrian ayudarme por favor con el codigo.

//jose luis silva 24.900.481 sección: c4 
 
#include <iostream>
#include <string>
using namespace std;
 
class atraccion {
	private:
	int x;
	string name;
	public:
 
	atraccion () {} 
	atraccion (int var, string nnombre){
		x=var;
		name = nnombre;
	}
	~atraccion() {}
 
	void set_x (int val) { 				//modifica el x
		x = val;
	}
 
	int get_x () {						//devuelve el x
		return x;
	}
 
	void set_name ( string nom) {			//modifica el nombre
		name =nom;
	}
 
	string get_name () {					//devuelve el nombre
		return name;
	}
};
 
int main (){
	int m, n, h,div;
	int posmayor,mayor;
	string nombre;
	atraccion intercambio;
 
	cin>>m>>n>>h;
 
	atraccion ar [m];		//arreglo que almacena cada atraccion 
 
		for (int i=0;i<m;i++) {
			cin>>nombre;
			cin>>div;
			ar[i].set_name(nombre);
			ar[i].set_x (div);
		}
 
		for (int w=0;w<=m-2;w++){				//ordenamiento 
			posmayor = w;
			mayor = ar[w].get_x();
			for (int k=w+1; k<=m-1; k++){
				if (ar[k].get_x() > mayor) {
					mayor = ar[k].get_x();
					posmayor =k;
				}
			}
 
			intercambio = ar[posmayor];
			ar[posmayor] =ar[w];
			ar[w] = intercambio;
		}
 
		for (int j=0;j<n;j++) {
			cout<<ar[j].get_name()<<endl;
		}
 
	return 0;
}