Евгений Шатунов

#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<algorithm>
#include<iterator>
#include<iomanip>
#include<sstream>
using namespace std;

struct Book
{
  string name;
  int year = 0;
  int circulation = 0;
};

istream& operator>>(istream& is, Book& book)
{
  string line;
  getline(is, line);

  istringstream head(line);
  getline(head, book.name, ':');
  head >> book.year >> book.circulation;
  return is;
}

vector<Book> getBooksList(istream& source)
{
  return{ istream_iterator<Book>{source}, {} };
}

// Пришел в библиотеку - дайте мне немного книг, любых.
// А тебе говорят - сам возьми, вон там две полки - нижняя и верхняя. 
// А да, забыли предупридить - ВЫХОД платный!
enum class input_type : int {Console, File, None};
input_type get_input()
{
  if(!cin)
  {
    system(" ");
    cout << "\n\x1b[1;31mА вот и не угадал! Играй по правилам!\x1b[0m\n\n"
            "Правило первое - никаких правил ;)\n\n";
    cin.clear();
  }
  
  cout << "Жми откуда брать: \n [0] -- (консоль)\n [1] -- (файл)\n\n" 
          "[Ctrl + Z] -- (Извините ошибся дверью)\n\n$: ";
  int inp = 0;
  if(cin >> inp && inp == 0)
  {
    system(" "); 
    cout <<  "Вводи \x1b[1;31m [ Название : Год Тираж ]\n\n"
         <<  "Пример:"
         <<  "\t\x1b[0;40;36mЗолотой ключик, или Приключения Буратино : 1936 50000\n\n"
         <<  "\x1b[0mНе забудь \x1b[1;33mCtrl + Z\x1b[0m означает конец ввода.\n\n";
  }
  return static_cast<input_type>(inp);
}

// Не Аквафор
vector<Book> filter(vector<Book> const& books, int from, int to)
{
  vector<Book> filtered;
  copy_if(books.cbegin(), books.cend(), back_inserter(filtered), [=](auto const& b){
    return b.year >= from && b.year <= to;
  });
  
  return filtered;
}

// Что я прочитал за это лето
void print_table(vector<Book> const& books)
{
  auto max_width_elm = max_element(books.cbegin(), books.cend(), [](auto const& a, auto const& b){
    return a.name.size() < b.name.size();
  });
  
  if(max_width_elm == books.cend())
  {
    cout << "Ничего, бывает...\n";
    return;
  }

  size_t max_width = max_width_elm->name.size();

  // А какая у вас машина? - Зеленая O_o
  system(" ");
  cout << "\x1b[1;32m"
       << setw(8 + max_width) 
       << left     << "Название"
       << setw(12) << "Год"
       << setw(12) << "Тираж" << "\n"
       << "\x1b[0m";
  
  for(auto[name, year, circul] : books)
  {
    cout << setw(8 + max_width) 
         << left     << name
         << setw(12) << year
         << setw(12) << circul << "\n";
  }
}

enum class sort_field { Name, Year, Circul };
auto sort_by = [](sort_field field, auto& container){
  sort(container.begin(), container.end(), [=](const auto& a, const auto& b){ 
    bool result = false;
    switch(field)
    {
    case sort_field::Year:
      result = a.year < b.year;
      break;
    case sort_field::Circul:
      result = a.circulation < b.circulation;
      break;
    default:
      result = a.name < b.name;
      break;
    }
    return result;
  });
};

int main()
{ 
  setlocale(LC_ALL, "");

  //типа файл
  const string test_data = "book10 : 2010 10000\n"
                           "book09 : 2009 9000\n" 
                           "book19 : 2019 19000\n"
                           "book03 : 2003 3000\n"
                           "book84 : 1984 84000\n"
                           "book42 : 2042 42000";
  istringstream is(test_data);

  vector<Book> books;

  input_type input = input_type::None;

  while(input == input_type::None)
  {
    input = get_input();
    switch(input)
    {
    case input_type::Console:
      books = getBooksList(cin);
      break;
    case input_type::File:
      books = getBooksList(is);
      break;
    default:
      system(" ");
      cout << "\n\x1b[1;33mВыбери 0 или 1 ЧеГо НеПоНяТнОгО?\x1b[0m \n";
      input = input_type::None;
      break;
    }
  }
  
  sort_by(sort_field::Year, books);
  
  print_table(filter(books, 2000, 2010));
 
  system("pause");
}

#include<iostream> 
#include<iomanip> 
#include<fstream>
#include<string>
#include<Windows.h>
using namespace std;

struct book
{
  string name;
  unsigned year;
  unsigned circulation;
};

int count_if(book* b, int sz, int from, int to)
{
  int cn = 0;
  for(int i = 0; i < sz; ++i)
  {
    if(b[i].year >= from && b[i].year <= to)
    {
      ++cn;
    }
  }
  return cn;
}

book* get_books_list(book* arr, int n, int from, int to, int& out_sz)
{
  out_sz = count_if(arr, n, from, to);
  if(out_sz == 0)
  {
    return nullptr;
  }

  book* array = new book[out_sz];
  int idx = 0;

  for(int i = 0; i < n; ++i)
  {
    if(arr[i].year >= from && arr[i].year <= to)
    {
      array[idx].name = arr[i].name;
      array[idx].year = arr[i].year;
      array[idx].circulation = arr[i].circulation;
      ++idx;
    }
  }
  return array;
}

int main()
{
  SetConsoleCP(1251);
  SetConsoleOutputCP(1251);
  
  string kng = "TextFile1.txt";
  int N;
  book *arr;
  int otkr;
  cout << "ВЫБЕРИТЕ СПОСОБ ВВОДА. 0 - С КЛАВИАТУРЫ, 1 - ИЗ ФАЙЛА  \n";
  cin >> otkr;
  if(otkr == 0)
  {
    cout << "введите размер массива \n";
    cin >> N;
    arr = new book[N];
    for(int i = 0; i < N; ++i)
    {
      cout << "Введите название книги\n";
      cin >> arr[i].name;
      cout << "Введите тираж \n";
      cin >> arr[i].circulation;
      cout << "Введите год издания \n";
      cin >> arr[i].year;
    }

    for(int i = 0; i < N; ++i)
    {
      cout << arr[i].name << "  " << arr[i].circulation << "  " << arr[i].year << endl;
    }

  }
  else
  {
    fstream knigi;
    knigi.open("TextFile1.txt");
    knigi >> N;
    arr = new book[N];
    for(int i = 0; i < N; i++)
    {
      knigi >> arr[i].name >> arr[i].circulation >> arr[i].year;
    }
  }

  int sz = 0;

  book* books = get_books_list(arr, N, 2000, 2010, sz);

  delete[] arr;

  if(books)
  {
    cout << "НАЗВАНИЕ И ТИРАЖ КНИГ С ИЗДАННЫХ С 2000-2010 ГГ:\n";
    for(int i = 0; i < sz; ++i)
    {
       cout << books[i].name << "  " << books[i].circulation << "\n";
    }
    delete[] books;
  }
  else
  {
    cout << "ТАКИХ НЕТ.";
  }
  system("pause");
}

#include<iostream>
#include<filesystem>
#include<string>

using namespace std;
namespace fs = filesystem;

auto listFilesRecursively = [](auto const& dir, string const& mask = {}){
  if(!fs::is_directory(dir))
  {
    cerr << dir << " is not dir";
    throw "is not dir!";
  }
  
  for(auto const& file : fs::recursive_directory_iterator(dir))
  {
    if(fs::is_regular_file(file))
    {
      if(mask.empty() || file.path().extension().string() == mask)
      {
        // Здесь твоя функция вывода инфы
        cout << file.path().string() << " #size: " << file.file_size() << "\n";
      }
    }
    else if(fs::is_directory(file))
    {
      cout << "\n****** dir ****** [" << file.path().string() << "]\n";
    }
    else
    {
      cout << "\n***** other... ******[" << file.path().filename().string() << "]\n";
    }
  }
};

int main()
{
  const string start_dir = R"(C:\Program Files)";
  try
  {
    listFilesRecursively(start_dir, ".dll");
  }
  catch(exception& e)
  {
    cerr << e.what();
  }
}

#include <algorithm>
#include <iterator>
#include <iostream>
#include <vector>

using namespace std;

auto fx = [](int x){
  int r = 0;
  switch(x % 3)
  {
    case 0:
      r = x * x;
      break;
    case 1:
      r = x;
      break;
    default:
      r = x / 3;
      break;
  }
  return r;
};

auto calculate = [](const vector<int>& vx, auto fx){
  vector<int> calcValues(vx.size());
  transform(vx.begin(), vx.end(), calcValues.begin(), fx);
  return calcValues;
};

int main()
{
  cout << "Введи кол-во чисел: ";
  int n = 0;
  cin >> n;

  cout << "Введи через пробел " << n << " натуральных чисел:\n" << "$: ";
  vector<int> values(n);
  copy_n(istream_iterator<int>(cin), n, values.begin());

  cout << "Результат твоих расчетов:\n";
  copy_n(calculate(values, fx).begin(), n, ostream_iterator<int>(cout, "\n"));
}

#include<iostream>
#include<filesystem>
#include<string>
using namespace std;
namespace fs = filesystem;

auto getDirectorySize(const fs::path& p)
{
  uintmax_t size = 0;
  if(fs::is_directory(p))
  {
    for(const auto& f : fs::directory_iterator(p))
    {
      size += f.file_size();
    }
  }
  return size;
}

int main()
{
  string directory{ "C:\\TEMP" };
  fs::path dp{ directory };
  
  auto size{ getDirectorySize(dp) };
  cout << "size of "  << directory 
       << " "         << size 
       << " bytes"    << endl;
}

#include<iostream>
#include<fstream>
#include<string>
#include<vector>
using namespace std;

size_t getFileSize(const string& filename)
{
  ifstream ifs(filename);
  size_t size = 0;
  if(ifs)
  {
    ifs.seekg(0, ios_base::end);
    size = ifs.tellg();
  }
  return size;
}

int main()
{
  vector<string> filenames{
    "C:\\TEMP\\aaa.txt", "C:\\TEMP\\bbb.txt", "C:\\TEMP\\ccc.txt"
  };

  size_t size = 0;

  for(const string& fn : filenames)
  {
    size += getFileSize(fn);
  }

  cout << "Size: " << size << endl;
}

template<class ForwardIt, class Compare>
ForwardIt min_element(ForwardIt first, ForwardIt last, Compare comp)
{
    if (first == last) return last;
 
    ForwardIt smallest = first;
    ++first;
    for (; first != last; ++first) { // не возвращает значения сразу
        if (comp(*first, *smallest)) { //  каким образом происходит сравнение
            smallest = first;
        }
    }
    return smallest; // а только в конце
}