Как сделать проверку на положительность числа с

Добавил пользователь Евгений Кузнецов
Обновлено: 04.10.2024

Достаточно часто требуется узнать: записано ли в переменной число. Такая ситуация может возникнуть при обработке введенных пользователем данных. При чтении данных из файла или при обработке полученных данных от другого устройства.

В Python проверка строки на число можно осуществить двумя способами:

  • Проверить все символы строки что в них записаны цифры. Обычно используется для этого функция isdigit.
  • Попытаться перевести строку в число. В Python это осуществляется с помощью методов float и int. В этом случае обрабатывается возможное исключение.

Рассмотрим как применяются эти способы на практике.

isdigit, isnumeric и isdecimal

У строк есть метод isdigit, который позволяет проверить, являются ли символы, являются ли символы, из которых состоит строка цифрами. С помощью этого метода мы можем проверить, записано ли в строку целое положительное число или нет. Положительное — это потому, что знак минус не будет считаться цифрой и метод вернет значение False.

Если в строка будет пустой, то функция возвратит False.

Методы строки isnumeric и isdecimal работают аналогично. Различия в этих методах только в обработке специальных символов Unicode. А так как пользователь будет вводить цифры от 0 до 9, а различные символы, например, дробей или римских цифр нас не интересуют, то следует использовать функцию isdigit.

Проверка с помощью исключения

Что же делать, если требуется проверить строку на отрицательное число. В Python с помощью isdigit не удастся определить отрицательное число или число с плавающей точкой. В этом случае есть универсальный и самый надежный способ. Надо привести строку к вещественному числу. Если возникнет исключение, то значит в строке записано не число.

Чтобы просто проверить, это самый быстрый способ, кажется:

Он сообщает вам , если знак положительный (возвращает 1) или равен нулю (возвращает 0), а в противном случае (возвращает -1). Это хорошее решение, потому что 0 не является положительным, и оно не является отрицательным, но это может быть ваш var.

. будет считать 0 как отрицательное целое число, что неверно.

Если вы пытаетесь настроить условные обозначения, вы можете соответствующим образом настроить. Вот два аналогичных примера оператора if/else-if:

Эта проблема

Решение

Чтобы гарантировать, что вы имеете дело с целым числом, вы хотите привести свое значение к целому числу, а затем сравнить его с самим собой.

Некоторые аккуратные оптимизации

В качестве бонуса, есть несколько ярлыков для преобразования из числа с плавающей точкой в целое число в JavaScript. В JavaScript все побитовые операторы ( | , ^ , & и т.д.) Преобразуют ваш номер в целое число перед началом работы. Я предполагаю, что это потому, что 99% разработчиков не знают стандарт IEEE с плавающей запятой и будут ужасно запутаны, когда "200 | 2" оценивается как 400 (ish). Эти ярлыки, как правило, работают быстрее, чем Math.floor или parseInt , и занимают меньше байтов, если вы пытаетесь извлечь наименьший возможный код:

Но подождите, там больше!

Эти побитовые операторы работают с 32-битными знаковыми целыми числами. Это означает, что старший бит является знаковым битом. Если установить нулевой бит знака, ваше число останется неизменным, только если оно будет положительным. Вы можете использовать это для проверки позитивности и целочисленности за один удар:

Если у вас возникли проблемы с запоминанием этого запутанного числа, вы также можете рассчитать его заранее:

Проверка на негативы

Согласно комментарию @Reinsbrain, подобный побитовый хак может использоваться для проверки на отрицательное целое число. В отрицательном числе, мы хотим, чтобы левый бит быть 1, поэтому, заставляя этот бит в 1, то число будет только оставаться неизменным, если оно было отрицательным, чтобы начать с:

Это специальное число еще проще вычислить:

Краевые случаи

Как упоминалось ранее, поскольку битовые операторы JavaScript преобразуются в 32-разрядные целые числа, числа, которые не помещаются в 32-разрядные (более ~ 2 миллиардов), потерпят неудачу

Вы можете вернуться к более длинному решению для этих:

Однако даже это решение в какой-то момент дает сбой, потому что parseInt ограничен в своей точности для больших чисел. Попробуйте следующее и посмотрите, что произойдет:

На моем компьютере в консоли Chrome это выводит: 123123123123123130000

Причина этого заключается в том, что parseInt обрабатывает ввод как 64-битное значение IEEE с плавающей точкой. Это обеспечивает только 52 бита для мантиссы, что означает максимальное значение ~ 4.5e15 до начала округления

Прежде чем начать решать эту задачу, давайте вспомним, что такое натуральные и действительные числа.

