Mensajes

La idea de do-while es interesante, yo la adapté de la siguiente manera para crear un código más breve. La idea es empezar por el último carácter (no nulo) de la cadena y comparar con el siguiente. Si son diferentes, imprimir, sino, retroceder un carácter. En la función

Código (cpp) [Seleccionar] Expandir


void elimina_repetido2( char *start, char *c_ptr )
{

    static char c = '\0';

    if ( c_ptr == start || *c_ptr == '\0' )
        return;
    else {
        if ( *c_ptr != c ) printf( "%c", *c_ptr );
        c = *c_ptr;
        c_ptr--;
        elimina_repetido2( start, c_ptr );
    }
}

start es un apuntador al inicio de la cadena (para saber cuando detenernos al retroceder), c_ptr es un apuntador al carácter actualmente analizado (empezando por el último). La variable interna c funciona como auxiliar para almacenar el valor del carácter siguiente al apuntado por c_ptr.

Programa principal:

Código (cpp) [Seleccionar] Expandir


#include <cstdio>
#include <cstring>
#include <iostream>

int main(void) {

    char s1[100];

    cout << "Intro cadena: ";
    cin >> s1;

    cout << endl << "Salida:";
    elimina_repetido2( s1, s1 + strlen(s1) - 1 );
    cout << endl;

    return 0;
}

Salida en pantalla:

Intro cadena: aaabbbccdddeeee

Salida:edcba

Supongo que la debo utilizar de esta manera, ¿no?

Código (cpp) [Seleccionar] Expandir


int main(void) {

    char s1[100];

    sprintf( s1, "aaaabbbcccddddee");

    funcion(s1);

    return 0;
}


Hola kuni2006,

Bueno, hay algunos detalles para que pueda funcionar correctamente. Al parecer tratas de leer el fichero de texto y almacenar dichos datos en un fichero binario (tal vez para gestionar una sencilla Base o Estructura de Datos).

En cuanto a fscanf(), no se si has leído el tema pero esta función recibe como argumento APUNTADORES a las variables donde debe escribirse la infromación:

Código (cpp) [Seleccionar] Expandir


fscanf(file, "%u %s %s %[^\n]s", &persona.DNI, &persona.fnac, &persona.apellido, &persona.nombres)

y nota que hempos usando el "&" para definir un apuntador al registro persona. Otro detalle, si vas a trabajar con ficheros binarios no se puede escribir con fprintf() (lo cual sería para escritura con formato sobre ficheros de texto) sino con fwrite(), tal como te dijo Alberto. En este caso se requiere como auxiliar las funciones ftell(), fseek() por lo que deberías leer un poco el tema para terminar de comprender (o pregunta por aquí). Esto en caso que usemos "C crudo", pues en C++ hay algunas clases definidas para ello que quizá hagan la tarea menos ruda (aunque yo me llevo muy bien con C crudo).

Otro detalle sería que inmediatamente luego de abrir los ficheros, es bueno cerciorarse que la operación se realizó exitosamente (open() devuelve un puntero no nulo), y en caso contrario salir del programa:

Código (cpp) [Seleccionar] Expandir


if ( ( file = fopen("nombres.txt", "rt") ) == NULL ) {
     printf( "Error al abrir fichero \"nombres.txt\"\n" );
     return;
}

En nuestro caso, diseñé el programa para que, con propósitos demostrativos, luego escribir en el fichero binario también lo podamos leer a fin de inspeccionar el resultado. Por eso le cambié el modo de apertura como lo tenías "wb" a "r+b".

Aquí el código fuente:

Código (cpp) [Seleccionar] Expandir


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

struct persona {
unsigned int DNI;
char fnac[21];
char apellido[51];
char nombres[51];
};
typedef struct persona Persona;

void importar(char* nombreArchivo);

int main( ) {

char *nombreArchivo = "datos.dat";

importar( nombreArchivo );

return 0;
}

