Mensajes

Yo preguntaría, ¿qué es "centinela2"? ¿cuál es su valor?

Aquí hay una propuesta que imprime una tabla con los valores en binario de todos los números desde 1 hasta 256:

Código (c) [Seleccionar] Expandir


#include <stdio.h>

/* conversor de decimal a binario */
int main() {

   int i, numero;
   int base;

   printf("decimal\tbinario\n"
          "------------------------\n");
   for ( i = 1; i <= 256; i++ ) {

      numero = i;
      printf( "%d\t", numero );
      base = 2;
      while(numero >= 1) {

         printf("%d ", numero%base);
         numero/=base;
      }
      printf("\n");
   }
}

Ten en cuenta que el número binario aparece invertido, no se si sea un problema para tí. Si es así, avisa para decirte cómo podrías corregirlo.

Ahora, una propuesta que imprime en binario, octal y hexadecimal.Sólo tienes que cambiar el valor de la variable base, y en el caso de hex, debes imprimir letras cuando corresponda a digitos entre 10 y 15:

Código (c) [Seleccionar] Expandir


#include <stdio.h>

/* conversor de decimal a binario */
int main() {

   int i, numero, resto;
   int base;

   printf("decimal\tbinario\toctal\thex\n"
          "------------------------\n");
   for ( i = 1; i <= 256; i++ ) {

      numero = i;
      printf( "%d\t", numero );
     
      /* binario */
      base = 2;
      while(numero >= 1) {

         printf("%d", numero%base);
         numero/=base;
      }
     
      /* octal */
      printf("   ");
      base = 8;
      numero = i; /* rescatamos el valor de numero */
      while(numero >= 1) {

         printf("%d", numero%base);
         numero/=base;
      }
     
      /* hexadecimal */
      printf("   ");
      base = 16;
      numero = i; /* rescatamos el valor de numero */
      while(numero >= 1) {

         resto = numero % base;
         if ( resto < 10 )
            printf("%d", numero%base);
         else
            printf("%c", 'A' + resto - 10 );
         numero/=base;
      }
     
      printf("\n");
   }
}

Aquí la salida con los primeros 20 números, y como puedes ver la tabla sale un poco desordenada. Se requiere hacer más código si quieres embellecerla, jeje

decimal   binario   octal    hex
------------------------
1   1   1   1
2   01   2   2
3   11   3   3
4   001   4   4
5   101   5   5
6   011   6   6
7   111   7   7
8   0001   01   8
9   1001   11   9
10   0101   21   A
11   1101   31   B
12   0011   41   C
13   1011   51   D
14   0111   61   E
15   1111   71   F
16   00001   02   01
17   10001   12   11
18   01001   22   21
19   11001   32   31
20   00101   42   41

Juanma, trataré de explicarte con paciencia, ya que estás comprendo que estás empezando. Necesitas la función atoi() de la biblioteca <cstdlib> para poder convertir un argumento de tipo cadena en un número entero equivalente. Pues, las operaciones aritméticas sólo tienen sentido entre argumentos que sean numéricos. Por ejemplo en el código original tenías:

Código (cpp) [Seleccionar] Expandir


cociente=cociente/base;
donde 'cociente' y 'base' son tipos string. Pero no puedes dividir dos string (!), en todo caso dividir los números representados por dichos strings, que es lo que hace atoi(): recibe una cadena y devuelve un número equivalente, e.g., el valor devuelto por la sentencia

atoi( "123" )

es el número 123, de tipo int.

A continuación voy a proponer, a modo de complemento con leosansan, una versión que da el resultado en forma de cadena y no como número decimal (lo hacemos de esta manera justo por las razones que tú expones al principio, evitar limitaciones en cuánto al número de dígitos en la salida).

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <array>
#include <cstdlib>
#include <cstring>

using namespace std;

void Conversor( int numero, int base )
{
   int digito, i, N = 0;
   string resultado = "";
   char c;

   /* calcular la mayor potencia de la base que no supera al numero */
   while ( numero >= 1 ) {
      digito = numero % base;
      numero = numero / base;
      /* añadimos el digito, convertido a un char, al resultado */
      c = digito + '0';
      resultado = resultado + c;
      N++;
   }
   /* ahora imprimimos la cadena en reversa */
   for ( i = N - 1; i >= 0; i-- )
      cout << resultado[i];
   cout << endl;
}

int main()
{
   string str_numero, str_base;
   int numero, base;

   cout<<"Escribe el numero que quieres convertir (num/base): ";
   getline(cin, str_numero,'/');
   numero = atoi( str_numero.c_str() ); /* <-- ver aquí, convertimos el string en un entero */
   getline(cin, str_base,'\n');
   base = atoi( str_base.c_str() ); /* <-- ver aquí, convertimos el string en un entero */

   if( base <= 10 )
      Conversor( numero, base );
   else
      cout<<"Error no es una base menor de 10";

   return 0;
}

Ten en cuenta que el algoritmo de conversión que hemos usado (tanto leosansan como tú y yo) convierten el número calculando desde el dígito menos significativo hasta el más significativo, por eso la cadena debe imprimirse "al revés".

Espero te ayude.

---------------------------------------------------------------------------------------
P.D. En mi ignorancia, no conozco una función de biblioteca de C++ que imprima directamente cadenas en reversa, si alguien la sabe que me lo diga xD

Sólo como un aporte, tomando el código de ivance y modificándolo para trabajar con arreglos creo que se ahorra un poco de cálculo ya que no será necesario encadenar un while dentro del for. La desventaja es que debemos crear dinámicamente un arreglo con una longitud igual a la cantidad esperada de cifras del número:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <cmath>

using namespace std;

