Продолжим, т.к. предыдущая была слишком длинной:
Можно ли в 1С проверить, четное чиСло или нет без Цел и циклов?

Итак, нужно дать решение или доказать, что не существует решения для следующей задачи.

Для любого натурального числа нужно проверить, является ли оно четным, с помощью арифметических операций + - / *. При этом нельзя использовать циклы (явные или не явные), число итераци

(0) операции "<", ">" можно ?

не знаю есть ли в 1С 16-ичные числа и разрешены ли побитовые логические операции условиями задачи, но если бы я писал на сях, то получилось бы что-то вроде такого:

inline bool isEven(long x) { return ((x & 0x01) == 0); }

ну или аналогично:

inline bool isOdd(long x) { return (x & 0x01); }

(0) а рекурсию можно ?

(1) Можно, конечно же ветвление. ;-)
(3) Рекурсия - это скрытый цикл... Если число циклов не будет пропорционально величине числа, то можно...

(0) вообще поясните что такое "с помощью арифметических операций + - / *",
а конкретно - что значит операция "/"? выполняет деление с остатком?.. или деление нацело?
Если речь идет о программировании, то есть такое понятие, как преобразование типов. С потерей дробной части. Тогда решается задача просто: пусть у нас нет оператора {%, mod, остаток от деления, как вам угодно} - ну дак мы его можем легко получить..

mod(x / y) = x - long(x / y) * y;

и тогда уже пресловутый x % 2, преобразуясь в  x - long(x / 2) * 2; нам все подскажет про четность числа.. хотя этот вариант уже тоже писали и он чем-то не устроил

(0) достал топик, да! без циклов, если уж на то пошло, и операции * и / не делаются на низком уровне, так что в газенваген!

(6)+ к тому же % выполняется быстрее, чем / ....

(0) а чем не устроил пункт 201 из пред. ветки? хотя там есть преобразование в текст, но там нету операций над этим текстом...

(8) В текст преобразовывать нельзя!

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

log10(x*5+5)-log10(x*5-5) :)

очпросто - надо вытянуть из "оперативы" адрес этого целого числа и взять правый бит...

(10) ты не в теме...

(11) Функции нельзя.
(10) Блин, ну как-то привести число к нулю и посмотреть, что там в минусе остается   -0.5 или -1... Что то в этом духе, блин... Истина где-то ж рядом...

OFF: Можно ли реализовать операции *, %, и / без использования циклов для целых чисел

(13) ну дак введи в курс дела: что не так написал? как надо, чтобы быть в теме?

(16) Ты должен доказать, что задача не имеет решения. Жду доказательства.

Ляпнуть, что нет решения любой может, а вот доказать это сложнее

условие если оканчивается на 1 3 5 7 9 то , иначе ...

(19) А как определить на какую цифру оканчивается число? с помощью указанных арифм. действий...

(17),(18) если использовать wscript - из 1с его вызвать можно - сдвинуть вправо на 1 бит, сдвинуть влево, сравнить. на сим предлагаю ветку закрыть.

(20) в строку и по последнему справа символу )

(22) В строку нельзя, отпадает... :(

Вот ведь вопрос как определить последнюю цифру ...
1*5 = 5
2*5 = 10
3*5 = 15
и т. д.
Или цифру после запятой ...
0,5
1
1,5
И т. д.
Но мне кажется это не правильный путь ...

к (19) и (22) ну!? как это было!??

давайте звание гения сделаем переходящим по голосованию

Таб = СоздатьОбъект("ТаблицаЗначений");
Таб.НоваяКолонка("Достало","Число",10,0);
Таб.ДобавитьСтроку();
Таб.Достало = ПроверяемоеЧисло/2-0.1;
Если Таб.Достало*2 = ПроверяемоеЧисло Тогда
 // Четное
Иначе
 // Нечетное
КонецЕсли;
и ниипетъ

(23)я не пойму почему отпадает, что асфальт этим местом легче ковырять чем отбойным молотком?

(11) условие - только арифметика

Я как-то задался вопросом  - будет ли простое число простым в другой системе исчисления... Даже зачем-то начал проверять... Потом мне сказали, что простыми же бывают только натуральные числа... а какая разница в какой системе исчисления 31 корову или 17 яблок?

(28) не, условие - "в 1с"

Хрень какая... Теорема Ферма для 1С-ников :)

Или как определить целое число или нет, не используя функций - тож не правильный путь ...
Вот правильный :) Но вот как составить формулу ...
* Сложение и вычитание:
o чётное ± чётное = чётное
o чётное ± нечётное = нечётное
o нечётное ± чётное = нечётное
o нечётное ± нечётное = чётное
* Умножение:
o чётное ? чётное = чётное
o чётное ? нечётное = чётное
o нечётное ? чётное = чётное
o нечётное ? нечётное = нечётное
* Деление:
o чётное / чётное — может быть любым
o чётное / нечётное = чётное, если целое
o нечётное / чётное — не может быть целым
o нечётное / нечётное = нечётное, если целое

Гений, мой вариант принят или нет? он соответствует условию.

+(29) записать

без Цел и циклов в 1С я все сделал правильно, словоблудие заканчиватся, я победил

(32) эти данные - основа для рекурсии и 2-х базовых чисел - 1 и 0 как четного и нечетного. Гений сей подход отсеял как непродуктивный

(35) где???

(36)+ вообще в математике половина определений - рекурсивные ;) 2н+1 Р = М/н и тд...