void importar(char* nombreArchivo)
{
    Persona persona;
    FILE* file;
    FILE* file1;
int count;
int N_datos;

if ( ( file = fopen("nombres.txt", "rt") ) == NULL ) {
printf( "Error al abrir fichero \"nombres.txt\"\n" );
return;
}
if ( ( file1 = fopen(nombreArchivo, "r+b") ) == NULL ) {
printf( "Error al abrir fichero \"nombres.txt\"\n" );
return;
}

    printf( "\nEscribiendo en fichero binario:\n" );
count = 0;
    while (EOF != fscanf(file, "%u %s %s %[^\n]s", &persona.DNI, &persona.fnac, &persona.apellido, &persona.nombres))
    {
        /* === Escribiendo en el fichero binario === */
        fseek( file1, count * sizeof(Persona), SEEK_SET );
        fwrite( &persona, sizeof(Persona), 1, file1 );
        printf( "Dato %d:\n", count + 1 );
    printf( "  DNI: %u\n", persona.DNI );
    printf( "  DNI: %s\n", persona.fnac );
    printf( "  DNI: %s\n", persona.apellido );
    printf( "  DNI: %s\n", persona.nombres );
    printf( "========================================\n" );
       
        count++; /* actualizar contador */
    }
    fclose( file ); /* cerrar fichero de texto */
   
    /* === Ahora verificando los datos === */
    fseek( file1, 0, SEEK_END );
    N_datos = (int) (ftell( file1 ) / sizeof(Persona));
   
    printf( "\nLeyendo del fichero binario:\n" );
fseek( file1, 0, SEEK_SET ); /* posicionando al principio del fichero */
    for ( count = 0; count < N_datos; count++ ) {
        fread( &persona, sizeof(Persona), 1, file1 );
    printf( "Dato %d:\n", count + 1 );
    printf( "  DNI: %u\n", persona.DNI );
    printf( "  DNI: %s\n", persona.fnac );
    printf( "  DNI: %s\n", persona.apellido );
    printf( "  DNI: %s\n", persona.nombres );
    printf( "========================================\n" );
    }
   
    fclose( file1 ); /* cerrar fichero binario */
}

y suponiendo que en "nombres.txt" tengamos el siguiente contenido

12345 01/02/1980 Perez Jose Maria
85749 05/07/1978 Ramirez Ana Patricia
85711 21/07/1991 Fernandez Juan Manuel


el resultado sería:

Escribiendo en fichero binario:
Dato 1:
  DNI: 12345
  DNI: 01/02/1980
  DNI: Perez
  DNI: Jose Maria
========================================
Dato 2:
  DNI: 85749
  DNI: 05/07/1978
  DNI: Ramirez
  DNI: Ana Patricia
========================================
Dato 3:
  DNI: 85711
  DNI: 21/07/1991
  DNI: Fernandez
  DNI: Juan Manuel
========================================

Leyendo del fichero binario:
Dato 1:
  DNI: 12345
  DNI: 01/02/1980
  DNI: Perez
  DNI: Jose Maria
========================================
Dato 2:
  DNI: 85749
  DNI: 05/07/1978
  DNI: Ramirez
  DNI: Ana Patricia
========================================
Dato 3:
  DNI: 85711
  DNI: 21/07/1991
  DNI: Fernandez
  DNI: Juan Manuel
========================================


Un saludo, y cualquier cosa pregunta por aquí.

Hola avesudra. Bueno, ya que piden resolverlo con recursividad, se me ocurre crear dos funciones, una para eliminar los caracteres repetidos, y otra para invertir la cadena.

Por ejemplo, sea la cadena "aaaabbbcccddddeee", entonces la idea es que cada vez que llamemos la función se elimina una repetición. La función compara el primer carácter de la cadena con el segundo, si son iguales elimina la repetición de este carácter y se vuelve a llamar a sí misma. Tras esto, compara el segundo con el tercero y así sucesivamente. Entonces tras la primera ejecución devuelve "abbbcccddddeee", tras la segunda devuelve "abcccddddeee", y así sucesivamente. La función se ha codificado de manera que imprima los resultados parciales y así se pueda ver cómo va trabajando.

En cuánto a la parte de invertir la cadena, lo que hacemos es intercambiar los caracteres opuestos con respecto al centro, desde afuera hacia adentro. Por ejemplo, dada la cadena "abcde", intercambiamos 1º y 5º, luego 2º y 4º y así sucesivamente. El proceso se detiene cuando la cantidad de reordenamientos supera la mitad de la longitud de la cadena.

Código (cpp) [Seleccionar] Expandir


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>

using namespace std;

void elimina_repetido( char *s );
int invertir_cadena( char *s );

int main(void) {

char s1[100];

sprintf( s1, "aaaabbbcccddddee");

cout << "Eliminando repetidos" << endl
<< "==============================" << endl;
elimina_repetido ( s1 );

cout << "Invirtiendo cadena" << endl
<< "==============================" << endl;
invertir_cadena( s1 );

return 0;
}

/* Devuelve cero cuando se termine de analizar toda la
* cadena, y 1 si falta por analizar.
* La cadena transformada queda almacenada en el mismo
* argumento s.
* La función almacena la posición del último carácter leído
* (usando variables internas estáticas)
*/
void elimina_repetido( char* s )
{
static int pos = 0;
int k; /* indice auxiliar */
int count; /* cuantos caracteres repetidos */
char c1;

c1 = s[pos];
if ( c1 == '\0' ) return; /* terminó de analizar la cadena*/

k = pos + 1;
if ( s[k] == c1 ) {
while ( s[k] == c1 && s[k] != '\0' ) {
k++;
}
count = k - ( pos + 1 ); /* cantidad de caracteres repetidos, después de c1 */

/* Ahora s[k] es el primer carácter posterior a s[pos] distinto
* de c1. Vamos a mover hacia atrás los restantes caracteres,
* un total de <count> posiciones
*/
while ( s[k] != '\0' ) {
s[k - count] = s[k];
k++;
}
s[k - count] = '\0';
}

/* mostrar la cadena */
cout << "   " << s << endl;

/* preparar para el próximo llamado de la función */
pos++;
elimina_repetido( s );
}

/* Reordena la cadena, intercambiando los caracteres en posiciones
* opuestas respecto al centro, desde afuera hacia adentro.
* El proceso termina cuando el número de reordenamientos
* supera la mitad de la longitud de la cadena.
*/
int invertir_cadena( char *s )
{
static int count = 0;
int k, N;
char c;

N = strlen(s);
if ( count == N || N == 0 ) return 0;

/* intercambia las posiciones */
c = s[count];
s[count] = s[N - count - 1];
s[N - count - 1] = c;

cout << "   " << s << endl;

count++;
if  ( count < N / 2 ) invertir_cadena( s );
}

Aquí podemos ver el resultado:

Eliminando repetidos
==============================
   abbbcccddddee
   abcccddddee
   abcddddee
   abcdee
   abcde
Invirtiendo cadena
==============================
   ebcda
   edcba


Un saludo, Yoel.

[Yoel]

Porque cuando le pasas una cadena solamente, como el caso de pax, no le pasas la dirección.

Recuerda que en C las cadenas son arreglos de datos char, y como en todo arreglo en C, el nombre del arreglo es un apuntador al primer elemento del mismo. En otras palabras, el nombre de la cadena es realmente una variable tipo char* (puntero a char) que contiene la dirección de memoria del primer carácter de la misma.

Código (c) [Seleccionar] Expandir


char str[] = "Hola mundo";

printf( "contenido de str: %s\n", str );
printf( "pero str es un puntero cuyo valor es: %p\n", str );
printf( "y apunta al primer elemento el cual es --> '%c'\n", *str );

Salida:

    contenido de str: Hola mundo
    pero str es un puntero cuyo valor es: 0xbfcbe9b5
    y apunta al primer elemento el cual es --> 'H'


Saludos, Yoel.

[Yoel]

NOB2014, puedes aumentar la precisión cambiando en donde dice FLT_EPSILON por la constante DBL_EPSILON

En este caso cambias del épsilon de la máquina para punto flotante al épsilon para precisión doble. Creo que al manejar más de nueve decimales estás considerando una precisión doble, por eso requieres DBL_EPSILON

Saludos, Yoel

[Yoel]

Crea tu propio mini-intérprete, más o menos lo que te recomendó ivance.

Ahora, si el archivo contiene íntegramente código C válido, puedes programar un pequeño script de bath (Windows) o bash (Linux) con órdenes al sistema operativo, para que invoque el compilador de C sobre el fichero que tienes, genere el ejecutable, y lo ejecute.

Saludos, Yoel
Puedes enviarme un M.P.

[Yoel]

Bueno, .... está muy interesante el tema!

El problema parece ser que el redondeo a entero de un número teóricamente entero, no es necesariamente un "entero" desde el punto de vista de la máquina.
Entonces cuando multiplicamos por 10, nunca llegamos a obtener un "entero" desde el punto de vista de la máquina.

Probé a hacer lo siguiente, incluir la biblioteca <math.h>, y mandar a imprimir en cada ciclo la diferencia entre el número actual, y el redondeo del mismo. Lo imprimimos en notación científica para apreciar mejor el orden de magnitud del número

Código (cpp) [Seleccionar] Expandir


while( contador < 20 && fabs(numero - round(numero)) != 0 ) {
       contador++;
numero *= 10;
printf("Numero es ...: %lf, van: %d decimales\n", numero, contador );
printf("  Diferencia: %.2E\n", fabs(numero - round(numero)));
}

(donde la condición del contador menor a 20 es para prevenir ciclo infinito). El resultado será

Ingrese un numero con decimales...: .2155
1.19E-07
Numero es ...: 2.155000, van: 1 decimales
 Diferencia: 1.55E-01
Numero es ...: 21.550000, van: 2 decimales
 Diferencia: 4.50E-01
Numero es ...: 215.500000, van: 3 decimales
 Diferencia: 5.00E-01
Numero es ...: 2155.000000, van: 4 decimales
 Diferencia: 4.55E-13
Numero es ...: 21550.000000, van: 5 decimales
 Diferencia: 3.64E-12
Numero es ...: 215500.000000, van: 6 decimales
 Diferencia: 2.91E-11
Numero es ...: 2155000.000000, van: 7 decimales
 Diferencia: 4.66E-10
Numero es ...: 21550000.000000, van: 8 decimales
 Diferencia: 3.73E-09
Numero es ...: 215500000.000000, van: 9 decimales
 Diferencia: 2.98E-08
Numero es ...: 2155000000.000000, van: 10 decimales
 Diferencia: 4.77E-07


Pero vemos que el algún momento la diferencia entre ambos es un número muy pequeño, teóricamente cero pero que en la práctica no es cero. Debe ser un número menor al épsilon de la máquina, el cual desde el punto de vista teórico debemos tomaralo como un cero. Por lo tanto detenemos el ciclo cuando la diferencia entre el número y su redondeo sea menor a dicho épsilon:

Código (c) [Seleccionar] Expandir


while( contador < 20 && fabs(numero - round(numero)) > FLT_EPSILON ) {
   contador++;
   numero *= 10;
   printf("Numero es ...: %lf, van: %d decimales\n", numero, contador );
   printf("  Diferencia: %.2E\n", fabs(numero - round(numero)));
}
}

Con lo cual se obtiene lo esperado

Ingrese un numero con decimales...: .2155
1.19E-07
Numero es ...: 2.155000, van: 1 decimales
 Diferencia: 1.55E-01
Numero es ...: 21.550000, van: 2 decimales
 Diferencia: 4.50E-01
Numero es ...: 215.500000, van: 3 decimales
 Diferencia: 5.00E-01
Numero es ...: 2155.000000, van: 4 decimales
 Diferencia: 4.55E-13

Total de digitos despues de la coma..:4


De todos modos, creo que lo más seguro en estos casos sigue siendo recibir el número como cadena, y convertirlo internamente a número según un algoritmo implementado directamente por nosotros. Creo que así debe ser la manera como trabajan los intérpretes de comandos como cmd, o bash

Un saludo, Yoel
Puedes enviarme un M.P.



Por cierto, respondiendo este post tuve que editar el mensaje como 10 veces, recortarlo, editarlo por partes, etc ....

El servicio anti-DOS me enviaba una alerta de "Attention Required", como que supuestamente estaba intentando invadir el foro con Scripting Injection. Lo cual es totalmente falso, entonces no se por qué el anti-DOS me rebotaba a cada rato. A lo mejor estaba malinterpretando como nocivas las etiquetas "code", o "tt"

Disculpa Orb,

El mayor y el menor se inicializan al primer elemento del arreglo. Pues no puedes estar adivinando un número "inmensamente grande", o uno "inmensamente pequeño" (siempre habrá un número mayor o menor que otro). ¿Qué tal si el usuario pasa valores negativos?

Código (c) [Seleccionar] Expandir


mayor = datos[0];      /* <-- primer elemento */
menor = datos[0];      /* <-- primer elemento */
suma = 0;
for(i=1 ; i <cantidad_datos ; i++){      /* inicias el ciclo con el segundo elemento, y de ahi en adelante */
   if(datos[i] > mayor)
       mayor = datos[i];
   if(datos[i] < menos)
       menos = datos[i];
   suma = suma + datos[i];
}
promedio = suma / cantidad_datos;

y en este caso hemos reunido el cálculo de mayor, menor y suma en el mismo ciclo, de acuerdo a la sugerencia de fary

Bueno, al margen de que todas las respuestas anteriores están muy bien y el programa corre perfectamente, tengo una pequeña pregunta respecto al propósito del problema.

¿Se trata de todos los divisores (enteros) del número, o sólo de los divisores primos?

Por ejemplo, probando el programa para el número 24 daría 4 divisores, a saber:

2, 2, 2, 3

Estos divisores así calculados serán primos, pero en realidad son sólo dos divisores distintos: 2 y 3. Faltarían las combinaciones:

1, 2, 3, 4, 6, 12, 24

Entonces, divisores distintos son 7 (5 si se excluyen la unidad y el propio 24), y primos son sólo 2. ¿Qué es lo que se quiere?