Проектная функция f (f (n)) == -n [закрыто]

В PHP

function f($n) {
    if(is_int($n)) {
        return (string)$n;
    }
    else {
        return (int)$n * (-1);
    }
}

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

Изюминкой этого решения является то, что оно работает независимо от того, начинаете ли вы со строки или целого числа, и ничего не меняет при возврате f (n).

] По моему мнению, интервьюер спрашивает, «знает ли этот кандидат, как помечать данные для дальнейшей обработки», и «знает ли этот кандидат, как помечать данные, при этом меньше всего их изменяя?» Вы можете сделать это с двойными значениями, строками или любым другим типом данных, который вам по душе.

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

Изюминкой этого решения является то, что оно работает независимо от того, начинаете ли вы со строки или целого числа, и ничего не меняет при возврате f (n).

] По моему мнению, интервьюер спрашивает, «знает ли этот кандидат, как помечать данные для дальнейшей обработки», и «знает ли этот кандидат, как помечать данные, при этом меньше всего их изменяя?» Вы можете сделать это с двойными значениями, строками или любым другим типом данных, который вам по душе.

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

Изюминкой этого решения является то, что оно работает независимо от того, начинаете ли вы со строки или целого числа, и ничего не меняет при возврате f (n).

] По моему мнению, интервьюер спрашивает, «знает ли этот кандидат, как помечать данные для дальнейшей обработки», и «знает ли этот кандидат, как помечать данные, при этом меньше всего их изменяя?» Вы можете сделать это с двойными значениями, строками или любым другим типом данных, который вам по душе.

т слабо типизированные языки. Вы должны были бы перегрузить функцию для некоторых языков.

Изюминкой этого решения является то, что оно работает независимо от того, начинаете ли вы со строки или целого числа, и ничего не меняет при возврате f (n).

] По моему мнению, интервьюер спрашивает, «знает ли этот кандидат, как помечать данные для дальнейшей обработки», и «знает ли этот кандидат, как помечать данные, при этом меньше всего их изменяя?» Вы можете сделать это с двойными значениями, строками или любым другим типом данных, который вам по душе.

т слабо типизированные языки. Вы должны были бы перегрузить функцию для некоторых языков.

Изюминкой этого решения является то, что оно работает независимо от того, начинаете ли вы со строки или целого числа, и ничего не меняет при возврате f (n).

] По моему мнению, интервьюер спрашивает, «знает ли этот кандидат, как помечать данные для дальнейшей обработки», и «знает ли этот кандидат, как помечать данные, при этом меньше всего их изменяя?» Вы можете сделать это с двойными значениями, строками или любым другим типом данных, который вам по душе.

как насчет этого (язык C):

int f(int n)
{
    static int t = 1;
    return (t = t ? 0 : 1) ? -n : n;
}

только что попробовал, и

f(f(1000)) 

возвращает -1000

f(f(-1000)) 

возвращает 1000

это правильно или я упускаю точку?

Вот реализация C ответа rossfabricant . Обратите внимание, что, поскольку я всегда использую 32-разрядные целые числа, f (f (2147483647)) == 2147483647, не -2147483647.

int32_t f( int32_t n )
{
    if( n == 0 ) return 0;
    switch( n & 0x80000001 ) {
        case 0x00000000:
            return -1 * ( n - 1 );
        case 0x00000001:
            return n + 1;
        case 0x80000000:
            return -1 * ( n + 1 );
        default:
            return n - 1;
    }
}

Если вы определили проблему, разрешив f () принять и вернуть int64_t, тогда 2147483647 накрывается. Конечно, литералы, используемые в операторе switch, должны быть изменены.

прямо сейчас верно. Однако скорее, что построение х и у с 0, Я что-то пропустил? Многие «решения» кажутся слишком сложными, и, честно говоря, не работать (как я прочитал проблему).

просто:

function f($n) {
   if ($n%2 == 0) return ($n+1)*-1;
   else return ($n-1);
}

Возможно, измена? (python)

def f(n):    
    if isinstance(n, list):
        return -n[0]
    else:
        return [n,0]    
n = 4
print f(f(n))

--output--
-4

Кажется, достаточно просто.

<script type="text/javascript">
function f(n){
    if (typeof n === "string") {
        return parseInt(n, 10)
    }
    return (-n).toString(10);
}

alert(f(f(1)));
</script>

Проблема, как указано, не требует, чтобы функция принимала ТОЛЬКО 32-битные значения, только n, как указано , является 32-битным int.

Ruby:

def f( n )
  return 0 unless n != 0 
  ( n == n.to_i ) ? 1.0 / n : -(n**-1).to_i
end