Шёл второй день,
нобелёвку так никто и не получил.
А ведь путь к решение очевиден....

+(39)Ипанутую задачу с ипанутыми условиями может решить тока полный ипанашка с ипанутой логикой...

павтаряйув 1с без циклов и рекурсий:

Таб = СоздатьОбъект("ТаблицаЗначений");
Таб.НоваяКолонка("Достало","Число",10,0);
Таб.ДобавитьСтроку();
Таб.Достало = ПроверяемоеЧисло/2-0.1;
Если Таб.Достало*2 = ПроверяемоеЧисло Тогда
// Четное
Иначе
// Нечетное
КонецЕсли;

или - с элементами биосопроцессора:

Если Вопрос("Число "+Строка(ПроверяемоеЧисло)+" четное?","ДаНет") ="Да" Тогда
// четное
Иначе
// Нечетное
КонецЕсли

Смущает "в 1С" в заголовке темы. В "1С" можно создать реквизит типа число с точностью 0 и

   Исходное = Число;
   Число = Число / 2;
   
   Если Исходное = 2 * Число Тогда
       Сообщить("Четное");
   Иначе
       Сообщить("Нечетное");
   КонецЕсли;

Только это неявное ЦЕЛ.

(42) смотри внимательнее (41)... и ищи у себя ошибку ;)

Некоторая формализация задачи:
Работаем только с истинно вещественными числами. То есть будем считать, что выражение вычисляется математически точно (машинно естественно не реализуемо).
Без циклов означает, что независимо от входного значения будет использовано не более определенного числа итераций (возможно очень большого), ограниченного для всех входящих параметров одновременно.
1.    Задача эквивалентна определению, что число целое. Достаточно поделить на 2. И наоборот, если целое, то удвоенное четное.
2.    С помощью 4 арифметических операций можно получить дробно-линейные функции. Проверка на условия ><= может выявить знак этой функции (если сравниваем не с 0, то достаточно сделать вычитание этой функции и сравнивать таки с нулем). Эти функции меняют знак конечное число раз! Если условия вложенные, то есть «если то что посчитали>0 тогда посчитать вот это» означает, что на определенном участке знакопостоянства нужно применить другую функцию.
3.    В силу конечности итераций разбиений на знакопостоянные куски будет конечное число. Но нам нужно получить множество целых чисел и только его. А оно дискретно и бесконечно: состоит из бесконечного ряда изолированных точек. Противоречие.

(21) сдвигать нельзя, хватит тупить. Условие задачи уже сформировано, нужно или доказать что нет решения, или решить.

(33) В строку нельзя, весь прикол в чистой арифметике.
(31) Да, действительно, простая задача а решить никто не может... ;-)
(41) Харе прикалываться. Ты используешь неявное округление, а округление юзать нельзя. Неужели сложно соблюдать условие задачи, или 1сники не привыкли работать по ТЗ?
(44) Не вкурил, можно на примерах.

Пока я видел пример с делением на 10 и сравнением с единицей, но он зависит от разрядности числа. Лучше ничего никто не предложил.

(46) на каких примерах можно иллюстрировать доказательство несуществования?

Короче, я тут за ужином подумал, чуваки.
Я действительно гений. Учитесь.
Решение сделано в расчете на то, что разрядность хранения чисел в компьютере ограничена, но какая именно разрядность, нас не интересует.
Пусть есть некоторое число Х, нужно проверить его четность.
Берем в качестве I числа Х, Х+1, Х+2 и для каждого из них проверяем выполнение равенства: I/3 = I/3*3
Если равенство соблюдается, то число I делится на 3 нацело.
А тут уже легко подумать о четности X, зная Х и I.
Можно проверить, делится ли на 3 число X/2.

(46)а в теме этого не написано, как в песочнице, блин

(48)отрыл наверно где-то в юном технике 80-го года

(48) ты с математикой вообще дружишь?

Можно его забанить?

(51) я имел ввиду I = I / 3 * 3
например, 5 <> 5/3*3
т.к. при делении на 3 всегда получается или 3 или 6 в периоде, а т.к. разрядность ограниченная то при умножении на 3 получим другое число.

Вот, для числа 3 мы можем проверить, делится или нет на 3 нацело.
Где-то рядом и алгоритм на 2.

(53) Жжош! :))) С каких пор деление на 2 дает периодическую дробь? :)

(54) На 3 деление, на 3... Я пока придумал только как проверить делимость на 3.
Числа, которые делятся на 3 идут последовательно - четное нечетное:
3 6 9 12 15....
Т.е. я знаю, как проверить, что число делится на 3 или найти ближайшее число, делящееся на 3. ;-)

(55) Для двойки это никак не подходит. Твой способ - это _косвенное_ определение - является ли число переодической дробью.
Вопрос - можно ли только с помощью арифметики и условий отличить целое число от дробного в 1С? В этом задачка и заключается.

+(56) А вообще тупняк получается - отобрали один из основных инструментов(цикл) и требуем, чтоб работало и без него... Имхо есть куча задач, которые без цикла решить не получается, не только четность.

(48) Это не универсальное решение опирающееся чисто на арифметические операции а такое же (по типу) как и у меня где предполагается ограниченная разрядность представимых чисел. Какой же ты гений!? :)))))

(48) >>проверяем выполнение равенства: I/3 = I/3*3
Ничего не понял
I/3 = I/3*3
выполняется если I=0

(58) быстрее, чем твой метод, потому и без цикла

(57) Про трудоемкость алгоритма слыхал? N, n2 log2N? Вот и я хочу чтобы она была небольшой

(59) кури (53) тормозим?

(60) Да, быстрее но уже не "чиста арифметические операции" а это существенное нарушение условий задачи. Мой метод оставался строго в рамках арифметических операций. И для общего (но только общего!) решения требовал бы цикл. Короче ничего лучше своего метода я тут пока не видел. :))))

неплохая такая трудоемкость - для периодической дроби  для дробной части одноэсия выделит все те 1024 бита и потом будет это  дело умножать/делить сравнивать

(62) Если использовать особенности компьютера или интерпретатора, то и такой код канает:
Перем Масс[100000000];
Попытка
   Масс[ВыбЧисло/2]=0;
   Сообщить("Четное");
Исключение
   Сообщить("Нечетное");
КонецПопытки

(62) Странный ты ... Говоришь арифметически ... А сам пользуешься особенностью количества после запятой ...
Так знай гЕний ... Арифметически
A = A/3*3 всегда ...
Потому что существует возможность формулу выразить в следующем виде ...
A/3 = A/3
или
A*3 = A*3

Вот что меня удивило... А нахрена одинэске такие огромные числа? Я имею. в виду 1024битную разрядность. Нахрена спрашивается это в сугубо экономической проге?

(44) Прелагаю свои наметки доказательства невозможности.
Решаем задачу: дано число Х опрделеить целое оно или нет.
Чтоб доказать что число Х нецелое надо показать, что Х>N и Х<N+1, где N целое число.
Эта задача очень похожа на задачу поиска по ключу в отсортированном массиве.
Известно, что задача поиска не может быть решена за время быстрее O(logN)

(0) Задача поставлена некорректно.
Надо перечислить ВСЕ возможные методы, которыми можно пользоваться. Например:
+, -, *, /, ЕСЛИ, <, >
При помощи указанных арифметических операций задачу решить невозможно.
Нужен либо Цел, либо операция, аналогичная Цел (такие как: Таблицей Значений с ограничениями по количеству знаков после запятой, переводом в строку + Прав, взять байт из памяти).

(64) мы считаем число простых операций + - * /, а не циклов на языке 1с

(69) Или хотя бы тригонометрические функции чтобы преодолеть линейность арифметических операций. Можно что-то с косинусом и синусом замутить.

(69) Но ведь делимость на 3 я могу проверить с помощью всего двух операций - деления на 3 и умножения на 3... гыгыгыгы, а вы говорите невозможно...

(71) давай без извращений

Вот вам еще мысля.
1 2 3 4 5 6 - все при делении на 7 дают периодические дроби.
То бишь мы проверяем делимость на 3 и на 7, находим насколько число удалено от ближайшего числа, делящегося на 7 и на 3, исходя из этой инфы получаем четное или нет. Это уже можно проверить на компе.
Т.е. проанализировать первые 1000 чисел, для каждого из них вычислить расстояние до ближайшего делящегося на 3 и на 7 числа и посмотреть, какие из них четные, какие нет.

(73) Ну I <> I / 3 * 3 скорее извращения. :) А синус-косинус могутпомочь правда это уже иррациональные числа, пи опять таки. И операции не определяемые алгоритмически т.е. нет такого алгоритма который за конечно число шагов вычислить синус какого-то числа. :))))))

Подсчитал я тут количество прохождений по циклам в своем варианте. Получил следующую картину:
22 для 11
36 для 100
58 для 111
73 для 1011
87 для 1100
109 для 1111
125 для 10111
140 для 11011
154 для 11100
176 для 11111
193 для 101111
209 для 110111
224 для 111011
238 для 111100
260 для 111111
278 для 1011111
295 для 1101111
311 для 1110111
326 для 1111011
340 для 1111100
362 для 1111111
Это к вопросу об эффективности алгоритма :)
Можно, конечно, подчитать именно число арифметических операций... Но порядок от этого не сильно изменится - чем больше число, тем эффективней

(72) Точно так-же можно проверить делимость на любое простое число, кроме 2 :-))

(77) На 5 не получится

+(77) 1 2 и 5 =))) Извиняюсь)

Написал код:

Функция ПоискДелителя(Знач Ч, Делитель)
   Пока Истина Цикл
       Если Ч % Делитель = 0 Тогда
           Возврат Ч;
       КонецЕсли;
       
       Ч=Ч+1;
   КонецЦикла;
КонецФункции


Функция ___обВывестиТаблицуЗначений(П) Экспорт
#Если Клиент Тогда
   Перем
       ТЗ,
       Макет,
       Т,
       ПараметрыШапки,
       ПараметрыПодвала,
       ИмяШапки,    
       ИмяСтроки,
       ИмяПодвала,
       Показывать,
       РасчитыватьИтоги,
       НачальнаяСтрока, ЗаголовокОкна;
       
   П.Свойство("ЗаголовокОкна", ЗаголовокОкна);
   П.Свойство("ТЗ", ТЗ);
   П.Свойство("Макет", Макет);
   П.Свойство("Т", Т);
   П.Свойство("ПараметрыШапки", ПараметрыШапки);
   П.Свойство("ПараметрыПодвала", ПараметрыПодвала);
   Если НЕ П.Свойство("ИмяШапки", ИмяШапки) Тогда
       ИмяШапки="Шапка";
   КонецЕсли;
   Если НЕ П.Свойство("ИмяСтроки", ИмяСтроки) Тогда
       ИмяСтроки="Строка";
   КонецЕсли;
   Если НЕ П.Свойство("ИмяПодвала", ИмяПодвала) Тогда
       ИмяПодвала="Подвал";
   КонецЕсли;
   Если НЕ П.Свойство("Показывать", Показывать) Тогда
       Показывать=Истина;
   КонецЕсли;
   Если НЕ П.Свойство("РасчитыватьИтоги", РасчитыватьИтоги) Тогда
       РасчитыватьИтоги=Истина;
   КонецЕсли;
   
   //Если таблица не задана, создаем ее
   Если Т=Неопределено Тогда
       Т=Новый ТабличныйДокумент();
       НачальнаяСтрока=1;
   Иначе
       НачальнаяСтрока=Т.ВысотаТаблицы+1;
   КонецЕсли;
   
   
   //Выводим шапку через макет
   Если ИмяШапки<>Неопределено И Макет<>Неопределено Тогда
       Шапка=Макет.ПолучитьОбласть(ИмяШапки);
       Если ПараметрыШапки<>Неопределено Тогда
           Шапка.Параметры.Заполнить(ПараметрыШапки);
       КонецЕсли;
       Т.Вывести(Шапка);
   Иначе
       //выводим шапку непосредственно в ячейки
       Для Каждого Кол ИЗ ТЗ.Колонки Цикл
           Заг=СокрЛП(Кол.Заголовок);
           Заг=?(Заг="",Кол.Имя, Заг);
           Т.Область(НачальнаяСтрока, 1+ТЗ.Колонки.Индекс(Кол), НачальнаяСтрока, 1+ТЗ.Колонки.Индекс(Кол)).Текст=Заг;
       КонецЦикла;
   КонецЕсли;

   Для Каждого Стр ИЗ ТЗ Цикл
       Если ИмяСтроки<>Неопределено И Макет<>Неопределено Тогда
           Строка=Макет.ПолучитьОбласть(ИмяСтроки);
           Строка.Параметры.Заполнить(Стр);
           Т.Вывести(Строка);
       Иначе
           //выводим строки
           Для Каждого Кол ИЗ ТЗ.Колонки Цикл
               Т.Область(НачальнаяСтрока+1+ТЗ.Индекс(Стр), 1+ТЗ.Колонки.Индекс(Кол), НачальнаяСтрока+1+ТЗ.Индекс(Стр), 1+ТЗ.Колонки.Индекс(Кол)).Текст=Стр[Кол.Имя];
           КонецЦикла;
       КонецЕсли;
   КонецЦикла;
   
   Если ИмяПодвала<>Неопределено И Макет<>Неопределено Тогда
       Подвал=Макет.ПолучитьОбласть(ИмяПодвала);
       Если РасчитыватьИтоги=истина Тогда
           ПараметрыИтогов=Новый Структура();
           Для Каждого Кол ИЗ ТЗ.Колонки Цикл
               ПараметрыИтогов.Вставить(Кол.Имя, ТЗ.Итог(Кол.Имя));
           КонецЦикла;
           Подвал.Параметры.Заполнить(ПараметрыИтогов);
       КонецЕсли;
       
       Если ПараметрыПодвала<>Неопределено Тогда
           Подвал.Параметры.Заполнить(ПараметрыПодвала);
       КонецЕсли;
       Т.Вывести(Подвал);
   КонецЕсли;
   
   Если Показывать Тогда
       Т.Показать(ЗаголовокОкна);
   КонецЕсли;
   Возврат Т;
#КонецЕсли
КонецФункции



ТЗ=Новый ТаблицаЗначений();
ТЗ.Колонки.ДОбавить("Четное");
ТЗ.Колонки.ДОбавить("Р3");
ТЗ.Колонки.ДОбавить("Р7");

Для Инд = 1 по 1000 Цикл
   Р3 = ПоискДелителя(Инд, 3);
   Р7 = ПоискДелителя(Инд, 7);
   Стр=ТЗ.Добавить();
   Стр.Четное = Инд % 2 = 0;
   Стр.Р3 = Р3 - Инд;
   Стр.Р7 = Р7 - Инд;
КонецЦикла;

ТЗ.Свернуть("Четное, Р3, Р7", "");
ТЗ.Сортировать("Р3, Р7");

___обВывестиТаблицуЗначений(Новый Структура("ТЗ", ТЗ));


Получил ТЗ:

Четное    Р3    Р7
ложь        
истина        
ложь        1
истина        1
истина        2
ложь        2
ложь        3
истина        3
истина        4
ложь        4
ложь        5
истина        5
ложь        6
истина        6
ложь    1    
истина    1    
истина    1    1
ложь    1    1
ложь    1    2
истина    1    2
ложь    1    3
истина    1    3
ложь    1    4
истина    1    4
ложь    1    5
истина    1    5
ложь    1    6
истина    1    6
истина    2    
ложь    2    
ложь    2    1
истина    2    1
ложь    2    2
истина    2    2
ложь    2    3
истина    2    3
ложь    2    4
истина    2    4
истина    2    5
ложь    2    5
истина    2    6
ложь    2    6

Не, не канает, от делителей 3 и 7 на одинаковом растоянии всегда есть и четные и нечетные числа

(76) Это ты кому?

ТЗ=Новый ТаблицаЗначений();
ТЗ.Колонки.ДОбавить("Четное");
ТЗ.Колонки.ДОбавить("Р3");
ТЗ.Колонки.ДОбавить("Р7");
ТЗ.Колонки.ДОбавить("Р3_2");
ТЗ.Колонки.ДОбавить("Р7_2");

Для Инд = 1 по 1000 Цикл
   Р3 = ПоискДелителя(Инд, 3);
   Р7 = ПоискДелителя(Инд, 7);
   Р3_2 = ПоискДелителя(Р7, 3);
   Р7_2 = ПоискДелителя(Р3, 7);
   Стр=ТЗ.Добавить();
   Стр.Четное = Инд % 2 = 0;
   Стр.Р3 = Р3 - Инд;
   Стр.Р7 = Р7 - Инд;
   Стр.Р3_2 = Р3_2 - Инд;
   Стр.Р7_2 = Р7_2 - Инд;
КонецЦикла;

ТЗ.Свернуть("Четное, Р3, Р7, Р3_2, Р7_2", "");
ТЗ.Сортировать("Р3, Р7, Р3_2, Р7_2");

Все то же самое, блин...

(80) а чем тебя тогда Чётное = (Число % 2 = 0) не устраивало?

Ну, если циклы разрешены, то не легче-ли от осходного числа отнимать ближайшуюю степень числа 2, пока оно не станет равным 0 или 1? =)

(84) уже даже "%" разрешено :)))))

(83) ты не в теме, отдыхай дальше... Это не вопрос, как проверить четность в 1с, это вопрос, можно ли арифметически проверить четность и трудоемкость этого алгоритма.

http://www.college.ru/mathematics/courses/algebra/content/chapter1/section1/paragraph3/theory.html

Признаки делимости

Признак делимости на 2. Число, делящееся на 2, называется чётным, не делящееся на 2 – нечётным. Число делится на 2 тогда и только тогда, когда его последняя цифра делится на 2.

Признак делимости на 5. Число делится на 5 тогда и только тогда, когда его последняя цифра – 5 или 0.

Признак делимости на 25. Число делится на 25 тогда и только тогда, когда две его последние цифры либо нули, либо образуют число, делящееся на 25.

Признаки делимости на 10, 100, 1000. Число делится на 10 тогда и только тогда, когда его последняя цифра – 0. Число делится на 100 тогда и только тогда, когда две его последние цифры – нули. Число делится на 1000 тогда и только тогда, когда три его последние цифры – нули.

Признак делимости на 4. Число делится на 4 тогда и только тогда, когда две его последние цифры – нули, либо когда двузначное число, образованное двумя его последними цифрами, делится на 4.

Признак делимости на 3. Число делится на 3 тогда и только тогда, когда сумма его цифр делится на 3.

Признак делимости на 9. Число делится на 9 тогда и только тогда, когда сумма его цифр делится на 9.

Признак делимости на 11. Число делится на 11 тогда и только тогда, когда сумма его цифр, стоящих на нечётных местах, либо равна сумме цифр, стоящих на чётных местах, либо отличается от неё на число, кратное 11.

(84) С циклом решение известно. Трудоемкость log 10 (N). Надо быстрее.
(85) С какого бодуна? Я не разрешал

(87) Ты к чему это ляпнул? Сказал А говори и Б, или не флудераствуй.

(88) на свой код посмотри....

(89) Это к вопросу от делимости на 3 (ну, и т.д.)

(90) Мой код не решение, а исследование расстояния... Не путай мелкое с теплым

(91) В твоем сабже я не нашел ни слова про периодические дроби, которые получаются при делении на 3 и 7.

Точнее легче по другому


Перем ИсходноеЧисло, Дельта, СтепеньДвойки;
ТеньЧисла = 0;
Пока (ИсходноеЧисло-ТеньЧисла) > 1 Цикл
   СтепеньДвойки = 1;
   Пока (ТеньЧисла+2^СтепеньДвойки) < ИсходноеЧисло Цикл
       СтепеньДвойки = СтепеньДвойки+1;
   КонецЦикла;
   ТеньЧисла = ТеньЧисла + 2^(СтепеньДвойки-1);
КонецЦикла;

Если ИсходноеЧисло = ТеньЧисла Тогда
   Возврат("Чет");
Иначе
   Возврат("Нечет");
КонецЕсли;

(94) Хватит извращаться с циклами. такое решение мы знаем и его трудоемкость LOG 10 (N). Нужно что-то пооригинальнее.

(92) про периодические дроби можно было вообще не упоминать - для простых чисел длина периода равна p - 1, т.е. цикл даже длиннее, чем при факторизации числа

(0) ответ на (149) из пред. топика.
Сам обломись!

А кто мешает нам запускать функцию, написанную с ограничениями из (0) не только на натуральных числах, но и на вещественных???

Вот ты накодил эту функцию ПроверкаЧетности(ПроверяемоеЧисло) для целых чисел, а я потом, как самый злостный бета-тестер, возьму и запущу:

Сообщить(ПроверкаЧетности(1.239))

Какой результат она мне выдаст???? Повиснет?

В лучшем случае вылетит ошибка деления на 0, но и то эта ошибка может вылетать только на конечном количестве отрезков вещественных чисел!

(95)
Самое оригинальное решение было предложено с транком, но вы-же его отмели.
Объясни суть вопроса, поставь задачу нормально.
Ведь ты явно не собираешься в стотыщмиллиардой базе данных выяснять - целые там числа, или нет.
В 77 ИМХО вы не найдете решения пооригинальнее.