Что такое натуральное число

Натуральные числа (от лат. naturalis — естественный; естественные числа) - это числа, возникающие естественным образом при счёте (например, 1, 2, 3). Последовательность всех натуральных чисел, расположенных в порядке возрастания, называется натуральным рядом.

Существуют два подхода к определению натуральных чисел:

  1. Натуральные числа - это числа, возникающие при подсчёте (нумерации) предметов (первый, второй, третий и т.д.).
  2. Натуральные числа - это числа, возникающие при обозначении количества предметов (нет предметов, один предмет, два предмета и т.д).

В первом случае ряд натуральных чисел начинается с единицы, а во втором - с нуля.

Отрицательные и нецелые (рациональные, вещественные, …) числа к натуральным не относятся.

Что такое действительное число

Вещественное, или действительное число (от лат. realis - действительный) - это математический объект, возникший из потребности измерения геометрических и физических величин окружающего мира, а также проведения таких вычислительных операций, как извлечение корня, вычисление логарифмов, решение алгебраических уравнений, исследование поведения функций.

Если натуральные числа возникли в процессе счёта, а рациональные - из потребности оперировать частями целого, то вещественные числа предназначены для измерения непрерывных величин.

Не будем углубляться в теорию. Попробуем подвести итог простыми словами. Итак,

Натуральное число - это целое положительное число.

Вещественное (действительное) число - это не целое число (число с дробной частью).

Теперь попробуем найти решение задачи. Вариантов может быть несколько. Мы попробуем два из них - проверку натурального числа и проверку действительного числа. Они мало чем отличаются, но всё же.

Чтобы как-то отличить их, оформим их в виде функций.

Как проверить натуральное число

Можно выбрать, например, такой алгоритм:

  1. Получить число Х
  2. Проверить, не является ли число отрицательным
  3. Если да, то вывести “Х - действительное число”
  4. Если нет, то
    • Выделить дробную часть числа
    • Если она равна нулю, то вывести “Х - натуральное число”
    • Иначе вывести “Х - действительное число”
  5. Завершить программу

Поскольку мы решили оформить решения в виде функций, то проверка натурального числа поместится в одну строку исходного кода.

Проверка действительного числа

Как я уже говорил, такая проверка мало чем отличается от предыдущей и также помещается в одну строку исходного кода:

Ниже приведены примеры программ на языках Паскаль и С++.

ВАЖНО!
Из-за особенностей представления вещественных чисел в памяти компьютера эти примеры не будут работать с большими числами. Например, эти функции, скорее всего, определят, что число 567894,01 является натуральным, а число 567894,1 - действительным. Числа с меньшими значениями будут определяться более точно. Например, число 1,0000001 (шесть нулей) определится как вещественное, а число 1,00000001 (семь нулей) определится как натуральное.

Можно, конечно, постараться и сделать работу этих функций более точной. Но это уже будет более сложное решение.

На этом уроке мы рассмотрим арифметические операторы и их использование в языке С++.

Унарные арифметические операторы

Унарные операторы — это операторы, которые применяются только к одному операнду. Существуют два унарных арифметических оператора: плюс ( + ) и минус ( − ).

Оператор Символ Пример Операция
Унарный плюс + +x Значение x
Унарный минус − −x Отрицательное значение x

Унарный оператор + возвращает значение операнда. Другими словами, +5 = 5 или +х = х . Унарный плюс вам, скорее всего, не придется использовать. Его по большей части добавили в качестве симметрии с унарным оператором минус. Унарный оператор минус возвращает операнд, умноженный на −1 . Например, если х = 5 , то −х = −5 .

Оба этих оператора пишутся непосредственно перед самим операндом, без пробела ( −x , а не − x ).

Не следует путать унарный оператор минус с бинарным оператором вычитания, хоть они и используют один и тот же символ. Например, в выражении х = 5 − −3; , первый минус — это оператор вычитания, а второй — унарный минус.

Бинарные арифметические операторы

Бинарные операторы — это операторы, которые применяются к двум операндам (слева и справа). Существует 5 бинарных операторов.

Оператор Символ Пример Операция
Сложение + x + y x плюс y
Вычитание − x − y x минус y
Умножение * x * y x умножить на y
Деление / x / y x разделить на y
Деление с остатком % x % y Остаток от деления x на y

Операторы сложения, вычитания и умножения работают так же, как и в обычной математике. А вот деление и деление с остатком рассмотрим детально.

Деление целых чисел и чисел типа с плавающей точкой

