#include
<iostream>
#include <sstream>
#include <string>
#include <cstring>

using namespace std;

// true
если слово соответствует условию(двузначное число)
bool isValidWord(const
wstring& str)
{
  // Длина слова равна двум

if(str.length()==2)
  {
   // Пытаемся конвертировать в
число
      int num=_wtoi(str.c_str());
      
return !errno && num>9 && num<100;
  }
  else
  {
   return false;
  }
}

// true
если строка содержит только правильные(согласно условия) слова
bool
isValidString(const wstring& str)
{
  bool res=false;
    //
Поток
   wstringstream wstr(str);
   wstring word;
      // Читаем
каждое слово из потока
   while(wstr>>word &&
(res=isValidWord(word)));
        return res;
}

int
main()
{
    wstring str;
       // Читаем по строкам
       
getline(wcin,str);
  while(wcin)
  {
   // Если
строка соответствует условию
   if(isValidString(str))
     
  {
    // Выведем ее
           
wcout<<str<<endl;
   }
          
getline(wcin,str);
  }
}

#include <iostream>
#include <locale>
#include <stdlib.h>
#include <time.h>

using namespace std;

/*****************************<WBR>************************
Ищем максимальный элемент в квадратной матрице  
на местах, показанных на рисунке
|*******|
| ***** |
|   *    |
| ***** |
|*******|
******************************<WBR>***********************/
double calc_max(double *A, int n)
{
  int   i,j;            
//индексы строк и столбцов
  int   start;            
//стартовый столбец
  int   step;            
//поправка стартового столбца
  double  max = -1000.;   //максимальный элемент

  //Начальная поправка стартового столбца = 1 (сдвигаем вправо)
  //Стартовый столбец = 0
  //инкремент строки в теле цикла
  for(step=1,i=start=0;i<n;)  //цикл по строкам
  {
   for(j=start;j<n-start;j++)    //цикл по столбцам
   {
    if (max < *(A+i*n+j))    //ищем максимальный
элемент
     max = *(A+i*n+j);
   }
   start+=step;    //сдвигаем начальный
столбец
   i++;      //инкремент
строк
   switch (step)    //анализируем текущую
поправку
   {
    case 1:     //от начала к
середине
     if (i>n/2)   //середина?
     {
      step=-1;  //потом пойдем
от середины к концу
      start-=2;  //на предыдущий
столбец
     }
     else if(((n&1)==0) && (i==(n/2)))   
//для четного числа столбцов
     {            
//повторяем два средних элемента
      step=0;   //без смещения
начального столбца
      start--;  //повторяем
начальный столбец
     }
     break;
    case 0:     //для четного
числа столбцов
     step=-1;   //продолжаем
смещаться к началу
     start--;
   }
  }
  return max;
}

int    main()
{
  const int    n = 6;     //число строк и
столбцов
  double  *A = new double[n*n];    //запросим память под матрицу

  locale::global(locale("<WBR>russian_russia.866")); //чтобы
писалось по-русски

  srand(time(0));      //инициализация
случайных чисел
  for(i=0;i<n;i++)     //заполним
массив числами 0-999
  {
   for(j=0;j<n;j++)
    *(A+i*n+j)=rand()%1000;
  }
   
  //выведем матрицу
  wcout <<L"Исходная матрица:" <<endl;
  for(i=0;i<n;i++)
  {
   for(j=0;j<n;j++)
    cout << *(A+i*n+j) << "\t";
   cout <<endl;
  }
   
  //найдем и выведем максимальный элемент
  cout << "Max = " <<calc_max(A, n) <<endl;
    
  delete []A;      //освободим
память
  system("pause");    //press any key
  return 0;
}

#include <iostream>
using namespace std;
//----------------------------<WBR>------------------------------<WBR>--
// Функция нахождения минимального элемента столбца матрицы
// 1-й параметр - сама матрица,
// 2-й - число строк в ней,
// 3-й - столбец для поиска минимального элемента.
int iMinimal(int** piArray, int iRows, int iColumn)
{
  // Пусть минимальным будет 0-й элемент столбца
  int iMinimal = piArray[0][iColumn];
   
  // Проходим по элементам столбца (сортировка)
  for(int i = 1; i <iRows; ++i)
  {
   if(piArray[i][iColumn] <iMinimal) iMinimal =
piArray[i][iColumn];
  }
  return iMinimal;
}
//----------------------------<WBR>------------------------------<WBR>--
int main()
{
  int iRows, iColumns;
  cout << "Введите число строк в матрице: ";
  cin >> iRows;
  cout << "Введите число столбцов в матрице: ";
  cin >> iColumns;
   
  int** piMatrix; // Матрица в виде двойного указателя
  // Создан массив из iRows элементов, каждый из которых - указатель на
int.
  piMatrix = new int* [iRows];
  cout << "Начинайте ввод элементов в матрицу: "
<<endl;
  for(int i = 0; i <iRows; i++)
  {
   cout << "Строка " <<i <<
"." <<endl;
   // Определяется массив из iRows указателей, каждый из которых
   // адресует массив из iColumns целых чисел - элементов матрицы.
   piMatrix[i] = new int[iColumns];
   for(int j = 0; j <iColumns; j++)
   {
    cout << "[" <<i <<
"][" <<j << "]: ";
    // Ввод значения в элемент матрицы piMatrix[i][j]
обычным способом.
    cin >> piMatrix[i][j];
   }
  }
   
  int iArray[iColumns]; // Новый массив
  cout << "Элементы нового массива: " <<endl;
  // Заполняем элементы нового массива значениями минимальных элементов
столбцов матрицы
  for(int i = 0; i <iColumns; i++)
  {
   iArray[i] = iMinimal(piMatrix, iRows, i);
   cout <<i << ": " <<iArray[i]
<<endl;
  }
   
  // Не забываем освобождать память,
  // выделенную для для каждого из элементов матрицы.
  for(int i = 0; i <iRows; i++) delete[] piMatrix[i];
  // Не забываем освобождать память, выделенную для для самой матрицы.
  delete[] piMatrix;
   
  return 0;
}

#include <iostream>
using namespace std;
//----------------------------<WBR>------------------------------<WBR>--
int main()
{
  int iRows, iColumns;
  cout << "Введите число строк в матрице: ";
  cin >> iRows;
  cout << "Введите число столбцов в матрице: ";
  cin >> iColumns;
  if((iRows <= 2) || (iColumns <= 2))
  {
   cout << "Число элементов массива не должно быть
меньше 5!" <<endl;
   return 1;
  }
   
  int iMatrix[iRows][iColumns];
  cout << "Начинайте ввод элементов в матрицу: "
<<endl;
  for(int i = 0; i <iRows; i++)
  {
   cout << "Строка " <<i <<
"." <<endl;
   for(int j = 0; j <iColumns; j++)
   {
    cout << "[" <<i <<
"][" <<j << "]: ";
    // Ввод значения в элемент матрицы iMatrix[i][j].
    cin >> iMatrix[i][j];
   }
  }
   
  cout << "Введите индексы 5 элементов для суммирования."
<<endl;  
  int iSum = 0; // Сумма элементов. Пока не считали.
  int iX, iY; // Индексы указываемых пользователем элементов массива.
  for(int i = 0; i <5; i++)
  {
   cout << "Элемент №" <<i <<
"." <<endl;
   cout << "Строка: ";  
   cin >> iX;
   if(iX >= iRows)
   {
    cout << "Ошибка! Такой строки нет!"
<<endl;
    return 1;
   }
   cout << "Столбец: ";  
   cin >> iY;
   if(iY >= iColumns)
   {
    cout << "Ошибка! Такого столбца нет!"
<<endl;
    return 1;
   }
   iSum += iMatrix[iX][iY];
  }
   
  cout << "Сумма значений указанных элементов массива равна
" <<iSum << "." <<endl;
   
  return 0;
}

#include <iostream>
using namespace std;
//----------------------------<WBR>------------------------------<WBR>--
int main()
{
  int iRows, iColumns;
  cout << "Введите число строк в матрице: ";
  cin >> iRows;
  cout << "Введите число столбцов в матрице: ";
  cin >> iColumns;
  if((iRows <= 2) || (iColumns <= 2))
  {
   cout << "Число элементов массива не должно быть
меньше 5!" <<endl;
   return 1;
  }
   
  int** piMatrix; // Матрица в виде двойного указателя
  // Создан массив из iRows элементов, каждый из которых - указатель на
int.
  piMatrix = new int* [iRows];
  cout << "Начинайте ввод элементов в матрицу: "
<<endl;
  for(int i = 0; i <iRows; i++)
  {
   cout << "Строка " <<i <<
"." <<endl;
   // Определяется массив из iRows указателей, каждый из которых
   // адресует массив из iColumns целых чисел - элементов матрицы.
   piMatrix[i] = new int[iColumns];
   for(int j = 0; j <iColumns; j++)
   {
    cout << "[" <<i <<
"][" <<j << "]: ";
    // Ввод значения в элемент матрицы piMatrix[i][j]
обычным способом.
    cin >> piMatrix[i][j];
   }
  }
   
  cout << "Введите индексы 5 элементов для суммирования."
<<endl;  
  int iSum = 0; // Сумма элементов. Пока не считали.
  int iX, iY; // Индексы указываемых пользователем элементов массива.
  for(int i = 0; i <5; i++)
  {
   cout << "Элемент №" <<i <<
"." <<endl;
   cout << "Строка: ";  
   cin >> iX;
   if(iX >= iRows)
   {
    cout << "Ошибка! Такой строки нет!"
<<endl;
    return 1;
   }
   cout << "Столбец: ";  
   cin >> iY;
   if(iY >= iColumns)
   {
    cout << "Ошибка! Такого столбца нет!"
<<endl;
    return 1;
   }
   iSum += piMatrix[iX][iY];
  }
   
  cout << "Сумма значений указанных элементов массива равна
" <<iSum << "." <<endl;
   
   
  // Не забываем освобождать память,
  // выделенную для для каждого из элементов матрицы.
  for(int i = 0; i <iRows; i++) delete[] piMatrix[i];
  // Не забываем освобождать память, выделенную для для самой матрицы.
  delete[] piMatrix;

  return 0;
}

#include <string>
#include <locale>
#include
<iostream>
//---------------------------------------------------------------------------
using namespace std;
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
         locale
loc("rus_rus.866");// устанавливаем нашу локаль
         string
s; // тут будет наша строка
   int x = 0/*для размера строки*/;

        cout << "Input string\n>"; // просим ввести строку
    getline(cin,s); // получаем строку в переменную s
   
for(int i = 0, y = s.length(); i< y; i++)//пока не конец строки
         
{
           if(isalpha(s[i],loc)) // если это буква
     
         {
           x ++;  // увеличиваем счетчик на
1 если условие верно (не пробел) и на 0 (если не верно (это пробел)
        
         }
        }
       cout <<"\ncount:
"<<x<<" char\nPress any key..."; // сообщаем
результат
         cin.get(); //ждем нажатия любой клавиши
      
return 0; // выходим
}

bool
bBytes = false; // Изменялся ли счётчик байтов?
bool bKilobytes = false;
// Изменялся ли счётчик килобайтов?
bool bMegabytes = false; // Изменялся
ли счётчик мегабайтов?
bool bGigabytes = false; // Изменялся ли счётчик
гигабайтов?

// Файл TMainForm.h

#pragma once

namespace Bytes {

  using namespace System;
  using namespace System::ComponentModel;
  using namespace System::Collections;
  using namespace System::Windows::Forms;
  using namespace System::Data;
  using namespace System::Drawing;

  bool bBytes = false;
  bool bKilobytes = false;
  bool bMegabytes = false;
  bool bGigabytes = false;

  public ref class TMainForm : public System::Windows::Forms::Form
  {
  public:
   TMainForm(void)
   {
    InitializeComponent();
    //
    //TODO: Add the constructor code here
    //
   }

  protected:
   /// <summary>
   /// Clean up any resources being used.
   /// </summary>
   ~TMainForm()
   {
    if (components)
    {
     delete components;
    }
   }
  private: System::Windows::Forms::Label^  BytesLabel;
  private: System::Windows::Forms::Label^  KiloBytesLabel;
  private: System::Windows::Forms::Label^  MegaBytesLabel;
  private: System::Windows::Forms::Label^  GigaBytesLabel;
  private: System::Windows::Forms::<WBR>NumericUpDown^  BytesSpinBox;
  private: System::Windows::Forms::<WBR>NumericUpDown^  KiloBytesSpinBox;
  private: System::Windows::Forms::<WBR>NumericUpDown^  MegaBytesSpinBox;
  private: System::Windows::Forms::<WBR>NumericUpDown^  GigaBytesSpinBox;
  private: System::Windows::Forms::<WBR>Button^  CalculateButton;

  protected:  
  private:

   System::ComponentModel::<WBR>Container ^components;

#pragma region Windows Form Designer generated code
   /// <summary>
   /// Required method for Designer support - do not modify
   /// the contents of this method with the code editor.
   /// </summary>
   void InitializeComponent(void)
   {
    this->BytesLabel = (gcnew
System::Windows::Forms::Label(<WBR>));
    this->KiloBytesLabel = (gcnew
System::Windows::Forms::Label(<WBR>));
    this->MegaBytesLabel = (gcnew
System::Windows::Forms::Label(<WBR>));
    this->GigaBytesLabel = (gcnew
System::Windows::Forms::Label(<WBR>));
    this->BytesSpinBox = (gcnew
System::Windows::Forms::<WBR>NumericUpDown());
    this->KiloBytesSpinBox = (gcnew
System::Windows::Forms::<WBR>NumericUpDown());
    this->MegaBytesSpinBox = (gcnew
System::Windows::Forms::<WBR>NumericUpDown());
    this->GigaBytesSpinBox = (gcnew
System::Windows::Forms::<WBR>NumericUpDown());
    this->CalculateButton = (gcnew
System::Windows::Forms::<WBR>Button());
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->BytesSpinBox))-><WBR>BeginInit();
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->KiloBytesSpinBox))-><WBR>BeginInit();
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->MegaBytesSpinBox))-><WBR>BeginInit();
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->GigaBytesSpinBox))-><WBR>BeginInit();
    this->SuspendLayout();
    //  
    // BytesLabel
    //  
    this->BytesLabel->AutoSize = true;
    this->BytesLabel->Font = (gcnew
System::Drawing::Font(L"<WBR>Microsoft Sans Serif", 8.25F,
System::Drawing::FontStyle::<WBR>Bold, System::Drawing::GraphicsUnit:<WBR>:Point,  
     static_cast<System::Byte>(204)<WBR>));
    this->BytesLabel->Location =
System::Drawing::Point(19, 18);
    this->BytesLabel->Name = L"BytesLabel";
    this->BytesLabel->Size =
System::Drawing::Size(52, 13);
    this->BytesLabel->TabIndex = 0;
    this->BytesLabel->Text = L"Байты: ";
    //  
    // KiloBytesLabel
    //  
    this->KiloBytesLabel->AutoSize = true;
    this->KiloBytesLabel->Font = (gcnew
System::Drawing::Font(L"<WBR>Microsoft Sans Serif", 8.25F,
System::Drawing::FontStyle::<WBR>Bold, System::Drawing::GraphicsUnit:<WBR>:Point,  
     static_cast<System::Byte>(204)<WBR>));
    this->KiloBytesLabel->Location =
System::Drawing::Point(19, 48);
    this->KiloBytesLabel->Name =
L"KiloBytesLabel";
    this->KiloBytesLabel->Size =
System::Drawing::Size(80, 13);
    this->KiloBytesLabel->TabIndex = 1;
    this->KiloBytesLabel->Text = L"Килобайты:
";
    //  
    // MegaBytesLabel
    //  
    this->MegaBytesLabel->AutoSize = true;
    this->MegaBytesLabel->Font = (gcnew
System::Drawing::Font(L"<WBR>Microsoft Sans Serif", 8.25F,
System::Drawing::FontStyle::<WBR>Bold, System::Drawing::GraphicsUnit:<WBR>:Point,  
     static_cast<System::Byte>(204)<WBR>));
    this->MegaBytesLabel->Location =
System::Drawing::Point(19, 78);
    this->MegaBytesLabel->Name =
L"MegaBytesLabel";
    this->MegaBytesLabel->Size =
System::Drawing::Size(81, 13);
    this->MegaBytesLabel->TabIndex = 2;
    this->MegaBytesLabel->Text = L"Мегабайты:
";
    //  
    // GigaBytesLabel
    //  
    this->GigaBytesLabel->AutoSize = true;
    this->GigaBytesLabel->Font = (gcnew
System::Drawing::Font(L"<WBR>Microsoft Sans Serif", 8.25F,
System::Drawing::FontStyle::<WBR>Bold, System::Drawing::GraphicsUnit:<WBR>:Point,  
     static_cast<System::Byte>(204)<WBR>));
    this->GigaBytesLabel->Location =
System::Drawing::Point(19, 109);
    this->GigaBytesLabel->Name =
L"GigaBytesLabel";
    this->GigaBytesLabel->Size =
System::Drawing::Size(78, 13);
    this->GigaBytesLabel->TabIndex = 3;
    this->GigaBytesLabel->Text = L"Гигабайты:
";
    //  
    // BytesSpinBox
    //  
    this->BytesSpinBox->Location =
System::Drawing::Point(150, 18);
    this->BytesSpinBox->Maximum =
System::Decimal(gcnew cli::array<System::Int32 >(4) {-1530494976, 232830,
0, 0});
    this->BytesSpinBox->Name =
L"BytesSpinBox";
    this->BytesSpinBox->Size =
System::Drawing::Size(120, 20);
    this->BytesSpinBox->TabIndex = 4;
    this->BytesSpinBox-><WBR>ValueChanged += gcnew
System::EventHandler(this, &TMainForm::BytesSpinBox_<WBR>ValueChanged);
    //  
    // KiloBytesSpinBox
    //  
    this->KiloBytesSpinBox-><WBR>DecimalPlaces = 2;
    this->KiloBytesSpinBox-><WBR>Location =
System::Drawing::Point(150, 48);
    this->KiloBytesSpinBox-><WBR>Maximum =
System::Decimal(gcnew cli::array<System::Int32 >(4) {1215752192, 23, 0,
0});
    this->KiloBytesSpinBox->Name =
L"KiloBytesSpinBox";
    this->KiloBytesSpinBox->Size =
System::Drawing::Size(120, 20);
    this->KiloBytesSpinBox-><WBR>TabIndex = 5;
    this->KiloBytesSpinBox-><WBR>ValueChanged += gcnew
System::EventHandler(this, &TMainForm::KiloBytesSpinBox_<WBR>ValueChanged);
    //  
    // MegaBytesSpinBox
    //  
    this->MegaBytesSpinBox-><WBR>DecimalPlaces = 3;
    this->MegaBytesSpinBox-><WBR>Location =
System::Drawing::Point(150, 78);
    this->MegaBytesSpinBox-><WBR>Maximum =
System::Decimal(gcnew cli::array<System::Int32 >(4) {100000000, 0, 0,
0});
    this->MegaBytesSpinBox->Name =
L"MegaBytesSpinBox";
    this->MegaBytesSpinBox->Size =
System::Drawing::Size(120, 20);
    this->MegaBytesSpinBox-><WBR>TabIndex = 6;
    this->MegaBytesSpinBox-><WBR>ValueChanged += gcnew
System::EventHandler(this, &TMainForm::MegaBytesSpinBox_<WBR>ValueChanged);
    //  
    // GigaBytesSpinBox
    //  
    this->GigaBytesSpinBox-><WBR>DecimalPlaces = 6;
    this->GigaBytesSpinBox-><WBR>Location =
System::Drawing::Point(150, 109);
    this->GigaBytesSpinBox-><WBR>Maximum =
System::Decimal(gcnew cli::array<System::Int32 >(4) {1000, 0, 0, 0});
    this->GigaBytesSpinBox->Name =
L"GigaBytesSpinBox";
    this->GigaBytesSpinBox->Size =
System::Drawing::Size(120, 20);
    this->GigaBytesSpinBox-><WBR>TabIndex = 7;
    this->GigaBytesSpinBox-><WBR>ValueChanged += gcnew
System::EventHandler(this, &TMainForm::GigaBytesSpinBox_<WBR>ValueChanged);
    //  
    // CalculateButton
    //  
    this->CalculateButton-><WBR>Location =
System::Drawing::Point(195, 168);
    this->CalculateButton->Name =
L"CalculateButton";
    this->CalculateButton->Size =
System::Drawing::Size(75, 23);
    this->CalculateButton-><WBR>TabIndex = 8;
    this->CalculateButton->Text =
L"Рассчитать";
    this->CalculateButton-><WBR>UseVisualStyleBackColor =
true;
    this->CalculateButton->Click += gcnew
System::EventHandler(this, &TMainForm::CalculateButton_<WBR>Click);
    //  
    // TMainForm
    //  
    this->AutoScaleDimensions =
System::Drawing::SizeF(6, 13);
    this->AutoScaleMode =
System::Windows::Forms::<WBR>AutoScaleMode::Font;
    this->ClientSize = System::Drawing::Size(292, 216);
    this->Controls->Add(this-><WBR>CalculateButton);
    this->Controls->Add(this-><WBR>GigaBytesSpinBox);
    this->Controls->Add(this-><WBR>MegaBytesSpinBox);
    this->Controls->Add(this-><WBR>KiloBytesSpinBox);
    this->Controls->Add(this-><WBR>BytesSpinBox);
    this->Controls->Add(this-><WBR>GigaBytesLabel);
    this->Controls->Add(this-><WBR>MegaBytesLabel);
    this->Controls->Add(this-><WBR>KiloBytesLabel);
    this->Controls->Add(this-><WBR>BytesLabel);
    this->Name = L"TMainForm";
    this->Text = L"Пересчёт";
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->BytesSpinBox))-><WBR>EndInit();
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->KiloBytesSpinBox))-><WBR>EndInit();
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->MegaBytesSpinBox))-><WBR>EndInit();
           
(cli::safe_cast<System::<WBR>ComponentModel::<WBR>ISupportInitialize^  
>(this->GigaBytesSpinBox))-><WBR>EndInit();
    this->ResumeLayout(false);
    this->PerformLayout();

   }
#pragma endregion
  private: System::Void BytesSpinBox_ValueChanged(<WBR>System::Object^  
sender, System::EventArgs^  e)  
     {
      bBytes = true;
      bKilobytes = false;
      bMegabytes = false;
      bGigabytes = false;
     }
private: System::Void KiloBytesSpinBox_ValueChanged(<WBR>System::Object^  sender,
System::EventArgs^  e)  
    {
     bBytes = false;
     bKilobytes = true;
     bMegabytes = false;
     bGigabytes = false;
    }
private: System::Void MegaBytesSpinBox_ValueChanged(<WBR>System::Object^  sender,
System::EventArgs^  e)  
    {
     bBytes = false;
     bKilobytes = false;
     bMegabytes = true;
     bGigabytes = false;
    }
private: System::Void GigaBytesSpinBox_ValueChanged(<WBR>System::Object^  sender,
System::EventArgs^  e)  
    {
     bBytes = false;
     bKilobytes = false;
     bMegabytes = false;
     bGigabytes = true;
    }
private: System::Void CalculateButton_Click(System::<WBR>Object^  sender,
System::EventArgs^  e)  
    {
     double dBytes =
Convert::ToDouble(<WBR>BytesSpinBox->Value);
     double dKiloBytes =
Convert::ToDouble(<WBR>KiloBytesSpinBox->Value);
     double dMegaBytes =
Convert::ToDouble(<WBR>MegaBytesSpinBox->Value);
     double dGigaBytes =
Convert::ToDouble(<WBR>GigaBytesSpinBox->Value);

     if(bBytes)
     {
      dKiloBytes = dBytes / 1024;
      dMegaBytes = dKiloBytes / 1024;
      dGigaBytes = dMegaBytes / 1024;
     }
     else if(bKilobytes)
     {
      dBytes = dKiloBytes * 1024;
      dMegaBytes = dKiloBytes / 1024;
      dGigaBytes = dMegaBytes / 1024;
     }
     else if(bMegabytes)
     {
      dKiloBytes = dMegaBytes * 1024;
      dBytes = dKiloBytes * 1024;
      dGigaBytes = dMegaBytes / 1024;
     }
     else if(bGigabytes)
     {
      dMegaBytes = dGigaBytes * 1024;
      dKiloBytes = dMegaBytes * 1024;
      dBytes = dKiloBytes * 1024;
     }

     BytesSpinBox->Value = Convert::ToDecimal(dBytes);
     KiloBytesSpinBox->Value =
Convert::ToDecimal(dKiloBytes)<WBR>;
     MegaBytesSpinBox->Value =
Convert::ToDecimal(dMegaBytes)<WBR>;
     GigaBytesSpinBox->Value =
Convert::ToDecimal(dGigaBytes)<WBR>;
    }
};
}

//
Если предыдущий символ - пробел (флаг равен 1), а текущий  - нет,
// (т.е.
начало нового слова), а слово начинается с буквы, то увеличиваем  
//
счётчик слов.
if(iSpacePrevious && !iSpaceCurrent &&
cCharacter == LETTER)
{
     iWordsCount++; // Увеличиваем счётчик
слов, если начало слова - искомая буква.
}

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
//----------------------------<WBR>------------------------------<WBR>------------------------------<WBR>-----
#define LETTER \'w\' // Буква
//----------------------------<WBR>------------------------------<WBR>------------------------------<WBR>-----
int iWordsCount = 0; // Счётчик слов
//----------------------------<WBR>------------------------------<WBR>------------------------------<WBR>-----
int iProcessFile(char* psFileName)
{
     char cCharacter; // Текущий символ.
      
     // Флаги состояния разделителей слов - пробелов.
     int iSpacePrevious;  
     int iSpaceCurrent = 1; // Предположим, что текущий символ - пробел
      
     // Открываем файл.
     FILE* pFile = fopen(psFileName, "r");
     // Если не смогли открыть файл - выходим.
     if(!pFile)  
     {
  printf("Невозможно открыть файл \'%s\'\n",
psFileName);
  return 1;
     }
     // Если файл пуст, выходим.
     else if(feof(pFile)) return 0;
     else
     {
  // Считываем символы из файла.
  // Достигнув конца файла - выходим.
  while((cCharacter = getc(pFile)) != EOF)  
  {
      // Запоминаем текущий флаг как предыдущий
      iSpacePrevious = iSpaceCurrent;
      // Проверяем, является ли текущий символ пробелом
      iSpaceCurrent = isspace(cCharacter);
      // Если предыдущий символ - пробел (флаг равен 1), а текущий  -
нет,
      // (т.е. начало нового слова), а слово начинается с буквы, то
увеличиваем  
    // счётчик слов.
      if(iSpacePrevious && !iSpaceCurrent && cCharacter
== LETTER)
    {
     iWordsCount++; // Увеличиваем счётчик слов,
если начало слова - искомая буква.
    }
  }
     }
     // Закрываем файл.
     fclose(pFile);
      
     return 0;
}
//----------------------------<WBR>------------------------------<WBR>------------------------------<WBR>-----
int main(int iArgc, char* psArgv[])
{
     if(iArgc <2) printf("Использование программы: wc [FILE]\n");
     else if(iArgc > 2) printf("Слишком много аргументов!\n");
     else  
     {
  if(iProcessFile(psArgv[1]) == 0)
  {
      printf("Файл \"%s\" содержит %i слов, начинающихся с
буквы \"w\".\n", psArgv[1], iWordsCount);
  }
     }
     return 0;
}

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

#define CLASSNAME "class"
#define WIDTH 335
#define HEIGHT 230

#define IDC_SA    101
#define IDC_SB    102
#define IDC_SZ    103
#define IDC_SR    104
#define IDC_EA    105
#define IDC_EB    106
#define IDC_EZ    107
#define IDC_ER    108
#define IDC_BR    109
#define IDC_BC    110
#define IDC_BE    111

void func1 (int a, int b, char znak, char * pStr)  
{  
  float c;
  switch (znak)
  {
   case \'+\':
    c = (float)a + (float)b;
    break;
   case \'-\':
    c = (float)a - (float)b;
    break;
   case \'*\':
    c = (float)a * (float)b;
    break;
   case \'/\':
    if (b)             
//проверим допустимость операции деления
     c = (float)a / (float)b;
    else
    {
     lstrcpy(pStr, "Деление на 0");
     return;
    }
    break;
   default:      //на
всякий случай
    lstrcpy(pStr, "Недопустимая операция");
    return;
  }
  sprintf(pStr, "%.2f", c);    //сформируем строку ответа
}

