Программа перевода числа из 10 СС в 2 СС

[fs444]

У Дейтлов есть задача:

Напишите программу, которая печатает таблицу двоичных, восьмеричных и шестнадцатеричных эквивалентов десятичных в диапазоне от 1 до 256.

Они предлагают следующие инструкции по переводу чисел:
10 СС -> 2 СС


10 СС -> 8 СС


10 СС -> 16 СС


Я для пробы написал код, который переводит десятичную 10 в двоичную 1010. Код очень корявый и не выводит то, что мне надо. Подскажите, в ту ли сторону я иду (уже 3 дня разбираюсь, и никак)?

#include<iostream>
using std::cout;
using std::endl;

#include<windows>

int stepen(int chislo, int stepenChisla)
{
   int chisloVStepeni = 1;

   if (stepenChisla == 0)
   {
      chisloVStepeni = 1;
   }
   else
   {
      for (int i = 0; i < stepenChisla; i++)
      {
         chisloVStepeni *= chislo;
      }
   }

   return chisloVStepeni;
}

int main()
{
   int chisloV10SS; // число в 10 СС, которое будет преобразовано в 2 СС
   int maxStepen2 = 0; // число 2 в максимальной степени
   int s = 0; // значение степени (0...)
   int textMaxStepen2; // проверочное maxStepen2
   int i;
   int cifraChislaV2SS; // очередная цифра числа в 2СС (слева направо)
   int chisloV2SS = 0; // число в 2 СС, полученное прибавлением cifraChislaV2SS
   int ostChislaV10SS; // остаток от числа в 10 СС
   int j;
   int umenshStepen; // уменьшающаяся степень
   int vremOstChislaV10SS;  // хранит временный остаток

   for (chisloV10SS = 10; chisloV10SS < 11; chisloV10SS++)
   {
      cout << chisloV10SS << " v 10 CC = ";

      while (maxStepen2 < chisloV10SS)
      {
         maxStepen2 = stepen(2, s);
         textMaxStepen2 = stepen(2, (s+1));

         if (textMaxStepen2 > chisloV10SS)
         {
            break;
         }

         s++;
      }

      ostChislaV10SS = chisloV10SS;
      umenshStepen = s;

      for (i = 0; i < s; i++)
      {
         if (ostChislaV10SS >= stepen(2, umenshStepen))
         {
            cifraChislaV2SS = ostChislaV10SS / stepen(2, umenshStepen);
         }

         if ((cifraChislaV2SS > 0) || (ostChislaV10SS >= stepen(2, umenshStepen)))
         {
            cifraChislaV2SS = 0;
         }

         if (cifraChislaV2SS != 0)
         {
            cifraChislaV2SS *= stepen(10, umenshStepen);
         }

         chisloV2SS += cifraChislaV2SS;

         vremOstChislaV10SS -= stepen(2, umenshStepen);

         if (vremOstChislaV10SS > 0)
         {
            ostChislaV10SS -= stepen(2, umenshStepen);
         }

         umenshStepen--;

      }

      cout << chisloV2SS << " v 2 SS " <<endl;
   }

   system("pause");
   return 0;
}

[Гром]

Вот, скажем, простой и незатейливый способ перевода из десятичной в троичную систему:

#include <iostream>

const int degrees3[] = {729, 243, 81, 27, 9, 3, 1};
int number;
char number3[7];

void ten_to_three()
{
int n = number;
for (i = 0; i < 7; i++)
 {
 number3[i] = n / degrees3[i]; //Находим цифру в разряде
 n %= degrees3[i]; //Оставляем остаток, дальше работаем с ним
 }
}

int main()
{
number = 1621;
ten_to_three();
std::cout << number3;
std::cin.get();
}

Написано курицелапой, но общий смысл функции должен быть понятен.

[fs444]

degrees3[]

Спасибо, но я пока не знаю вещей типа этой. По книжке я пока даже не знаю, как создавать функции. Но я просто не удержался =)

[Гром]

const int degrees3[] = {729, 243, 81, 27, 9, 3, 1};

Это просто константный массив целых чисел. В данном случае можно было написать и так:

const int degrees3[7] = {729, 243, 81, 27, 9, 3, 1};

[fs444]

Слепил я такую вот штуковину:

#include <iostream>
using namespace std;

#include<time>
#include<math>

int pow(int x, int y)
{
        int n=1;
        while(y--)
                n*=x;
        return n;
}

int main()
{
   setlocale(LC_ALL, "Russian");
   int etalonChislaV10SS; // эталон числа в 10 СС
   int chisloV10SS;//Число в десятичной СС
   int chisloV2SS = 0;//Искомое число в двоичной CC
   int razrjadChislaV2SS = 0;//Разряд двоичного числа
   int chisloV8SS = 0;  // искомое число в восьмеричной СС
   int razrjadChislaV8SS = 0; // разряд восьмеричного числа
   int chisloV16SS = 0;  // искомое число в восьмеричной СС
   int razrjadChislaV16SS = 0; // разряд восьмеричного числа

   for (chisloV10SS = 1; chisloV10SS <= 256; chisloV10SS++)
   {
      chisloV2SS = 0;
      chisloV8SS = 0;
      chisloV16SS = 0;

      razrjadChislaV2SS = 0;
      razrjadChislaV8SS = 0;
      razrjadChislaV16SS = 0;

      cout << "10 SS: " << chisloV10SS << endl;
      etalonChislaV10SS = chisloV10SS;
// преобразование в 2 СС
      while(chisloV10SS > 1)
      {
         chisloV2SS += (chisloV10SS%2) * pow(10, razrjadChislaV2SS);//Присваиваем i-тому разряду остаток от деления
         chisloV10SS /= 2;
         razrjadChislaV2SS++;
      }

      chisloV2SS += chisloV10SS * pow(10, razrjadChislaV2SS);

      cout << "2 SS: " << chisloV2SS << endl;
      chisloV10SS = etalonChislaV10SS;

// преобр. в 8 СС

      chisloV10SS = etalonChislaV10SS;

      while(chisloV10SS > 1)
      {
         chisloV8SS += (chisloV10SS%8) * pow(10, razrjadChislaV8SS);//Присваиваем i-тому разряду остаток от деления
         chisloV10SS /= 8;
         razrjadChislaV8SS++;
      }

      chisloV8SS += chisloV10SS * pow(10, razrjadChislaV8SS);

      cout << "8 SS: " << chisloV8SS << endl;

      chisloV10SS = etalonChislaV10SS;
   }

      system("pause");
      return 0;
}

Но когда я добавляю в конец цикла for код

// преобр. в 16 СС
cout << "16 SS: ";
cout << hex << chisloV10SS << endl << endl;
chisloV10SS = etalonChislaV10SS;

Вывод сразу портиться. Почему так получается? Дело в моем незнании манипуляторов потоков?

[Granus]

#include <stdio.h>

int main(){
    int n,k,d,m;
    scanf("%i",&n);
    scanf("%i",&k);
    d=1;
    m=0;
    while(n>0){
        m+=d*(n%k);
        n=n/k;
        d*=10;
    };
    printf("%i (%i)",m,k);
}

n - число, которое переводим
k - в какую систему счисления
m - результат (записан как число, то есть четыре в двоичной будет сто)
d - степень десяти, для записи цифр поочередно в m

работает только для систем 1< k <= 10

/* если что, printf() - вывод, scanf() - ввод */

-----------------------------

переделал для любых систем

#include <stdio.h>

int main(){
    int n,k,d,i;
    char r[10];
    scanf("%i",&n);
    scanf("%i",&k);
    d=1;
    i=0;
    while((d*=k)<n){i++;};
    r[i+1]=0;
    //printf("%i\n",i);
    while(n>0){
        d=n%k;
        if((k>10)&&(d>9)){d+=7;};
        r[i--]=d+48;
        n=n/k;
    };
    printf("%s (%i)",r,k);
}

тут результат записывается в строку, если не знаешь как с ними работать - почитай

[fs444]

Granus, спасибо, но тут мне надо немного разобраться. Я сделал так:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
 
int pow(int x, int y)
{
        int n=1;
        while(y--)
                n*=x;
        return n;
}
 
int main()
{
        setlocale(LC_ALL, "Russian");
        int etalonChislaV10SS; // эталон числа в 10 СС
        int chisloV10SS;//Число в десятичной СС
        int chisloV2SS = 0;//Искомое число в двоичной CC
        int razrjadChislaV2SS = 0;//Разряд двоичного числа
        int chisloV8SS = 0;  // искомое число в восьмеричной СС
        int razrjadChislaV8SS = 0; // разряд восьмеричного числа
        int chisloV16SS = 0;  // искомое число в восьмеричной СС
        int razrjadChislaV16SS = 0; // разряд восьмеричного числа
 
                cout.setf(ios::left, ios::adjustfield);//Выравнивание по левому краю
 
   cout << setw(12) << "Dec" << setw(12) <<"Bin"  << setw(12) << "Oct"  << setw(12) << "Hex" << endl;
 
   for (chisloV10SS = 1; chisloV10SS <= 256; chisloV10SS++)
   {
        cout << setw(12) << chisloV10SS;
 
        chisloV2SS = 0;
        razrjadChislaV2SS = 0;
        chisloV8SS = 0;
        razrjadChislaV8SS = 0;
        chisloV16SS = 0;
        razrjadChislaV16SS = 0;
 
        etalonChislaV10SS = chisloV10SS;
// преобразование в 2 СС
        while(chisloV10SS > 1)
        {
           chisloV2SS += (chisloV10SS%2) * pow(10, razrjadChislaV2SS);//Присваиваем i-тому разряду остаток от деления
           chisloV10SS /= 2;
           razrjadChislaV2SS++;
        }
 
        chisloV2SS += chisloV10SS * pow(10, razrjadChislaV2SS);
 
        cout << setw(12) << chisloV2SS;
// преобр. в 8 СС
 
        chisloV10SS = etalonChislaV10SS;
        while(chisloV10SS > 1)
        {
           chisloV8SS += (chisloV10SS%8) * pow(10, razrjadChislaV8SS);//Присваиваем i-тому разряду остаток от деления
           chisloV10SS /= 8;
           razrjadChislaV8SS++;
        }
 
        chisloV8SS += chisloV10SS * pow(10, razrjadChislaV8SS);
 
        cout << '0' << setw(12) << chisloV8SS;
// преобр. в 16 СС
        chisloV10SS = etalonChislaV10SS;
        cout << "0x" << hex << setw(12) << chisloV10SS << dec << endl;
        chisloV10SS = etalonChislaV10SS;
   }
        system("pause");
        return 0;
}

[Granus]

ну, вы делаете тем же способом что и я)
только

while(chisloV10SS > 1)
        {
           chisloV2SS += (chisloV10SS%2) * pow(10, razrjadChislaV2SS);
           chisloV10SS /= 2;
           razrjadChislaV2SS++;
        }
        chisloV2SS += chisloV10SS * pow(10, razrjadChislaV2SS);

1) можно заменить на

while(chisloV10SS > 0)
        {
           chisloV2SS += (chisloV10SS%2) * pow(10, razrjadChislaV2SS);
           chisloV10SS /= 2;
           razrjadChislaV2SS++;
        }

2) каждый раз возводить 10 в нужную степень очень долго. я предлагаю такой вариант:

razrjadChislaV2SS=1;
while(chisloV10SS > 0)
        {
           chisloV2SS += (chisloV10SS%2) * razrjadChislaV2SS;
           chisloV10SS /= 2;
           razrjadChislaV2SS*=10;
        }

и аналогично для других степеней

[pu4koff]

Зачем вообще переводить в двоичную систему счисления, если и так всё на компе хранится в ней? Просто нужно вывести число в двоичной системе, а не в 10-ричной, как по умолчанию происходит.
Как-то так можно в обратном порядке биты получить:

while (i)
{
	std::cout << (i & 1);
	i >>= 1;
}

Если в (i & 1) единицу поменять на соответствующую маску, то можно и в прямом порядке получить

[fs444]

Granus, согласен

Зачем вообще переводить в двоичную систему счисления, если и так всё на компе хранится в ней?

Упражнение такое для закрепление материала в книге Дейтлов.

Как-то так можно в обратном порядке биты получить:

while (i)
{
	std::cout << (i & 1);
	i >>= 1;
}

Я пока не в теме вещей вроде &

А вот вопрос про строки. У меня код

#include<iostream>
using std::cout;
using std::cin;
using std::endl;

#include<windows>

AnsiString Int_To_StrHex(int A)
  {
  AnsiString S, S1, Str = "0123456789ABCDEF";

  if (A == 0) S = "0";

  while(A > 0)
    {
    S = S + Str[(A % 16) + 1];
    A = A / 16;
    }

  if ((S.Length() % 5) == 1) S = S + "000";
  if ((S.Length() % 5) == 2) S = S + "00";
  if ((S.Length() % 5) == 3) S = S + "0";

  for (int I = 1; I < (S.Length() + 1); I++)
    {
    S1 = S1 + S[S.Length() + 1 - I];
    }

  return S1;
  }

int main()
{
    Int_To_StrHex(10);

    system("pause");
    return 0;
}

выдает "Declaration syntax error". Что неправильно?