Оператор деления имеет два режима. Если оба операнда являются целыми числами, то оператор выполняет целочисленное деление. Т.е. любая дробь (больше/меньше) отбрасывается и возвращается целое значение без остатка, например, 7 / 4 = 1 .

Если один или оба операнда типа с плавающей точкой, то тогда будет выполняться деление типа с плавающей точкой. Здесь уже дробь присутствует. Например, выражения 7.0 / 3 = 2.333 , 7 / 3.0 = 2.333 или 7.0 / 3.0 = 2.333 имеют один и тот же результат.

Попытки деления на 0 (или на 0.0 ) станут причиной сбоя в вашей программе, и это правило не следует забывать!

Использование оператора static_cast в операциях деления

На уроке о символьном типе данных char мы уже использовали оператор static_cast для вывода ASCII-символов в виде целых чисел.

Аналогичным образом мы можем использовать static_cast для конвертации целого числа в число типа с плавающей точкой. Таким образом, вместо целочисленного деления выполнится деление типа с плавающей точкой. Например:

std :: cout "double / double crayon-h"> static_cast double > ( x ) / static_cast double > ( y ) "\n" ;

Результат выполнения программы:

int / int = 1
double / int = 1.75
int / double = 1.75
double / double = 1.75

Деление с остатком

Оператор деления с остатком ( % ) работает только с целочисленными операндами и возвращает остаток от целочисленного деления. Например:

Пример №1: 7 / 4 = 1 с остатком 3 , таким образом, 7 % 4 = 3 .

Пример №2: 25 / 7 = 3 с остатком 4 , таким образом, 25 % 7 = 4 . Остаток составляет не дробь, а целое число.

Пример №3: 36 % 5 = 7 с остатком 1 . В числе 36 только 35 делится на 5 без остатка, поэтому 36 − 35 = 1 , 1 — это остаток и результат.

Данный оператор чаще всего используют для проверки деления без остатка одних чисел на другие. Если х % у == 0 , то х делится на у без остатка.

Например, мы хотим написать программу, которая выводит числа от 1 до 100 по 20 значений в каждой строке. Мы можем использовать оператор деления с остатком для создания разрыва строк. Несмотря на то, что мы еще не рассматривали цикл while, в следующей программе всё максимально просто и понятно:

Результат выполнения программы:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100

О while мы еще поговорим на соответствующем уроке.

Отрицательные числа в операциях деления до C++11

До C++11, если любой из операндов целочисленного деления является отрицательным, то компилятор округляет результат самостоятельно! Например, результатом −5 / 2 может быть либо −3 , либо −2 . Однако большинство современных компиляторов округляют числа в сторону нуля (например, в −5 / 2 результатом будет −2 ). В спецификации C++11 определили, что компилятор должен всегда округлять к нулю (или, проще говоря, просто отбрасывать дробь).

Также до C++11, если один из операндов оператора деления с остатком является отрицательным, то результат может быть как положительным, так и отрицательным! Например, результатом −5 % 2 может быть как 1 , так и −1 . В спецификации C++11 решили сделать так, чтобы результат a % b был того же знака, что и значение а .

Арифметические операторы присваивания

Оператор Символ Пример Операция
Присваивание = x = y Присваиваем значение y переменной x
Сложение с присваиванием += x += y Добавляем y к x
Вычитание с присваиванием −= x −= y Вычитаем y из x
Умножение с присваиванием *= x *= y Умножаем x на y
Деление с присваиванием /= x /= y Делим x на y
Деление с остатком и с присваиванием %= x %= y Присваиваем остаток от деления x на y переменной x

До этого момента, когда нам нужно было добавить число 5 к определенной переменной, мы делали следующее:

Уроки программирования, алгоритмы, статьи, исходники, примеры программ и полезные советы

Является ли число простым – Проверяем на языке Си

Напишем на языке Си программу, проверяющую является ли число простым. Для проверки будем использовать простейший алгоритм, основанный непосредственно на определении простого числа.

Простое число – определение

Простое число – это натуральное число (то есть целое и положительное), большее, чем единица, которое делится без остатка только на единицу и само на себя.

Список простых чисел (приведем до ста) начинается так: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97…

Функция на Си, проверяющая – является ли число простым

Напишем на языке Си функцию, которая будет проверять – простое ли число. И возвращать результат проверки в виде логической величины bool: true (да) или false (нет).

Алгоритм проверки числа n на простоту строится на определении термина простого числа.

Для работы данного метода требуется подключить заголовочный файл stdbool.h в начале файла с исходным кодом. В stdbool.h содержится определение логических констант true и false, поскольку в чистой версии языка Си они отсутствуют.

Читайте также: