Mensajes

Una pregunta muy muy muy tonta...

Supongo que no tienes el fichero abierto, por ejemplo en Notepad o similar para hacer alguna comprobación anterior.

A veces cuestiones tremendamente "tontas" pasan

Er... moléculas orgánicas las hay en muchos sitios, y os recuerdo que se entiende por "orgánico" a prácticamente cualquier forma de la química del carbono.

Mas que nada para que nadie lance las campanas al vuelo y se crea que se han encontrado marcianitos en el cometa. Producir moleculas orgánicas a partir de elementos básicos inorgánicos es tremendamente sencillo y se da con mucha frecuencia en la naturaleza, incluso en el espacio es posible detectar moléculas de alcoholes, azucares y otros compuestos.

Lo raro sería que no hubiera encontrado nada

Prueba

Código [Seleccionar] Expandir

ofstream ofile ("data2.txt", ofstream::out);

A ver que pasa

ENTONCES COMO PUEDO HACER PARA QUE ME LEA TODA LA ORACION CREO QUE ES CON gets PERO NO SE COMO SE UTILIZA

Creas una variable de típo string, por ejemplo "entrada"

Luego sustituyes "cin" por "Getline (cin, entrada);

Al final obtienes toda la cadena introducida, incluyendo espacios hasta el fin de línea.

lo he reformado un poco (bastante)... pero a ver si entiendes como lo hago

Código [Seleccionar] Expandir


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

using namespace std;

int main(){
          string entrada;
          bool band= true;
          cout<<"ingresa la frase: ";
          getline (cin, entrada);
          char frase[entrada.size()+1];
          strcpy(frase, entrada.c_str());
          int tam = entrada.size();
          for (int i=0; i<tam; i++){
               if (frase[i] != frase[tam-i-1]) band = false;
               }

   if (band) cout << "si es palindromo";
   if (!band) cout << "no es palindromo";

   }


Quizás lo mas "exótico" es como se convierte el string de entrada en un array de caracteres (además del tamaño justo). Claro, si no te convence se puede hacer fácilmente una función para eso.

Algo interesante sería que pensaras que estrictamente hablando, un programa que comprueba frases palindromas debería de funcionar convirtiendo antes todo el texto a mayúsculas o minúsculas, porque la comprobación entre "A" y "a" te daría falso, y lo mismo para acentos (aunque no podrás usarlos en windows a menos que uses clocale)

Edito: Ahora que lo pienso un poco (que bruto que soy a veces) en realidad no necesitas hacer una comprobación de todo el arreglo, solo desde el principio hasta la mitad, ya que al comparar la primera con la última, la segunda con la penúltima, etc... a partir de la mitad del arreglo, estás comprobando de nuevo lo mismo.

Como IDE te recomiendo Codeblocks, que es bastante cómodo de usar

http://www.codeblocks.org/

Eso si, te recomiendo que te bajes el compilador "aparte", concretamente el mingw-w64

http://sourceforge.net/projects/mingw-w64/

En Internet hay vídeos de como instalarlo y configurarlo.

Te lo comento mas que nada, porque el compilador por defecto a mi me ha dado tremendos dolores de cabeza, ya que no soporta muy bien en estándar C++11 y hasta que me dí cuenta (por novato) de donde estaba el problema, pasé unos días muy entretenidos dándome cabezazos.

Hay otras opciones claro

Así a bote pronto, creo que estás pensando que "Pow" eleva al cubo.

Si, pero no... eleva a cualquier exponente.

El modo correcto de usarlo es (por ejemplo)

Código [Seleccionar] Expandir


float base, exponente, resultado // tres valores. la base, o numero que quieres elevar al cubo, el exponente, en este caso 3 (al cubo) y obviamente el resultado.
base = 10.33 // (por ejemplo)
exponente = 3 // o cualquier otro numero
resultado = pow(base, exponente);


Obviamente puedes acortar mucho la cosa. No hace falta usar la variable exponente (ni que sea doble, lo he hecho por sencillez). Podrías tranquilamente usar:

Código [Seleccionar] Expandir


resultado = pow(base, 3);


A ver si así consigues que funcione.

[si no es palindromo]

Bueno, hay formas de invertir una cadena entera, pero asumo que esto es un ejercicio, no otra cosa.

Tu bucle está mal enfocado, en lugar de intentar averiguar si una palabra es un palindromo, deberías intentar demostrar que no lo es.

Me explico... la situación es sencilla. Tienes el string de caracteres, tienes la longitud de la palabra, y puedes comparar los caracteres... estupendo.

Pues entonces, haz que el bucle avise de que no existe una coincidencia. Es decir: si no es palindromo.

Compara los caracteres por parejas, y abandona el bucle en el mismo momento en que no haya una coincidencia.

Declara una variable bool que sea "true" indicando que es palíndromo, y que solo pase a false si dentro del bucle no se cumple alguna de las comparaciones, luego una vez que has salido del bucle puedes mostrar el resultado.

La diferencia puede parecer trivial, pero implica una forma de abordar el problema que debes de tener en cuenta, y es que debes de intentar siempre que el programa haga el mínimo esfuerzo posible.

Claro, podemos comprobar todas las letras, y si son iguales decir que es palindromo, pero lo contrario tiene la ventaja de que si en la primera pasada no hay coincidencia, podemos salir inmediatamente del bucle sin necesidad de comprobar el resto.

Esto en una palabra de 5, 10 o 12 caracteres es irrelevante, pero si abordamos un caso similar, donde haya cientos, o miles de casos la cuestión ya no es tan simple, porque el programa debe de intentar siempre "atajar" los problemas lo mas rápido posible y con el menor uso posible de recursos. Bueno, no siempre se consigue, pero al menos intentarlo.

Es un poco como la "política" a la hora de comprobar una condición que contiene comparadores lógicos como && or !! de poner primero el mas simple, ya que el programa entonces si el primer caso no se cumple, no comprueba nada mas ahorrando tiempo y recursos.

A todo esto, si no me equivoco mucho (y si lo estoy que me corrijan) no es necesario declarar el #include<string.h> porque la biblioteca string forma parte de iostream.

Igualmente, puedes averiguar la longitud de un string sin necesidad de usar otras bibliotecas usando el método string::size();

Así en este caso, podrías usar

Código [Seleccionar] Expandir

tam = frase.size();

En lugar de

Código [Seleccionar] Expandir

tam = strlen(frase);

Ni que decir, que como te han señalado es posible invertir directamente la cadena usando algo como:

Código [Seleccionar] Expandir

tekst = string ( tekst.rbegin(), tekst.rend() );

Pero claro, este no es el propósito del ejercicio

Si pudieras pegar un trozo del archivo a procesar sería probablemente mas fácil entender lo que quieres hacer exactamente, y se podrían hacer algunas pruebas.

Se puede ademas reducir un poco el código, pero si así te aclaras está bien

El tema de control de errores por parte del usuario es... una batalla perdida, los usuarios tontos son muy inteligentes 

Pero, puedes hacer obviamente controles... por ejemplo (una opción, hay otras) la entrada por CIN haz que sea un string, ya que un string virtualmente se lo come "todo". Luego compruebas que lo introducido es efectivamente un número, y si es así lo "das por bueno".

Intenta por ejemplo en una función convertir ese string en un objeto istringstream, y sacas "a piñón" un entero. Si la lectura tiene éxito, el contenido es un entero, si no tiene éxito obras en consecuencia.

Por ejemplo:

Código [Seleccionar] Expandir


#include <iostream>
#include <sstream>

using namespace std;

int numero(string entrada, bool& correcto){
    int valor;
    istringstream S(entrada);
    if (!(S >> valor)) correcto = false;
    return valor;
}


int main(){
    bool lectura = true;
    string In;
    int X;
    int Y;
    int N;
    cout << "Enter the first term: \n";
    cin >> In;
    X = numero(In, lectura);
    cout << "Enter the second term: \n";
    cin >> In;
    Y = numero(In, lectura);
    cout << "Enter the number of terms: \n";
    cin >> In;
    N = numero(In, lectura);
    // -------------------------
    cout << "Valor de X = " << X << endl;
    cout << "Valor de Y = " << Y << endl;
    cout << "Valor de N = " << N << endl;
    if (!lectura) cout << "Uno de los valores es erroneo" << endl;
}


Eso si, aquí tenemos un "medio problema", y es que tal y como te lo planteo, solo te dice que uno de los valores es erróneo, no cual, y además si introduces un valor como por ejemplo "125df" tomará solo 125 e ignorará el resto.

Espero que te sirva de algo, aunque seguro que a alguien se le ocurre como meter un dato erróneo.

[dentro de la función]

El problema lo tengo también en que no tengo claro como declarar que el vector tiene "x" filas y "x columnas", y para empeorar la referencia oficial no me aclara mucho al respecto.

Si, se que el vector se crea vacio, por eso uso precisamente push_back, que supuestamente aumenta el tamaño del vector para acomodar nuevos datos de forma automática

Por ejemplo:

Código [Seleccionar] Expandir


vector<string> Concatena (const vector<string>& A, const vector<string>& B){
   vector<string> Salida;
   Salida = A;
   int tam = B.size();
   for (int i=0; i<tam; i++){
       Salida.push_back(B[i]);
   }
   return Salida;
}


El vector Salida lo creo vacío, lo lleno con el contenido del vector A, y luego añado una por una las posiciones del vector B, sin cambiar su tamaño. Teóricamente push_back incluye nuevos datos al final del vector y cambia su tamaño.

Y si, en vectores de una dimensión funciona sin problemas, pero nada, algo se me escapa, probablemente en la notación al pasar a 2 dimensiones.

Entiendo, que :

Código [Seleccionar] Expandir

vector <vector<int> > Entrada(4);

Debería teóricamente de crearme un vector de vectores enteros, inicializando un valor inicial de 4 filas. ¿Es así?... porque incluso intentando entonces introducir datos de las columnas, por ejemplo así

Código [Seleccionar] Expandir


   vector <vector<double> > Datos(4);
   Datos[0].push_back(0.1);
   Datos[0].push_back(0.2);
   Datos[0].push_back(0.3);
   Datos[0].push_back(0.4);
   Datos[1].push_back(2.2);
   Datos[1].push_back(1.1);
   Datos[1].push_back(0.0);
   Datos[3].push_back(-15.0);
   Datos[3].push_back(-14.0);
   Datos[3].push_back(-13.0);


También "casca", a no ser claro está, que el 4 sea el valor de las columnas (lo cual explicaría porque casca), pero entonces me quedo sin tener claro como declaro las filas.

Esta es la parte que mas me está costando del tema de vectores, el resto lo llevo bastante "sueltito" y progreso sin problemas, pero esa cuestión de vectores en 2D me lleva por la calle de la amargura

PDD. Una solución que me han sugerido... habilitar el standar C++11 en el compilador

Código [Seleccionar] Expandir


int main(){
vector< vector<int> > v ( 3, vector<int> (3) );
v = {
{1,2,3},
{4,5,6},
{7,8,9}
};

cout << v[0].size() << endl;
cout << v[1].size() << endl;
cout << v[2].size() << endl;
}


Y... de momento no explota y parece que funciona.

Actualización

Parece que si... pero no.

Aparentemente mi problema real, es que a la hora de pasar a una función por referencia el vector, no lo hago correctamente, y en el mismo momento en que intente, no ya modificar algo del mismo, sino incluso leer sus propiedades el programa "casca"

Os pongo al corriente...

Código [Seleccionar] Expandir


#include <iostream>
#include <vector>
using namespace std;


vector<int> aplana(const vector< vector<int> >& v , int filas){
      vector<int> Salida;
      for (int i=0; i<filas; i++){
       cout << v[i].size();
      }
}


int main(){
   vector< vector<int> > v ( 3, vector<int> (4) );
   v = {
   {1,2,3},
   {4,5},
   {6,7,8,9}
   };
   int filas = v.size();
   cout << filas << endl;
   //aplana(v, 3);
   for (int i=0; i<filas; i++){
       cout << v[i].size() << endl;
      }
}


Como podéis ver, el constructor es "diferente", pero funciona, al menos en C++11 funciona.

Mi duda es si estoy pasando el vector a la función correctamente

Código [Seleccionar] Expandir

const vector< vector<int> >& v

Algo estoy obviamente haciendo mal ahi, porque si paso el vector, e intento leer su longitud dentro de la función el programa se cuelga, ya sea intentando leer el número de filas, como intentando leer el número de columnas de cada una.

No obstante, si intento exactamente lo mismo dentro del "main", entonces el problema no aparece y funciona correctamente.

Tengo la impresión (no confirmada) de que cuando paso un vector por referencia a una función, en realidad estoy pasando un puntero (o algo así) y dentro de una función no se comporta como espero (bueno, eso es obvio) y aunque el programa compile, se cuelga.

Supongo que al no haber pasado bien por referencia (o eso creo) el vector, al intentar leerlo es posible que se intenten leer zonas de memoria incorrectas.

Claro, podría hacer las cosas dentro del main, donde ese problema no lo tengo, pero la intención es que la función sea capaz de "desmontar" un vector de vectores y devolverme un solo vector con los contenidos consecutivos, no un caso aislado

Nueva actualización.

Estimados compañeros de foro... quiero matar a alguien, o suicidar a alguien... o pegarle fuego a algo, pero me contendré

Tras días de darle vueltas, tras dolores de cabeza y desesperación, resulta que aparentemente, mi problema es (era) el compilador GNU.

Con el mismo código, me he instalado el compilador MinGw64, y... funciona.

No me da errores, no explota el programa y el resultado es el esperado.

A falta de que alguien con mas conocimientos que yo (lo cual no es dificil) me diga que "es posible, pero estabas haciendo tal o tal cosa mal", la verdad es que me he quedado bastante "a cuadros" al ver que aparentemente la fuente de mis problemas era esa.

De momento voy a mantener este compilador como "por defecto" y continuaré haciendo experimentos, pero ahora parece que las cosas empiezan a tener sentido.