Кстати, по поводу (94) - проверь, сколько итераций будет выполнено. Полагаю, сильно удивишься. Ведь не зря вся маш. логика изначально двоична.

Можно пойти еще таким путем.
Делим число X на 2 затем умножаем число на 10, получаем число, заканчивающееся на 0 или 5.
Теперь отнимаем единицу, получаем число, заканчивающееся на 9 или 4.

Дальше вот не знаю, надо найти ближайшее число, делящееся на 3 что ли?

(97) Блин, ну это ущербная логика программиста, не умеющего работать по ТЗ. Тебе сказали - проверяем только натуральные числа. Такова суть задачи!

сто

(98) Это не практическая задача, а интеллектуальная, для развития мозгов. Как на практике проверить четность я знаю - с помощью оператора %

(101) мазилло

Блин, уже поздно, но можно вот такой вариант посмотреть. Уже не шарит голова, завтра.

Значитца, если проверяем на четность Х.
Берем Х + (Х + 1) * 2 + 1 = 3 * Х + 3 = K
Далее, делим К на 2 и проверяем делимость на 3.

Итак, точнее, берем С = (3 * Х + 3) / 2
для 5, С = 9 делится на 3, нечетное
для 6, С = 8.5 не делится на 3, четное
для 7, К = 12, делится на 3, нечетное
для 8, К = 13.5, не делится на 3, четное
для 9, К = 15, делится на 3, нечетное
для 10, К = 16.5, не делится на 3, четное

Гыгыгы

Ну что, мазафакеры, кто тут гений...
Все, задача решена, все неверующие идут глубоко в сад...

Как проверять деление на 3 я уже знаю и рассказывал...
итого за конечное число действий мы проверяем нечетность числа..

Итак, вот моя статья для дневника:

У меня возник вопрос, как проверить, четное число или нет, только с помощью математических операций +, -, *, /, причем без использования циклов, буквально за пару действий на компьютере с ограниченной разрядностью.

Долго бился над решением и все таки его нашел.

Допустим, мы проверяем число Х.
Берем С = (3 * Х + 3) / 2. Если С делится на 3, тогда число нечетное, если не делится, тогда четное.

Например:
для 5, С = 9 делится на 3, нечетное
для 6, С = 8.5 не делится на 3, четное
для 7, К = 12, делится на 3, нечетное
для 8, К = 13.5, не делится на 3, четное
для 9, К = 15, делится на 3, нечетное
для 10, К = 16.5, не делится на 3, четное

А как проверить, делится ли число на 3? Учитывая, что разрядность компьютера ограничена, мы сначала делим Х на 3, а затем умножаем на 3, получаем К. Если К = Х, то число делится на 3, иначе не делится.

Вот все, вопрос решен.

(107) и как же проверить делимость на 3? если как в (48) + (53) - это несерьёзно.....

(109) Читай полностью в 108. Вуаля, я решил задачу, мозг освободился от нее, гы, ларчик просто открывался!

(110) я там не вижу проверки делимости на 3

+(111) - 16.5/3*3 = 16.5 выдаёт Истина, думай дальше

(108)
Блин, и смех и грех ...

(112) Надо тогда проверить три подряд идущих числа по этому сценарию Х, Х+1 и Х+2

или протестировать ряд из Х, Х+2, Х+4, Х+6, Х+8, Х+10 и кто из них даст больше (избавляемся от ошибки), то и ок

Что ж у Вас не возникает этого вопроса к разработчикам С++ или С#...
Да грамотно релизуйте операцию % ... в нее все и войдет... Или нет ?

(115) в общем ты уже пытаешься без рекурсии число факторизовать....

(116) % нельзя использовать, а И в 1с с числами работает вот так: Число1 И Число2 = Ложь, только если одно из них или оба равны 0, во всех остальных случаях Истина

(116) перечитайте ветку,лень чисто вам объяснять банальности

Для любого нормального языка программирования такого вопроса нет...
Решается все на уровне реализации операторов ..  Бред какой-то...

(112) мда, засада... ;-)

(120) Блин, специально для тебя, военного программиста - это не задача языка программирования, это логическая задача... Народ, ну объясните ему...

(108)
>>> для 10, К = 16.5, не делится на 3, четное
Неверно. Все представленные тобой числа делятся на 3.
Представь себе 1.5   /3 = 0.5    *3 = 1.5

И опять-же, все проверки на делимость (например, на 3) основаны на ограниченности вычислений.
Но калькуляторы-то умнеют, и сейчас, я думаю что если ты на хорошем калькуляторе 5 разделишь на 3, а затем умножишь ты получишь не 4,(9) а 5.
В реальной математике ни для одного числа нельзя проверить делимость без циклов. Имхо.

*реальной понимать как абсолютной или точной.

Так умножьте логически на 1 - и проблем :)

(124) речь идет о машинах с ограниченной разрядностью. Они никогда не будут выдавать для 5 / 3 * 3 число 5

(123) да, ступил

(126) точнее плиз

(97) Это не ушербность, а доказательство невозможности написания такой функции  при помоши расширения ее поля действия.
Ты еще назови ущербным человека, который стал извлекать корень из -1 и придумавшего комплексные числа.

(108) А вот тут липа!
Для начала ты определись, чисто математическая задача это, или все таки учитываем погрешности вычислений?
К тому же, ограниченная разрядность вовсе не означает, что  1/3*3 <> 1. Если вдруг кодеры платформы 1C возьмут в новой версии за основу в вычислениях движок от Mathcad, там  1/3 в памяти хранится не как 0.333...3 а именно как дробь 1/3 со всеми вытекающими...