int main()
{
   unsigned numero=0, base=0, cociente=0, contador=1;
   cout<<"Escribe el numero que quieres convertir: ";
   cin>>numero;
   cout<<"La base a la que quieres pasarlo: ";
   cin>>base;
   cociente=numero;

   /* cantidad de cifras en la base especificada */
   int n = 1;
   while ( cociente >= base ) {
      cociente/=base;
      ++n;
   }
   /* reservar arreglo de n cifras */
   unsigned *cifras = new unsigned[n];
   if ( cifras == NULL ) return -1;

   for (int i = 0; i < n; i++) {
      cifras[n - i - 1] = numero % base;
      numero /= base;
   }
   for (int i = 0; i < n; i++)
      cout << cifras[i];
   cout << endl;

   delete cifras;
   return 0;
}

No es que la cadena posea dos '\0', pues sólo el primero cuenta. Para poner un ejemplo imagínate que tienes:

'h' 'o' 'l' 'a' '\0' '\0' '\0' '\0' '\0'

entonces el primer '\0' encontrado marca el fin de la cadena, que es "hola" y su longitud es 4.

En el ejemplo que dices, si conviertes

'h' 'o' 'l' 'a' '\n' '\0'

en

'h' 'o' 'l' 'a' '\0' '\0'

entonces haces una cadena "más corta", y pasa de tener 5 caracteres a tener 4.

==========================
EDITO

Sólo por comentar, aunque no se si me estoy extendiendo en el tema. El código que propones se puede optimizar eliminando la sobrecarga por llamar dos veces a la función strlen() (aunque un usuario me dijo que los compiladores modernos saben cómo evitar este problema). Una manera es por supuesto depositar el valor de la longitud de la cadena en una variable intermedia:

Código (c) [Seleccionar] Expandir


int len = strlen(cadena);
if(cadena[len-1] == '\n'{
   cadena[len-1] = '\0'
}
O incluso otra forma "autoconstruida", donde no se llama a ninguna función de biblioteca:

Código (c) [Seleccionar] Expandir


for ( i = 0; cadena[i] != '\0'; i++ )
   if ( cadena[i] == '\n' ) cadena[i] = '\0';
o:

Código (c) [Seleccionar] Expandir


char c;
int i = 0;
while ( (c = cadena[i]) != '\n' && c != '\0' )
   i++;
if ( c == '\n' ) cadena[i] = '\0';


Hay otra forma sutil, aunque elegante de hacerlo. Poniendo la cadena vacía como indicador para el fin del programa (en lugar de la cadena "fin").

Me explico, por ejemplo si usamos en C la función gets(), (ojo peligro, cuidado con desbordamiento de buffer) y al pedir la cadena presionas Enter, pues se recibe la cadena vacía, y finalizas el programa:

Código (cpp) [Seleccionar] Expandir


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

int main(void) {

   char buffer[100];

   gets( buffer );
   while ( *buffer != '\0' ) {
      printf("Usted escribio: %s\n", buffer);
      gets( buffer );
   }

   return 0;
}

Otra forma sería usando la secuencia de fin de archivo EOF para terminar el programa, aunque es algo más complicado, mejor para ti el primer método.

¿Alguien ofrece solución equivalente en C++?

La diferencia es de un ciclo de procesador (una operación aritmética elemental) por cada repetición del "for". Eso en el último ejemplo con mil millones de repeticiones en el "for" ha debido producir una diferencia cercana a 1 segundo, que no ha sido así. Y he ahí la incógnita  , jaja.

Pero cuidado que si queremos adentrarnos en este mundo debemos sacar con exactitud las cuentas. Tengo en mente (no se si bien recuerdo) que la frecuencia de reloj de procesador no es exactamente igual a la frecuencia de las instrucciones de máquina, dependiendo del procesador una instrucción de máquina puede demorar 4 ciclos de reloj, en otros puede demorar 12 ciclos. O sea, que el procesador de 1.5Ghz en realidad computa menos de 1500 millones de operaciones por segundo. Claro, están las arquitecturas de doble núcleo que corren en paralelo, etc. En realidad, es algo difícil predecir cuánto demorará la ejecución de un programa en una máquina determinada, sólo podemos decir que son "muchos" millones por segundo 

Pero ojo, floor() devolverá valor del cociente entero pero considerado como un double (2.0, no 2). Para tenerlo entero, si es tu propósito, debes hacer cast explícito:
(int) floor(5 / 2)

Vaya, ustedes sí que tienen ocio de ponerse a medir el tiempo con cada uno de los algoritmos, jaja!

Bueno, yo uso la filosofía del mínimo recurso, me parece lo más lógico declarar n como entero, pues la función que realiza es la de un entero. Tengan en cuenta que comparar dos float es más complicado, a nivel de máquina, que comparar dos enteros. Los float llevan mantisa y exponente, y supongo que nivel de bits primero se comparan los exponentes, y si son iguales se pasa a las mantisas. En cambio en los enteros se comparan todos sus bits de una vez y punto.

A pesar de ello yo hubiera supuesto que el manejo de leosansan, de sumar dos al contador n+=2 sería más eficiente que calcular 2*n+1 (suma y multiplicación incluida). Pero el ensayo demostró que fueron equivalentes, jeje, no se por qué.

Por otra parte, es cierto que resumir el código fuente no necesariamente reduce el tiempo de ejecución. Para lo segundo hay que ponerse a pensar en lo que traduce el compilador, y por ende la manera como se ejecuta el código a nivel de la máquina (los tipos de datos involucrados, etc). Es un punto que precisamente yo venía sosteniendo desde otro post.

Por supuesto, estas son cosas para entretenernos los usuarios más avanzados, no son cosas para considerar aún por la autora del tema quién está apenas comenzando a programar (algún día lo hará), jeje.

Saludos a todos 

Gracias, un saludo.