//Процедура окна
long __stdcall wp (HWND hw, unsigned ms, unsigned wp, long lp)  
{
  static HWND hwStatica, hwStaticb,  
     hwStaticznak, hwStaticr,  
     hwEdita, hwEditb, hwEditznak, hwEditr,
     hwButtonOK, hwButtonClear, hwButtonQuit;
  char  *sResult, *sa, *sb, *sz;
  int   la,lb,lz,ia,ib;

  switch (ms)  
  {
   case WM_CTLCOLORSTATIC:
    return (long)GetStockObject(WHITE_<WBR>BRUSH);
   
   case WM_GETMINMAXINFO:
    ((MINMAXINFO*)lp)-><WBR>ptMinTrackSize.x = WIDTH;
    ((MINMAXINFO*)lp)-><WBR>ptMinTrackSize.y = HEIGHT;
    ((MINMAXINFO*)lp)-><WBR>ptMaxTrackSize.x = WIDTH;
    ((MINMAXINFO*)lp)-><WBR>ptMaxTrackSize.y = HEIGHT;
    return 0;

   case WM_CREATE:
    hwStatica = CreateWindowEx(0, "STATIC",
"Введите число а :", WS_CHILD | WS_VISIBLE | SS_LEFT,  
     10, 10, 200, 20, hw, (HMENU)IDC_SA,
GetModuleHandle(0), 0);

    hwStaticb = CreateWindowEx(0, "STATIC",
"Введите число b :", WS_CHILD | WS_VISIBLE | SS_LEFT,  
     10, 40, 200, 20, hw, (HMENU)IDC_SB,
GetModuleHandle(0), 0);

    hwStaticznak = CreateWindowEx(0, "STATIC",
"Введите знак операции :", WS_CHILD | WS_VISIBLE | SS_LEFT,  
     10, 70, 200, 25, hw, (HMENU)IDC_SZ,
GetModuleHandle(0), 0);

    hwEdita = CreateWindowEx(0, "EDIT",
"", WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP,
     215, 10, 100, 25, hw, (HMENU)IDC_EA,
GetModuleHandle(0), 0);
    SendMessage(hwEdita, EM_LIMITTEXT, 9,0);         
                  
    //длины 9 знаков

    hwEditb = CreateWindowEx(0, "EDIT",
"", WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP,
     215, 40, 100, 25, hw, (HMENU)IDC_EB,
GetModuleHandle(0), 0);
    SendMessage(hwEditb, EM_LIMITTEXT, 9,0);         
                  
    //длины 9 знаков

    hwEditznak = CreateWindowEx(0, "EDIT",
"", WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP,  
     215, 70, 100, 25, hw, (HMENU)IDC_EZ,
GetModuleHandle(0), 0);
    SendMessage(hwEditznak, EM_LIMITTEXT, 1,0);         
                  
    //длины 1 знак

    hwButtonOK = CreateWindowEx(0, "BUTTON",
"Рассчитать", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,  
     10, 100, 100, 20, hw, (HMENU)IDC_BR,
GetModuleHandle(0), 0);

    hwButtonClear = CreateWindowEx(0, "BUTTON",
"Очистить", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,  
     115, 100, 95, 20, hw, (HMENU)IDC_BC,
GetModuleHandle(0), 0);

    hwButtonQuit = CreateWindowEx(0, "BUTTON",
"Выход", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,  
     220, 100, 95, 20, hw, (HMENU)IDC_BE,
GetModuleHandle(0), 0);

    hwStaticr = CreateWindowEx(0, "STATIC",
"Результат:", WS_CHILD | WS_VISIBLE | SS_LEFT,  
     110, 130, 100, 20, hw, (HMENU)IDC_SR,
GetModuleHandle(0), 0);

    hwEditr = CreateWindowEx(0, "EDIT",
"", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_READONLY,  
     10, 150, 300, 25, hw, (HMENU)IDC_ER,
GetModuleHandle(0), 0);
    return 0;

  case WM_DESTROY:
   PostQuitMessage(0);
   return 0;
   
  case WM_COMMAND:
   switch (wp >> 16)
   {
    case BN_CLICKED:
     switch ((WORD)wp)
     {
      case IDC_BR:
       la =
GetWindowTextLength(hwEdita);    //проверим наличие поля a
       if (la == 0)  
       {
               
SetWindowText(hwEditr," Введите число а !");
        return 0;
       }

       lb =
GetWindowTextLength(hwEditb);    //проверим наличие поля b
       if (lb == 0)  
       {
               
SetWindowText(hwEditr," Введите число b !");
        return 0;
       }

       lz =
GetWindowTextLength(<WBR>hwEditznak);//проверим наличие поля знака
       if (lz == 0)  
       {
               
SetWindowText(hwEditr," Введите знак операции (+, -, *, /) !");
        return 0;
       }
       //запросим значение кода
операции
       sz = new char [lz + 1];
       GetWindowText(hwEditznak, sz,
lz + 1);   
       
       //запрашиваем числа
       sa = new char [la + 1];
       GetWindowText(hwEdita, sa, la +
1);

       sb = new char [lb + 1];
       GetWindowText(hwEditb, sb, lb +
1);

       //преобразовываем
       ia = atoi(sa);
       ib = atoi(sb);

       //считаем и выводим
       sResult = new char [256];
       func1(ia, ib, sz[0], sResult);
       SetWindowText(hwEditr,
sResult);
      
       //удаляем строки
       delete [] sResult;
       delete [] sa;
       delete [] sb;
       delete [] sz;
       break;

      case IDC_BC:           
//чистим
       SetWindowText(hwEdita,
"");
       SetWindowText(hwEditb,
"");
      SetWindowText(hwEditznak,
"");
       SetWindowText(hwEditr,
"");
       break;

      case IDC_BE:
       PostQuitMessage(0);
     }
     break;
     
    case EN_CHANGE:             
  //проверим коректность полей по изменению
     la = GetWindowTextLength((HWND)lp);     
//проверим цифровое поле
     sa = new char [la + 1];
     GetWindowText((HWND)lp, sa, la + 1);//считаем
     switch ((WORD)wp)
     {
      case IDC_EA:           
  //для a и b
      case IDC_EB:
       lz = 1;           
   //признак корректности
       for (lb=0; lb<la; lb++)      
  //пробежимся по всей строке
       {
        switch(sa[lb])
        {
         case
\'+\':
         case
\'-\':
          lz
&= (lb == 0);//корректны только в начале строки
          break;
         default:
          lz
&= ((sa[lb]>=\'0\') && (sa[lb]<=\'9\'));
//остальые должны быть только цифрами
        }
        if (!lz)    //если
что-то не то, то удаляем введенный символ
        {
         for (;
lb<la; lb++)
          sa[lb]
= sa[lb+1];
                
SetWindowText((HWND)lp, sa);    //засылаем в edit
                
SendMessage((HWND)lp, EM_SETSEL, lb-1, lb-1) ;//курсор в конец строки
        }
       }
       break;
       
      case IDC_EZ:           
  //для знака
       switch(sa[0])
       {
        case \'+\':
        case \'-\':
        case \'*\':
        case \'/\':
         break;         
   //все ок
        default:
                
SetWindowText((HWND)lp, ""); //вытрем
       }
     }
     delete [] sa;    //удалим буфер
   }
   return 0;
   // fall through to default
  default:
   return DefWindowProc(hw, ms, wp, lp);
  }
}

int __stdcall WinMain (HINSTANCE hinst, HINSTANCE, char*, int) {
   
  WNDCLASSEX wcx = {
   sizeof(WNDCLASSEX),
   0,
   wp,
   0,
   0,
   hinst,
   LoadIcon(0, IDI_APPLICATION),
   LoadCursor(0, IDC_ARROW),
   (HBRUSH)GetStockObject(WHITE_<WBR>BRUSH),
   0,
   CLASSNAME,
   LoadIcon(0, IDI_APPLICATION)
  };
  RegisterClassEx(&wcx);

  HWND hwMain = CreateWindowEx(
   WS_EX_OVERLAPPEDWINDOW,
   CLASSNAME,
   "lab",
   (WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN) & ~WS_MAXIMIZEBOX,
   CW_USEDEFAULT,
   CW_USEDEFAULT,
   WIDTH,
   HEIGHT,
   0,
   0,
   hinst,
   0
  );
  if (hwMain) {
   ShowWindow(hwMain, SW_SHOW);
   MSG mes;
   while (GetMessage(&mes, 0, 0, 0) > 0) {
    if (!IsDialogMessage(hwMain, &mes)) {
     TranslateMessage(&mes);
     DispatchMessage(&mes);
    }
   }
  }
  ExitProcess(0);
  return 0;
}

/*Задать функцию fun1 c параметрами a,b(integer) и znak(char).В качестве
параметров - два числа (a,b) и знак (znak) арифметической операции
(*,/,-,+).Функция fun1 выводит выражение результатов(float).При попытке ввода
числа или знака несоответствующего типа вывод на экран сообщения об ошибке.*/

#include
<iostream>
#include <string>
#include <cstdlib>

using namespace std;

string getFileName(const char* const
path)
{
   char name[_MAX_FNAME];
     char ext[_MAX_EXT];
#pragma warning(disable:4996)
   _splitpath(path,0,0,name,ext);
    
  return string(name)+string(ext);
}

int main(int argc,char**
argv)
{
   cout<<getFileName(argv[0])<<endl;

    
     system("PAUSE");
      return 0;
}

#include
"stdio.h"
#include "stdlib.h"
#include
"string.h"

size_t getFileName(const char* const path,char*
fileName)
{
  char name[_MAX_FNAME]={0};
         char
ext[_MAX_EXT]={0};
    size_t len;
#pragma warning(disable:4996)

    _splitpath(path,0,0,name,ext);
     len=strlen(name)+strlen(ext);
   
    if(fileName)
     {
     strcpy(fileName,name);
          
    strcat(fileName,ext);
     }
  return len;
}

int
main(int argc,char** argv)
{
        size_t
len=getFileName(argv[0],0);
   char* name=(char*)malloc(len+1);

  getFileName(argv[0],name);
   printf("%s\n",name);
    
  free(name);

  system("PAUSE");
   return 0;
}

#include
<iostream>
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <iomanip>

using
namespace std;

// Размерность массива
const size_t Dim=20;
// Максимальное значение для авто-генерации
const double
MaxValue=50.0;

// Заполняет массив случайными числами
template<size_t Dim>
void fillArray(double (&array)[Dim])
{
    for(size_t i=0;i<Dim;++i)
      {
      // Разбавим
нулевыми элементами, чтоб можно было отсортировать согласно условия
        
     
array[i]=rand()%5?(static_cast<double>(rand())/RAND_MAX-0.5)*MaxValue*2.0:0.0;
  }
}

// Выводит массив
template<class Elem,class
Traits,size_t Dim>
basic_ostream<Elem,Traits>&
operator<<(basic_ostream<Elem,Traits>& stream,const double
(&array)[Dim])
{
      const ctype<Elem>&
facet=use_facet<ctype<Elem> >(stream.getloc());
   Elem
comma=facet.widen(',');
     streamsize width=stream.width();
   streamsize precision=stream.precision();
   for(size_t
i=0;i<Dim;++i)
       {
       stream.width(width);
          
      stream.precision(precision);
        
stream<<array[i]<<(i<Dim-1?comma:facet.widen(' '));
    }
  return stream;
}

// Ищет сумму по условию
template<size_t Dim>
double sum(const double (&array)[Dim])
{
   double result=0.0;
     // Указатели на начало и конец

    const double* begin=array;
     const double* end=array+Dim;
    
    // Пропустим не положительные от начала
    while(begin<end
&& *begin<=0.0)
      {
       ++begin;
   }
  //
Пропустим не положительные от конца
     while(begin<--end &&
*end<=0.0);
  // Суммируем
  if(begin<end)
  {

  while(++begin<end)
   {
           
result+=*begin;
   }
  }
  return result;
}

// Ф-я предикат для сортировки
bool sortPredicate(const double&
left,const double& right)
{
     return left==0 &&
right!=0;
}

int main()
{
    
setlocale(LC_ALL,"russian_russia");
      
srand(static_cast<unsigned int>(time(0)));

  // Наш
массив
   double array[Dim];

   // Заполним массив
        
  fillArray(array);

   // Выведем его
   
cout<<"Исходный массив:"<<endl
          
<<array<<endl;

  // Ищем минимальный элемент  
   
double* minItem=min_element(array,array+Dim);
      
cout<<endl<<"Минимальный элемент
["<<minItem-array<<"]="<<*minItem<<endl;

    // Сумма между первым и последним положительным
    
cout<<endl<<"Сумма между первым и последним
положительным:"<<sum(array)<<endl;

     // Сортируем
согласно условия
     sort(array,array+Dim,sortPredicate);

      
    // Выводим, что получилось
     cout<<endl<<"Массив
после сортировки:"<<endl
     
<<array<<endl;

  system("PAUSE");
         
return 0;
}

#include
<iostream>
#include <iomanip>
#include <locale>
#include <cmath>
#include <cstdlib>

using
namespace std;

// Заполняет матрицу случайными числами
template<size_t _dim1,size_t _dim2>
void generateMatrix(int
(&matrix)[_dim1][_dim2])
{
       for(size_t i=0;i<_dim1;++i)
      {
         for(size_t j=0;j<_dim2;++j)
         {
      
         matrix[i][j]=rand()%50;
         }
   }
}

// Оператор вывода для матрицы
template<class _Elem,class
_Traits,size_t _dim1,size_t _dim2>
basic_ostream<_Elem,_Traits>&
operator<<(basic_ostream<_Elem,_Traits>& stream,int
(&matrix)[_dim1][_dim2])
{
    streamsize width=stream.width();
    for(size_t i=0;i<_dim1;++i)
      {
       for(size_t
j=0;j<_dim2;++j)
        {
          
stream<<setw(width)<<matrix[i][j]<<' ';
            
}
    stream<<endl;
   }
   return stream;
}

// Решение задачи здесь
template<size_t _dim1,size_t
_dim2>
void solve(int (&matrix)[_dim1][_dim2])
{
     //
Строка в которую будем переносить упорядоченную строку
   size_t to=0;

       for(size_t i=0;i<_dim1;++i)
      {
        // Флаг. Если
упорядочена по возрастанию.
     bool ascending=true;
            
    // Проверяем на упорядоченность
      for(size_t j=1;j<_dim2
&& ascending;++j)
          {
          // Строго
по возрастанию. Если надо по не убыванию сделайте <=
           
ascending=matrix[i][j-1]<matrix[i][j];
    }
    // Если
упорядочена
    if(ascending)
    {
            
   // Индекс строки которую переносим
     size_t
from=i;
      // Перенос осуществляется постепенным сдвигом
строки вверх,   
       // не нарушая порядок остальных
строк
     // Пока не переместили куда надо
            
   while(from!=to)
     {
              
// Сдвигаем вверх
      for(size_t
j=0;j<_dim2;++j)
          {
             
        swap(matrix[from][j],matrix[from-1][j]);
             
       }
          --from;
         }
       
        // Строка перемещена, значит в следующий раз перемещать будем на
строку ниже
           ++to;
          }
   }
}

int main()
{
      srand(static_cast<unsigned
int>(time(0)));
    setlocale(LC_ALL,"russian");
     //
Матрица
        int matrix[5][3];
   // Заполняем
         
generateMatrix(matrix);
   // Выводим
           
cout<<"Исходная
матрица:"<<endl<<setw(4)<<matrix<<endl;
     //
Решаем задачу
    solve(matrix);
      // Выводим результат
         
cout<<"Результат:"<<endl<<setw(4)<<matrix<<endl;
    system("PAUSE");
       return 0;
}

#include <stdio.h>
#include <stdlib.h>

/* Элементы матрицы могут быть любого типа. Указываем тип. */
#define item_type float
/* Число строк и столбцов. Можно сделать ввод через аргументы или запросить...
*/
size_t rows=10;
size_t cols=3;

/* Заполняет матрицу случайными числами */

item_type ** generateMatrix(size_t dim0, size_t dim1, item_type (create)())
{
  item_type ** matrix;
  matrix=calloc(dim0,sizeof(<WBR>item_type *));
  /* Памяти может не хватить */
  if(matrix==NULL)return NULL;
  size_t i=0;
  for(i=0;i<dim0;++i)
  {
   matrix[i]=calloc(dim1,sizeof(<WBR>item_type));
   /* Памяти может не хватить */
   if(matrix[i]==NULL)
   {
    size_t j=0;
    for(j=0;j<i;++j)
     free(matrix[j]);
    free(matrix);
    return NULL;
   };
   size_t j=0;
   for(j=0;j<dim1;++j)
   {
    matrix[i][j]=create();
   };
  };
  return matrix;
};

/* Функция вывода для матрицы */
void printMatrix(item_type **matrix, size_t dim0, size_t dim1,void
(print)(item_type))
{
  size_t i=0;
  for(i=0;i<dim0;++i)
  {
   size_t j=0;
   for(j=0;j<dim1;++j)
   {
    print(matrix[i][j]);
   };
   printf("\n");
  };
};

/* Решение задачи */
item_type ** solve(item_type ** matrix, size_t dim0, size_t dim1, int
(compare)(item_type,item_type)<WBR>)
{
  item_type ** new_matrix;
  new_matrix=calloc(dim0,sizeof(<WBR>item_type *));
  if(new_matrix==NULL)return NULL;
  item_type ** head_ptr=new_matrix;
  item_type ** tail_ptr=&new_matrix[dim0-1];
   
  /* помещаем в начало упорядоченные строки */
  size_t i=0;
  for(i=0;i<dim0;++i)
  {
   /* Флаг. Если упорядочена по возрастанию.*/
   int ascending=1;
   /* Проверяем на упорядоченность */
   size_t j=0;
   for(j=1;j<dim1 && ascending;++j)
   {
    /* Строго по возрастанию. Если надо по не убыванию
сделайте <= */
    ascending=compare(matrix[i][j-<WBR>1],matrix[i][j])<0;
   };
   /* Если упорядочена */
   if(ascending)
   {
    /* помещаем в начало результирующего массива */
    *head_ptr=matrix[i];
    ++head_ptr;
   }else{
    /* иначе в конец */
    *tail_ptr=matrix[i];
    --tail_ptr;
   };
  };
  return new_matrix;
};

/* Вспомогательные функции, зависящие от типа элемента*/
/* Сравнение элементов */
int item_compare(item_type a,item_type b)
{
  if(a<b)return -1;
  if(a>b)return 1;
  return 0;
};

/* Создание элемента */
item_type item_create()
{
  return (float)(rand()%10000)/100;
};

/* Вывод элемента */
void item_print(item_type item)
{
  printf("%6.2f ",item);
};

int main()
{
  srand((int)time(0));
  /* Матрица */
  item_type ** matrix;
  /* Заполняем */
  matrix=generateMatrix(rows,<WBR>cols,item_create);
  if(matrix==NULL)
  {
   fprintf(stderr,"Ошибка: не хватило памяти для заполнения
матрицы\n");
   return 1;
  };
  /* Решаем задачу */
  item_type ** solved=solve(matrix,rows,cols,<WBR>item_compare);
  if(solved==NULL)
  {
   fprintf(stderr,"Ошибка: не хватило памяти для
отсортированного массива\n");
   return 1;
  };
  /* Выводим исходныю матрицу и результат */
  printf("Исходная матрица размером %d x %d\n",rows,cols);
  printMatrix(matrix,rows,cols,<WBR>item_print);
  printf("Полученная матрица размером %d x %d\n",rows,cols);
  printMatrix(solved,rows,cols,<WBR>item_print);
  return 0;
};

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <time.h>

#define MAX_WORD_LEN 1024

char * dig2char[10];
char char2dig[256];

void fill_en()
{
  dig2char[0]=" 0";
  dig2char[1]=".,?!\'\"1()@/:-";
  dig2char[2]="abc2";
  dig2char[3]="def3";
  dig2char[4]="ghi4";
  dig2char[5]="jkl5";
  dig2char[6]="mno6";
  dig2char[7]="pqrs7";
  dig2char[8]="tuv8";
  dig2char[9]="wxyz9";
  int k;
  for(k=0;k<256;k++)
  {
   char2dig[k]=-1;
  };
  int t,l;
  for(k=0;k<10;k++)
  {
   l=strlen(dig2char[k]);
   for(t=0;t<l;t++)
   {
    char2dig[dig2char[k][t]]=k;
   };
  };
};

struct dict_word
{
  struct dict_word * next;
  char * word;
};

struct dict_node
{
  int word_count;
  struct dict_word * words;
  struct dict_node * next[10];
};

add_to_dict(struct dict_node ** dict,char *str)
{
  char * pc=str;
  int ln=strlen(str);
  char * pe=str+ln;
  struct dict_node *pd;
  if(ln>0 && *dict == NULL)
  {
   *dict = calloc(1,sizeof(struct dict_node));
  };
  pd=*dict;
  while(pc<pe)
  {
   if(pd->next[char2dig[*pc]] == NULL)
    pd->next[char2dig[*pc]]=<WBR>calloc(1,sizeof(struct
dict_node));
   pd=pd->next[char2dig[*pc]];
   pc++;
  };
  struct dict_word * new_word;
  if(pd->words==NULL)
   new_word=pd->words=calloc(1,<WBR>sizeof(struct dict_word));
  else{
   new_word=pd->words;
   while(new_word->next != NULL)
    if(strcmp(new_word->word,str)=<WBR>=0)return;
    else new_word=new_word->next;
   new_word->next=calloc(1,<WBR>sizeof(struct dict_word));
   new_word=new_word->next;
  };
  new_word->word=calloc(1,ln+1);
  strcpy(new_word->word,str);
  pd->word_count++;
};

void save_dictionary_fd(struct dict_node * dict,FILE * fd)
{
  if(dict==NULL)return;
  struct dict_word * word=dict->words;
  while(word != NULL)
  {
   fprintf(fd,"%s\n",word->word);
   word=word->next;
  };
  int k;
  for(k=0;k<10;k++)save_<WBR>dictionary_fd(dict->next[k],<WBR>fd);
};

int save_dictionary(struct dict_node * dict,char *file_name)
{
  FILE * fd=fopen(file_name,"w");
  if(fd==NULL)return -1;
  save_dictionary_fd(dict,fd);
  fclose(fd);
  return 0;
};

struct dict_node * load_dictionary(char *file_name)
{
  struct dict_node * tmp=NULL;
  char buffer[MAX_WORD_LEN];
  FILE * fd=fopen(file_name,"r");
  if(fd==NULL)return NULL;
   
  while(fscanf(fd,"%s",&buffer)=<WBR>=1)
  {
   add_to_dict(& tmp,&buffer[0]);
   memset(&buffer,0,sizeof(<WBR>buffer));
  };
  fclose(fd);
  return tmp;
};

struct dict_node * find_dict_node(struct dict_node * dict,char * seq)
{
  struct dict_node *pd=dict;
  if(pd==NULL)return NULL;
  char *pc=seq;
  char *pe=seq+strlen(seq);
  while(pc<pe && pd != NULL)
  {
   pd=pd->next[*pc -\'0\'];
   pc++;
  };
  return pd;
};

struct dict_word * any_word(struct dict_node * dict)
{
  struct dict_node *pd=dict;
  if(pd==NULL)return NULL;
  if(pd->words != NULL)return pd->words;
  int k;
  struct dict_word *tmp=NULL;
  for(k=0;k<10;k++)
   if(pd->next[k]!=NULL)
    if((tmp=any_word(pd->next[k])) != NULL)return tmp;
  return NULL;
   
};

struct dict_word * find_part_word(struct dict_node * dict,char * seq)
{
  struct dict_node *pd=dict;
  if(pd==NULL)return NULL;
  char *pc=seq;
  char *pe=seq+strlen(seq);
  while(pc<pe && pd != NULL)
  {
   pd=pd->next[*pc -\'0\'];
   pc++;
  };
  if(pd==NULL)return NULL;
  return pd->words;
};

void cleanline(struct dict_word *ls,char*add)
{
  int len=0;
  struct dict_word *lp=ls;
  while(lp != NULL)
  {
   len+=strlen(lp->word);
   lp=lp->next;
  };
  if(len<12)len=12;
  len+=strlen(add);
  char * buf=calloc(1,len+1);
  memset(buf,32,len);
  fprintf(stderr,"\r%s",buf);
  free(buf);
};

summary()
{
  fprintf(stderr,"T9 like input demo.\n");
  fprintf(stderr,"\n");
  fprintf(stderr,"2-9  - input letters using dictionary.\n");
  fprintf(stderr,"1   - input symbols/submit word.\n");
  fprintf(stderr,"0   - input space/submit word.\n");
  fprintf(stderr,"*   - search dictionary for entered sequence of
digits.\n");
  fprintf(stderr,".   - delete last char (does not work for
submitted words/spaces/symbols for now.\n");
  fprintf(stderr,"\n");
  fprintf(stderr,"If sequence has no valid dictionary match input
mode will switch to cycle-through-letter-with-<WBR>delay.\n");
  fprintf(stderr,"This will be indicated with \"by
letters\" prompt.\n");
  fprintf(stderr,"0-9  - input letters/digits/symbols.\n");
  fprintf(stderr,"*   - submit and store new word in
dictionary/return if empty.\n");
  fprintf(stderr,".   - delete last char.\n");
  fprintf(stderr,"Delay is around 1-2 seconds. Then the same digit
will advance to next letter.\n");
  fprintf(stderr,"\n");
  fprintf(stderr,"Hit Enter to quit.\n");
   
   

};

int main()
{
  summary();
  char buf,indx;
  char word[MAX_WORD_LEN];
  struct dict_word * word_list=NULL;
  struct dict_word * word_last=NULL;
  char *current=&word[0];
  char t9buffer[MAX_WORD_LEN];
  char *pt9=&t9buffer[0];
  char *dict_file="dict";
  int k;
  for(k=0;k<sizeof(word);k++)<WBR>word[k]=0;
  for(k=0;k<sizeof(word);k++)<WBR>t9buffer[k]=0;
  fill_en();
  struct dict_node * dict=load_dictionary(dict_<WBR>file);
  fprintf(stderr,"\n");
  /*set up terminal*/
  struct termios term,old;
  tcgetattr(fileno(stdin),&term)<WBR>;
  tcgetattr(fileno(stdin),&old);
   
  term.c_lflag &= ~ICANON;
  term.c_lflag &= ~ECHO;
  tcsetattr(fileno(stdin),0,&<WBR>term);
   
  /*timing*/
  time_t prev,now,in_delay;
  prev=time(NULL);
  now=prev;
   
  struct dict_word * found_word=NULL;
  struct dict_node *dn=NULL;
  int started=0;
  int mode=1;
  int symbols=0;
  while(1)
  {
   //buf=fgetc(stdin);read(stdin,<WBR>&buf,1);
   buf=getchar();
   now=time(NULL);
   in_delay=now-prev;
   if(!started)in_delay=0;
   prev=now;
    
   if(mode==0 || mode==2)//raw
   {
    started=1;
    if(buf>=\'0\' &&
buf<=\'9\')
    {
      
     indx=buf-\'0\';
     if(in_delay>=2)current++;
     if(char2dig[*current]!=indx &&
*current!=0)current++;
     if(*current==0)
      *current=dig2char[indx][0];
     else
     {
      int k,l;
      l=strlen(dig2char[indx]);
      for(k=0;k<l;k++)
      {
       if(dig2char[indx][k]==*current
&& k+1<l)
       {
               
*current=dig2char[indx][k+1];
        break;
       };
       if(dig2char[indx][k]==*current
&& k+1==l)
       {
               
*current=dig2char[indx][0];
        break;
       };
      }
     };
     if(mode==2 && indx==0) *current =
\'0\';
     if(mode==2 && indx==1) *current =
\'1\';
    };
    if(buf==127 || buf==8 || buf==\'.\')
    {
     if(*current != 0)
     {
      *current=0;
      if(current > &word[0])
      {
       current--;
       prev-=2;
      }else started=0;
     };
     fprintf(stderr,"\033[1D ");
     //fprintf(stderr,"\r          
        ");
    };
    if(mode==2 && buf==\'*\')
    {
     /*finish editing*/
     if(strlen(word)>0)
     {
      if(word_list==NULL)
      {
              
word_list=calloc(1,sizeof(<WBR>struct dict_word));
       word_last=word_list;
      }else{
              
word_last->next=calloc(1,<WBR>sizeof(struct dict_word));
       word_last=word_last->next;
      };
             
word_last->word=calloc(1,<WBR>strlen(word)+1);
             
strcpy(word_last->word,&word[<WBR>0]);
             
add_to_dict(&dict,word_last-><WBR>word);
      save_dictionary(dict,dict_<WBR>file);
     };
     cleanline(word_list,&word[0]);
     for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
     for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
     found_word=NULL;
     dn=NULL;
     pt9=&t9buffer[0];
     current=&word[0];
     mode=1;
     buf=0;
    };
   };
    
   if(mode==1)//dict
   {
    started=0;
    int changed=0;
    if(buf==\'0\')
    {
     //finish word if not possible or switch to 2
     if(symbols)
     {
      if(word_list==NULL)
      {
              
word_list=calloc(1,sizeof(<WBR>struct dict_word));
       word_last=word_list;
      }else{
              
word_last->next=calloc(1,<WBR>sizeof(struct dict_word));
       word_last=word_last->next;
      };
      word_last->word=calloc(1,2);
             
strcpy(word_last->word,&word[<WBR>0]);
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
      found_word=NULL;
      dn=NULL;
      pt9=&t9buffer[0];
      symbols=0;
     }else{
      if(dn == NULL)
      {
       if(strlen(t9buffer)>0)
       {
               
cleanline(word_list,&word[0]);
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
        found_word=NULL;
        dn=NULL;
        pt9=&t9buffer[0];
        current=&word[0];
        mode=2;
       };
      }else{
       if(word_list==NULL)
       {
               
word_list=calloc(1,sizeof(<WBR>struct dict_word));
        word_last=word_list;
       }else{
               
word_last->next=calloc(1,<WBR>sizeof(struct dict_word));
               
word_last=word_last->next;
       };
        
       if(dn->words != NULL)
       {
               
word_last->word=found_word-><WBR>word;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
        found_word=NULL;
        dn=NULL;
        pt9=&t9buffer[0];
       }else{
        //submit partial word,
add to dict
               
word_last->word=calloc(1,<WBR>strlen(t9buffer)+1);
               
strcpy(word_last->word,&word[<WBR>0]);
               
add_to_dict(&dict,word_last-><WBR>word);
               
save_dictionary(dict,dict_<WBR>file);
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
        found_word=NULL;
        dn=NULL;
        pt9=&t9buffer[0];
       };
      };
     };
     if(mode==1)
     {
      //add space
             
word_last->next=calloc(1,<WBR>sizeof(struct dict_word));
      word_last=word_last->next;
      word_last->word=" ";
     };
    };
    if(buf==\'1\')
    {
     if(symbols)
     {
      int k,l;
      l=strlen(dig2char[1]);
      for(k=0;k<l;k++)
      {
       if(dig2char[1][k]==*current
&& k+1<l)
       {
               
*current=dig2char[1][k+1];
               
if(*current==\'1\')*current=<WBR>dig2char[1][k+2];
        break;
       };
       if(dig2char[1][k]==*current
&& k+1==l)
       {
               
*current=dig2char[1][0];
        break;
       };
      };
      changed=1;
     }else{
      symbols=1;
      if(dn == NULL)
      {
       if(strlen(t9buffer)>0)
       {
               
cleanline(word_list,&word[0]);
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
        found_word=NULL;
        dn=NULL;
        pt9=&t9buffer[0];
        current=&word[0];
        mode=2;
       };
      }else{
       if(word_list==NULL)
       {
               
word_list=calloc(1,sizeof(<WBR>struct dict_word));
        word_last=word_list;
       }else{
               
word_last->next=calloc(1,<WBR>sizeof(struct dict_word));
               
word_last=word_last->next;
       };
       if(dn->words != NULL)
       {
               
word_last->word=found_word-><WBR>word;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
        found_word=NULL;
        dn=NULL;
        pt9=&t9buffer[0];
       }else{
        //submit partial word,
add to dict
               
word_last->word=calloc(1,<WBR>strlen(t9buffer)+1);
               
strcpy(word_last->word,&word[<WBR>0]);
               
add_to_dict(&dict,word_last-><WBR>word);
               
save_dictionary(dict,dict_<WBR>file);
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
               
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
        found_word=NULL;
        dn=NULL;
        pt9=&t9buffer[0];
       };
      };
      if(mode==1)
      {
       word[0]=dig2char[1][0];
      };
     };
    };
    if(buf>=\'2\' &&
buf<=\'9\')
    {
     if(symbols)
     {
      if(word_list==NULL)
      {
              
word_list=calloc(1,sizeof(<WBR>struct dict_word));
       word_last=word_list;
      }else{
              
word_last->next=calloc(1,<WBR>sizeof(struct dict_word));
       word_last=word_last->next;
      };
      word_last->word=calloc(1,2);
             
strcpy(word_last->word,&word[<WBR>0]);
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
      found_word=NULL;
      dn=NULL;
      pt9=&t9buffer[0];
      symbols=0;
     };
     *pt9=buf;
     pt9++;
     changed=1;
    };
    if(buf==\'*\' && !symbols)
    {
            
if(found_word!=NULL)found_<WBR>word=found_word->next;
     if(found_word==NULL)
     {
      cleanline(word_list,&word[0]);
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
      found_word=NULL;
      dn=NULL;
      pt9=&t9buffer[0];
      current=&word[0];
      mode=2;
     };
    };
    if(buf==127 || buf==8 || buf==\'.\')
    {
     if(pt9 > &t9buffer[0])pt9--;
     *pt9=0;
     for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
     fprintf(stderr,"%c ",127);
     changed=1;
     symbols=0;
    };
    if(changed)
    {
     changed=0;
     dn=find_dict_node(dict,&<WBR>t9buffer[0]);
     if(dn==NULL)
     {
      cleanline(word_list,&word[0]);
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
      found_word=NULL;
      dn=NULL;
      pt9=&t9buffer[0];
      current=&word[0];
      mode=2;
     }else{
      if(dn->words==NULL)
      {
       found_word=any_word(dn);
      }else{
       found_word=dn->words;
      };
     };
     if(found_word==NULL)
     {
      cleanline(word_list,&word[0]);
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>word[k]=0;
             
for(k=0;k<MAX_WORD_LEN;k++)<WBR>t9buffer[k]=0;
      pt9=&t9buffer[0];
      current=&word[0];
      mode=2;
     };
    };
    if(found_word != NULL)
    {
            
strncpy(&word[0],found_word-><WBR>word,strlen(&t9buffer[0]));
    };
   };
    
   if(buf==10)
   {
    tcsetattr(fileno(stdin),0,&<WBR>old);
    fprintf(stderr,"\n");
    exit(0);
   };
   fprintf(stderr,"\r");
   if(mode==2)fprintf(stderr,"by letters :");
   else  
   if(word_list != NULL)
   {
    struct dict_word * tmp=word_list;
    while(tmp != NULL)
    {
     fprintf(stderr,"%s",tmp->word)<WBR>;
     tmp=tmp->next;
    };
   };
   fprintf(stderr,"%s",&word);
  };
   
   
   
  return 0;
};

#include <stdio.h>
#include <stdlib.h>
//----------------------------<WBR>------------------------------<WBR>------------------------------<WBR>---
int main()
{
  FILE* pF;
  char psString1[10000]; // Строка для хранения исходного текста
  char psString2[10000]; // Строка для хранения изменённого текста
  char cSymbol; // Переменная для хранения символов, считываемых из файла
  int i = 0; // Счётчик символов первой строки
  int j = 1; // Счётчик символов второй строки
   
  psString2[0] = \' \'; // Начало нулевой строки в тексте №2
сразу начинаем пробелом
   
  pF = fopen("f.txt", "r"); // Открываем файл f для
чтения
  if(pF != NULL) // Если открылся, то...
  {
   while(!feof(pF)) // ...пока не достигнут конец файла...
   {
    cSymbol = (char)fgetc(pF); // ...считываем из него
символы
    if(cSymbol == EOF) cSymbol = \'\0\'; // Если
достигнут конец файла, вставляем символ конца строки
    psString1[i] = cSymbol;
    psString2[j] = cSymbol;
    if(cSymbol == \'\n\') // Если встречаем символ
перевода строки...
    {
     j++; // ...то увеличиваем счётчик символов 2-го
текста и...
     psString2[j] = \' \'; // ...вставляем
пробел.
    }
    i++;
    j++;
   }
   fclose(pF);
  }
  else  
  {
   puts("Невозможно открыть файл для чтения!");
   exit(1);
  }

  puts("Из файла загружен текст: ");
  puts(psString1); // Выводим на консоль первоначальный текст
   
  FILE* pG;
  pG = fopen("g.txt", "w"); // Открываем файл g для
записи
  if(pG != NULL)
  {
   fprintf(pG, "%s", psString2); // Записываем в него
изменённый текст
   fclose(pG);
  }
  else  
  {
   puts("Невозможно открыть файл для записи!");
   exit(1);
  }
   
  puts("Преобразованный текст: ");
  puts(psString2);
   
  return 0;
}

#include <iostream> // Для доступа к стандартному вводу-выводу
на консоль.
#include <cmath> // Для доступа к функции вычисления степени pow.
using namespace std;
//----------------------------<WBR>------------------------------<WBR>------------------------------<WBR>--
// Функция, возвращает вычисленное значение точки.
// В качестве аргументов принимает a, x и n.
double CalculatePoint(double a, double x, double n)
{
  return pow((a + 1 / x), n);
}
//----------------------------<WBR>------------------------------<WBR>------------------------------<WBR>--
int main()
{
  double a; // a - число вводится пользователем
  cout << "Введите a: ";
  cin >> a;
   
  double S = 0;
  double point;
  for(int n = 0; n <= 10; n++) // Сумма от 0 до 10
  {
   for(int x = 1 ; x <= 15; x += 2) // Точки от 1 до 15 с шагом
2
   {
    point = CalculatePoint(a, (double)x, (double)n);
    cout << "При n = " <<n <<
" и x = " <<x << " значение точки равно "
<<point << "." <<endl;
    S += point;
   }
  }

  cout << "S равна " <<S << "."
<<endl;
  return 0;
}

#include <iostream>
// 174971
// s=sum(a+1/x)^n, x=1(2)15
using namespace std;

double s(double a, double x, int n);
int main()
{
     const int left = 1;
     const int right = 15;
     const int step = 2;
     const int n = 10;

     double a;
     double x;

     cout << "a=";
     cin >> a;

     cout << "x\tsum(" <<a << ", x, "
<<n << ")" <<endl;
     for (x=left; x<=right; x+=step)
     {
  // поскольку x принят целым, а соответствующий параметр функции
  // должен быть double, преобразуем x явным образом
  cout <<x << "\t";
  if (x==0)
  {
      cout << "нет значений" <<endl;
  }
  else
  {
      cout <<s(a, static_cast<double>(x), n) <<endl;
  }
     }
     system("Pause");

     return 0;
}

double s(double a, double x, int n)
{
     int i;
     double b=1; // нулевой член ряда
     double sum=1; // сумма для n=0
     for (i=1; i<=n; i++)
     {
  b *= (a+1/x); // последующий член ряда выражается через предыдущий
  sum+=b; // и прибавляем к текущему значению суммы
     }
     return sum; // возвращаем текущее значение суммы
}

//найти сумму ряда с точностью E=10^(-4) , общий член которого
An=(-1)^n-1/n^n
#include <math.h>  //для pow и fabs
#include <iostream.h>    //для cout

int main()
{
  double    E = 1.e-4;    //погрешность
  double    An;   //очередной член
  double    sum = 0;    //сумма
  double    n = 1;  //номер члена 1,2,...
  double    one = 1.;    //для очередного +1,-1,...

  do
  {
   An = one/pow(n, n);    //вычисляем (pow(n,n) = n в степени n)
   one *= -1;   //для следующей итерации
   n++;    //очередной номер
   sum +=An;   //накапливаем сумму
  }while(fabs(An) >= E);    //продолжаем, пока модуль очередного
члена больше погрешности
   
  cout << "sum = " <<sum <<endl;      
//выведем результат
}

#include <stdio.h> /*Подключаем модуль стандартного ввода/вывода
*/
#include <math.h>  /* Подключаем модуль математических функций (требуется
для функции  log) */

void main()
{
float summ,an;
int n;
summ=0;        /*Начальная сумма равна    0 */
an=1;        /*Первое слагаемое*/
n=1;        /*номер текущего слагаемого */
while(an>=0.0001)   /*Цикл "Пока точность не достигнута -
выполнять" */
  {
  if (n%2==1) summ+=an;    /*Если номер слагаемого нечетный, то прибавляем
его к сумме */
  else summ-=an;  /*Если номер слагаемого четный, то вычитаем */
  n++;   /*Увеличиваем номер текущего слагаемого на 1 */
  an*=exp((log(1.0/(n+1))+(n*(<WBR>log((float)n/(n+1)))))); /*Считаем
следующее слагаемое*/
  }
printf("Summa %d elementov ravna = %f\n",n,summ); /*Выводим сумму на
экран */
getchar();
}

#include
<stdio.h>

// 1й пример
unsigned char
swapByteLoHi1(unsigned char byte)
{
  struct byteParts
   {
   
        unsigned lo:4;
         unsigned hi:4;
     }*
pByteParts;
     pByteParts=(struct byteParts*)&byte;
   return
pByteParts->lo<<4 | pByteParts->hi;
}

// 2й
пример
unsigned char swapByteLoHi2(unsigned char byte)
{
  return
(byte<<4) | (byte>>4);
}

// 3й пример
unsigned
char swapByteLoHi3(unsigned char byte)
{
   // AT&T
Assembler(не Intel!!!)
      asm("rorb
$4,%%al":"=al"(byte):"al"(byte));
  return
byte;
}

int main()
{
   unsigned char byte=0xab;

  printf("Вначале:%X\n",byte);
   printf("После
перестановки:%X\n",swapByteLoHi1(byte));
   printf("После
перестановки:%X\n",swapByteLoHi2(byte));
   printf("После
перестановки:%X\n",swapByteLoHi3(byte));
   return (0);
}

void __fastcall TForm1::btStartClick(TObject *Sender)
{
   int i;
   int records; // количество записей для показа
   AnsiString ans=""; // просто строка для показа чего-то из первых
записей
   AnsiString s="";

   records = StrToInt(txtRecords->Text); // берем из Edit
   if (q1->Active) q1->Close(); // если запрос открыт - закроем
   if (q2->Active) q2->Close(); // то же
   q2->SQL->Clear(); // очистим текст запроса
   // наращиваем строку s
   // например, SELECT Name, Capital FROM country.db Country WHERE Name IN
   // ("Argentina", "Brazil")
   //
   s="SELECT Name, Capital FROM country.db Country WHERE Name IN (";

   q1->Open(); // Откроем первый запрос
   if (q1->RecordCount<records)
     records = q1->RecordCount;
   for (i=0; i<records; i++)
   // Сформировали строку для показа
   // и строку для создания текста второго запроса
   {
     ans+=q1->FieldByName("Name")-><WBR>AsString+\'\n\';
     if (i>0)
       s=s+\',\';
     
s=s+\'"\'+q1->FieldByName("<WBR>Name")->AsString+\'"\'+\'
\';
     q1->Next();
   }
   s=s+")";
   q2->SQL->Add(s);
   q1->Close(); // первый запрос уже не нужен
   ShowMessage(ans); // показали строку
   if (records>0) q2->Open(); // открыли запрос
}

#include <iostream>
#include <cmath>
#include <conio.h>

using namespace std;

void Solve()
{
  double y,z,x;
  int n;
  cout<<"\nN = "; cin>>n;
  cout<<"\nX = "; cin>>x;
  y=sin(n*x+0.5);
  z=pow(x,3)/y;
  cout<<"\n\nOtvet :  Z =
"<<z<<"\n\n";
}

void Menu()
{
  while(true)
  {
   cout<<"****  MENU    ***\n";
   cout<<"1 - schitat\'\n";
   cout<<"2 - vihod\n";
   cout<<"*****************\n\n";
   int c;
   cout<<">> "; cin>>c;
   switch(c)
   {
       case 1: Solve();
     break;
    case 2: cout<<"\nVihodim...";
         _getch();
      exit(0);
    default: cout<<"\n\nOshibka!\nPovtorite
vvod!\n\n";
         break;
   }
  }
}

int main()
{
  Menu();
}

#include <stdio.h> //для функции printf/scanf
#include <conio.h> //для функции getch
#define SIZE 255 //размерность строки

int main ()
{
  char str[SIZE]; //строка
  gets_s (str, SIZE); //ввод строки
  for (size_t i=0; i<strlen(str); i++) //преобразование строки
   str[i] = \'z\'-(str[i]-\'a\');
  puts (str); //вывод строки
  _getch (); //ожидание реакции пользователя
  return 0;
}

#include <stdio.h> //для функции printf/scanf
//#include <stdlib.h> //для функции system
#include <conio.h> //для функции getch
#include <locale.h> //для функции setlocale
#include <time.h> //для функции time
#include <iostream> //для cin/cout
using namespace std;

int main ()
{
  setlocale (LC_ALL, "Russian"); //для отображения русского
языка в консоли
  cout << "Введите размерность массива (число строк, число
столбцов):\n";
  int m, n; //размерность
  cin >> m; //ввод размерности
  cin >> n;
  int** a; //матрица
  a = new int* [m]; //выделяем необходимое количество памяти под строки
  for (int i=0; i<m; i++)
   a[i] = new int [n]; //под столбцы
  srand (time(NULL)); //инициализируем генератор случайных чисел
  for (int i=0; i<m; i++) {
   for (int j=0; j<n; j++) {
    a[i][j] = rand()%100; //заполняем матрицу
    //cin >> a[i][j]; - заменить на это предыдущую
строку для ввода матрицы вручную
    printf ("%4i", a[i][j]); //выводим полученные
числа (при вводе вручную эту строку убираем)
   }
   cout <<endl;
  }
  double s; //среднее арифметическое
  for (int j=0; j<n; j++) { //идём по столбцам
   s = 0; //обнуляем сумму
   for (int i=0; i<m; i++) //идём по строке
    s+=a[i][j]; //накапливаем сумму
   cout << "Столбец " <<j << ":
" <<s/m <<endl; //выводим среднее арифметическое
  }
  _getch (); //ожидание реакции пользователя
  return 0;
}

BOOL
BrowseForFolder(TCHAR *pszPath, HWND hWnd)
{
  BROWSEINFO bi;
  LPITEMIDLIST pil;
  bi.hwndOwner = hWnd;// это "хозяин" окна, окно будет модально
по отношению к нему; может быть NULL
  bi.pidlRoot = NULL;
  bi.pszDisplayName = pszPath;
  bi.lpszTitle = "";//"Select destination directory";
  bi.ulFlags = BIF_RETURNONLYFSDIRS;
  bi.lpfn = BrowsePathProc;
  bi.iImage = 0;
  bi.lParam = (long)pszPath;
  pil = SHBrowseForFolder(&bi);
  if(pil)
  {
   SHGetPathFromIDList(pil, pszPath);
   return TRUE;
  }
  return FALSE;
}
///  callbak for folder_browser
INT CALLBACK BrowsePathProc(HWND hwnd, UINT uMsg, LPARAM lp, LPARAM pData)  
{    TCHAR    szDir[MAX_PATH];
  static HWND hTitle;
  switch(uMsg)
  {
  case BFFM_INITIALIZED:
           
if(((char*)pData)[strlen((<WBR>char*)pData)-1]==\'\\\')
     strrchr((char*)pData,\'\\\')[<WBR>0]=0;
    SendMessage(hwnd, BFFM_SETSELECTION, TRUE, pData);
   break;
  case BFFM_SELCHANGED:
   if (SHGetPathFromIDList((<WBR>LPITEMIDLIST) lp ,szDir))
   {
    SendMessage(hwnd,BFFM_<WBR>SETSTATUSTEXT,0,(LPARAM)szDir)<WBR>;
   }
   break;
  }
  return 0;
}