Хорошо.
Похоже, 1С не знает операции логического умножения...
Я недавно занимаюсь 1С :)

(127) ты не поверищь, в mathcad-е даже sqrt(2)*sqrt(2) = 2

(130) Хорошо. Интересно, есть ли решение трудоемкостью быстрее чем LOG 10 N в двух случаях:
1. Для чистой арифметики, где X / 3 * 3 всегда равно X
2. Для компьютеров, использующих особености вычислений, где X / 3 * 3 равно X только если X нацело делится на 3.

;-)

(130) (132) Такая постановка удовлетворит?

По сути действительно, задача сводится к другой:

Функция Четность(Х)
 Возврат ЭтоЦелоеЧисло(Х/2);
КонецФункции

Таким образом можно размышлять только о способе проверки числа на целое, хотя эти числа могут заканчиваться только на *.5 или на *.0

Кстати, есть такой тупой алгоритм, но у него тоже цикл:
Функция ЭтоЧетное(Х)
 Р = БлижайшееДелящеесяНа3Слева(Х);
 Д = Х - Р;
 Ч = ЭтоЧетное(Д/3);
 Если Ч и (Д = 0 ИЛИ Д = 2) Тогда Возврат истина КонецЕсли;
 Если Ч и (Д = 1) Тогда Возврат ложь КонецЕсли;
 Если НЕ Ч и (Д = 0 ИЛИ Д = 2) Тогда Возврат ложь КонецЕсли;
 Если НЕ Ч и (Д = 1) Тогда Возврат истина КонецЕсли;
КонецФункции

(133)
1. Нельзя. Вникай в док-во (148) из прошлой ветки.
2. Вот тут скорее всего можно, надо подумать..

Число AND 0x1 - в зависимости от четного или нечетного числа отличается ?

(129) Куда точнее ?

Уж четность совершенно необязательно определять арифметическими операциями - здесь битики :)

(133)
для идиотов которые создают алгоритмы нарушая своиже собственные ограничения...


в 1С следующее равенство справедливо всегда х = (х / 3) * 3 ... независимо от твоего бреда


(1 / 3) * 3 = 1
(2 / 3) * 3 = 2
(3 / 3) * 3 = 3

(141)
Он поставил задачу с учетом ограничений и возможностей накладываемых компьютером и языком 1с.
И ругаешься ты очень зря, так как всего-лишь повторил содержание постов выше, добавив ругань. Очень, очень плохо.

(142)какие ограничения для определения четности числа на тебя накладывает компьютер и язык 1С?

Пока гении 1С почивают:

Если из Х, используя комбинацию арифметических операции, можно получить такое Y, для которого, используя обратную комбинацию операций, можно получить не Х, то Вы "... и гений, парадоксов друг ...".

PS: А афтору смените ник на "Геев Парадоксов Друг" :о)

От создателя алгоритма

Возврат СтрЧислоВхождений(Число/2, Сред(0.1,2,1));

Еще одна "нетленка" под девизом "О боже - ОНО работает...":

Функция ЧетноеЧисло(Число) Экспорт

  Индекс = ?(Число<0, -Число, +Число);
  Массив = Новый Массив(2); Массив[0]=Истина; Массив[1]=Ложь;
  Попытка
     Возврат Массив[Индекс];
  Исключение
     ЭтоНеЯЭто1СОкругляет = Новый Массив(Индекс/2);
     Возврат Массив[Число(ЭтоНеЯЭто1СОкругляет.Количество()*2<>Индекс)];
  КонецПопытки;

КонецФункции;

PS: и не ругайтесь сильно, - я сам пойду УППоплюсь!

(108) "Учитывая, что разрядность компьютера ограничена..." - это неявное округление. Такой подход не отличается от A=(X/2); B=2*A; X?=B, когда разрядность переменной А равна нулю. Стыдно, товарищ.

Короче, все извращения нужны, чтобы реализовать операцию выделения целой части.(Или аналогичную) Без нее решить ни у кого не получается.

Я думаю это не сработает для любого числа которое 1С может использовать
Например 10000000000000000000000000000000000000000000000000000000000000000000000

(141) Для яндекс-дятла. Набери в табло 1С: (1 / 3) * 3  и получишь 0,999999999999999999999999999

(143) Идиот, речь не о практической задаче, а о головоломке... По-моему условия задачи уже кристально чисты. Решения пока еще нет, ровно как и доказательства его отсутствия. Есть решение трудоемкостью LOG 10 (N)

(144) Читай (147) молодой зеленый человечек.

(148)для гей-дятла... я тебе из табло сообщения и показал...

(148) Не сработает в троичной системе счисления! :)

(145) А ты попробуй реши задачу не с явным округлением, а с неявным. Решишь - дам медаль, гыгыгыы... Типо от того что это округление неявное, условие облегчается... Харе возбухать по поводу условия, так и скажи - не Ферма, я, мол, как решить не знаю... А то только трендеж.

(149)баран ... ты сам запретил использовать другие функции и циклы

(151) Ты в 7.7 проверял или в 8.0? гыгыгы... Не суди о других по себе, узкоклювый

(154) ладно, обзываться некрасиво, больше небуду. Но яндекс тупит, увы.

(155)иплан а где в условии сказано, что надо 8.х ... так что либо учись формулировать задачи широкозадый... либо в школу учить математику

(156)до товего тупняка мне еще далеко

