cd /D d:\temp\out
dir /b *.py

#include <iostream>
int matrix[10][10]{ { 5,-3, 1,-2}, 
                  {   1, 2, 3, 1}, 
                  {   6,-3,-1, 3} };

int main()
{  
    int determinant =
        matrix[0][0] * matrix[1][1] * matrix[2][2] +
        matrix[0][1] * matrix[1][2] * matrix[2][0] +
        matrix[1][0] * matrix[2][1] * matrix[0][2] -
        matrix[0][2] * matrix[1][1] * matrix[2][0] -
        matrix[0][1] * matrix[1][0] * matrix[2][2] -
        matrix[1][2] * matrix[2][1] * matrix[0][0];
    
    int determinant_a =
        matrix[0][3] * matrix[1][1] * matrix[2][2] +
        matrix[0][1] * matrix[1][2] * matrix[2][3] +
        matrix[1][3] * matrix[2][1] * matrix[0][2] -
        matrix[0][2] * matrix[1][1] * matrix[2][3] -
        matrix[0][1] * matrix[1][3] * matrix[2][2] -
        matrix[1][2] * matrix[2][1] * matrix[0][3];

    int determinant_b =
        matrix[0][0] * matrix[1][3] * matrix[2][2] +
        matrix[0][3] * matrix[1][2] * matrix[2][0] +
        matrix[1][0] * matrix[2][3] * matrix[0][2] -
        matrix[0][2] * matrix[1][3] * matrix[2][0] -
        matrix[0][3] * matrix[1][0] * matrix[2][2] -
        matrix[1][2] * matrix[2][3] * matrix[0][0];

    int determinant_c =
        matrix[0][0] * matrix[1][1] * matrix[2][3] +
        matrix[0][1] * matrix[1][3] * matrix[2][0] +
        matrix[1][0] * matrix[2][1] * matrix[0][3] -
        matrix[0][3] * matrix[1][1] * matrix[2][0] -
        matrix[0][1] * matrix[1][0] * matrix[2][3] -
        matrix[1][3] * matrix[2][1] * matrix[0][0];
    
    float x1 = static_cast<float>(determinant_a) / determinant;
    float x2 = static_cast<float>(determinant_b) / determinant;
    float x3 = static_cast<float>(determinant_c) / determinant;
    std::cout << "determinant = " << determinant << std::endl;
    std::cout << "determinant 1 = " << determinant_a << std::endl;
    std::cout << "determinant 2 = " << determinant_b << std::endl;
    std::cout << "determinant 3 = " << determinant_c << std::endl;
    std::cout << "X1 = " << x1 << std::endl;
    std::cout << "X2 = " << x2 << std::endl;
    std::cout << "X3 = " << x3 << std::endl;
}

// exp_010.cpp : 
// Реалізувати алгоритм «Решето Ератосфена» для знаходження всіх
// простих чисел на проміжку від 1 до N.Виконати задачу по варіанту,
// заміряти час роботи.


#include <iostream>
#include <cmath>

bool isPrimeE(size_t);
void FillArray();

const size_t MAXN = 1000;
bool primeNumbers[MAXN] = { true };

int main()
{
    for (size_t i = 0; i < MAXN; i++)
    {
        primeNumbers[i] = true;
    }
    std::cout << "Hello World!\n";
    FillArray();
    for (size_t i = 2; i < 77; i++)
    {

        std::cout << "value=" << i << " isPrimeE = " << isPrimeE(i) << std::endl; //"\t";
    }
    std::getchar();
}

bool isPrimeE(size_t n)
{
    return primeNumbers[n];
}

void FillArray()
{
    size_t len = (size_t)std::ceil(std::sqrt(MAXN));
    size_t j = 0;
    primeNumbers[0] = primeNumbers[1] = false;
    for (size_t i = 2; i < len; i++)
    {        
        if ( primeNumbers[i] )
        {
            j = i * i;            
            while (j < MAXN)
            {
                primeNumbers[j] = false;
                j += i;                
            }
        }
    }
}

// 3 клавіатури вводиться текстовий рядок. 
// Скласти програму, яка підраховує кількість слів у тексті, 
// які закінчуються на голосну літеру, виводить на екран всі слова, 
// довжина яких менша п'яти символів, 
// видаляє всі слова, як містять хоча б одну латинську літеру

#include <iostream>
#include <locale>
#include <string>
#include <sstream>
#include <vector>
#include <Windows.h>

std::vector<char> vomelLetters = { 'а','е','є','и','і','ї','о','у','ю','я' };
//std::vector<char> vomelLetters = { (char)'а',(char)'е',(char)'є',(char)'и',(char)'і',(char)'ї',(char)'о',(char)'у',(char)'ю',(char)'я' };

std::string delimiters = " ,-";

std::vector<std::string> split(const std::string, const std::string);

bool IsVomLetters(char);
size_t WordsCount(std::vector<std::string>);
void PrintVector(std::vector<std::string>);
//bool IsDelim(char);


