Mensajes

Debe ser algún algoritmo matemático conocido, pero implementado mediante colas, ¿no?

Bueno, estoy conjeturando ...

Mmmm, interesante  

Bueno desde mi punto de vista, interpretar el fichero de texto formateado como dices es como hacer un mini-análisis léxico. Es decir, tienes que distinguir los "tokens" o palabras clave en que se divide tu archivo. Los tokens serían por ejemplo:

• el carácter '('
• el carácter ')'
• el carácter ','
• la secuencia de caracteres "---"
• los números, o cadenas conformadas por dígitos consecutivos cada uno comprendido entre el 0 y el 9

Cualquier carácter o cadena de caracteres que no encaje en uno de estos patrones sería una palabra no reconocida. Pues bien, tu programa debe leer el fichero de texto de principio a fin, y desglosarlo en los posibles tokens reconocidos.

Voy a suponer que cada posible token tiene una longitud máxima de 50 caracteres, por ello la representamos por medio de un array de 51 caracteres (incluyendo el nulo de terminación). Si esto no es así hay opciones como arreglos dinámicos (función realloc(), o la clase string de C++), pero no se si esto sería muy avanzado para que lo pruebes en este momento)

Supongamos que tienes un fichero llamado datos.txt con el contenido:

(1,2)(3,4)---(10,6)(7,18)


Entonces el siguiente programa lee el fichero y lo desglosa en tokens:

Código (cpp) [Seleccionar] Expandir


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

int extract_token( FILE *, char * );
int isInt( const char * );

int main( ) {

char *file = "datos.txt";
char token[51];
FILE *fPtr;

/* Definiendo la estructura COORD, con capacidad para diez números */
struct COORD {
int x1[10];
int y1[10];
int x2[10];
int y2[10];
};
struct COORD P; /* objeto de tipo struct COORD */
int count = 0; /* lleva el conteo de miembros en COORD */

if ( ( fPtr = fopen(file, "r") ) == NULL )
return -1; /* error al abrir el fichero */

int status;
while ( !feof(fPtr) && !ferror(fPtr) ) {
*token = '\0'; /* inicializa cadena vacía */
extract_token( fPtr, token );
printf( "token: %s\n", token );
}

fclose( fPtr );
return 0;
}

/* Extrae un token del fichero.
* Devuelve 1 si finalizó el archivo o si reconoció un token valido.
* En cualquier otro caso, devuelve cero.
*/
int extract_token( FILE *fPtr, char *token )  {

char c;
size_t len;

while ( ( c = fgetc( fPtr ) ) != EOF ) {

//printf( "c: %c,\ttoken: %s\n", c, token );
/* ignorar espacios */
if ( isspace( c ) ) continue;

/* encontró parentesis, token reconocido y finalizar */
if ( *token == '\0' && c == '(' ) {
strcpy( token, "(" );
return 1;
}
/* encontró parentesis, token reconocido y finalizar */
if ( *token == '\0' && c == ')' ) {
strcpy( token, ")" );
return 1;
}
/* encontró coma, token reconocido y finalizar */
if ( *token == '\0' && c == ',' ) {
strcpy( token, "," );
return 1;
}
/* encontró '-' añadir al token, pero al haber tres '-' seguidos,
* finalizar */
if ( c == '-' ) {
strcat( token, "-" );
if ( !strcmp( token, "---" ) ) return 1;
continue;
}
/* encontró el primer carácter numérico, añadir a la cadena y continuar */
if ( *token == '\0' && isdigit(c) ) {
token[0] = c;
token[1] = '\0';
continue;
}
/* si token es una cadena numérica ... */
if ( isInt( token ) ) {
/* ... y se haya un nuevo carácter, añadir */
if ( isdigit( c ) ) {
len = strlen( token );
token[len] = c;
token[len + 1] = '\0';
}
/* ... sino, terminar */
else {
ungetc( c, fPtr ); /* "devuelve" el caracter al archivo */
return 1;
}
}

/* si es carácter no reconocido, terminar */
if ( !isspace(c) && !isdigit(c) && c != ',' && c != '(' && c != ')' && c != '-' )
return 0;
}

return 0;
}

