Здравствуйте, Панда, Вы писали:

П>Кстати, можно сформулировать аналогичную задачу по математике, а не по программированию.
П>Найти функцию f, для которой f(f(x)) — -x
П>x — любое вещественное число без ограничений.
П>Такую функцию я тоже придумал, но пока не смог записать ее аналитически.

А для комплексных?

Здравствуйте, Аноним, Вы писали:

А>А для комплексных?

f(x)=i*x
f(f(x))=-x

Легко и программно реализуется(класс КЧ и всё такое)...

Здравствуйте, deniok, Вы писали:

D>

D>Задача: написать функцию f(x), так, что f(f(x)) = -x. Разрешено использовать только
D>целые числа. x — целочисленный аргумент (например, 32-битный).

D>от avva

int f(int x)
{
static bool bEvenCall = false;
if( bEvenCall )
x = ~x;
else
x++;
bEvenCall = !bEvenCall;
return x;
}

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, deniok, Вы писали:

D>>

D>>Задача: написать функцию f(x), так, что f(f(x)) = -x. Разрешено использовать только
D>>целые числа. x — целочисленный аргумент (например, 32-битный).

D>>от avva

А>int f(int x)
А>{
А> static bool bEvenCall = false;
А> if( bEvenCall )
А> x = ~x;
А> else
А> x++;
А> bEvenCall = !bEvenCall;
А> return x;
А>}

Я эту идею уже утрировал

Автор: vadimcher
Дата: 18.01.08

в виде выдвигающегося/задвигающегося CD-ROM-а. В обоих случаях используется статическая переменная (в случае с CD-ROM -- hard static bool). Идея в том, что если между двумя последовательными вызовами что-то произойдет, ну, например, вы вызовите эту же функцию для другого аргумента из другого потока (или вручную задвините CD-ROM ), то все полетит.

Здравствуйте, deniok, Вы писали:

D>

D>Задача: написать функцию f(x), так, что f(f(x)) = -x. Разрешено использовать только
D>целые числа. x — целочисленный аргумент (например, 32-битный).

D>от avva

Лехко:

   typedef TArgType int;

   TArgType f( TArgType x )
    {
        if( x )
        {
            if( x & 1 )
            {
                if( x > 0 ) x++;
                else        x--;
            }
            else
            {
                x = -x;
                if( x > 0 ) x--;
                else        x++;
            }
        }

        return x;
    }

Всего наилучшего

Здравствуйте, yachmen, Вы писали:

Y>Здравствуйте, deniok, Вы писали:

D>>

D>>Задача: написать функцию f(x), так, что f(f(x)) = -x. Разрешено использовать только
D>>целые числа. x — целочисленный аргумент (например, 32-битный).

D>>от avva

Y>Лехко:

Y>

Y>   typedef TArgType int;

Y>   TArgType f( TArgType x )
Y>    {
Y>        if( x )
Y>        {
Y>            if( x & 1 )
Y>            {
Y>                if( x > 0 ) x++;
Y>                else        x--;
Y>            }
Y>            else
Y>            {
Y>                x = -x;
Y>                if( x > 0 ) x--;
Y>                else        x++;
Y>            }
Y>        }

Y>        return x;
Y>    }
Y>

Y>Всего наилучшего

f(f(0x80000001)) = 0x80000001

Здравствуйте, vadimcher, Вы писали:

V>f(f(0x80000001)) = 0x80000001

Прикольно — ведь я и проверял-то только -1, 0, 1, 0x7fffffff, 0x80000000 и 0x80000001 — но глаз замылился и не увидел это в логе
Т.о. вывод такой — можно сделать эту функцию для всех чисел кроме двух, необязательно 0x80000000 и 0x80000001.

Всего наилучшего

Здравствуйте, Ячменников Александр, Вы писали:

ЯА>Здравствуйте, vadimcher, Вы писали:

V>>f(f(0x80000001)) = 0x80000001

ЯА>Прикольно — ведь я и проверял-то только -1, 0, 1, 0x7fffffff, 0x80000000 и 0x80000001 — но глаз замылился и не увидел это в логе
ЯА>Т.о. вывод такой — можно сделать эту функцию для всех чисел кроме двух, необязательно 0x80000000 и 0x80000001.

ЯА>Всего наилучшего

Я бы даже сказал, можно для всех чисел, кроме одного.

Здравствуйте, vadimcher, Вы писали:

V>Здравствуйте, Ячменников Александр, Вы писали:

ЯА>>Здравствуйте, vadimcher, Вы писали:

V>>>f(f(0x80000001)) = 0x80000001

