Задачи для тренировки и лучшего понимания

/////////////////////////////////////////////////////////////////////////////////////////
//Вычисление последней ненулевой цифры факториала.
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef long long    T_num;
typedef std::string  T_str;
/////////////////////////////////////////////////////////////////////////////////////////
void  add_2_count_and_mult_multiplier_for_interval
    (
        T_num   interval,
        T_num   n,
        T_num&  _2_count,
        T_num&  multiplier
    )
{
    T_num  n_cur  =   n / interval;
    _2_count      +=  n_cur / 10 * 4;     
 
    for(T_num i = 2; i <= n_cur % 10; ++i)
    {
        if(i % 5 != 0)
        {            
            multiplier = multiplier * i % 10;        
        }
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
T_num  get_last_nonzero_dig(T_num  n)
{
    const int  _2_COUNT_MOD  = 4;
    T_num      _2_count      = 0;   
    T_num      _5_fact       = 5;
 
    while(n / _5_fact > 0)
    {
       _2_count -= n / _5_fact;
       _5_fact  *= 5;
    }
 
    T_num  res = 1;
    for(T_num  interval = 1; interval <= n; interval *= 5)
    {
        add_2_count_and_mult_multiplier_for_interval
            (
                interval,
                n,
                _2_count,
                res
            );
    }
    ++(--_2_count %= _2_COUNT_MOD);
 
    if(_2_count < 0)
    {
        _2_count += _2_COUNT_MOD;
    }    
 
    while(_2_count--)
    {
        res = res * 2 % 10;
    }    
    return  res;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));    
    
    for(;;)
    {
        std::cout << std::endl
                  << std::endl
                  << std::endl
                  << "n <= "
                  << std::numeric_limits<T_num>::max()                  
                  << std::endl
                  << "    :";
        T_str  s;
        std::cin >> s;
        std::istringstream  ssin(s); 
        T_num  n = 0;
        if(   !(ssin >> n)
           || n <= 0      )
        {
            break;     
        }
 
        std::cout << "Последняя цифра у "
                  << n                   
                  << "! равна "
                  << get_last_nonzero_dig(n)                  
                  << std::endl;   
    }
}

#define N 7
int main () {
    int a[N];
    int *b, *c;
    cout << " vvedite massiv: " << endl;
    for (int k = 0; k < N; k ++ ) {
        cin >> a[k];
    }
    for(int i = 0; i < N; i++) {
        b = &a[i];
        int count = 0;
        for(int j=0; j < N; j++) {
            if (a[i] == a[j] ) count += 1;
            else if(count == 1) { b = &a[j]; }
        }
        if (count == 1) { c = &a[i]; }
 
 
    }
        cout << "final odpoved: " << *c << endl;
 
 
}

    unsigned int result()
    {
        unsigned int r = nLastNumber;
        int t = dPower;
        t = t%4;
        if (t == 0) t=-4;
 
        while (t<0)
        {
            t++;
            r = (r*2)%10;
        }
        return r;
    }

#ifndef CLASSES_H_
#define CLASSES_H_
#include <string>
class Person
 { 
 protected:
  std::string name,surname;   
 public:
   Person(){};
   Person(std::string n,std::string s):name(n),surname(s){};
  ~Person(){};
  virtual void Set(std::string n,std::string s);
  virtual void Show();
};
 
class Gunslinger:virtual public Person
{
public:
    Gunslinger(){};
    Gunslinger(std::string n,std::string s,unsigned short k):Person(n,s),stvol(k){};
    void Set(std::string n,std::string s,unsigned short k);
    virtual~Gunslinger(){};
    virtual void Show();
    double Draw();
protected:
    unsigned short stvol;
};
 
 class PokerPlayer:virtual public Person
 {
 public:
     PokerPlayer(){};
     PokerPlayer(std::string n,std::string s):Person(n,s){};
     virtual~PokerPlayer(){};
     int Draw();
     void Show();
     void Set(std::string n,std::string s);
 };
 
 class BadDude:public Gunslinger,public PokerPlayer
{
public:
    BadDude(std::string n,std::string s,unsigned short k):PokerPlayer(n,s),Gunslinger(n,s,k){};
    virtual~BadDude(){};
    double Gdraw();
    int Cdraw();
    void Set(std::string n,std::string s,unsigned short k);
    void Show();
};
#endif

#include<iostream>
#include<string>
#include "classes.h"
#include<ctime>
//------------------------------------------------
//--------------------PERSON----------------------
//------------------------------------------------
void Person::Set(std::string n="Name",std::string s="Surname")
{
 name=n;
 surname=s;
}
void Person::Show()
{
 std::cout<<"Name:"<<name<<"\n"<<"Surname:"<<surname<<"\n";
}
//------------------------------------------------
//--------------------GUNSLINGER------------------
//------------------------------------------------
void Gunslinger::Set(std::string n,std::string s,unsigned short k)
{
 Person::Set(n,s);
 stvol=k;
}
double Gunslinger::Draw()
{
 double hours,minutes;
 srand((unsigned)time(NULL));
 hours=rand()%(24);
 minutes=rand()%(59)+1;
 minutes/=100;
 double tim=hours+ minutes;
 return tim;
}
void Gunslinger::Show()
{
    Person::Show();
    std::cout<<"Number of stvols:"<<stvol<<"\n";
    std::cout<<"Time:"<<Draw()<<"\n";
}
//------------------------------------------------
//--------------------POKERPLAYER-----------------
//------------------------------------------------
int PokerPlayer::Draw()
{
 srand((unsigned)time(NULL));
 return rand()%(52)+1;
}
void PokerPlayer::Show()
{
    Person::Show();
    std::cout<<"Next card:"<<Draw()<<"\n";
}
void PokerPlayer::Set(std::string n,std::string s)
{
 Person::Set(n,s);
}
//------------------------------------------------
//--------------------BADDUDE---------------------
//------------------------------------------------
int BadDude::Cdraw()
{
 return PokerPlayer::Draw();
}
double BadDude::Gdraw()
{
 return Gunslinger::Draw();
}
void BadDude::Set(std::string n,std::string s,unsigned short k)
{
 name=n;
 surname=s;
 stvol=k;
}
void BadDude::Show()
{
 std::cout<<"Name:"<<name<<"\n";
 std::cout<<"Surname:"<<surname<<"\n";
 std::cout<<"Number of stvols:"<<stvol<<"\n";
 std::cout<<"Next card:"<<Cdraw()<<"\n";
 std::cout<<"Time:"<<Gdraw()<<"\n";
}

#include <iostream>
#include<string>
#include "classes.h"
int main()
{
 std::string name,surname;
 unsigned short type,k;
 std::cout<<"Enter type:\n-1 for person\n-2 for gunslinger\n-3 for poker player\n-4 for bad dude\n";
 std::cin>>type;
 std::cout<<"Enter name\n";
 std::cin>>name;
 std::cout<<"Enter surname\n";
 std::cin>>surname;
 if(type==2 || type==4)
 {
  std::cout<<"Enter number of stvols\n";
  std::cin>>k;
 }
 Person* pers;
 switch(type)
 {
  case 1:{pers=new Person(name,surname);break;}
  case 2:{pers=new Gunslinger(name,surname,k);break;}
  case 3:{pers=new PokerPlayer(name,surname);break;}
  case 4:{pers=new BadDude(name,surname,k);break;}
  default:std::cout<<"Illegal type";
 }
 pers->Show();
 std::cin.get();
 std::cin.get();
}

    BadDude(std::string n,std::string s,unsigned short k):PokerPlayer(n,s),Gunslinger(n,s,k){};

    BadDude(std::string n,std::string s,unsigned short k){Set(n,s,k);};

#include <iostream>
#include <cmath>
 
using namespace std;
 
void PrintSum(int x);
 
int main()
{
    double d(-0.5);
 
    int f(floor(d));
    int c(ceil(d));
    int s(signed(d));
    int i(d);
 
    cout << bool(f) == 0;
    cout << bool(c) == 0;
    cout << bool(s) == 0;
    cout << bool(i) == 0;
    cout << endl;
 
    for (int i = 0, s = 0; i < 2; s += i++)
    {
        PrintSum(f + c + s + i);
    }
}
 
int s(int x)
{
    static int sum = 0;
    return sum += x;
}
 
void PrintSum(int x)
{
    cout << s(x) << endl;
}