int main()
{
    std::cout << "Input Line" << std::endl;
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    //SetConsoleCP(CP_UTF8);
    //SetConsoleOutputCP(CP_UTF8);
    std::string inputline;

    std::getline(std::cin, inputline);
    std::vector<std::string> wordsArray = split(inputline, delimiters);
        
    PrintVector(wordsArray);
    std::cout << "\n1. The number of words in the text that end with a vowel = " << WordsCount(wordsArray) << std::endl;
    std::cout << "2. All words whose length is less than five characters = " << std::endl;
    //
    for (size_t i = 0; i < wordsArray.size(); i++)
    {
        if (wordsArray[i].size() < 5)
            std::cout << " " << i << "\t" << wordsArray[i] << std::endl;
    }

}


size_t WordsCount(std::vector<std::string> vwords)
{
    char ch;
    //bool b = false;
    size_t count = 0;
    for (size_t i = 0; i < vwords.size(); i++)
    {
        ch = vwords[i].back();
        if ( IsVomLetters( ch ) )
        {
            //std::cout << "w[" << i << "] " << vwords[i] << " " << ch << std::endl;
            count++;
        }
    }
    return count;
}

bool IsVomLetters(char ch)
{
    for (size_t i = 0; i < vomelLetters.size(); i++)
    {
        if (vomelLetters[i] == ch)
            return true;
    }
    return false;
}

std::vector<std::string> split(const std::string str, std::string delim)
{
    std::vector<std::string> wordVector;
    std::string line = str;
    std::size_t prev = 0, pos;
    while ((pos = line.find_first_of(delim, prev)) != std::string::npos)
    {
        if (pos > prev)
            wordVector.push_back(line.substr(prev, pos - prev));
        prev = pos + 1;
    }
    if (prev < line.length())
        wordVector.push_back(line.substr(prev, std::string::npos));
    return wordVector;
}



void PrintVector(std::vector<std::string> v)
{
    for (size_t i = 0; i < v.size(); i++)
    {
        std::cout << "[" << i << "] = " << v[i] << '\t';
    }
    std::cout << "\n";
}

// .
// З клавіатури вводиться текстовий рядок. Написати програму, 
// яка підраховує кількість різних слів, 
// що входять до заданого тексту;видаляє всі слова, що мають подвоєнні літери.

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <string>
//#include <unordered_set>

std::vector<std::string> split(std::string,std::string);
std::vector<size_t> words_count(std::vector<std::string>);

bool IsDoubleChars(std::string);

int _tmain(int argc, _TCHAR* argv[])
{    
    std::string delimiter(" .,!");
    std::string instr;
    
    std::getline(std::cin,instr);
    //instr = "wordd1 word2 word2 44455, Hello word2 r4556788. Hello fryier World!";
        
    std::cout << instr << std::endl;
    std::vector<std::string> strarray = split(instr, delimiter);
    for (int i = 0; i < strarray.size(); i++)
        std::cout << strarray[i] << std::endl;
    
    std::vector<size_t> array_counts = words_count(strarray);

    size_t num_uniq_word = 0;

    for (size_t i = 0;i < array_counts.size(); i++)
    {
        std::cout << "string [" << i << "] = "<< strarray[i] << " count = " << array_counts[i] << std::endl;
        if (array_counts[i] == 1)
            num_uniq_word++;
    }
    std::cout << "number of unique words = " << num_uniq_word << std::endl;


    std::cout << std::endl;
    std::cout << "---------------" << std::endl;
    for (size_t i = 0;i < strarray.size(); i++)
    {
        if ( !IsDoubleChars(strarray[i]) )
        {
            std::cout << strarray[i] << " "; //<< std::endl;
        }
    }
    getchar();
    return 0;
}

std::vector<std::string> split(std::string str,std::string delim)
{
    std::vector<std::string> tokens;
    char *str_c = strdup(str.c_str()); 
    char *token = NULL;

    token = strtok(str_c, delim.c_str()); 
    while (token != NULL) { 
        tokens.push_back(std::string(token));  
        token = strtok(NULL, delim.c_str()); 
    }

    delete[] str_c;

    return tokens;
}

std::vector<size_t> words_count(std::vector<std::string> str_array)
{
    std::vector<size_t> ret;
    size_t count = 0;
    size_t i = 0;
    for (i = 0; i < str_array.size(); i++)
    {
        count = 0;
        for (size_t j = 0; j < str_array.size(); j++)
        {
            if (str_array[i] == str_array[j])
            {
                count++;
            }            
        }
        ret.push_back(count);
    }
    return ret;
}


bool IsDoubleChars(std::string str)
{
    int k = 0;
    int l = str.length();
    for(int i = 0; k < l; i++) 
    {
        k = i + 1;
      if (str[i] == str[k])
        {             
            return true;
        }
    }
    return false;
}