Это будет работать в очень широком диапазоне чисел:

    static int f(int n)
    {
        int lastBit = int.MaxValue;
        lastBit++;
        int secondLastBit = lastBit >> 1;
        int tuple = lastBit | secondLastBit;
        if ((n & tuple) == tuple)
            return n + lastBit;
        if ((n & tuple) == 0)
            return n + lastBit;
        return -(n + lastBit);
    }

Мой первоначальный подход состоял в том, чтобы использовать последний бит как контрольный бит, чтобы узнать, где мы будем в первом или втором вызове. По сути, я бы установил этот бит в 1 после первого вызова, чтобы сигнализировать о втором вызове, который первый уже прошел. Но этот подход был побежден отрицательными числами, последний бит которых уже достигает 1 во время первого вызова.

Та же теория применяется ко второму последнему биту для большинства отрицательных чисел. Но обычно случается так, что в большинстве случаев последние и вторые последние биты совпадают. Либо они оба равны 1 для отрицательных чисел, либо они равны 0 для положительных чисел.

Поэтому мой последний подход заключается в проверке того, являются ли они обоими 1 или обоими 0, что означает, что в большинстве случаев это первый вызов. Если последний бит отличается от второго последнего бита, то я предполагаю, что мы находимся во втором вызове, и просто повторно инвертирую последний бит. Очевидно, что это не работает для очень больших чисел, которые используют эти два последних бита. Но, опять же, он работает для очень широкого диапазона чисел.

Не сбой на MIN_INT:

int f(n) { return n < 0 ? -abs(n + 1) : -(abs(n) + 1); }

Причудливое и немного хитрое решение в Scala с использованием неявных преобразований:

sealed trait IntWrapper {
  val n: Int
}

case class First(n: Int) extends IntWrapper
case class Second(n: Int) extends IntWrapper
case class Last(n: Int) extends IntWrapper

implicit def int2wrapper(n: Int) = First(n)
implicit def wrapper2int(w: IntWrapper) = w.n

def f(n: IntWrapper) = n match {
  case First(x) => Second(x)
  case Second(x) => Last(-x)
}

Я не думаю, что это вполне правильная идея, хотя.

Clojure solution:

