no entiendo por que en los fread() le pasas &ptr. ptr es un puntero a int, el cual no inicializas ya sea diciendole que apunte a alguna variable o reservandole memoria, y encima lo pasas por referencia con lo que a fread() le estas pasando la direccion de memoria del puntero

luego dentro del while tampoco entiendo cual es la finalidad de ptr=&ultimo, o directamente para que usas el puntero ptr. ademas, por cada caracter que lees, sumas 1 a "ultimo", cuando por cada linea deberias sumar 1. si la estructura del fichero siempre es 1 numero, 1 espacio, y luego una frase, podrias leer caracter por caracter, y si este es igual a '\n' sumar 1 a "ultimo".

ademas que abres el fichero 2 veces, podrias abrirlo solo 1 vez en modo lectura y escritura y con fseek() cuando lo necesites te situas al final de este.

en fin, que no me aclaro mucho con tu codigo... quizas soy yo asi que esperemos a que alguien mas conteste porque seguramente se me hayan pasado varias cosas.

un saludo!

edito: tenia ganas de programar algo y me puse con tu ejercicio. te dejo el code por si te sirve. este incluye la frase que se le pase por linea de comandos entre "" en el archivo con el numero que le toque al inicio.

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char** argv) {
 
	char fichero[]="prueba.txt", aux;
	unsigned int num=0, i;
	FILE *f;
 
	//comprobaciones de error
	if (argc != 2) {
		printf("MODO DE USO: %s \"frase\"\n", argv[0]);
		exit(0);
	}
 
	if (!(f=fopen(fichero, "r+"))) {
		printf("ERROR: No se pudo abrir %s.\n", fichero);
		if (!(f=fopen(fichero, "w"))) {
		printf("ERROR: No se pudo crear %s.\n", fichero);
		exit(1);
		} else printf("Fichero %s creado.\n", fichero);
	}
 
	//lineas totales en el archivo
	do {
		i=fread(&aux, sizeof(char), 1, f);
		if (aux == '\n') num++;
	} while (i > 0);
	if (num == 0) num++;
 
	//escribimos el numero y la frase
	fprintf(f, "%u %s\n", num, argv[1]);
 
	fclose(f);
	return 0;
}
 

ya y yo tambien creia eso, pero cogi su codigo y lo copie, compile solo cambiando un par de cosas por no estar en windows, y corria perfectamente, de ahi que dude. sabes por que funciona aunque recomienden no hacerlo?

gracias y un saludo!

para sumar 2 matrices deben tener la misma dimension. luego en tu codigo usas la libreria conio.h, algo que no se recomienda por el foro mas que nada porque no es una libreria estandar (diria, yo no uso windows y la verdad no lo se seguro, pero diria que es eso). ademas, creo que la usas para la funcion getch(), y es que tienes una equivalente en la libreria estandar stdio.h que es getchar(). luego yo no estoy muy a favor de usar variables globales, y menos para contadores y demas. si es imprescindible pues si... pero en este caso no lo veo asi. ademas, tus 2 funciones de generar matrices son exactamente la misma, solo cambia el nombre de la variable. por que no haces una solo un poco mas generica y la aplicas a las variables que quieras?

para acabar, no sabia que se podia pedir la dimension de un arreglo y luego declarar la variable estaticamente en medio del codigo. si alguien experto puede aclararme esta duda se lo agradeceria, ya que yo en estos casos suelo usar memoria dinamica.

te dejo el codigo probado:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int** GenerarMatriz(int n); //funcion que devuelve un apuntador a un array de apuntadores
void SumarMatrices(int** m1, int** m2, const int n); //funcion que toma como parametros un apuntador a un array de apunt.
 
int main() {
 
	int **matriz1=NULL, **matriz2=NULL, n; //se inicializan los apuntadores a apuntadores con NULL para evitar posibles problemas
	srand(time(NULL));
 
	printf("Dimension de las matrices: ");
	scanf("%d", &n);
	printf("\n");
	while (getchar() != '\n'); //limpiamos el bufer stdin de basura, es buen habito ponerlo despues del scanf 
 
	matriz1=GenerarMatriz(n); //primera matriz
	matriz2=GenerarMatriz(n); //segunda matriz
	SumarMatrices(matriz1, matriz2, n);
 
	free(matriz1); //siempre que se reserva memoria hay que liberarla al final
	free(matriz2);
	printf("Pulse enter para salir...");
	getchar();
	return 0;
}
 
int** GenerarMatriz(const int n) {
 
	int** matriz=NULL, i, j;
 
	//se reserva memoria
	matriz=(int**)malloc(n*sizeof(int*)); //reservamos memoria para el array de apuntadores (seran las filas abc en el caso del ejemplo de abajo)
	for (i=0; i<n; i++)
		*(matriz+i)=(int*)malloc(n*sizeof(int)); //para cada apuntador en el array, le asignamos memoria (los vectores 123, 456, 789, o columnas de la matriz)
 
	//aqui rellenamos cada elemento con un numero aleatorio
	for (i=0; i<n; i++) {
		for (j=0; j<n; j++) {
			*(*(matriz+i)+j)=rand()%16;
			printf("%d\t", *(*(matriz+i)+j));
		}
		printf("\n");
	}
	printf("\n");
	return matriz; //con esto hacemos que matriz1 (variable del main y primera matriz) apunte al mismo sitio que "matriz", la creada en esta funcion
}
 