/* Decide si la cadena corresponde a un numero entero */
int isInt( const char *s ) {

char *cPtr = (char *)s;

if ( *cPtr == '\0' ) return 0; /* devuelve 0 si la cadena es nula */

while ( *cPtr != '\0' ) {
if ( !isdigit( *cPtr ) ) return 0;
cPtr++;
}
return 1;
}

Observa la salida:

token: (
token: 1
token: ,
token: 2
token: )
token: (
token: 3
token: ,
token: 4
token: )
token: ---
token: (
token: 10
token: ,
token: 6
token: )
token: (
token: 7
token: ,
token: 18
token: )
token:
o sea, que ha identificado los tokens: "(", "1", ",", ... etc

Luego de esto ya tienes divivido el fichero, lo que viene es más fácil. Sólo tienes que agarrar los tokens e irlos asignando como valores de x1, y1, x2, y2.

/*************************************************************************************/
(Continuando el tema)

Voy a asumir que vas a leer como máximo 10 cuartetas de valores (por supuesto, puedes indicar una cantidad mayor, o si lo prefieres, programar arrays dinámicos que crezcan conforme la necesidad, pero esto es más avanzado)
En fin, modifica el código de la función main() de la siguiente manera:

Código (cpp) [Seleccionar] Expandir


int main( ) {

char *file = "datos.txt";
char token[51];
FILE *fPtr;

/* Definiendo la estructura COORD, con capacidad para diez números */
#define MAX 10 /* <-- asignas el tamano maximo de cuartetos a leer */
struct COORD {
int x1[MAX];
int y1[MAX];
int x2[MAX];
int y2[MAX];
};
struct COORD P; /* objeto de tipo struct COORD */
int count = 0; /* lleva el conteo de miembros en COORD */
int i, k = 0;

if ( ( fPtr = fopen(file, "r") ) == NULL )
return -1; /* error al abrir el fichero */

while ( !feof(fPtr) && !ferror(fPtr) ) {
*token = '\0'; /* inicializa cadena vacía */
extract_token( fPtr, token );
//printf( "token: %s\n", token );

if ( isInt(token) && count < MAX) {
switch ( k % 4 ) {
case 0:
P.x1[count] = atoi(token);
break;
case 1:
P.y1[count] = atoi(token);
break;
case 2:
P.x2[count] = atoi(token);
break;
case 3:
P.y2[count] = atoi(token);
count++;
break;
}
k++;
}
}
printf( "x1\ty1\tx2\ty2\n----------------------------\n" );
for ( i = 0; i < count; i++ )
printf( "%d\t%d\t%d\t%d\n", P.x1[i], P.y1[i], P.x2[i], P.y2[i] );

fclose( fPtr );
return 0;
}

La variable "count" lleva el conteo de los cuartetos leidos, que debe ser menor a la constante definida MAX. La variable auxiliar k se utiliza para leer consecutivamente x1, luego y1, luego x2, luego y2. En efecto, aumentamos consecutivamente el valor de k y luego calculamos su resto de la división entera entre 4, el cual puede ser 0, 1, 2 ó 3, es como un contador cíclico que se reinicia continuamente.

La salida del anterior programa, es como se muestra:


x1   y1   x2   y2
----------------------------
1    2   3    4
10   6   7   18


Puedes probar modificando el fichero datos.txt y observando los resultados. Por supuesto, si dicho fichero está escrito de manera incorrecta, los valores obtenidos por el programa no serán correctos, y además no hemos programado rutinas para verificación y validación de datos (aunque sería deseable hacerlo).

Estoy a tu disposición si quieres mejorar, ampliar o corregir esta propuesta, o adaptarla mejor a lo que necesitas ....
Yoel.

