using namespace std;
int var1; // описание переменной var1
int var2; // описание переменной var2
var1 = 20; // присвоение значения переменной var1
var2 = var1 + 10; // присвоение значения переменной var2
// charvars.cpp // применение символьных констант
#include // для cout и т.п.
using namespace std;
char charvar1 =’A ‘; // символьная переменная со значением ‘A’
char charvar2 =’t ‘; // символьная переменная со значением символа табуляции
charvar1 =’B’; // присваивание константного значения символьной переменной
//fahren.cpp //применение cin и n
using namespace std;
int ftemp; // температура по Фаренгейту
cin >> ftemp; int ctemp = (ftemp-32)*5 / 9;
//circarea.cpp //работа с переменными вещественного типа
#include //для cout и т.д.
using namespace std;
float rad; // переменная вещественного типа const
float PI =3.14159F; // вещественная константа
cin >> rad; // получение радиуса
Красивый код на Python #айти #shorts
float area = PI *rad *rad; // вычисление площади круга
//width2.cpp //применение манипулятора setw
#include // для использования setw
using namespace std;
long pop1 = 8425785, pop2 = 47, pop3 = 9761;
// signtest.cpp // работа со знаковыми и беззнаковыми переменными
using namespace std;
int signedVar = 1500000000; //знаковая переменная
unsigned int unsignVar = 1500000000; //беззнаковая переменная
signedVar = (signedVar *2) / 3; //выход за границы диапазона
unsignVar = (unsignVar *2) / 3; // вычисления внутри диапазона
// mixed.cpp // использование смешанных выражений
using namespace std;
float avgWeight = 155.5F;
double totalWeight = count *avgWeight;
// cast.cpp // работа со знаковыми и беззнаковыми переменными
using namespace std;
int intVar = 1500000000; // 1 500 000 000
intVar = (intVar * 10) / 10; // слишком большой результат
intVar = 1500000000; // приведение к типу double
intVar = (static_cast (intVar) * 10) / 10;
// remaind.cpp // применение операции остатка от деления
using namespace std;
// assign.cpp // применение арифметических операций с присваиванием
using namespace std;
ans += 10; // то же самое, что ans = ans +10;
ans -= 7; // то же самое, что ans = ans -7;
ans *=2 ; // то же самое, что ans = ans *2;
ans /= 3; // то же самое, что ans = ans /3;
ans %= 3; // то же самое, что ans = ans %3;
// increm.cpp // применение операции инкрементирования
using namespace std;
// sqrt.cpp // использование библиотечной функции sqrt()
#include //для cout и т.п.
using namespace std;
double number,answer; //аргументы типа double для функции sqrt()
cin >> number; // ввод числа
answer = sqrt(number); // извлечение корня
// relat.cpp // применение операций отношения
using namespace std;
Прекрати писать код в ОДНОМ файле Python | ТОП 5 Ошибок и создание правильной архитектуры
// fordemo.cpp // демонстрирует работу простейшего цикла for
using namespace std;
int j; // определение счетчика цикла
// cubelist.cpp // подсчет кубов целых чисел от 1 до 10
using namespace std;
int numb; // счетчик цикла
int cube = numb * numb * numb; // вычисление куба
// factor.cpp // подсчет факториала числа с помощью цикла for
using namespace std;
unsigned int numb;
unsigned long fact = 1; // тип long для результата
cin >> numb; // ввод числа
for(int j=numb; j>0; j—) // умножение 1 на
fact *= j; // numb, numb-1, . 2, 1
// endon0.cpp // применение цикла WHILE
using namespace std;
int n = 99; // n не должна быть равна 0 перед началом цикла
while(n != 0 ) // цикл, пока значение n не равно 0
cin >> n; // считывание n с клавиатуры
// while4.cpp // возведение в четвертую степень целых чисел
using namespace std;
int pow = 1; // первое возводимое число равно 1
int numb = 1; // 1 в 4-й степени равна 1
++numb; // инкремент текущего числа
pow = numb*numb*numb*numb; // вычисление 4-й степени
// fibo.cpp // генерирование чисел Фибоначчи с помощью цикла while
using namespace std;
//граница типа unsigned long
const unsigned long limit = 4294967295;
unsigned long next = 0; // предпоследний член
unsigned long last = 1; // последний член
long sum = next + last; // сложение двух последних членов
next = last; // обновление предпоследнего
last = sum; // и последнего членов
// divdo.cpp // применение цикла do
using namespace std;
long dividend, divisor;
do // начало цикла do
while(ch != ‘n’)); // условие цикла
// ifdemo.cpp // применение оператора if
using namespace std;
// if2.cpp // использование нескольких операторов в теле цикла if
using namespace std;
// prime.cpp // применение цикла if для определения простых чисел
using namespace std;
unsigned long n,j;
cin >> n; // ввод проверяемого числа
if(n%j == 0) // начиная с 2; если остаток
//нулевой, то число не простое
exit(0); // выход из программы
// ifelse.cpp // применение конструкции if. else
using namespace std;
// chcount.cpp // подсчет числа слов и символов в строке
using namespace std;
#include // для getche()
int chcount = 0; // число непробельных символов
int wdcount = 1; // число пробелов
char ch = ‘a’; // ch должна иметь определенное значение
while(ch != ‘r’ )) // цикл, пока не будет нажата клавиша Enter
ch = getche(); // считывание символа
if( ch == ‘ ‘ ) // если символ является пробелом,
wdcount++; // то инкрементируем число слов
else // в противном случае
chcount++; // инкрементируем число символов
// вывод результатов на экран
// chcnt2.cpp // подсчет числа слов и символов в строке
using namespace std;
#include // для getche()
int wdcount = 1; // пробел между двумя словами
char ch; while( (ch=getche()) != ‘r ‘ ) // цикл, пока не нажата клавиша Enter
if (ch == ‘ ‘) // если введен пробел,
wdcount++; // инкрементировать счетчик слов
chcount++; // инкрементировать число символов
// adifelse.cpp // приключенческая игра с применением ветвления if. else
using namespace std;
#include // для getche()
while ( dir != ‘r ‘ ) // пока не будет нажата клавиша Enter
dir = getche(); // ввод символа
if ( dir == ‘n’ ) // движение на север
else if ( dir == ‘s’ ) // движение на юг
else if ( dir == ‘e’ ) // движение на восток
else if ( dir == ‘w’ ) // движение на запад
> // конец цикла while
> // конец функции main()
// platters.cpp // применение ветвления switch
using namespace std;
int speed; // скорость вращения грампластинки
cin >> speed; // ввод скорости пользователем
switch(speed) // действия, зависящие от выбора скорости
case 33: // если пользователь ввел 33
case 45: // если пользователь ввел 45
case 78: // если пользователь ввел 78
// adswitch.cpp // приключенческая игра с использованием switch
using namespace std;
#include // для getche()
dir = getche(); // ввод переменной
switch(dir) // switch c переменнной dir
y—; break; // движение на север
case ‘s’: y++; break; // движение на юг
case ‘e’: x++; break; // движение на восток
case ‘w’: x—; break; // движение на запад
// condi.cpp // печать символа ‘x’ каждые 8 позиций с применением условной операции
using namespace std;
char ch = (j%8) ? ‘ ‘ :: ‘x’; // номер позиции кратен 8,
// advenand.cpp // применение операции логического И
using namespace std;
#include // для getche()
dir = getche(); // ввод направления
case ‘n’: y—; break; // обновление координат
if( x==7 y==11 ) // если x равно 7 и y равно 11
exit(0); // выход из программы
// advenor.cpp // применение операции логического ИЛИ
using namespace std;
#include // для getche()
while( dir != ‘r ‘ ) //выход при нажатии Enter
if( x15 ) //если x меньше 5 или больше 15
dir = getche(); //выбор направления
case ‘n’: y—; break; // обновление координат
// showprim.cpp // изображает распределение простых чисел
using namespace std;
##include // для getche()
const unsigned char WHITE =219; // белый цвет для простых чисел
const unsigned char GRAY =176; // серый цвет для остальных чисел
unsigned char ch; // действия для каждой позиции на экране
if( count%j == 0) // если остаток равен 0,
ch = GRAY; // то число не простое
break; // выход из внутреннего цикла
getch(); // задержка полученного изображения
// divdo2.cpp // применение оператора continue
using namespace std;
long dividend, divisor;
if( divisor == 0 ) // при попытке
continue; // возврат в начало цикла
Источник: 4its.ru
Русские Блоги
// Вернемся к классическому примеру «имя + фамилия = полное имя», вы можете оглянуться назад: сделать автоматический атрибут fullName доступным для записи и позволить пользователю напрямую.
«Python Great God’s Propamition Road».
Общий гость ： Учитель Чжан，Церковь знаний «Эксплуатация и техническое обслуживание Python» Лектор курса,Старший эксперт по развитию Python. В 6 -летнем опыте разработки Python человек, отвеч.
Насколько пузырька находится под новым розничным воздухом?
Текст | Большая научная техника Gao Qianru редактировать| Sanlu. Number1 Нет времени покинуть беспилотную трансформацию шельфа. В 2016 году М.А. Юн выдвинул новые розничные концепции, и новая роз.
Дизайн Шаблоны-Стратегия
Очень распространенный алгоритм: 1 Что нам делать без этого режима? Например, если есть несколько алгоритмов для членов, v1, v2, v3, просто написать три if в бизнес-классе XxxBiz. Простой, прямой и эф.
Источник: russianblogs.com
Реализация длииииииинной арифметики на C++
В большинстве современных языков программисту уже не нужно заботиться о числах, с которыми процессор непосредственно манипулировать не может. Где-то, как в Python или Haskell, поддержка длинных целочисленных типов встроена прямо в ядро языка, где-то, как в Java или C#, реализована в виде отдельных классов. Но в стандартной библиотеке языка C++ длинные числа до сих пор не поддерживаются. Поэтому я решил написать её сам.
Структура класса
Первое, что нужно решить — это то, как хранить наше число. Я храню его в виде массива цифр, в обратном порядке (это позволяет проще реализовывать все операции), сразу по 9 цифр в одном элементе массива (что позволяет сэкономить память):
class big_integer < // основание системы счисления (1 000 000 000) static const int BASE = 1000000000; // внутреннее хранилище числа std::vector_digits; // знак числа bool _is_negative; >;
В моей реализации будет сразу два представления нуля — в виде пустого вектора и в виде вектора с одним-единственным нулём.
Создание числа
Первое, что нужно научиться делать — это создавать число. Вот так оно преобразуется из строки, содержащей цифры:
big_integer::big_integer(std::string str) < if (str.length() == 0) < // из пустой строки создается ноль this->_is_negative = false; > else < if (str[0] == ‘-‘) < str = str.substr(1); this->_is_negative = true; > else < this->_is_negative = false; > // Вообще-то i должно иметь тип size_t. Но так как это беззнаковый тип, // а в int размер теоретически может и не влезть, я использовал long long for (long long i = str.length(); i > 0; i -= 9) < if (i < 9) this->_digits.push_back(atoi(str.substr(0, i).c_str())); else this->_digits.push_back(atoi(str.substr(i — 9, 9).c_str())); > // удалим из числа ведущие нули, если они есть this->_remove_leading_zeros(); > >
Код процедуры удаления ведущих нулей прост до безобразия:
void big_integer::_remove_leading_zeros() < while (this->_digits.size() > 1 this->_digits.back() == 0) < this->_digits.pop_back(); > // этот код нужен, чтобы у нас не было отрицательного нуля if (this->_digits.size() == 1 this->_digits[0] == 0) this->_is_negative = false; >
Также нам нужно уметь преобразовывать обычные числа в длинные:
big_integer::big_integer(signed long long l) < if (l < 0) < this->_is_negative = true; l = -l; > else this->_is_negative = false; do < this->_digits.push_back(l % big_integer::BASE); l /= big_integer::BASE; > while (l != 0); > big_integer::big_integer(unsigned long long l) < this->_is_negative = false; do < this->_digits.push_back(l % big_integer::BASE); l /= big_integer::BASE; > while (l != 0); >
Код преобразования из остальных типов еще проще, я не стал приводить его здесь.
Вывод числа
Теперь нам нужно научиться печатать наше число в поток и преобразовывать его в строку:
std::ostream<(std::ostream bi) < if (bi._digits.empty()) os << 0; else < if (bi._is_negative) os << ‘-‘; os << bi._digits.back(); // следующие числа нам нужно печатать группами по 9 цифр // поэтому сохраним текущий символ-заполнитель, а потом восстановим его char old_fill = os.fill(‘0’); for (long long i = static_cast(bi._digits.size()) — 2; i >= 0; —i) < os os.fill(old_fill); > return os; > big_integer::operator std::string() const
Сравнение чисел
Теперь нам нужно научиться сравнивать два числа друг с другом. Теория говорит, что для этого достаточно всего двух операций, остальные могут быть выведены на их основе. Итак, сначала научимся сравнивать два числа на равенство:
bool operator ==(const big_integer right) < // числа разных знаков точно не равны if (left._is_negative != right._is_negative) return false; // поскольку у нас два представления нуля, нужно это особо обработать if (left._digits.empty()) < if (right._digits.empty() || (right._digits.size() == 1 right._digits[0] == 0)) return true; else return false; >if (right._digits.empty()) < if (left._digits.size() == 1 left._digits[0] == 0) return true; else return false; >// так как у нас нет ведущих нулей, то в числах должно быть одинаковое количество цифр (разрядов) if (left._digits.size() != right._digits.size()) return false; for (size_t i = 0; i
Теперь проверим, меньше ли одно число другого:
bool operator <(const big_integer right) < if (left == right) return false; if (left._is_negative) < if (right._is_negative) return ((-right) < (-left)); else return true; >else if (right._is_negative) return false; else < if (left._digits.size() != right._digits.size()) < return left._digits.size() < right._digits.size(); >else < for (long long i = left._digits.size() — 1; i >= 0; —i) < if (left._digits[i] != right._digits[i]) return left._digits[i] < right._digits[i]; >return false; > > >
Здесь мы используем унарное отрицание, чтобы сменить знак числа. Также я для симметрии ввел унарный плюс:
const big_integer big_integer::operator +() const < return big_integer(*this); >const big_integer big_integer::operator -() const
Знания о том, почему нужно возвращать const big_integer, а не просто big_integer, а также о правилах выбора между дружественной функцией-оператором и оператором-членом класса, я подчерпнул из этой статьи.
Дальше все совсем просто:
bool operator !=(const big_integer right) < return !(left == right); >bool operator <=(const big_integer right) < return (left < right || left == right); >bool operator >(const big_integer right) < return !(left bool operator >=(const big_integer right)
Арифметические операции
Сложение
Я не стал мудрить с операциями и реализовал обычное школьное сложение в столбик. Поскольку нам в любом случае нужно будет создать новое число как результат операции, я сразу копирую в стек левый операнд по значению и прибавляю числа непосредственно к нему:
const big_integer operator +(big_integer left, const big_integer // мы напишем лишь сложение двух положительных чисел // остальное мы выведем, используя смену знака и вычитание if (left._is_negative) < if (right._is_negative) return -(-left + (-right)); else return right — (-left); >else if (right._is_negative) return left — (-right); int carry = 0; // флаг переноса из предыдущего разряда for (size_t i = 0; i < std::max(left._digits.size(), right._digits.size()) || carry != 0; ++i) < if (i == left._digits.size()) left._digits.push_back(0); left._digits[i] += carry + (i < right._digits.size() ? right._digits[i] : 0); carry = left._digits[i] >= big_integer::BASE; if (carry != 0) left._digits[i] -= big_integer::BASE; > return left; >
Здесь я избежал «дорогой» операции деления в случае, когда получившаяся «цифра» больше основания, по которому я работаю, путем простого сравнения.
Вычитание
В принципе, вычитание аналогично сложению. Нужно лишь рассмотреть случай, когда уменьшаемое меньше вычитаемого:
const big_integer operator -(big_integer left, const big_integer if (right._is_negative) return left + (-right); else if (left._is_negative) return -(-left + right); else if (left < right) return -(right — left); int carry = 0; for (size_t i = 0; i < right._digits.size() || carry != 0; ++i) < left._digits[i] -= carry + (i < right._digits.size() ? right._digits[i] : 0); carry = left._digits[i] < 0; if (carry != 0) left._digits[i] += big_integer::BASE; >left._remove_leading_zeros(); return left; >
Инкремент и декремент
Перед реализацией этих двух операций нам нужно реализовать сложение и вычитание с присвоением:
big_integer value) < return *this = (*this + value); >big_integer value)
Тогда префиксные версии операций реализуются в одну строчку, а постфиксные — лишь немногим сложнее:
const big_integer big_integer::operator++() < return (*this += 1); >const big_integer big_integer::operator ++(int) < *this += 1; return *this — 1; >const big_integer big_integer::operator —() < return *this -= 1; >const big_integer big_integer::operator —(int)
Умножение
Я не стал писать быстрое умножение Карацубы, а снова использовал «школьную» арифметику:
const big_integer operator *(const big_integer right) < big_integer result; result._digits.resize(left._digits.size() + right._digits.size()); for (size_t i = 0; i < left._digits.size(); ++i) < int carry = 0; for (size_t j = 0; j < right._digits.size() || carry != 0; ++j) < long long cur = result._digits[i + j] + left._digits[i] * 1LL * (j < right._digits.size() ? right._digits[j] : 0) + carry; result._digits[i + j] = static_cast(cur % big_integer::BASE); carry = static_cast(cur / big_integer::BASE); > > // не забудем про знак result._is_negative = left._is_negative != right._is_negative; result._remove_leading_zeros(); return result; >
Деление
Поскольку я не нашел в Интернете быстрых способов деления, воспользуемся школьным делением уголком. Начнем делить со старших разрядов. Нам нужно уменьшить текущее значение делимого на максимально возможное число делимым. Это максимальное значение будем искать двоичным поиском. Но сначала нам нужно определить функцию «сдвига» числа вправо, которая позволит нам перебирать разряды последовательно:
void big_integer::_shift_right() < if (this->_digits.size() == 0) < this->_digits.push_back(0); return; > this->_digits.push_back(this->_digits[this->_digits.size() — 1]); // здесь размер массива равен как минимум двум и перебор идет до предпоследнего разряда, // поэтому i имеет «верный» тип size_t for (size_t i = this->_digits.size() — 2; i > 0; —i) this->_digits[i] = this->_digits[i — 1]; this->_digits[0] = 0; >
Теперь опишем само деление:
const big_integer operator /(const big_integer right) < // на ноль делить нельзя if (right == 0) throw big_integer::divide_by_zero(); big_integer b = right; b._is_negative = false; big_integer result, current; result._digits.resize(left._digits.size()); for (long long i = static_cast(left._digits.size()) — 1; i >= 0; —i) < current._shift_right(); current._digits[0] = left._digits[i]; current._remove_leading_zeros(); int x = 0, l = 0, r = big_integer::BASE; while (l else r = m — 1; > result._digits[i] = x; current = current — b * x; > result._is_negative = left._is_negative != right._is_negative; result._remove_leading_zeros(); return result; >
Здесь big_integer::divide_by_zero это пустой класс, унаследованный от std::exception .
Взятие остатка
Вообще-то в предыдущей операции остаток фактически хранится в переменной current . Но я задался вопросом определения знака остатка. Википедия говорит, что остаток от деления всегда положителен. Поэтому я написал такую версию этой операции:
const big_integer operator %(const big_integer right) < big_integer result = left — (left / right) * right; if (result._is_negative) result += right; return result; >
Возведение в степень
Я использовал алгоритм быстрого возведения в степень. Он требует проверки числа на нечетность. Поскольку вычислять остаток от деления на 2, мягко говоря, было бы затратно, введем такие операции:
bool big_integer::odd() const < if (this->_digits.size() == 0) return false; return this->_digits[0] > bool big_integer::even() const < return !this->odd(); >
Теперь напишем само возведение:
const big_integer big_integer::pow(big_integer n) const < big_integer a(*this), result(1); while (n != 0) < if (n.odd()) result *= a; a *= a; n /= 2; >return result; >
Всё! Теперь можно вычислить, к примеру, 2 1000 , либо факториал 100:
#include #include «big_integer.hpp» using namespace std; int main()
Литература
- e-maxx.ru — сайт, посвященный олимпиадным алгоритмам
- cppalgo.blogspot.ru/2010/05/blog-post.html — блог Игоря Беляева
Источник: habr.com