• Задача 14. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int k;
       cin>>k;
       cout<<(!((k+325)%2==1))<<endl;
       return 0;
    }
    

    Задача 15. В решението на задачата се ползва следният алгоритъм:

    1. Цифрите на числото се отделят в променливите c1, c2, c3, като се използва целочислено деление с 10.
    2. Получените цифри се извеждат в обратен ред.

    Решение1:

    #include<iostream>
    using namespace std;
    int main()
    {
      int а,c1,c2,c3;
      cin>>а;
      c1=a/100;
      c2=a/10%10;
      c3=a%10;
      cout<<c3<<c2<<c1<<endl;
      return 0;
    }
    

    Може да се предложи и второ решение, без да се използват помощни променливи. Цифрите на числото последователно се отделят отдясно наляво и се извеждат на екрана.

    #include<iostream>
    using namespace std;
    int main()
    {
      int а;
      cin>>а;
      cout<<(a%10);
      cout<<(a/10%10);
      cout<<(a/100)<<endl;
      return 0;
    }
    

    Задача 16. За решение на задачата могат да се използват променливите c1, c2, c3, c4, в които да се отделят цифрите на даденото четирицифрено число.
    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       unsigned int а,c1,c2,c3,c4;
       cin>>а;
       c1=a/1000;
       c2=a/100%10;
       c3=a/10%10;
       c4=a%10;
       cout<<”Sum=”<<c1+c2+c3+c4<<’ ‘;;
       cout<<”Pr=”<<c1*c2*c3*c4<<endl;
       return 0;
    }
    

    Задача 17. При решението на задачата първо трябва да се отчете фактът, че въведеното петцифрено число може да надвиши диапазона допустими стойности за типа int. В зависимост от компилатора, който се ползва, трябва да се направи избор кой тип е целесъобразно да се използва – int или long.
    а) Остатъкът от целочислено деление на нечетно число с числото 2 е 1, а на четно число е 0. Следният алгоритъм дава решението на задачата:
    1. Отделят се всички цифри на числото.
    2. Съставя се израз, който представлява сбор на остатъците от делението на всяка цифра на числото с 2.
    3. Стойността на израза е търсеният резултат (броят на нечетните цифри).
    Решение 1:

    #include<iostream>
    using namespace std;
    int main()
    {
       unsigned long int а;
       int c1,c2,c3,c4,c5;
       cin>>а;
       c1=a/10000;
       c2=a/1000%10; 
       c3=a/100%10;
       c4=a/10%10;
       c5=a%10;
       cout<<c1%2+c2%2+c3%2+c4%2+c5%2<<endl;
       return 0;
    }
    

    б) Използвайки идеята от подусловие а), може да се намери остатъкът от деление на всяка цифра с числото 2. Полученият резултат е 0 или 1 в зависимост от това дали цифрата е четна или нечетна. При умножение на остатъка от делението със самата цифра може да се получи или цифрата, ако тя е нечетна, или 0, ако е четна. Така се получава сумата на нечетните цифри. А сумата на четните може да се намери като разлика от сумата на всички цифри и сумата на нечетните.
    Решение 2:

    #include<iostream>
    using namespace std;
    int main()
    {
       unsigned long int a;
       int c1,c2,c3,c4,c5,sum;
       cin>>a;
       c1=a/10000;
       c2=a/1000%10; 
       c3=a/100%10;
       c4=a/10%10;
       c5=a%10;
       sum=c1+c2+c3+c4+c5;
       cout<<(sum-(c1%2*c1+c2%2*c2+c3%2*c3+c4%2*c4+c5%2*c5));
       return 0;
    }
    

    Забележка: Поради това, че операциите умножение и остатък от деление са с еднакъв приоритет, се налага най-напред да се намери остатъкът от делението и след това да се умножава с цифрата.

    Задача 18. И тук, както в предната задача, трябва да се отбележи, че типът int няма да отговаря на диапазона на входни данни, поради което трябва да се използва long.
    Решение 1:

    #include<iostream>
    using namespace std;
    int main()
    {
       unsigned long int a;
       double sum;
       cin>>a;
       sum=a/10000000;
       sum+=a/1000000%10;
       sum+=a/100000%10;
       sum+=a/10000%10;
       sum+=a/1000%10;
       sum+=a/100%10;
       sum+=a/10%10;
       sum+=a%10;
       cout<<sum/8<<endl;
       return 0;
    }
    

    Може да се предложи и второ решение. В него се използва последователно отделяне на последната цифра, натрупването й към сумата и премахването й от числото.
    Решение 2:

    #include<iostream>
    using namespace std;
    int main()
    {
       unsigned long int a;
       double sum;
       cin>>a;
       sum=a%10;
       a/=10;
       sum+=a%10;
       a/=10;
       sum+=a%10;
       a/=10;
       sum+=a%10;
       a/=10;
       sum+=a%10;
       a/=10;
       sum+=a%10;
       a/=10;
       sum+=a%10;
       a/=10;
       sum+=a%10;
       cout<<sum/8<<endl;
       return 0;
    }
    

    Предлагаме и трето решение, в което вместо стандартния подход с отделяне на цифри се използва символна променлива. Тя служи за последователно въвеждане и обработване на всяка цифра от числото. При обработката цифрата се преобразува от символ в число и се добавя към сумата. Необходимо е променливата sum да бъде от целочислен тип. Защо?
    Решение 3:

    #include<iostream>
    using namespace std;
    int main()
    {
       char s;
       int sum;
       cin>>s;
       sum=s-‘0’;
       cin>>s;
       sum+=s-‘0’;
       cin>>s;
       sum+=s-‘0’;
       cin>>s;
       sum+=s-‘0’;
       cin>>s;
       sum+=s-‘0’;
       cin>>s;
       sum+=s-‘0’;
       cin>>s;
       sum+=s-‘0’;
       cin>>s;
       sum+=s-‘0’;
       cout<<(double)sum/8<<endl;
       return 0;
    }
    

    При извеждането на резултата се прилага преобразуване на променливата sum до реален тип, за да не се изпълни целочислено деление.
    Този подход дава възможност да се обработва n-цифрено число.

    Задача 19. За да се реши задачата, трябва да се използва отделяне на цифра. Най-лесно се отделя последната цифра на цяло число. Затова е удачно даденото число да се умножи по 100 и да се превърне в цяло, като се премахне дробната му част. Така търсената цифра ще бъде последна в полученото число.
    Забележка: При преобразуване от реален в целочислен тип някои компилатори правят закръгляне на резултата. Това може да промени последната цифра, което налага преди преобразуването да се отреже дробната част на числото чрез функцията floor.
    Решение 1:

    #include<iostream>
    #include<cmath>
    #include<iomanip>
    using namespace std;
    int main()
    {
       double a;
       long int b;
       cin>>a;
       a*=100;
       a=floor(a);
       b=a; //Неявно преобразуване на типа
       cout<<setw(5)<<b%10<<endl;
       return 0;
    }	
    

    Недостатъкът на това решение е, че при големи стойности на въведеното реално число a може да се надхвърли диапазонът на цялото число b. Поради тази причина е удачно цялата част на числото да се преобразува в нула по следния начин: a=a-floor(a);.
    Така за окончателно решение се получава:
    Решение 2:

    #include<iostream>
    #include<cmath>
    #include<iomanip>
    using namespace std;
    int main()
    {
       double a;
       int b;
       cin>>a;
       a=a-floor(a);
       a*=100;
       a=floor(a);
       b=a;//Неявно преобразуване на типа
       cout<<setw(5)<<b%10<<endl;
       return 0;
    }