En primer lugar, debes especifica qué se entiende por una contraseña fuerte. Investiga un poco sobre ésto, o establece tus propios criterios. Por ejemplo, digamos que la contraseña debe:

• tener una longitud de al menos 8 caracteres
• poseer al menos un carácter entre a-z, uno entre A-Z, y un dígito 0-9
• poseer al menos un carácter especial como -_?*%&$

Este sencillo programa pide al usuario una cadena y luega prueba todas estas condiciones, indicando por pantalla si la contraseña es débil o fuerte. La verificación es realizada por la función auxiliar es_fuerte() que devuelve 0 si es débil, 1 si es fuerte.

EI: codigo removido, no hagas tareas ajenas por favor.

Veamos la ejecución del programa:

_____________________________________________
yoel@debian:~/Documentos/C/test$ ./test
intro contrasena: Abc31
contrasena debil

yoel@debian:~/Documentos/C/test$ ./test
intro contrasena: Abcs145Ahy*yh_1
contrasena fuerte
_____________________________________________


Ten en cuenta que los criterios de fortaleza de contraseña pueden ser variados, así que podrían existir algoritmos más sofisticados que el que aquí pongo de ejemplo. De todos modos espero haberte ayudado al menos a iniciar.

Aquí tienes un excelente tutorial de iniciación de lenguaje C.

Y recuerda que nunca es tarde para empezar, mucha constancia y éxito!!!

En efecto eferion, disculpen todos mi lapsus, la relación de orden está bien. Pero lo malo sigue siendo que no indexa el array. Para mí que la idea original del programa era hacer

Código (c) [Seleccionar] Expandir


*(array + i)
o también hubiera servido incrementar el valor del puntero array

Código (c) [Seleccionar] Expandir


for(i=0; i<t; i++, array++){
    if(*mayor < *array) *mayor = *array;
    if(*menor > *array) *menor = *array;
    suma+= *array;
}

Yo particularmente entre ambas, prefiero la forma que mencioné primero pues así damos uso a la variable i para algo más que como contador.

Bueno, en líneas generales te voy a decir que la función estadisticaArray toma como primer ()argumento un array de números reales, como segundo argumento la cantidad de elementos del vector, y los argumentos tercero, cuarto y quinto (pasados por "referencia") son para obtener el mayor, menor y promedio de los elementos del vector, respectivamente.

Para comprender mejor el funcionamiento debes estudiar el tema de punteros o apuntadores en C, así como paso a funciones de argumentos por referencia.

Y aprovecho para declarar que estoy en desacuerdo con la línea del programa:

suma += array

puesto que no está sumando los elementos del arreglo, como cabría esperar. Debería ser:

suma += array[ i ]

¿no?

También, tiene otras cosas extrañas, por ejemplo

if(*mayor<array) *mayor=array;

para empezar no debería ser '<', sino '>', y tampoco se accede a un elemento específico dentro del array. Pienso que debería ser:

if(*mayor > array) *mayor = array[ i ];

o a menos que incrementes el valor de array en cada ejecución del ciclo, cosa que tampoco veo que se haga.

Cuéntanos de dónde sacaste este programa, porque tiene como varios errores ... 

De acuerdo con Eternal, de repente no has inicializando algún elemento del arreglo sucursal, y por ello tiene almacenado el valor cero.

Aquí tienes más o menos una versión que calcula el total a pagar por los articulos elegidos (faltaría solamente la parte calcular el cambio). Me tomé la libertad de cambiar el tipo de la variable opcion de int a char, así respondes a la pregunta de si quieres elegir otro artículo con un 's' ó un 'n' lo cual a mí me parece mucho maś lógico y cómodo que responder con un número.

Código (c) [Seleccionar] Expandir


#include<stdio.h>
#include<conio.h>