ЯА>>Прикольно — ведь я и проверял-то только -1, 0, 1, 0x7fffffff, 0x80000000 и 0x80000001 — но глаз замылился и не увидел это в логе
ЯА>>Т.о. вывод такой — можно сделать эту функцию для всех чисел кроме двух, необязательно 0x80000000 и 0x80000001.

ЯА>>Всего наилучшего

V>Я бы даже сказал, можно для всех чисел, кроме одного.

Что, кстати, иллюстрирует необходимость покрытия кода тотальными тестами (или использования формальной верификации программы)

Здравствуйте, Ячменников Александр, Вы писали:

ЯА>Т.о. вывод такой — можно сделать эту функцию для всех чисел кроме двух, необязательно 0x80000000 и 0x80000001.

Ну это скорее следствие того, что для какого-то числа х нельзя вычислить -х...

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Ячменников Александр, Вы писали:

ЯА>>Т.о. вывод такой — можно сделать эту функцию для всех чисел кроме двух, необязательно 0x80000000 и 0x80000001.

E>Ну это скорее следствие того, что для какого-то числа х нельзя вычислить -х...

Ну, в общем, да... Хотя, -x формально можно вычислить для любого числа: -0=0, -0x80000000=0x80000000. Просто для одного из них это будет математически неверное -x.

Но проблема здесь не в этом. Если a->b, то b->-a, и -a->-b->a. Т.е. если a!=-a, то требуются четверки чисел, а все такие числа, для которых a!=-a на четверки как раз и не делятся. Т.е. если бы таких чисел было число, кратное 4, то задача решалась бы.

Здравствуйте, deniok, Вы писали:

D>Здравствуйте, vadimcher, Вы писали:

V>>Здравствуйте, Ячменников Александр, Вы писали:

ЯА>>>Здравствуйте, vadimcher, Вы писали:

V>>>>f(f(0x80000001)) = 0x80000001

ЯА>>>Прикольно — ведь я и проверял-то только -1, 0, 1, 0x7fffffff, 0x80000000 и 0x80000001 — но глаз замылился и не увидел это в логе
ЯА>>>Т.о. вывод такой — можно сделать эту функцию для всех чисел кроме двух, необязательно 0x80000000 и 0x80000001.

ЯА>>>Всего наилучшего

V>>Я бы даже сказал, можно для всех чисел, кроме одного.

D>Что, кстати, иллюстрирует необходимость покрытия кода тотальными тестами (или использования формальной верификации программы)

Да уж... Я сразу вспоминаю недавний глюк Excel 2007, который "работал" только для 12 из 9.2*10^18 64-битных чисел с плавающей точкой.

Здравствуйте, vadimcher, Вы писали:

V>Ну, в общем, да... Хотя, -x формально можно вычислить для любого числа: -0=0, -0x80000000=0x80000000. Просто для одного из них это будет математически неверное -x.

Зависит от. Если используется прямой код, то -0x80000000=0x00000000, т.е -(-0)=0.
В обратном коде -0x80000000=0x7FFFFFFFF или -(-2147385345)=2147385345.

Здравствуйте, Ячменников Александр, Вы писали:

ЯА>Прикольно — ведь я и проверял-то только -1, 0, 1, 0x7fffffff, 0x80000000 и 0x80000001 — но глаз замылился и не увидел это в логе
ЯА>Т.о. вывод такой — можно сделать эту функцию для всех чисел кроме двух, необязательно 0x80000000 и 0x80000001.

Ну, тут уже показывали, что для 32-битных целых (да и вообще для любых целых в двоичной сетке) это невозможно.
Дело в том, что все числа кроме 0 и INT_MIN (в дополнительном коде INT_MIN < -INT_MAX) группируются по 4:
{ x, y=f(x), -x=f(y), -y=f(-x) }, дальше будет x=f(-y)
Остаются 0 и INT_MIN, так что либо f(0)=0, f(INT_MIN)=INT_MIN, либо f(0)=INT_MIN, f(INT_MIN)=0.

Итого, мощность множества целых чисел равна 4n+2. А на самом деле — 2^p.

А в прямом коде, где -0 и 0 — это разные числа, и они не выпадают из общего правила f(f(x))=-x, f(f(0))=-0, — решение есть.
Произвольным образом разбиваем множество Z+ неотрицательных чисел на два равномощных подмножества A+, B+ и строим f как колечки: A+ -> B+ -> A- -> B-.
В качестве способа разбиения проще всего предложить чётность.

То же касается неограниченных целых чисел, и для вещественных. Там есть единственное особое число 0, и для него f(0)=0. А все остальные так же группируются.
У вещественных можно разбивать по признаку frac(x) < / >= 0.5, например.