Пока все решают основную задачу можно параллельно найти самое короткое решение
Тут предложили

Возврат СтрЧислоВхождений(Число/2, Сред(0.1,2,1));

Можно укоротить

Возврат СтрЧислоВхождений(Число/2, Сред(0.5,2));

Есть еще короче?
(Пробелы не считать)

возврат найти(число/2, сред(.5, 2))

Мдя ... Что сказать "генИй" ... Сам ставит правила ... Сам их нарушает ...

кстати,
Если Синус(НашеЧисло* Пи/2) = 1 Тогда
четное
Иначе
нечетное
КонецЕсли

(162), вернее наоборот

Кстати, с возведением в степень X можно, но это опять же цикл.

(164) да нет, просто определение числа четного и нечетного - рекурсивное через сложение и умножение, так что определить четное ПРОИЗВОЛЬНОЕ число или нет, можно только используя циклы, или циклические функции... ну или операцию ОСТАТКА от деления

(164) так?

Если Pow(-1, Число) = 1 Тогда
  сообщить("Чет");
Иначе
  сообщить("НеЧет");
КонецЕсли

(165)+ а если число не произвольное - то тогда уж способов море

(165) И я про то же.
(166) Ну да.

(168) хотя, можно разложить конечное число шагов разложения синуса в ряд фурье, и сравнивать с 0.5... получится один из приемов оптимизации из экстремального программирования... шагов 7-8 будет достаточно для не очень больших чисел ;)

(169) в смысле, использовать конечное число итераций вычисления ряда фурье - записать их линейно, и все... там как раз только *,+ и - получается.

162 и 166 наиболее близко подошли к решению задачи :) Теперь надо добить решение примитивными действиями :)

(170) О :) Грамотно... Тем более, что синус так и вычисляется.

(171) а что тут добивать? просто гуглить про ряд синуса мне лень...

(173) http://upload.wikimedia.org/math/3/3/4/3342704720a80cd858d7bedc5e4b7928.png

Гений, ты где???? скажи нам, что здесь не так? :))))

Только степень без цикла ну ни как не выразишь.

(-1) в степени нашего числа это большой цикл.

(176) причем здесь степень? вы ряды фурье обосрите :)

(176) Произвольную степень - никак, но тут-то надо конечное количество членов. И вместо равенства единице проверять скажем на (>0.9). Формально можно реализовать без цикла.

(179)+ надо проверять принадлежность (-0.5,0.5) - тогда четное. а поскольку наш вычисляемый ряд - для значений, для которых полный ряд 0 или 1 - то длина ряда может быть не очень большой.

(180) мне кажется, что с синусом можно и обычной тригонометрией выразить...

(181) не понял, чем синус от обычной тригонометрии отличается?

+(182) И что такое "необычная тригонометрия"? :)

(182) у ряд Тейлора для синуса нужен цикл ещё больший чем даже перебор от 1 до числа


//*******************************************
функция ЧетНеЧет2(чисЗнач)
   тзТемп.Целое = чисЗнач / 2;
   если (тзТемп.Целое * 2) = чисЗнач тогда
       возврат "четное";
   иначе
       возврат "нечетное";
   конецесли;
конецфункции

//*******************************************
тзТемп = создатьобъект("ТаблицаЗначений");
тзТемп.НоваяКолонка("Целое", "число", 255, 0);
тзТемп.НоваяСтрока();

//*******************************************
для ВыбЧисло = 99999999999999999999999999999999999999999999999990 по 99999999999999999999999999999999999999999999999999 цикл
   сообщить(ЧетНеЧет2(ВыбЧисло));
конеццикла



(182) я имел школьный курс, что-то не выходит  )

(184) Эээ... С какого? Для вычисления первых 7-8 членов ряда формула будет не такая уж и большая. Явно меньше действий, чем перебор от 1 до миллиона, например...

(187) попробуй например для 10000....

+(188) я думаю, что разрядности очень быстро не хватит....

+(189) ряд то знакопеременный, поэтому для 10000 первые 7000 слагаемых будут достаточно большими по модулю

(189) Какая задача - такое и решение ;)

(185) баян. гений сказал, что "неявное округление" и вся фигня...

(190) Какие нахрен 7000 слагаемых?

(191) +111111111111111111111111111111111111111111111111111111адынадын!нечетное1

(193) для 10000 их будет гораздо больше

(190) там делится на факториал, вообщето. 10! = 3628800, т.е. для числа до миллиона 10 слагаемых хватит

(196), хотя гоню

+(195) слагаемых по количеству больше чем число, проверь на числе 10

(198) ну задача-то все равно решение принципиальное имеет, так что...

+(198) задача сведётся к выделению целых 2*pi - т.е. шило на мыло

(134) Короче, в формулировке опять много неточностей... неясно как быть с условием проверки типа (1/3)/3 *3 = 1/3 ?

Можно переформулировать задачу так: К разрешенным операциям +,-,/,* добавляются операции проверки на делимость на любое простое p, отличное от 2 и 5.

Т.е. добавляется такая функция mod(x, p), p <> 2 и <>5

где для любого десятичного числа типа x=y/10^n, когда y делится на p
mod(x,p) =1
иначе
mod(x,p) =0

(201) так вот, в такой формулировке решения не существует.
Доказательство посложнее, чем с запретом такой функции, может вечером выложу.

Суть в том, что из информации об остатках при делении x на простые числа>2, никак нельзя получить информацию о четности числа. Это следует из теоремы Эйлера.