int main()
{
clrscr();
int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q,r,s,t,u;
int p;
char opcion; /* <--- te cambie opcion a tipo char */
printf("øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø\n");
printf("                 BIENVENIDOS A LA TIENDITA DE LA ESQUINA\n");
printf("øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø\n\n\n\n\n\n");

double TOTAL = 0;

opcion = 's';
while( opcion == 's' )
{
printf("              Que desea llevar?\n\n");
printf("1. Coca cola 600ml\n");
printf("2. Huevo 1kg\n");
printf("3. Sopa de fideo\n");
printf("4. Sopa maruchan\n");
printf("5. Azucar 1kg\n");
printf("6. Sal 1kg\n");
printf("7. pan blanco\n");
printf("8. Pan integral\n");
printf("9. Salchicas 1kg\n");
printf("10. Yogurth\n");
printf("11. Bubalo\n");
printf("12. Leche lala\n");
printf("13. Leche alpura\n");
printf("14. Jamon 1/4\n");
printf("15. Papas sabritas\n");
printf("16. Agua 1lt\n");
printf("17. Paleta payaso\n");
printf("18. Cigarros\n");
printf("19. Cerveza 1lt\n");
printf("20. Agua mineral 2lt\n");
scanf("%i",&p);
getchar();
if(p==1) {
printf(" son: $10");
TOTAL += 10; /* suma 10 al total */
}
else if(p==2) {
printf(" son: $28");
TOTAL += 28;
}
else if(p==3) {
printf(" son: $5");
TOTAL += 5;
}
else if(p==4) {
printf(" son: $8");
TOTAL += 8;
}
else if(p==5) {
printf(" son: $12");
TOTAL += 12;
}
else if(p==6) {
printf(" son: $8");
TOTAL += 8;
}
else if(p==7) {
printf(" son: $14");
TOTAL += 14;
}
else if(p==8) {
printf(" son: $19");
TOTAL += 19;
}
else if(p==9) {
printf(" son: $36");
TOTAL += 36;
}
else if(p==10) {
printf(" son: $8.50");
TOTAL += 8.50;
}
else if(p==11) {
printf(" son: $.50");
TOTAL += 0.50;
}
else if(p==12) {
printf(" son: $17");
TOTAL += 17;
}
else if(p==13) {
printf(" son: $19");
TOTAL += 19;
}
else if(p==14) {
printf(" son: $21");
TOTAL += 21;
}
else if(p==15) {
printf(" son: $9");
TOTAL += 9;
}
else if(p==16) {
printf(" son: $12");
TOTAL += 12;
}
else if(p==17) {
printf(" son: $9.50");
TOTAL += 9.5;
}
else if(p==18) {
printf(" son: $35");
TOTAL += 18;
}
else if(p==19) {
printf(" son: $30");
TOTAL += 19;
}
else if(p==20) {
printf("\n son: $20");
TOTAL += 20;
}
printf("\n\n\nDesea llevar algo mas s/n?: ");
scanf("%c",&opcion);
getchar();
if ( opcion != 's' ) opcion = 'n';
clrscr();
}
printf("Total:\t%.2lf\n", TOTAL);
getchar();
return 0;
}

Desde luego que se puede mejorar mucho el programa, y si ese es tu objetivo, estamos aquí para ayudarte.

¿Por qué me siento algo aludido con el mensaje anterior?, Jaja, broma.

Bueno, traté de dar una solución con métodos elementales, ya ese era más o menos el estilo del programa originalmente presentado. Pero esperemos que al autor aclare qué tipo de programación está dispuesto a usar .....

Y como decimos los programadores, entre más "bajo" o elemental el nivel que usemos, más trabajo para uno 

Mmmmm, perfecto pero yo opino que si sólo quiere imprimir los valores en Kelvin no es necesario el segundo argumento en la función kelvin(). Bastaría con:

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#define MAX 30

void kelvin(float *grados ){
    int i, float kel;
    for( i = 0; i < MAX; i++ ){
        kel = grados[i] + 273.15;
        printf("%f\n", kel);
    }
}
}