)производится одноканальная (моно) звукозапись с частотой дискретизации 256 гц. при записи использовались 4096 уровней дискретизации. запись длится 10 минут, её результаты записываются в файл, причём каждый сигнал кодируется минимально возможным и одинаковым количеством битов. какое из ниже чисел наиболее близко к размеру полученного файла, выраженному в килобайтах?

Так как ча­сто­та дис­кре­ти­за­ции 256 гц, то за одну се­кун­ду за­по­ми­на­ет­ся 256 зна­че­ний сиг­на­ла.  ис­поль­зу­ет­ся 4096 = 212  уров­ней дис­кре­ти­за­ции, зна­чит, глу­би­на ко­ди­ро­ва­ния 12 бит.  время за­пи­си 10 мин = 600 сек, по­это­му для хра­не­ния ин­фор­ма­ции о такой за­пи­си по­тре­бу­ет­ся  256 * 12 * 600 = 28  * 4 * 3 * 15 * 40 бит = 210  * 3 * 15 * 5 * 8 бит = 225 кбайт.

#include < iostream> #include < string> using namespace std; string solve(int num, int divd) {       string result = "";       int count = 0;       while(num)       {               count = num / divd;               if(count)               {                       num %= divd;                       for (int i = 0; i < count; i++)                               switch(divd)                               {                                       case 1000:                                       {                                               result+="m";                                               break;                                       }                                       case 900:                                       {                                               result+="cm";                                               break;                                       }                                       case 800:                                       {                                               result+="dcc";                                               break;                                       }                                       case 700:                                       {                                               result+="dcc";                                               break;                                       }                                       case 600:                                       {                                               result+="dc";                                               break;                                       }                                       case 500:                                       {                                               result+="d";                                               break;                                       }                                       case 400:                                       {                                               result+="cd";                                               break;                                       }                                       case 300:                                       {                                               result+="ccc";                                               break;                                       }                                       case 200:                                       {                                               result+="cc";                                               break;                                       }                                       case 100:                                       {                                               result+="c";                                               break;                                       }                                       case 90:                                       {                                               result+="xc";                                               break;                                       }                                       case 80:                                       {                                               result+="lxxx";                                               break;                                       }                                       case 70:                                       {                                               result+="lxx";                                               break;                                       }                                       case 60:                                       {                                               result+="lx";                                               break;                                       }                                       case 50:                                       {                                               result+="l";                                               break;                                       }                                       case 40:                                       {                                               result+="xl";                                               break;                                       }                                       case 30:                                       {                                               result+="xxx";                                               break;                                       }                                       case 20:                                       {                                               result+="xx";                                               break;                                       }                                       case 10:                                       {                                               result+="x";                                               break;                                       }                                       case 9:                                       {                                               result+="ix";                                               break;                                       }                                       case 8:                                       {                                               result+="viii";                                               break;                                       }                                       case 7:                                       {                                               result+="vii";                                               break;                                       }                                       case 6:                                       {                                               result+="vi";                                               break;                                       }                                       case 5:                                       {                                               result+="v";                                               break;                                       }                                       case 4:                                       {                                               result+="iv";                                               break;                                       }                                       case 3:                                       {                                               result+="iii";                                               break;                                       }                                       case 2:                                       {                                               result+="ii";                                               break;                                       }                                       case 1:                                       {                                               result+="i";                                               break;                                       }                               }               }               if(divd < = 1000 & & divd > 100) divd-=100;               else if(divd < = 100 & & divd > 10) divd-=10;               else divd-=1;       }       return result; } int main() {       int num,count;       cin > > num;       if(num < = 3999) cout < < solve(num,1000);       else cout < < "incorrect input.";       return 0; }

#include< iostream> #include< string> using std: : string; string func(int num, string, string, string); int main(int argc, char argv[]) {     system("chcp 1251> 0");     std: : cout < < "введите число не большее 3999: ";       int arabien_num;       if : : cin > > arabien_num) || (arabien_num > 3999)) {         std: : cerr < < "невозможно инициализировать число! " < < std: : endl;         exit(1);     }       std: : string rome_num;       rome_num += func(arabien_num / 1000, "", "", "m");     arabien_num %= 1000;     rome_num += func(arabien_num / 100, "m", "d", "c");     arabien_num %= 100;     rome_num += func(arabien_num / 10,   "c", "l", "x");     arabien_num %= 10;     rome_num += func(arabien_num ,   "x", "v", "i");     std: : cout < < rome_num < < std: : endl;     return 0; } string func(int num, string hi, string re, string lo) {     switch(num)     {         case 9:             return lo + hi;         case 8:             return re + lo + lo + lo;         case 7:             return re + lo + lo;         case 6:             return re + lo;         case 5:             return re;         case 4:             return lo + re;         case 3:             return lo + lo + lo;         case 2:             return lo + lo;         case 1:             return lo;         case 0:             return "";     } }