Вийшов отакий код.
/* 
 * set_operations
 * 1. Користувач вибирає розмір трьох множин,
 *    діапазон їх значень і задає значення елементів.
 * 2. Програма виводить множини на екран.
 * 3. Програма розраховує функції:
 *    В∩(С∩А∩В);
 *    |A∩C|;
 *    2^B
 *    і виводить результат на екран.
 */
#include <cstdio>
#include <cstdlib>
#include <iostream>
/* INPUT_BUFFER - буфер для вводу користувача */
#define INPUT_BUFFER 20
using namespace std;
/* set - множина 
 * start - покажчик на початок масиву із елементами множини
 * size - розмір множини
 * range_max - максимальне значення елементів множини
 * range_min - мінімальне значення елементів множини
 */
struct set {
    int *start;
    int size;
    int range_max;
    int range_min;
};
/* init_set - ініціалізує множину із параметрами, заданими користувачем */
set  init_set(void);
/* print_set - виводить на екран множину */
void print_set(set given_set);
/* intersect - розраховує перетин двох множин */
set  intersect(set a, set b);
/* exist - визначає чи є задане число в масиві */
bool exist(int number, int *array, int size);
/*
 * Демонстрація роботи із множинами 
 */
int main(int argc, char** argv) {
    set a, b, c, new_set;
    
    /* Ініціалізація множин */
    cout << "Будь ласка, задайте початкові значення множин.\n"
            "Множина A.\n";
    a = init_set();
    cout << "Множина B.\n";
    b = init_set();
    cout << "Множина C.\n";
    c = init_set();
    
    /* Вивід на екран */
    cout << "Утворені наступні множини:\n"
            "A: ";
    print_set(a);
    cout << "B: ";
    print_set(b);
    cout << "C: ";
    print_set(c);
    
    /* Демонстрація розрахунків */
    cout << "Обраховується формула В∩(С∩А∩В).\n";
    new_set = intersect(intersect(a, b), c); 
    cout << "В∩(С∩А∩В) = ";
    if (new_set.size) {
        print_set(new_set);
    } else {
        cout << "Порожня множина\n";
    }
                
    cout << "Обраховується формула |A∩C|.\n";
    new_set = intersect(a, c);
    cout << "|A∩C| = " << new_set.size << '\n';
    
    cout << "Обраховується формула 2^B.\n";
    if (b.size == 1 && *(b.start) == 2) {
        cout << "2^B = true\n";
    } else {
        cout << "2^B = false\n";
    }
        
    return 0;
}
set init_set(void) {
    /* Нова множина */
    set given_set;
    /* Буфер для вводу користувача */
    char str[INPUT_BUFFER];
    /* Лічильник */
    int i;
    /* Змінна для згенерованого випадкового числа */
    int random;
    
    /* Ініціалізація нової множини */
    given_set.size = 10;
    given_set.range_min = -10;
    given_set.range_max = 10;
    
    do {
        cout << "Оберіть розмір множини від 1 до 10\n";
        gets(str);
        given_set.size = atoi(str);
    } while (given_set.size < 1 || given_set.size > 10);
    
    do {
        cout << "Задайте мінімальне значення для множини від -100 до "
             << 100 - given_set.size << '\n';
        gets(str);
        given_set.range_min = atoi(str);
    } while (given_set.range_min < -100 || given_set.range_min > 100 - given_set.size);
    
    do {
        cout << "Задайте максимальне значення для множини від "
             << given_set.range_min + given_set.size << " до 100\n";
        gets(str);
        given_set.range_max = atoi(str);
    } while (given_set.range_max < -100 
            || given_set.range_max > 100 
            || given_set.range_max < given_set.range_min + given_set.size);
    
    /* Виділення пам’яті для нової множини */
    given_set.start = new int[given_set.size];
    
    cout << "Ви бажаєте, щоб програма задала значення множини? (y/n): ";
    gets(str);
    if (str[0] == 'y') {
        /* Розраховуємо унікальні випадкові числа */
        i = 0;
        while(i < given_set.size) {
            /* Продовжуємо отримувати випадкові числа, доки не знайдемо таке,
             * якого іще немає в множині
             */
            random = rand() % (given_set.range_max - (given_set.range_min - 1)) + given_set.range_min;
            if ( !(exist(random, given_set.start, i)) ) {
                *(given_set.start + i) = random;
                i++;
            }
        }
    } else {
        cout << "Задайте значення елементів множини.\n";
        for (i = 0; i < given_set.size; i++){
            /* Перевіряємо отримані числа, щоб вони входили в допустимий діапазон
             * і були унікальними
             */
            do {
                cout << i << ": ";
                gets(str);
                *(given_set.start + i) = atoi(str);
            } while (*(given_set.start + i) < given_set.range_min 
                    || *(given_set.start + i) > given_set.range_max
                    || exist(*(given_set.start + i), given_set.start, i));
        }
    }
    
    /* Повертаємо утворену множину */
    return given_set;
}
void print_set(set given_set) {
    int i = 0;
    
    /* Послідовно виводимо елементи масиву через пробіл */
    for (i = 0; i < given_set.size; i++) {
        cout << *(given_set.start + i) << ' ';
    }
    
    cout << '\n';
}
bool exist(int number, int *array, int size) {
    int i;
    
    /* Перевіряємо елементи масиву доки не знайдемо задане число */
    for (i = 0; i < size; i++){
        if (*(array + i) == number) {
            return true;
        }
    }
    
    return false;
}
set intersect(set a, set b) {
    /* Лічильники */
    int i, j;
    /* Розмір нової множини */
    int new_size = 0;
    /* Покажчик на початок нової множини */
    int *ptr;
    /* Нова множина */
    set new_set;
    
    /* Знаходимо меншу множину */
    if (a.size < b.size) {
        /* При перетині елементів буде не більше ніж в меншій множині */
        ptr = new int[a.size];
        /* Знаходимо однакові елементи */
        for (i = 0; i < a.size; i++) {
            for (j = 0; j < b.size; j++) {
                if( *(a.start + i) == *(b.start + j) ) {
                    *(ptr + new_size) = *(a.start + i);
                    new_size++;
                }
            }
        }
    } else {
        ptr = new int[b.size];
        for (i = 0; i < b.size; i++) {
            for (j = 0; j < a.size; j++) {
                if( *(b.start + i) == *(a.start + j) ) {
                    *(ptr + new_size) = *(b.start + i);
                    new_size++;
                }
            }
        }
    }
    
    /* Ініціалізуємо нову множину */
    new_set.size = new_size;
    new_set.start = ptr;
    
    /* Повертаємо нову множину */
    return new_set;
}
Які є зауваження по коду?
Чи правильно я зрозумів умови задачі?
Є питання по 133 рядку. Якщо на українській розкладці ввести 'н', а потім змінити розкладку на англійську і прибрати 'н' і написати 'y', то програма запропонує ввести елементи автоматично. Як із цим боротись?