(defmacro f [n]
  (if (list? n) `(- ~n) n))

Работает с положительными и отрицательными целыми числами любого размера, а также с удвоением и отношением!

f(n) { return -1 * abs(n) }

Как с этим справиться? Или я упускаю суть?

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

def f(n)
    case n
    when Integer
        proc { n * -1 }
    when Proc
        n.call
    else
        raise "Invalid input #{n.class} #{n.inspect}"
    end
end

(-10..10).each { |num|
    puts "#{num}: #{f(f(num))}"
}

Это на Python. Работает для всех отрицательных значений n:

f = abs

Легко, просто заставьте f вернуть что-то, что равно любому целому числу и может быть преобразовано из целого.

public class Agreeable
{
    public static bool operator==(Agreeable c, int n)
        { return true; }

    public static bool operator!=(Agreeable c, int n)
        { return false; }

    public static implicit operator Agreeable(int n)
        { return new Agreeable(); }
}

class Program
{
    public static Agreeable f(Agreeable c)
        { return c; }

    static void Main(string[] args)
    {
        Debug.Assert(f(f(0)) == 0);
        Debug.Assert(f(f(5)) == -5);
        Debug.Assert(f(f(-5)) == 5);
        Debug.Assert(f(f(int.MaxValue)) == -int.MaxValue);
    }
}

Мой дает правильный ответ ... в 50% случаев, всегда .

int f (int num) {
    if (rand () / (double) RAND_MAX > 0.5)
         return ~num + 1;
    return num;
}

int f( int n ){
    return n==0?0:(n&1?n:-n)+(n<0?-1:1);
}

Как насчет этого?

int nasty(int input)
{
    return input + INT_MAX/2;
}

Хотя в вопросе говорилось, что n должно быть 32-битным int, в нем не говорилось, что параметр или возвращаемый тип должен быть 32-битным int. Это должно быть скомпилировано на java - в c вы можете избавиться от редактирования! = 0

private final long MAGIC_BIT=1<<38;
long f(long n) {
    return n & MAGIC_BIT != 0 ? -(n & !MAGIC_BIT) : n | MAGIC_BIT;
}

:

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

• Они просто сдаются?
• Они говорят, что это глупо?
• Они пытаются уникальные подходы?
• Общаются ли они с вами, пока работают над проблемой?
• Просят ли они о дальнейших уточнениях требований?

и т. д.

Никогда не отвечайте просто на поведенческие вопросы, если у вас нет ОЧЕНЬ ХОРОШИЙ ответ. Всегда будьте любезны и постарайтесь привлечь спрашивающего. Не расстраивайтесь и не сдавайтесь рано!

I have another solution that works half of the time:

def f(x):
    if random.randrange(0, 2):
        return -x
    return x

This is also a solution (but we are bending the rules a little bit):

def f(n):
    if isinstance(n,int):
        return str(n)
    else:
        return -int(n)

Lua:

function f(n)
    if type(n) == "number" then
        return (-number) .. ""
    else
        return number + 0
    end
end

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

Функция здесь написана вокруг идеи замкнутого 4 цикла. Если функции f разрешено приземляться только на 32-разрядные целые числа со знаком, то все вышеприведенные решения будут работать, за исключением трех чисел входного диапазона, как указали другие. minint никогда не будет удовлетворять функциональному уравнению, поэтому мы вызовем исключение, если оно является входным.

Здесь я разрешаю моей функции Python работать и возвращать либо кортежи , либо целые числа. Спецификация задачи допускает это, это только указывает, что два приложения функции должны возвращать объект, равный исходному объекту, если это int32. (Я хотел бы попросить более подробную информацию о спецификации.)

Это позволяет моим орбитам быть красивыми и симметричными и покрывать все входные целые числа (кроме minint). Первоначально я предполагал, что цикл будет посещать половинные целочисленные значения, но я не хотел запутываться с ошибками округления. Отсюда и представление кортежа. Это способ скрывать сложные вращения в виде кортежей, без использования сложных арифметических механизмов.

Обратите внимание, что между вызовами не требуется сохранять состояние, но вызывающая сторона должна разрешить, чтобы возвращаемое значение было либо кортежем, либо int.

def f(x) :
  if isinstance(x, tuple) :
      # return a number.
      if x[0] != 0 :
        raise ValueError  # make sure the tuple is well formed.
      else :
        return ( -x[1] )

  elif isinstance(x, int ) :
    if x == int(-2**31 ):
      # This value won't satisfy the functional relation in
      # signed 2s complement 32 bit integers.
      raise ValueError
    else :
      # send this integer to a tuple (representing ix)
      return( (0,x) )
  else :
    # not an int or a tuple
    raise TypeError

Таким образом, применение f к 37 дважды дает -37, и наоборот:

>>> x = 37
>>> x = f(x)
>>> x
(0, 37)
>>> x = f(x)
>>> x
-37
>>> x = f(x)
>>> x
(0, -37)
>>> x = f(x)
>>> x
37

Применение f дважды к нулю дает ноль:

>>> x=0
>>> x = f(x)
>>> x
(0, 0)
>>> x = f(x)
>>> x
0

И мы обрабатываем один случай, для которого проблема не имеет решения (в int32):

>>> x = int( -2**31 )
>>> x = f(x)

Traceback (most recent call last):
  File "<pyshell#110>", line 1, in <module>
    x = f(x)
  File "<pyshell#33>", line 13, in f
    raise ValueError
ValueError

Если вы думаете, что функция нарушает правило «без комплексной арифметики», подражая поворотам на 90 градусов умножения на i, мы можем изменить это, искажая вращения. Здесь кортежи представляют половину целых чисел, а не комплексные числа. Если вы отследите орбиты в числовой строке, вы получите непересекающиеся циклы, которые удовлетворяют заданному функциональному отношению.

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

Упражнение: реализуйте этот f2, изменив f. Есть и другие решения, например, промежуточные точки посадки должны быть рациональными числами, отличными от половины целых. Есть модуль дроби, который может оказаться полезным. Вам понадобится функция знака.

Это упражнение действительно доставило мне удовольствие от языка с динамической типизацией. Я не вижу такого решения в C.

>>> x = int( -2**31 )
>>> x = f(x)

Traceback (most recent call last):
  File "<pyshell#110>", line 1, in <module>
    x = f(x)
  File "<pyshell#33>", line 13, in f
    raise ValueError
ValueError

Если вы думаете, что функция нарушает правило «без сложной арифметики», имитируя повороты на 90 градусов умножения на i, мы можем изменить это, исказив повороты. Здесь кортежи представляют половину целых чисел, а не комплексные числа. Если вы отследите орбиты в числовой строке, вы получите непересекающиеся циклы, которые удовлетворяют заданному функциональному отношению.

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

Упражнение: реализуйте этот f2, изменив f. Есть и другие решения, например, промежуточные точки посадки должны быть рациональными числами, отличными от половины целых. Есть модуль дроби, который может оказаться полезным. Вам понадобится функция знака.

Это упражнение действительно доставило мне удовольствие от языка с динамической типизацией. Я не вижу такого решения в C.

>>> x = int( -2**31 )
>>> x = f(x)

Traceback (most recent call last):
  File "<pyshell#110>", line 1, in <module>
    x = f(x)
  File "<pyshell#33>", line 13, in f
    raise ValueError
ValueError

Если вы думаете, что функция нарушает правило «без сложной арифметики», имитируя повороты на 90 градусов умножения на i, мы можем изменить это, исказив повороты. Здесь кортежи представляют половину целых чисел, а не комплексные числа. Если вы отследите орбиты в числовой строке, вы получите непересекающиеся циклы, которые удовлетворяют заданному функциональному отношению.

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

Упражнение: реализуйте этот f2, изменив f. Есть и другие решения, например, промежуточные точки посадки должны быть рациональными числами, отличными от половины целых. Есть модуль дроби, который может оказаться полезным. Вам понадобится функция знака.

Это упражнение действительно доставило мне удовольствие от языка с динамической типизацией. Я не вижу такого решения в C.

правило, имитируя повороты на 90 градусов умножения на i, мы можем изменить это, искажая повороты. Здесь кортежи представляют половину целых чисел, а не комплексные числа. Если вы отследите орбиты в числовой строке, вы получите непересекающиеся циклы, которые удовлетворяют заданному функциональному отношению.

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

Упражнение: реализуйте этот f2, изменив f. Есть и другие решения, например, промежуточные точки посадки должны быть рациональными числами, отличными от половины целых. Есть модуль дроби, который может оказаться полезным. Вам понадобится функция знака.

Это упражнение действительно доставило мне удовольствие от языка с динамической типизацией. Я не вижу такого решения в C.

правило, имитируя повороты на 90 градусов умножения на i, мы можем изменить это, искажая повороты. Здесь кортежи представляют половину целых чисел, а не комплексные числа. Если вы отследите орбиты в числовой строке, вы получите непересекающиеся циклы, которые удовлетворяют заданному функциональному отношению.

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

Упражнение: реализуйте этот f2, изменив f. Есть и другие решения, например, промежуточные точки посадки должны быть рациональными числами, отличными от половины целых. Есть модуль дроби, который может оказаться полезным. Вам понадобится функция знака.

Это упражнение действительно доставило мне удовольствие от языка с динамической типизацией. Я не вижу такого решения в C.

Если вы отследите орбиты в числовой строке, вы получите непересекающиеся циклы, которые удовлетворяют заданному функциональному отношению.

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

Упражнение: реализуйте этот f2, изменив f. Есть и другие решения, например, промежуточные точки посадки должны быть рациональными числами, отличными от половины целых. Есть модуль дроби, который может оказаться полезным. Вам понадобится функция знака.

Это упражнение действительно доставило мне удовольствие от языка с динамической типизацией. Я не вижу такого решения в C.

Если вы отследите орбиты в числовой строке, вы получите непересекающиеся циклы, которые удовлетворяют заданному функциональному отношению.

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

Упражнение: реализуйте этот f2, изменив f. Есть и другие решения, например, промежуточные точки посадки должны быть рациональными числами, отличными от половины целых. Есть модуль дроби, который может оказаться полезным. Вам понадобится функция знака.

Это упражнение действительно доставило мне удовольствие от языка с динамической типизацией. Я не вижу такого решения в C.

1235 Это упражнение действительно доставило мне удовольствие от динамически типизированного языка. Я не вижу такого решения в C.

1235 Это упражнение действительно доставило мне удовольствие от динамически типизированного языка. Я не вижу такого решения в C.

​​

На CodePlex есть библиотека с открытым исходным кодом: MsmqJava . Бесплатно.

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

Пример того, что может быть:

R = числа, делящиеся на 3 и S = ​​числа, не делящиеся на 3.

Затем берем g (6r) = 3r + 1, g (6r + 3 ) = 3r + 2.

const unsigned long Magic = 0x8000000;

unsigned long f(unsigned long n)
{    
    if(n > Magic )
    {
        return Magic - n;
    }

    return n + Magic;
} 

0 ~ 2 ^ 31

Что насчет следующего:

int f (int n)
{
    static bool pass = false;
    pass = !pass;
    return pass? n : -n;
}

int j = 0;

void int f(int n)
{    
    j++;

    if(j==2)
    {
       j = 0;
       return -n;
    }

    return n;
}

: D

void f(int x)
{
     Console.WriteLine(string.Format("f(f({0})) == -{0}",x));
}

Извините, ребята ... это было слишком заманчиво;)

C++ solution;

long long f(int n){return static_cast <long long> (n);}
int f(long long n){return -static_cast <int> (n);}

int n = 777;
assert(f(f(n)) == -n);