Y ya, si lo quieres hacer precioso, usas el operador ternario en vez de los ifs xD

Por ejemplo:

Acabo de leer el error. "No such file or directory" es que no encuentra la librería y eso es debido o al PATH o a que realmente no está la librería (?) xD

Verifica la variable PATH y si no es por eso, te aconsejo que reinstales.

El problema de Geany es el de compilar proyectos. Lo ideal sería compilar con makefile.

Desinstala y reinstala todo. Así te despreocupas de qué puede pasar y si tienes una instalación defectuosa. Creo que en la página oficial de C::B hay un enlace de descarga que te incluye el MinGW con las librerías además del C::B todo en un paquete listo para instalar.

(Qué buen vendedor soy (?)) XD

Puedes hacerlo con una estructura stat a partir de leer la entrada de directorio que corresponda al fichero que quieres analizar.

Te pongo un esbozo en C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h> // para la ruta
#include <dirent.h> // para la struct dirent
#include <sys/stat.h> // para la struct stat
#define TAM 256 // macro TAM de la ruta
 
 
int main() {
    char * ruta = malloc(TAM*sizeof(char));
    strncpy(ruta,"Aqui_la_ruta_que_quieras",TAM);
    struct dirent *entrada;
    struct stat status;
    DIR * dir = opendir(ruta); // abrimos el directorio
    if (!dir) exit(1); // comprobamos si lo pudimos abrir
    else {
        chdir(ruta);
        while ( (entrada=readdir(dir)) != NULL ) { // leemos entradas de directorio hasta que se devuelva puntero a NULL
            if ( ( strcmp(entrada->d_name, ".") == 0 ) ||
                 ( strcmp(entrada->d_name, "..") == 0 ) )
                 continue; // Saltamos las entradas de directorio actual y directorio raíz
            if (stat(entrada->d_name,&status) == 0) // cargamos la estructura stat (mejor usar lstat() para symbolic links)
                puts(entrada->d_name); // mostramos el nombre de la entrada
                puts((char *)ctime(&status.st_mtime)); // cogemos la fecha de modificación
         }
    }
}
 

Ahí te dejo el código medio comentado. Modifícalo a tus necesidades

Bueno, el código lee las entradas de un directorio y posteriormente lista el nombre de cada entrada junto a su última fecha de modificación (m_time de la struct stat).

Lo puedes hacer sencillamente aplicando recursividad. La idea de llevar un contador en la recursividad de este problema es interesante.

Si aplicas recursividad recuerda reconocer explícitamente el caso base.

A ver qué links pasamos...

Sorry, this file is infected with a virus.

Only the owner is allowed to download infected files.



· En el primer while haces una asignación en vez de colocar una expresión booleana.

· Dentro de los ciclos no modificas la variable de control...

El uso de los operadores unarios ++ (incremento) o -- (decremento) sirve para aumentar o decrementar en una unidad respectivamente (variables, punteros...). La posición que ocupan estos operadores infiere en el resultado obtenido de la evaluación de estos.

++a => La variable a se incrementa en una unidad y luego uso el valor de la variable a.

a++ => Primero usamos el valor de la variable a y finalmente incrementamos su valor.

La explicación para el operador -- es análoga.

Ejemplo:

Será eso de la experiencia... jaja

Este pequeñito aporte va dedicado especialmente a aquellos que comienzan recién en la programación

Prerrequisitos (?)

→ Vectores
→ Saber qué es y cómo se lleva a cabo la búsqueda binaria

Adjunto el código del algoritmo no recursivo (Por: Rodrigo Burgos Domínguez.):
http://algorithmmx.blogspot.com.es/2011/11/algoritmo-de-busqueda-binaria.html

int busqueda_binaria(vector <int> list, int val){
   int der = list.size() - 1, izq = 0, m;
   while(izq <= der){
      m = (izq + der) / 2;
      if(m == list[val]) return m; //la posicion del valor
      if(m > list[val]) der = m – 1;
      else izq = m + 1;
   }
   return -1; // no se encontro el dato :P
}

Teniendo en cuenta que ya sabemos la lógica que sigue este algoritmo y su implementación arriba expuesta, vamos a pensar en hacerlo de forma recursiva, es decir, que la misma función vaya reduciendo el tamaño (N) del problema a un caso base, de tal manera, al conocer la solución del caso base, va a poder dar solución a cualquier problema de tamaño N.

Entonces el código sería el siguiente:

(utilizo int casting para no usar la librería math.h)

int BinarySearch(int x, int v[], int tam) {
 
    int RecursiveBinarySearch(int x, int v[], int i, int m, int d) {
        if (i>d) return -1;
        else if ( x == v[m] ) return m;
        else if ( x < v[m] ) return RecursiveBinarySearch(x, v, i, (int)((i+m-1)/2), (m-1));
        else return RecursiveBinarySearch(x, v, (m+1), (int)((d+m+1)/2), d);
    }
 
    int i = 0;
    int m = tam/2;
    int d = tam;
 
    return RecursiveBinarySearch(x, v, i, m, d);
 
}

Explicación general:

La premisa que tenemos es que nosotros tenemos que buscar un elemento x en un vector v de tamaño N que está previamente ordenado. Teniendo eso en cuenta podemos afirmar que cualquier subvector w de v de tamaño [0..N] también está ordenado.

Pues teniendo eso en cuenta vamos reduciendo el tamaño del problema (N) a la mitad en cada llamada recursiva. ¿Por qué? Porque si x no es el elemento medio del vector v de tamaño N, entonces verificamos si es menor o mayor que él. Si es menor, buscamos en el subvector de tamaño N/2 izquierdo, sino en el derecho.

Como véis, en este caso, el algoritmo se pasa de forma cíclica a forma recursiva casi sin pensar. ¿Por qué? Estamos ante una Tail Recursive Function (la autollamada es lo último que se hace) y podemos pensar en definitiva que estamos ejecutando un ciclo simplemente.

Podría aquí estar escribiendo horas y horas sobre algoritmos de búsqueda y ordenación pero no es plan xD

Decir simplemente que hay tener en cuenta que el vector en el que vayamos a buscar un elemento, debe estar previamente ordenado.

En este momento os preguntaréis: ¿Qué me conviene más, buscar directamente en un vector con la búsqueda lineal o es mejor ordenarlo previamente (quicksort) y luego aplicar búsqueda binaria? Bueno eso ya son temas de complejidad algorítmica y haciendo un pequeño estudio se puede sacar conclusiones.

Decir también que hay estructuras de datos eficientes para la búsqueda como lo son por ejemplo las Tablas Hash o los Árboles Binarios de Búsqueda, ABB (variante AVL), por ejemplo.

Bueno con esto y un bizcocho me despido.

¡Saludos!

Todos los comentarios serán bien recibidos

Si al compilar no se reconoce la función gotoxy, algo pasa con los headers. En este caso conio.h. Y supuestamente según el error que te da, la función no se encuentra en el header conio.h o_O

En mi caso al compilar desde codeblocks con el gcc me suelta:


Ya ni conio.h tengo en el path de los headers. Creo que no está porque conio no es una librería estándar de C.