Проверить число на четность 1с
Подскажите пожалуйста молодому-неопытному как проверить в С++ чётное число или нечётное? Есть какя-то специальная функция?
Проверка числа типа double на чётность/нечётность
В программе необходимо проверить число типа double на то, является оно четным или нет. Это возможно.
Итератор и проверка на чётность/нечётность
Добрый день. Не получается организовать проверку на нечётное количество. При вводе нечётного.
Определить для целого числа его четность и нечетность, для дробного - целую часть
Написать программу, которая для введенного числа определяет для целого числа его четность и.
Четность/нечетность
Как определить четность/нечетность числа (использовать остаток от деления нацело (%) и другие.
Решение
panicwassano, Это одно и тоже, просто когда пишу для себя, всегда пишу так(всмисле с логическим not), а прировнял к нулю, потому что так читабильней и понятней для новичка.
Тогда уж лучше так:
люди не пойму зачем использовать оператор %, если лучше &.Например в 8086 операция 'и' - не менше 3 тактов, операция деления ('div') - не менше 90 тактов.Помойму мой вариант оптимальный(особенно если надо находить много четных или нечетных чисел).
люди не пойму зачем использовать оператор %, если лучше &.Например в 8086 операция 'и' - не менше 3 тактов, операция деления ('div') - не менше 90 тактов.Помойму мой вариант оптимальный(особенно если надо находить много четных или нечетных чисел).
Есть число типа double. Необходимо округлить его до двух знаков после запятой, и сделать его дробную часть четным. т.е 1.96 1.98 2 2.02 2.04 как решить сию проблему?
Четность-нечетность вещественных чисел на C/C++
Кто-нибудь подскажите, как сделать проверку на условие четности-нечетности у вещественного числа на.
Четность, нечетность наборов чисел
Нужно вывести на экран набор чисел по четным и нечетным ПОЗИЦИЯМ (не сами числа) например: (3 8).
Четность/нечетность строк в двумерном массиве
Подскажите, пожалуйста, как получить условие в двумерном массиве на четность/нечетность строк. Не.
Проверка элемента одномерного массива на нечетность, вычисление числа нечетных элементов
Помогите, пожалуйста, с задачей: Создать объектный тип данных-вектор, который имеет указатель на.
Пример 1. Создадим числовую переменную
Преобразование значений другого типа в число
Преобразовать в число можно значения строкового типа, либо логического типа (Булево). Значение типа Булево преобразуется в число по следующим правилам:
- Ложь преобразуется в 0;
- Истина преобразуется в 1.
Значение типа Строка преобразуется в число в том случае, если оно является строковым представлением литерала численного типа.
После выполнения данного кода в переменной ПолученноеЧисло будет содержаться числовое значение 1.25
Функции работы со значениями типа Число в 1с 8.3
В данном разделе будут рассмотрены основные функции работы с числами в 1с 8 и приведены примеры их использования.
Цел(). Возвращает целую часть числа переданного в параметре.
Пример 4. Определить делится ли число 121 на 11.
Окр(, , ). Функция округляет число, переданное в первом параметре, до знака после запятой переданного во втором параметре. Значение разрядности может быть и нулевым (округление до целого) и отрицательным (округление до соответствующего разряда целой части). Параметр РежимОкругления может принимать значения:
- 0 (или РежимОкругления.Окр15как10). Округляет в меньшую сторону, то есть при округлении 1.5 будет возвращено 1;
- 1 (или РежимОкругления.Окр15как20). Округляет в большую сторону, то есть при округлении 1.5 будет возвращено 2;
Пример 5. Для того чтобы лучше разобраться с принципами округления рассмотрим округление до целого в меньшую и большую стороны, на ряде чисел от 1.1 до 1.9
Pow(, ). Возводит число переданное в первом параметре в степень переданную во втором параметре.
Пример 6. Извлечь квадратный корень из числа 144, а затем возвести его в квадрат, в итоге снова должно получится число 144.
Проверка числа на четность
Привет.
Как можно в 1С проверить число четное или нечетное. Нужен код. Можно делением на 2, но не знаю как проверить число получилось с дробной частью или нет.
"Если У тебя число целое тогда примерно так:
а = 4;
б = а / 2;
Если б <> Цел(б) тогда
Сообщить("нечет");
иначе
Сообщить("чет");
КонецЕсли;
Если число не целое, то либо округляй, либо б = Цел(а) / 2"
Спасибо за подсказку
"Если Число%2=0 Тогда
Сообщить("Чет");
Иначе
Сообщить("НизачОт");
КонецЕсли;"
Читают тему:
Мероприятия
При использовании материалов активная прямая гиперссылка на перепечатанный материал обязательна.
Редакция БУХ.1С не несет ответственности за мнения и информацию, опубликованную в комментариях к материалам.
Редакция уважает мнение авторов, но не всегда разделяет его.
Мы используем файлы cookie, чтобы анализировать трафик, подбирать для вас подходящий контент и рекламу, а также дать вам возможность делиться информацией в социальных сетях. Если вы продолжите использовать сайт, мы будем считать, что вас это устраивает.
1C 8.3: Как программно проверить строки Таблицы Значений на чётность?
Скажите, пожалуйста:
есть такая вот часть задачи:
"создать таблицу значений. Добавить в неё колонку. Колонку заполнить рандомными числами. Затем удалить из таблицы все чётные числа и вывести таблицу на экран".
Понятно, что
Процедура ВыполнитьКод();
ТаблицаЗначений1 = Новый ТаблицаЗначений;
ТаблицаЗначений1.Колонки.Добавить("Числа");
Строка = ТаблицаЗначений1.Добавить();
Строка.Числа = "3";
Строка.Числа = "17";
Строка.Числа = "6";
Строка.Числа = "9";
Не знаю, как обойти таблицу и сделать проверку на чётность.
Наверное, что-то вроде
Для Каждого СтрокаТЗ Из Объект.ТЗ Цикл
.
Помогите, пожалуйста.
Всегда выбираю Ответ-Решение, заранее спасибо.
Проверка на четность в разных языках программирования
Чтобы проверить числа на четность в языке С/С++ , вычисляют остаток числа при делении на 2, используя оператор «%». Например:
using namespace std;
Проверка на четность в Си является несложной операцией. Давайте посмотрим, как происходит дело в других языках.
Проверка чисел на четность в Python
Проверка чисел на четность в Python происходит так же, как и в С/С++ , — пр и помощи оператора «%», который вычисляет остаток от деления. Если остаток равен 0, значит , число четное.
Вот как это выглядит:
number = int(input(“Введите число для проверки: “))
print(number + “это четное число“)
print(number + “это нечетное число“)
Проверка числа на четность в Java
В Java проверка на четность происходит при помощи того же оператора «%», как и в предыдущих двух примерах. Однако написание программы выглядит немного громоздким:
public class Even_Number_Odd
public static void main(String[] args)
Scanner reader = new Scanner(System.in);
System.out.print("Введите число для проверки: ");
int number = reader.nextInt();
System.out.println(number + " это ч е тное число");
System.out.println(number + " это неч е тное число");
Проверка числа на четность в PHP
В PHP проверка числа на четность также осуществляется при помощи оператора «%». Выглядит это следующим образом:
echo “$num это четное число“;
echo “$num это нечетное число“;
Проверка числа на четность в JavaScript
В JS проверка числа на четность также происходит при помощи оператора «%» , и выглядит это следующим образом:
const number = prompt("Введите число для проверки: ");
console.log("Это четное число");
console.log("Это нечетное число");
Заключение
В нашей статье мы показали, как происходит проверка на четность в некоторых языках программирования: С/С++, Python, Java, PHP, JavaScript. Не сложно заметить, что везде проверка проходит с применением оператора «%» и по одинаковому алгоритму. В других языках проверка на четность будет проходить по такому же алгоритму, но с применением специфики языка.
Мы будем очень благодарны
если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.
Определение четности числа с использованием рекурсии
Программа принимает на вход число и рекурсивно определяет, четное это число или нечетное.
Решение задачи
- Принимаем число и записываем его в переменную.
- Передаем это число в качестве аргумента в рекурсивную функцию.
- Определяем базовое условие рекурсии (т.е., базу рекурсии), при котором решение задачи тривиально и не требует дальнейшего обращения функции к самой себе. В данном случае значение переменной должно быть меньше 2 . Если это условие выполняется, то работа функции завершается.
- В противном случае мы опять рекурсивно вызываем нашу функцию, уменьшив значение переменной на 2 .
- В конце концов работа функции завершается, и по ее результату ( True или False ) мы определяем четность числа.
- Выводим конечный результат на экран.
- Конец.
Исходный код
Ниже дан исходный код для программы для рекурсивного определения четности числа. Результаты работы программы также даны ниже.
Определение четности числа в Python
Оператор вычисления остатка от деления
Определения четности числа с помощью оператора остатка от деления
Мы знаем, что при делении четного числа на 2 у нас в остатке остается 0. Поэтому для определения четного и нечетного числа можем воспользоваться оператором остатка от деления. Напишем для этого условие:
Написание функции для определения четности числа
Проверьте число нечетное или четное без оператора модуля
Учитывая число, проверьте, является ли оно четным или нечетным.
Примеры :
Способ 1: использование цикла.
Идея состоит в том, чтобы начать с переменной логического флага как true и переключать ее n раз. Если переменная-флаг возвращает исходное значение (которое является истинным), то n является четным. Иначе n ложно.
Ниже приведена реализация этой идеи.
using namespace std;
// Возвращает true, если n четное, иначе нечетное
bool isEven( int n)
bool isEven = true ;
// Простая Java-программа для
// проверка на четность или нечетность
Как проанализировать четность / нечетность чисел в Java
- Все 3 числа нечетные ИЛИ
- Все 3 числа четные ИЛИ
- 2 числа нечетные и 1 четное ИЛИ
- 1 число нечетное, а 2 четное
Это то, что я до сих пор:
В Java оператор модуля является % , Вы можете использовать это так:
Объедините его с некоторыми утверждениями if или некоторым счетчиком, чтобы реализовать конечный результат.
PS: тип newnumX выглядит странно:)
Я бы порекомендовал вам
Начните записывать на листе бумаги, как бы вы сделали это вручную. (Напишите алгоритм)
Затем определите, какие части являются "программируемыми", а какие нет (укажите переменные, операторы и т. Д.).
Попробуйте вручную разные цифры и посмотрите, работает ли он.
Оттуда мы можем помочь вам перевести эти мысли в рабочий код (это самая простая часть).
Это базовые навыки программирования, которые вы должны освоить.
Не стоит просто отвечать:
Потому что мы не поможем тебе.
Чтобы избежать больших некрасивых вложенных IF, я бы объявил небольшой счетчик (в псевдокоде):
Это даже проще, у вас есть номера деревьев а, б, в
Запишите основные шаги, которые вы должны выполнить, чтобы выполнить задачу, а затем попытайтесь реализовать ее в коде.
Вот что вы должны сделать:
1 — Получить 3 номера от пользователя.
2 — Вам нужны две переменные: одна для хранения числа нечетных входов, а другая для хранения числа четных. Позволяет называть эти четные и нечетные. (Подсказка: поскольку вы знаете, что у вас есть только 3 числа, после того как вы определили одно из них, другое будет отличаться от 3)
3 — Затем вам нужно провести серию тестов (если evenCnt равен 3, тогда показать "3 четных", иначе, если. )
(А Паскаль и Курош в значительной степени дали вам фрагменты, которые вам нужно заполнить в шагах 2 и 3.)
[Редактировать: мой № 2 шерстистый. Вам нужна только одна переменная.]
Я не согласен с альфазеро. Я не думаю, что две переменные необходимы. каждое число либо всегда, либо нечетно. Поэтому достаточно одного счета.
Что касается кода Асафа, я думаю, что он хорошо документирован, но если вам все еще нужно объяснение, вот так:
Вот что делает цикл for:
Он читает (как строки) пользовательский ввод для 3-х чисел
Integer.parseInt это функция, которая принимает String в качестве параметра (например, ‘4’ ) и возвращает int (в этом примере 4 ). Затем он проверяет, является ли это целое число четным, изменяя его на 2. Основная идея: 4%2 = 0 и 9%2 = 1 (оператор mod при использовании в качестве a%b дает остаток после операции a/b , Поэтому если a%2 0, то четно). Есть счетчик (называется evenCount ), который отслеживает, сколько четных чисел (на основе %s тестовое задание).
Затем он приступает к выполнению команды переключения на evenCount , Оператор switch похож на оператор if-else. Это работает путем тестирования параметра switch (в этом случае evenCount ) против значений регистра (в данном случае 3, 2, 1, 0). Если тест возвращает True, тогда выполняется код в блоке case. Если в конце этого блока case нет оператора break, то также выполняется код в следующем блоке case.
Здесь Асаф проверяет количество четных чисел, сравнивая evenCount с 0, 1, 2 и 3, а затем использует соответствующие операторы печати, чтобы сообщить пользователю, сколько существует четных чисел.
Как проверить, является ли целое число четным или нечетным? [закрыто]
Как я могу проверить, является ли данное число четным или нечетным в C?
Используйте оператор по модулю (%), чтобы проверить, есть ли остаток при делении на 2:
Несколько человек раскритиковали мой ответ выше, заявив, что использование x & 1 «быстрее» или «более эффективно». Я не верю, что это так.
Из любопытства я создал две тривиальные тестовые программы:
Затем я скомпилировал их с помощью gcc 4.1.3 на одной из моих машин 5 раз:
- Без флагов оптимизации.
- С -O
- С -Os
- С -O2
- С -O3
Я проверил вывод сборки каждого компилятора (используя gcc -S) и обнаружил, что в каждом случае выходные данные для and.c и modulo.c были идентичны (они оба использовали инструкцию andl $ 1,% eax). Я сомневаюсь, что это «новая» функция, и я подозреваю, что она восходит к древним версиям. Я также сомневаюсь, что какой-либо современный (созданный за последние 20 лет) неуместный компилятор, коммерческий или с открытым исходным кодом, не имеет такой оптимизации. Я бы протестировал другие компиляторы, но в данный момент у меня нет доступных.
Если кто-то еще захочет протестировать другие компиляторы и / или целевые платформы и получит другой результат, мне было бы очень интересно узнать.
Наконец, стандарт по модулю гарантирует , что он будет работать независимо от того, является ли целое число положительным, отрицательным или нулевым, независимо от представления реализации целых чисел со знаком. Побитовая версия — нет. Да, я понимаю, что два дополнения несколько повсеместно, так что это не проблема.
Вы, ребята, вааааааааа слишком эффективны. То, что вы действительно хотите, это:
Повторите для isEven .
Конечно, это не работает для отрицательных чисел. Но с блеском приходит жертва .
Используйте битовую арифметику:
Это быстрее, чем при использовании деления или модуля.
РЕДАКТИРОВАТЬ: Добавлены запутанные значения в enum.
В ответ на ffpf — у меня был точно такой же аргумент с коллегой несколько лет назад, и ответ — нет , он не работает с отрицательными числами.
Стандарт C предусматривает, что отрицательные числа могут быть представлены тремя способами:
- 2-е дополнение
- 1 дополнение
- знак и величина
Проверка как это:
будет работать для дополнения 2 и представления знака и величины, но не для дополнения 1.
Тем не менее, я считаю, что следующее будет работать для всех случаев:
Спасибо ffpf за то, что он указал, что текстовое поле съедает все после моего менее чем характер!
Обратите внимание, что этот метод использует хвостовую рекурсию с участием двух функций. Это может быть эффективно реализовано (превращено в цикл время / пока), если ваш компилятор поддерживает хвостовую рекурсию, как компилятор Scheme. В этом случае стек не должен переполняться!
Число является четным, если при делении на два остаток равен 0. Число является нечетным, если при делении на 2 остаток равен 1.
Я бы сказал, просто разделите его на 2, и если есть остаток 0, он четный, в противном случае он нечетный.
Использование модуля (%) делает это легко.
например. 4% 2 = 0, поэтому 4 — четное 5% 2 = 1, поэтому 5 — нечетное
Еще одно решение проблемы
(дети могут голосовать)
Я бы построил таблицу четностей (0, если четное 1, если нечетное) целых чисел (так что можно было бы сделать поиск: D), но gcc не позволит мне создавать массивы таких размеров:
Поэтому давайте вместо этого прибегнем к математическому определению четных и нечетных.
Целое число n является четным, если существует такое целое число k, что n = 2k.
Целое число n нечетно, если существует такое целое число k, что n = 2k + 1.
Вот код для этого:
Пусть C-целые числа обозначают возможные значения int в данной C-компиляции. (Обратите внимание, что C-целые числа являются подмножеством целых чисел.)
Теперь можно беспокоиться о том, что для данного n в C-целых числах соответствующее целое число k может не существовать в C-целых числах. Но с небольшим доказательством можно показать, что для всех целых чисел n | n |
Аналогичный аргумент показывает, что если n нечетно, существует ak в C-целых числах, такое что n = 2k + 1.
Следовательно, функции even и odd представленные здесь будут работать правильно для всех C-целых чисел.
Вот ответ на Java:
Читая это довольно занимательное обсуждение, я вспомнил, что у меня была реальная, чувствительная ко времени функция, которая проверяла нечетные и четные числа внутри основного цикла. Это целочисленная функция мощности, размещенная в другом месте в StackOverflow следующим образом. Тесты были довольно удивительными. По крайней мере, в этой реальной функции модуль медленнее , и это значительно. Победителем, с большим отрывом, требующим 67% времени по модулю, является подход или (|) , и его нигде больше нет на этой странице.
Для 300 миллионов циклов контрольные сроки следующие.
3,962 | и маска подход
Для людей, которые думают, что теория или листинг на ассемблере приводят подобные аргументы, это должно быть предостерегающим рассказом. Горацио, на небесах и на земле больше вещей, о которых ты и не мечтал в своей философии.
3 сигма, после выполнения каждого теста 10 раз для 500.000 .000 итераций). Если у вас действительно долгая блестящая карьера, сделайте шаг назад и подумайте, если ваши заявления имеют смысл, а затем опубликуйте фактический код, используемый для тестирования. В противном случае, пост — это то, что я считаю, просто ошибка в измерении.
Это продолжение обсуждения с @RocketRoy относительно его ответа , но оно может быть полезно всем, кто хочет сравнить эти результаты.
tl; dr Из того, что я видел, подход Роя ( (0xFFFFFFFF == (x | 0xFFFFFFFE) ) не полностью оптимизирован x & 1 как mod подход, но на практике время выполнения должно быть одинаковым во всех случаях.
Итак, сначала я сравнил скомпилированный вывод, используя Compiler Explorer :
Проверенные функции:
CLang 3.9.0 с -O3:
GCC 6.2 с -O3:
Сняв шляпу до CLang, он понял, что все три случая функционально равны. Тем не менее, подход Роя не оптимизирован в GCC, поэтому YMMV.
Это похоже на Visual Studio; Изучив разборку Выпуска x64 (VS2015) для этих трех функций, я увидел, что часть сравнения равна для случаев "mod" и "and", и немного больше для случая "Roy’s" или ":
Однако после запуска фактического теста для сравнения этих трех параметров (обычный мод, поразрядный или, поразрядный и) результаты были полностью равны (опять же, Visual Studio 2005 x86 / x64, сборка выпуска, отладчик не подключен).
Сборка релиза использует test инструкцию для случаев and и mod случаев, в то время как случай Роя использует cmp eax,0FFFFFFFFh подход, но он в значительной степени развернут и оптимизирован, поэтому на практике нет никакой разницы.
Мои результаты после 20 запусков (i7 3610QM, план питания Windows 10 установлен на High Performance):
Разница между этими вариантами составляет менее 0,3%, поэтому очевидно, что сборка одинакова во всех случаях.
Теперь вы можете сделать следующее
В «творческой, но запутанной категории» я предлагаю:
Вариант на эту тему, специфичный для Microsoft C ++:
Побитовый метод зависит от внутреннего представления целого числа. Modulo будет работать везде, где есть оператор по модулю. Например, некоторые системы фактически используют низкоуровневые биты для тегирования (например, динамические языки), поэтому необработанные x & 1 в этом случае не будут работать.
Доказательство правильности — рассмотрим множество всех натуральных чисел и предположим, что существует непустое множество целых чисел, которые не являются нечетными. Поскольку положительные целые числа хорошо упорядочены, будет наименьшее нечетное число, которое само по себе довольно странно, поэтому ясно, что число не может быть в наборе. Поэтому этот набор не может быть не пустым. Повторите эти действия для отрицательных целых чисел, за исключением того, что ищите наибольшее нечетное число.
Как сообщают некоторые люди, существует множество способов сделать это. По данным этого сайта , самый быстрый способ — это оператор модуля:
Тем не менее, вот еще один код, отмеченный автором, который работал медленнее, чем обычная операция модуля:
Сколько людей даже знали о методе Math.System.DivRem или почему они его используют?
Чтобы дать более подробную информацию о методе побитового оператора для тех из нас, кто не делал много булевой алгебры во время наших исследований, вот объяснение. Возможно, не очень полезен для ОП, но мне хотелось прояснить, почему работает NUMBER & 1.
Обратите внимание, что, как кто-то ответил выше, способ представления отрицательных чисел может остановить этот метод. Фактически он может даже нарушить метод оператора по модулю, поскольку каждый язык может отличаться в том, как он работает с отрицательными операндами.
Однако, если вы знаете, что NUMBER всегда будет положительным, это работает хорошо.
Как Туни выше указал, что важна только последняя цифра в двоичном коде (и динарий).
Логический логический элемент И требует, чтобы оба входа были равны 1 (или высокому напряжению) для возврата 1.
Если вы возьмете любое число и используете побитовое И (& в java) его на 1, оно либо вернет 00000001, = 1, что означает, что число нечетное. Или 00000000 = 0, то есть число четное.
Вот почему это работает:
Извините, если это излишне.
Последовательность кода Python.
Вам нужно только взглянуть на последнюю цифру в любом заданном числе, чтобы увидеть, является ли она четной или нечетной. Подписанный, неподписанный, положительный, отрицательный — все они одинаковы в этом отношении. Так что это должно работать со всех сторон:
Ключ здесь находится в третьей строке кода, оператор деления выполняет целочисленное деление, поэтому в результате пропускается дробная часть результата. Так, например, 222/10 даст 22 в результате. Затем умножьте это снова на 10, и вы получите 220. Вычтите это из исходного 222, и вы получите 2, которое по волшебству совпадает с последней цифрой в исходном числе. 😉 Скобки предназначены для напоминания о порядке выполнения вычислений. Сначала выполните деление и умножение, затем вычтите результат из исходного числа. Мы могли бы их опустить, поскольку приоритет для деления и умножения выше, чем для вычитания, но это дает нам «более читаемый» код.
Мы могли бы сделать все это совершенно нечитаемым, если бы захотели. Для современного компилятора не имеет значения:
Но в будущем код будет сложнее поддерживать. Просто представьте, что вы хотели бы изменить текст для нечетных чисел на "не четный". Затем кто-то еще позже захочет узнать, какие изменения вы сделали, и выполнить svn diff или подобное .
Если вы не беспокоитесь о переносимости, а больше о скорости, вы можете взглянуть на наименее значимый бит. Если этот бит установлен в 1, это нечетное число, если это 0, это четное число. В системе с прямым порядком байтов, такой как архитектура Intel x86, это будет примерно так:
Обратите внимание, что переменная numbers имеет тип float, но я проверил его на четность)))))). P.S. c++ , dev-c++.
>
int main()
setlocale(0, "");
srand(time(NULL));
float numbers;
int size;
int *arraySize;
arraySize=new int [size];
cout cin>>size;
float numberArray[size];
cout filling( numberArray, numbers, size);
>
Вероятно, имелась в виду чётность числа, хранящегося в переменной типов float или double , которое само по себе вполне может быть целым, например 5.0 .
эм
а если до множить до целого числа
и x%2==0
будет ли работать?)
ПЫСЫ
можно сделать так
долгий код, но его можно сократить :)
всего лишь взять ласт цифру и по ней судить о её кратности
Можно округлить в большую/меньшую сторону или до ближайшего целого (в зависимости от потребностей ТС), а после уже проверять на четность.
Вещественное число - это всегда приближённое значение, его нельзя сравнивать == . ни с каким значением, и с 0 особенно.
Вещественное число не может быть чётным или нечётным. Вещественное число - это всегда приближённое значение (хотя бы поэтому, его остаток от деления на 2 всегда будет не нулевой).
Зацени и заметь, что переменная numbers имеет тип float, но я проверил его на четность. P.S. c++ , dev-c++.
>
int main()
setlocale(0, "");
srand(time(NULL));
float numbers;
int size;
int *arraySize;
arraySize=new int [size];
cout cin>>size;
float numberArray[size];
cout filling( numberArray, numbers, size);
>
Из контекста следует, что речь идёт о целых числах, представленных в вещественном формате. Если так, тогда переводить в целое число, как выше советовали, - это не универсальный метод, поскольку число может выходить за пределы разрядной сетки целого типа. Проверять нужно следующим образом:
0.5*x==round(0.5*x)
Читайте также: