Mensajes

[Aquí]

Sí!

Que bien......

Aquí tienes un listado de varias funciones de cadena. Todo es ir mirando una a una.

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡¡ Saluditos! ..... !!!!]

Doctores en C++ tiene esre foro y yo no soy uno de ellos.

Pero probando, probando obtengo la salida que deseas:

Escribe la frase: leosansan, san,sam, leon, noel, 123,321
leosansan,
san,sam,
leon,
noel,
123,321

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstring>
#include <sstream>

using namespace std;

int main(){
  string frase, aux;
  cout<<"Escribe la frase: ";
  getline(cin, frase);
  istringstream iss(frase);
  if(getline(iss, aux, ',')){
    istringstream iss(frase);
    while(getline(iss, aux, ' ')){
      istringstream iss(aux);
      cout<<aux<<endl;
    }
  }
  return 0;
}

Supongo que se puede hacer de manera más eficiente, pero es hasta donde yo doy usando sólo istringstream.

¡¡¡¡ Saluditos! ..... !!!!

[strcpy]

Ahondando en lo que comenta E.I, al hacer:

 

Código (cpp) [Seleccionar] Expandir

x = "101010101";

al tratarse de una cadena de caracteres constantes no podrás modificarla a posteriori, de ahi que al intentarlo con strcpy el programa cruja. Para ello, para modificar el valor del puntero, tendría que "apuntar" a una dirección que no sea una constante, como un array.

El resultado que quieres obtener te lo puede proporcionar curiosamente lo mismo que te daba problema:strcpy.

Como ejemplo:

x=strcpy1=[101010101]
x=strcpy2=[hola]
Process returned 0 (0x0)

Código (cpp) [Seleccionar] Expandir


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

int main(){
  char *x;
  x = (char*)calloc(10,1);

  strcpy(x,"101010101");
  printf("\nx=strcpy1=[%s]",x);

  strcpy(x,"hola");
  printf("\nx=strcpy2=[%s]",x);

  free(x);
  return 0;
}

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡¡ Saluditos! ..... !!!!]

Estas comparando "palabra", que si tiene o puede tener mayúsculas con aux a las que has eliminado las mayúsculas:

Código (cpp) [Seleccionar] Expandir

for(int i=0; i<longCad(aux); i++) { // Bucle para convertir cualquier mayuscula a minuscula.
    if(aux[i]<97){
      palabra[i]+= 32;
      aux[i] += 32;
     }
   }

¡¡¡¡ Saluditos! ..... !!!!

[eferion]

A bote pronto a mi me sale esto:

los numeros introducidos son:
dato 1 es 3
dato 2 es 8
dato 3 es 6
dato 4 es 5
dato 5 es 4
dato 6 es 7
dato 7 es 9
dato 8 es 12
dato 9 es 11
dato 10 es 10
dato 11 es 13
dato 12 es 2
dato 13 es 21
dato 14 es 14
dato 15 es 15

el vector par-impar ordenado es:
dato 1 es 21
dato 2 es 15
dato 3 es 13
dato 4 es 11
dato 5 es 9
dato 6 es 7
dato 7 es 5
dato 8 es 3
dato 9 es 2
dato 10 es 4
dato 11 es 6
dato 12 es 8
dato 13 es 10
dato 14 es 12
dato 15 es 14

Código (cpp) [Seleccionar] Expandir

void ordenar_pares_impares(int vector[], int elementos)
{
  int i, j, t,n;
    for (i=1; i<elementos; i++)
    {
        j=i;
        t=vector[j];
        if(t%2==0)
        {
        while (j>0 && vector[j-1]>t && vector[j-1]%2==0)
        {
            vector[j]=vector[j-1];
            j--;
        }
        }
        else
        {
        while (j>0 && (vector[j-1]<t || vector[j-1]%2==0))
        {
            vector[j]=vector[j-1];
            j--;
        }
        }
        vector[j]=t;
    }

  printf("\n\nel vector par-impar ordenado es: ");
  //imprimimos el vector con su respectivo ordenamiento
  for( n=0;n<elementos;n++)
{
printf("\n dato %d es %d", (n+1), vector[n]);
}

char letra;
printf("\ndesea buscar un elemento en el vector?\n presione s para SI y n para NO:  ");
letra=getch();

if (letra =='s')
{
busqueda_secuencial(vector,elementos);
}
}

Y para mi:

Código (cpp) [Seleccionar] Expandir


 int elementos;
 scanf("%d",&elementos);

 int v [(elementos-1)];

está bien ya que primero obtienes la dimensión y luego declaras el array. Otra cosa es que lo hubieras hecho al revés aunque como te comentó eferion convendría poner una validación a dicha entrada.

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡¡ Saluditos! ..... !!!!]

Por lo que tengo entendido al usar esas secuencias de escape la siguiente letra a dicha secuencia no puede ser un dígito numérico ni letra de la a a la f o el compilador la tomará como parte del hexadecimal y dará el warning que comentas.

Es decir si quieres escribir "tenía"=ten\xA1a como lo que sigue a xA1 es una a se tomará como parte del hexadecimal imprimiendo por ello un caracter no esperado y lanzando el consiguiente warning.

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡¡ Saluditos! ..... !!!!]

.............................................
Aunque en verdad, esa condición debe de ser la única que cumplan los números primos y es lo que no se hacer, como aislar los números que solo cumplen esa condición y ninguna mas.

Has puesto el dedo en la llaga: si es primo los divisores, sin contar el 1 y al propio número son cero, si no no es primo.

Como ves todo se reduce a ver si tiene algún divisor, cosa que previamente no sabes y habrá que ir comprobando para cada número.

Te paso un código comentado con esa idea.

Ya lo de ir de dos en dos recorriendo sólo los impares o llegar tan sólo hasta sqrt(i) o mejor, porque no usamos la librería math para sqrt, hasta j*j<=i, son detalles de mejorar la eficiencia pero creo que no era esa la cuestión.

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>

int main(){
 int i,j,num=15,aux=0;
 printf("2  ");/** supuesto num>1 **/
 for (i=3; i<=num;i+=2) {
   aux=0;
   for (j=3;j*j<=i;j+=2){
/** Aqui si tiene un divisor no es primo y pongo aux a 1
para saberlo y rompo el bucle ya que no tiene mayor importancia
que tenga mas divisores **/
     if (i%j==0){
       aux=1;
       break;
     }
   }
/** Aqui si aux=0 es que no tiene divisores y por tanto es primo **/
   if (aux==0)
     printf ("%d  ",i);
 }
 return 0;
}

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡¡ Saluditos! ..... !!!!]

gracias. Aunq la librería cstdlib no la he dado y eso de atoi nunca lo he usado.
Ademas el ejercicio dice q acepte de entrada una cadena y devuelva un número entero. Y la cadena de entrada es un string en formato "número/base".
Es un ejemplo del tema de array, ¿sabrías alguna forma de hacerlo usando la librería array?

Creo que confundes el usar arrays con usar la librería array.

Una posible solución sin usar atoi ni stdlib y sí arrays donde después de la entrada en el formato 123/2 tipo string paso los valores a enteros para luego poder operar con ellos:

Código (cpp) [Seleccionar] Expandir

/**
Entrada ejemplo en el formato string:123/2
**/
#include <iostream>

using namespace std;

void Conversor(int num,int bas){
  int resto=0;
  for (int factor=1;num>=1;factor*=10,num=num/bas)
    resto+=(num%bas)*factor;
  cout<<resto;
}

int main(){
  int i,lon,num=0,bas=0,factor;
  string  numero,base;
  cout<<"Escribe el numero que quieres convertir (num/base): ";
  getline(cin,numero,'/');
  getline(cin,base,'\n');
  for (lon=0;numero[lon];lon++);
  for (i=lon-1,factor=1;i>=0;i--,factor*=10)
    num+=(numero[i]-'0')*factor;
  for (lon=0;base[lon];lon++);
  for (i=lon-1,factor=1;i>=0;i--,factor*=10)
    bas+=(base[i]-'0')*factor;
  if(bas<=10)
    Conversor(num,bas);
  else
    cout<<"Error no es una base menor de 10";
  return 0;
}

¡¡¡¡ Saluditos! ..... !!!!

[Blaster]

Inesperada la salida que obtengo con el código de Blaster:

Dame 3 valores de grados a convertir en grados celsius:
Numero 1 >>>> 100
Numero 2 >>>> 200
Numero 3 >>>> 300
Grados Kelvin:

373.149994
473.149994
573.150024

No así con el de yoel_alejandro:

Dame 3 valores de grados a convertir en grados celsius:
Numero 1 >>>> 100
Numero 2 >>>> 200
Numero 3 >>>> 300
Grados Kelvin:

373.150000
473.150000
573.150000

Análogo al de usar %g en lugar de %f:

Código (cpp) [Seleccionar] Expandir

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

Dame 3 valores de grados a convertir en grados celsius:
Numero 1 >>>> 100
Numero 2 >>>> 200
Numero 3 >>>> 300
Grados Kelvin:

373.15
473.15
573.15

¿Alguna sugerencia a este comportamiento del %f?.

¡¡¡¡ Saluditos! ..... !!!!

[¡¡ ¡Es broma !!!, ¿ehhhh?.]

¡Que manía con obtener las cadenas a la inversa y luego tener que darles la vuelta!

¡¡ ¡Es broma !!!, ¿ehhhh?.

Pero esa es en esencia la diferencia sustancial con códigos anteriores: calculo previamente la longitud de la cadena contenedora del número en la base en cuestión y luego la relleno al revés. Además de otras sutiles diferencias:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>

#define DIGITOS   "0123456789ABCDEF"/*"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"*/

int main(){
  int i,n_digitos,numero,base,cociente,num;
  char cadena[11];
  for (numero=1;numero<=256;numero++){
    printf("\n%3d",numero);
    for(base=2;base<=14/*37*/;base+=6/*base++*/){
      if (base==14)
        base=16;
      cociente=num=numero;
      for (n_digitos=0;num;n_digitos++,num/=base);
      for (i=n_digitos-1;cociente;i--,cociente/=base)
        cadena[i]=DIGITOS[cociente % base];
      cadena[n_digitos]='\0';
      printf("  en BASE (%d)=%-9s ",base,cadena);
    }
  }
  return 0;
}

Y creo que se ve que el código "estaba" para otra cosa. Concreta mente para obtener un número decimal en las bases de 2 a 36, cosa que se consigue activando lo que está desactivado, pero ese ya sería otro problema.

Y aquí la salida para los veinte últimos:

236  en BASE (2)=11101100    en BASE (8)=354         en BASE (16)=EC
237  en BASE (2)=11101101    en BASE (8)=355         en BASE (16)=ED
238  en BASE (2)=11101110    en BASE (8)=356         en BASE (16)=EE
239  en BASE (2)=11101111    en BASE (8)=357         en BASE (16)=EF
240  en BASE (2)=11110000    en BASE (8)=360         en BASE (16)=F0
241  en BASE (2)=11110001    en BASE (8)=361         en BASE (16)=F1
242  en BASE (2)=11110010    en BASE (8)=362         en BASE (16)=F2
243  en BASE (2)=11110011    en BASE (8)=363         en BASE (16)=F3
244  en BASE (2)=11110100    en BASE (8)=364         en BASE (16)=F4
245  en BASE (2)=11110101    en BASE (8)=365         en BASE (16)=F5
246  en BASE (2)=11110110    en BASE (8)=366         en BASE (16)=F6
247  en BASE (2)=11110111    en BASE (8)=367         en BASE (16)=F7
248  en BASE (2)=11111000    en BASE (8)=370         en BASE (16)=F8
249  en BASE (2)=11111001    en BASE (8)=371         en BASE (16)=F9
250  en BASE (2)=11111010    en BASE (8)=372         en BASE (16)=FA
251  en BASE (2)=11111011    en BASE (8)=373         en BASE (16)=FB
252  en BASE (2)=11111100    en BASE (8)=374         en BASE (16)=FC
253  en BASE (2)=11111101    en BASE (8)=375         en BASE (16)=FD
254  en BASE (2)=11111110    en BASE (8)=376         en BASE (16)=FE
255  en BASE (2)=11111111    en BASE (8)=377         en BASE (16)=FF
256  en BASE (2)=100000000   en BASE (8)=400         en BASE (16)=100

Y un fuerte saludo para yoel_alejandro del que hace semanas que no sabíamos nada. Se te ha echado de menos campeón.

¡¡¡¡ Saluditos! ..... !!!!