void SumarMatrices(int** m1, int** m2, const int n) {
 
	int i, j;
 
	for (i=0; i<n; i++) {
		for (j=0; j<n; j++) {
			printf("%d\t", (*(*(m1+i)+j))+(*(*(m2+i)+j)));
		}
		printf("\n");
	}
	printf("\n");
}
 

un saludo!

vaya es verdad, me olvide del objetivo del programa y no cai... 

un saludo!

DEFCON (DEFense CONdition) se usa para referirse al nivel de alerta de algun sistema o algo asi. DEFCON 5 seria el nivel normal, en el que no hay peligro por decirlo de alguna manera; y DEFCON 1 seria la maxima alerta.

http://es.wikipedia.org/wiki/DEFCON

que es exactamente lo que quieres hacer?

no se si te refieres a usar threads o hilos de ejecucion (1 proceso podria hacer varias cosas "a la vez"):

http://www.chuidiang.com/clinux/procesos/procesoshilos.php

o si te refieres a que un programa ejecute otro a parte y que de esta manera no sea un proceso hijo:

http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/exec.htm

y no se me ocurren mas si ya has encontrado el fork().

un saludo!

nunca habia visto esta manera de ordenar un arreglo y me la apunto

solo una cosa y es que diria que en un arreglo de int no hace falta reservar un espacio al final para un null. y si reservas memoria, asegurate al final de liberarla con free(vec).

un saludo!

t=tiempo. la intensidad y el voltaje son funciones del tiempo. en el ejercicio no lo necesitas para nada, ya que segun el enunciado consume una instensidad y la fuente entrega un voltaje constante.

j=indica que es un numero complejo. en matematicas teoricas se suele usar "i", aunque en fisica se suele utilizar la "j".

w= frecuencia angular. es la frecuencia en rad/s en vez de Hz.

en el caso de tu problema:

i=0.02A
v=12V
f=2000Hz

usando modulos se tiene que:
V=Z*i=w*L*i=2*pi*f*L*i -> L=47.7mH

no olvides que en alterna son fasores, numeros complejos con modulo y angulo, y que para resolver un circuito siempre hay que hacerlo con fasores. en este caso, solo hay una inductancia, y pasar la igualdad V=Z*I (fasores) a modulo queda igual ya que Z tiene un angulo de 90º y I de -90º. pero si tuvieras mas de un componente con diferentes inductancias o capacidades, entonces deberias plantear la ecuacion obligatoriamente en fasores. haciendo esto te ahorraras mucho de los errores mas comunes al tratar con corriente alterna.

un saludo!

no acabo de entender tu codigo, mezclas en asignaciones punteros y structs, ademas de que a mi parecer esta algo desordenado... para arreglar esto, deberias tener una funcion que te inserte 1 nodo en la lista, 1 funcion que te elimine 1 nodo de la lista, y una funcion que te elimine la lista entera. luego otra funcion que te permita buscar cosas en ella. te dejo la funcion para crear 1 nodo, con el trozo de codigo en el main para hacer n nodos, y asi veras donde te has equivocado.

struct lista* insertar_nodo(struct lista* l, struct dato x) 
{
	struct lista *q, *p;
 
	q=(struct lista*)malloc(sizeof(struct lista)); // reservamos memoria para 1 nodo
        //aqui rellenamos la estructura del nodo creado
	q->datos=x;
	q->sig=NULL; //NULL ya que sera el ultimo elemento de la lista
 
	if (l == NULL) return q; // si el puntero l de los parametros era NULL, retornamos el nodo creado ya que sera el unico elemento de la lista
 
        // si l ya tenia nodos, buscamos el ultimo para poder añadir el nuevo nodo
	p=l; //no usamos q ya que necesitamos la direccion del nuevo nodo creado
	while (p->sig != NULL) p=p->sig; //buscamos el ultimo nodo de la lista
	p->sig=q; //al ultimo nodo le asignamos a siguiente el nuevo nodo q
 
	return l; //retornamos l, q era tanto parametro de la funcion como el valor de retorno
}

y en el main, se usaria de esta manera para crear una lista con n nodos:

struct lista {
	struct dato datos;
	struct lista *sig;
};
 
int main() {
        struct dato d;
	struct lista *l=NULL;
 
        //(codigo.....)
 
        for (i=0; i<n; i++)
		l=insertar_nodo(l, d);
 
        //(Codigo.....)
}

si quieres que te pase el codigo entero dimelo, era un problema bastante divertido que posteo un usuario el foro hace tiempo, aunque es algo largo y por eso no lo postee. un saludo

para hacerlo desde codigo podrias mirar estas funciones:
http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/exec.htm

aunque extrayendo el siguiente parrafo de aqui:
"Running a shell command in a child process is generally more useful than simply using the exec subroutine, as shown in this example. The simplest way to do this is to use the system subroutine."

yo entiendo que para solo correr un comando de terminal en el programa, lo mejor es usar system().

y para que arranque, pues no uso linux asi que no puedo probarlo, pero podrias probar lo que se dice aqui:
http://stackoverflow.com/questions/7221757/run-automatically-program-on-startup-under-linux-ubuntu

un saludo!