Знайдіть максимум два числа. Ви не повинні використовувати if-else або будь-який інший оператор порівняння. Я знайшов це запитання на дошці оголошень в Інтернеті, тому я подумав, що повинен поставити в StackOverflow

ПРИКЛАД Вхід: 5, 10 Вихід: 10

Я знайшов це рішення, хтось може допомогти мені зрозуміти ці рядки коду

int getMax(int a, int b) {  
    int c = a - b;  
    int k = (c >> 31) & 0x1;  
    int max = a - k * c;  
    return max;  
}

int getMax(int a, int b) {
    int c = a - b;
    int k = (c >> 31) & 0x1;
    int max = a - k * c;
    return max;
}

Давайте розберемо це. Цей перший рядок здається прямим - він зберігає різницю aта b. Це значення є негативним, якщо a < bі в іншому випадку невід’ємним. Тут насправді є помилка - якщо різниця чисел aі bтака велика, що не може поміститися в ціле число, це призведе до невизначеної поведінки - ой! Тож припустимо, що тут цього не відбувається.

У наступному рядку, який є

int k = (c >> 31) & 0x1;

ідея полягає в тому, щоб перевірити, чи значення cвід’ємне. Практично на всіх сучасних комп'ютерах числа зберігаються у форматі, який називається доповненням двох, в якому найвищий біт числа дорівнює 0, якщо число додатне, і 1, якщо число від'ємне. Більше того, більшість ints мають 32 біти. (c >> 31)зміщує число на 31 біт, залишаючи найвищий біт числа на місці для найнижчого біта. Наступний крок, коли беремо це число та додаємо до нього 1 (двійкове представлення якого дорівнює 0 скрізь, крім останнього біта), стирає всі старші біти і просто дає вам найнижчий біт. Оскільки найнижчий біт c >> 31- це найвищий біт c, це читає найвищий біт cяк 0 або 1. Оскільки найвищий біт дорівнює 1, якщо cдорівнює 1, це спосіб перевірити, чиcє негативним (1) або позитивним (0). Поєднуючи це міркування з вищезазначеним, kце 1, якщо a < bі 0, інакше.

Останній крок - це зробити:

int max = a - k * c;

Якщо a < b, тоді k == 1і k * c = c = a - b, і так

a - k * c = a - (a - b) = a - a + b = b

Що є правильним максимумом, оскільки a < b. В іншому випадку, якщо a >= b, то k == 0і

a - k * c = a - 0 = a

Що також є правильним макс.

Ось і ми: (a + b) / 2 + |a - b| / 2

Використовуйте побітові хаки

r = x ^ ((x ^ y) & -(x < y)); // max(x, y)

Якщо ви знаєте, що INT_MIN <= x - y <= INT_MAX,тоді ви можете скористатися наступним, що швидше, оскільки (x - y)потрібно оцінити лише один раз.

r = x - ((x - y) & ((x - y) >> (sizeof(int) * CHAR_BIT - 1))); // max(x, y)

Джерело: Bit Twiddling Hacks Шона Ерона Андерсона

(sqrt( a*a + b*b - 2*a*b ) + a + b) / 2

Це базується на тій же техніці, що і рішення mike.dld , але тут менш очевидно, що я роблю. Операція "abs" виглядає так, ніби ви порівнюєте знак чогось, але я тут користуюся тим фактом, що sqrt () завжди повертає вам позитивний квадратний корінь, тому я квадратикую (ab) виписую його повністю, а потім квадрат- вкорінюючи його знову, додаючи a + b і ділячи на 2.

Ви побачите, що це завжди працює: наприклад, приклад користувача 10 і 5 ви отримуєте sqrt (100 + 25 - 100) = 5, потім додайте 10 і 5, ви отримаєте 20, а ділення на 2 - 10.

Якщо ми використовуємо 9 і 11 як наші числа, ми отримаємо (sqrt (121 + 81 - 198) + 11 + 9) / 2 = (sqrt (4) + 20) / 2 = 22/2 = 11

Найпростіша відповідь - нижче.

#include <math.h>

int Max(int x, int y)
{
    return (float)(x + y) / 2.0 + abs((float)(x - y) / 2);
}

int Min(int x, int y)
{
    return (float)(x + y) / 2.0 - abs((float)(x - y) / 2);
}

int max(int i, int j) {
    int m = ((i-j) >> 31);
    return (m & j) + ((~m) & i);
}

Це рішення дозволяє уникнути множення. m буде або 0x00000000, або 0xffffffff

Використовуючи ідею переміщення для вилучення знаку, розміщеного іншими, ось ще один спосіб:

max (a, b) = new[] { a, b } [((a - b) >> 31) & 1]

Це виштовхує два числа в масив з максимальним числом, заданим елементом масиву, індекс якого є знаковим бітом різниці між двома числами.

Зверніть увагу, що:

1. Різниця (a - b) може переповнитися.
2. Якщо цифри без знака, а >>оператор посилається на логічний зсув вправо, & 1це непотрібно.

Ось як я думаю, що я б зробив цю роботу. Це не так читабельно, як вам може сподобатися, але коли ви починаєте з "як зробити X, не використовуючи очевидний спосіб X, ви повинні начебто цього очікувати. Теоретично це також відмовляється від певної мобільності, але ви" мені доведеться знайти досить незвичну систему, щоб побачити проблему.

#define BITS (CHAR_BIT * sizeof(int) - 1)

int findmax(int a, int b) { 
    int rets[] = {a, b};
    return rets[unsigned(a-b)>>BITS];
}

Це має певні переваги перед наведеною у питанні. Перш за все, він обчислює правильний розмір зсуву, замість того, щоб мати жорстке кодування для 32-розрядних входів. По-друге, з більшістю компіляторів ми можемо розраховувати, що все множення відбуватиметься під час компіляції, тому все, що залишається під час виконання - це тривіальна маніпуляція з бітами (віднімання і зсув) з подальшим завантаженням і поверненням. Коротше кажучи, це майже напевно буде досить швидким, навіть на найменшому мікроконтролері, де в оригіналі використовувалося множення, яке мало відбуватися під час виконання, тому, хоча це, мабуть, досить швидко на настільній машині, це часто буде досить трохи повільніше на маленькому мікроконтролері.

Ось що роблять ці рядки:

c ab. якщо c від’ємне, a <b.

k - це 32-й біт c, який є знаковим бітом c (припускаючи 32-бітові цілі числа. Якщо це зробити на платформі з 64-бітними цілими числами, цей код не буде працювати). Він зміщується на 31 біт вправо, щоб видалити крайній правий 31 біт, залишаючи знаковий біт у самому правому місці, а потім, поєднуючи його з 1, видаляє всі біти ліворуч (які заповнюються 1, якщо c негативне). Отже, k буде 1, якщо c від’ємне та 0, якщо c додатне.

Тоді max = a - k * c. Якщо c дорівнює 0, це означає a> = b, тому max дорівнює a - 0 * c = a. Якщо c дорівнює 1, це означає, що a <b, а потім a - 1 * c = a - (a - b) = a - a + b = b.

Загалом, це просто використання знакового біта різниці, щоб уникнути використання операцій, більших або менших. Чесно кажучи, трохи безглуздо говорити, що цей код не використовує порівняння. c - результат порівняння a та b. У коді просто не використовується оператор порівняння. Ви можете зробити подібне в багатьох кодах збірки, просто віднімаючи цифри, а потім стрибаючи на основі значень, встановлених у реєстрі стану.

Слід також додати, що всі ці рішення припускають, що ці два числа є цілими числами. Якщо вони плаваючі, подвійні або щось більш складне (BigInts, Rational numbers тощо), тоді вам дійсно доведеться використовувати оператор порівняння. Біт-трюки зазвичай не підходять для тих.

функція getMax () без будь-якої логічної операції-

int getMax(int a, int b){
    return (a+b+((a-b)>>sizeof(int)*8-1|1)*(a-b))/2;
}

Пояснення:

Давайте розіб'ємо `` макс '' на шматки,

max
= ( max + max ) / 2
= ( max + (min+differenceOfMaxMin) ) / 2
= ( max + min + differenceOfMaxMin ) / 2
= ( max + min + | max - min | ) ) / 2

Тож функція повинна виглядати так -

getMax(a, b)
= ( a + b + absolute(a - b) ) / 2

Зараз,

absolute(x)
= x [if 'x' is positive] or -x [if 'x' is negative]
= x * ( 1 [if 'x' is positive] or -1 [if 'x' is negative] )

У цілочисловому додатному числі перший біт (знаковий біт) дорівнює 0 ; у мінусі - 1 . Зміщуючи біти вправо (>>), перший біт може бути захоплений.

Під час зрушення вправо порожній простір заповнюється знаковим бітом. Отже, 01110001 >> 2 = 00011100 , тоді як 10110001 >> 2 = 11101100 .

У результаті для 8-бітового зсуву числа 7 біт або дасть - 1 1 1 1 1 1 1 [0 або 1] для негативного, або 0 0 0 0 0 0 0 [0 або 1] для позитивного.

Тепер, якщо операція АБО виконується з 00000001 (= 1) , негативне число дає - 11111111 (= -1) , а додатне - 00000001 (= 1) .

Так,

absolute(x)
= x * ( 1 [if 'x' is positive] or -1 [if 'x' is negative] )
= x * ( ( x >> (numberOfBitsInInteger-1) ) | 1 )
= x * ( ( x >> ((numberOfBytesInInteger*bitsInOneByte) - 1) ) | 1 )
= x * ( ( x >> ((sizeOf(int)*8) - 1) ) | 1 )

Нарешті,

getMax(a, b)
= ( a + b + absolute(a - b) ) / 2
= ( a + b + ((a-b) * ( ( (a-b) >> ((sizeOf(int)*8) - 1) ) | 1 )) ) / 2

Інший спосіб -

int getMax(int a, int b){
    int i[] = {a, b};
    return i[( (i[0]-i[1]) >> (sizeof(int)*8 - 1) ) & 1 ];
}

статичний int mymax (int a, int b)

    {
        int[] arr;
        arr = new int[3];
        arr[0] = b;
        arr[1] = a;
        arr[2] = a;
        return arr[Math.Sign(a - b) + 1];

    }

Якщо b> a тоді (ab) буде від'ємним, знак поверне -1, додавши 1, ми отримаємо індекс 0, який є b, якщо b = a, тоді ab буде 0, +1 дасть 1 індекс, так що це не має значення якщо ми повертаємо a або b, коли a> b, тоді ab буде додатним, а знак поверне 1, додаючи 1, ми отримуємо індекс 2, де зберігається a.

#include<stdio.h>
main()
{
        int num1,num2,diff;
        printf("Enter number 1 : ");
        scanf("%d",&num1);
        printf("Enter number 2 : ");
        scanf("%d",&num2);
        diff=num1-num2;
        num1=abs(diff);
        num2=num1+diff;
        if(num1==num2)
                printf("Both number are equal\n");
        else if(num2==0)
                printf("Num2 > Num1\n");
        else
                printf("Num1 > Num2\n");
}

Код, який я надаю, призначений для пошуку максимуму між двома числами, числа можуть бути будь-якого типу даних (цілі числа, плаваючі). Якщо введені числа рівні, функція повертає число.

double findmax(double a, double b)
{
    //find the difference of the two numbers
    double diff=a-b;
    double temp_diff=diff;
    int int_diff=temp_diff;
    /*
      For the floating point numbers the difference contains decimal
      values (for example 0.0009, 2.63 etc.) if the left side of '.' contains 0 then we need
      to get a non-zero number on the left side of '.'
    */
    while ( (!(int_diff|0)) && ((temp_diff-int_diff)||(0.0)) )
    {
       temp_diff = temp_diff * 10;
       int_diff = temp_diff;
    }
    /*
      shift the sign bit of variable 'int_diff' to the LSB position and find if it is 
      1(difference is -ve) or 0(difference is +ve) , then multiply it with the difference of
      the two numbers (variable 'diff') then subtract it with the variable a.
    */
    return a- (diff * ( int_diff >> (sizeof(int) * 8 - 1 ) & 1 ));
}

Опис

• Перше, що функція приймає аргументи як double і має тип return як double. Причиною цього є створення єдиної функції, яка може знайти максимум для всіх типів. Коли наводяться цілі числа, або одне є цілим, а інше - з плаваючою комою, тоді також завдяки неявному перетворенню функція може бути використана для знаходження максимуму і для цілих чисел.
• Основна логіка проста, припустимо, у нас є два числа a & b, якщо ab> 0 (тобто різниця додатна), тоді a максимум, якщо ab == 0, то обидва рівні, а якщо ab <0 (тобто diff - ve) b максимальна.

• Біт знаку зберігається у пам'яті як найзначніший біт (MSB). Якщо MSB дорівнює 1 і навпаки. Щоб перевірити, чи MSB дорівнює 1 або 0, ми переміщуємо MSB в положення LSB і побітовим & з 1, якщо результат 1, то число -ve ще ні. становить + ve. Цей результат отримується за твердженням:

  int_diff >> (sizeof (int) * 8 - 1) & 1

Тут, щоб отримати знаковий біт від MSB до LSB, ми вправо переносимо його на біти k-1 (де k - кількість бітів, необхідна для збереження цілого числа в пам'яті, що залежить від типу системи). Тут k = sizeof (int) * 8, оскільки sizeof () дає кількість байтів, необхідну для збереження цілого числа, щоб отримати no. бітів, ми множимо його на 8. Після правильного зсуву застосовуємо побітове & з 1, щоб отримати результат.

• Тепер після отримання результату (припустимо його як r) як 1 (для -ve diff) і 0 (для + ve diff) ми множимо результат на різницю двох чисел, логіка подається наступним чином:

  1. якщо a> b, то ab> 0, тобто, є + ve, то результат дорівнює 0 (тобто r = 0). Отже, a- (ab) * r => a- (ab) * 0, що дає "a" як максимум.
  2. якщо a <b, то ab <0, тобто, є -ve, то результат дорівнює 1 (тобто r = 1). Отже, a- (ab) * r => a- (ab) * 1 => a-a + b => b, що дає 'b' як максимум.

• Тепер залишилось два пункти: 1. використання циклу while і 2. чому я використав змінну 'int_diff' як ціле число. Щоб правильно відповісти на них, ми повинні зрозуміти деякі моменти:

  1. Значення плаваючого типу не можна використовувати як операнд для побітових операторів.
  2. Через вищезазначену причину нам потрібно отримати значення у цілочисельному значенні, щоб отримати знак різниці за допомогою побітових операторів. Ці два пункти описують потребу змінної 'int_diff' як цілочисельний тип.
  3. Тепер, скажімо, ми знаходимо різницю у змінній 'diff', тепер є 3 можливості для значень 'diff' незалежно від знака цих значень. (а). | різниця |> = 1, (b). 0 <| різниця | <1, (c). | різниця | == 0.
  4. Коли ми призначаємо подвійне значення цілочисельній змінній, десяткова частина втрачається.
  5. Для випадку (а) значення 'int_diff'> 0 (тобто 1,2, ...). Для інших двох випадків int_diff = 0.
  6. Умова (temp_diff-int_diff) || 0.0 перевіряє, якщо diff == 0, тож обидва числа рівні.
  7. Якщо diff! = 0, то ми перевіряємо, чи int_diff | 0 відповідає дійсності, тобто case (b) відповідає дійсності
  8. У циклі while ми намагаємось отримати значення int_diff як ненульове, щоб значення int_diff також отримувало знак diff.

Ось пара дрібниць методів щоб отримати максимум двох інтегральних значень:

Спосіб 1

int max1(int a, int b) {
  static const size_t SIGN_BIT_SHIFT = sizeof(a) * 8 - 1;
  int mask = (a - b) >> SIGN_BIT_SHIFT;
  return (a & ~mask) | (b & mask);
}

Пояснення:

• (a - b) >> SIGN_BIT_SHIFT - Якщо a > bтоді a - bпозитивне, то знаковий біт є 0, а маска є 0x00.00. В іншому випадку, a < bтак a - bнегативно, знаковий біт1 і після зсуву, ми отримуємо маску0xFF..FF
• (a & ~ mask) - Якщо маска є 0xFF..FF, тоді ~maskє 0x00..00і тоді це значення є 0. В іншому випадку ~maskє0xFF..FF і значення єa
• (b & mask) - Якщо маска є 0xFF..FF, то це значення є b. В іншому випадку maskє 0x00..00і значення є 0.

Нарешті:

• Якщо a >= bтоді a - bпозитивне, ми отримуємоmax = a | 0 = a
• Якщо a < bтоді a - bнегативне, ми отримуємоmax = 0 | b = b

Спосіб 2

int max2(int a, int b) {
  static const size_t SIGN_BIT_SHIFT = sizeof(a) * 8 - 1;
  int mask = (a - b) >> SIGN_BIT_SHIFT;
  return a ^ ((a ^ b) & mask);
}

Пояснення:

• Пояснення маски те саме, що і для методу 1 . Якщо a > bмаска є 0x00..00, інакше маска є0xFF..FF
• Якщо маска є 0x00..00, то (a ^ b) & maskє0x00..00
• Якщо маска є 0xFF..FF, то (a ^ b) & maskєa ^ b

Нарешті:

• Якщо a >= bми отримуємоa ^ 0x00..00 = a
• Якщо a < bми отримуємоa ^ a ^ b = b

// У C # ви можете використовувати математичну бібліотеку для виконання функції min або max

за допомогою системи;

клас NumberComparator {

static void Main()
{

    Console.Write(" write the first number to compare: ");
    double first_Number = double.Parse(Console.ReadLine());

    Console.Write(" write the second number to compare: ");
    double second_Number = double.Parse(Console.ReadLine());

    double compare_Numbers = Math.Max(first_Number, second_Number);
    Console.Write("{0} is greater",compare_Numbers);

}

}

Немає логічних операторів, немає libs (JS)

function (x, y) {
    let z = (x - y) ** 2;
    z = z ** .5;
    return (x + y + z) / 2
}

Логіку, описану в задачі, можна пояснити, як якщо 1-е число менше, то 0 буде віднято, інакше різниця буде віднята з 1-го числа, щоб отримати 2-е число. Я знайшов ще одне математичне рішення, яке, на мою думку, простіше зрозуміти це поняття.

Розглядаючи a та b як задані числа

c=|a/b|+1;
d=(c-1)/b;
smallest number= a - d*(a-b);

Знову ж таки, ідея полягає в тому, щоб знайти k, яке в'яне 0 або 1, і помножити його на різницю двох чисел. І нарешті це число слід відняти від 1-го числа, щоб отримати менше з двох чисел. PS це рішення не вдасться, якщо друге число дорівнює нулю

Є один шлях

 public static int Min(int a, int b)
  {
   int dif = (int)(((uint)(a - b)) >> 31);
   return a * dif + b * (1 - dif);
  }

і один

return (a>=b)?b:a;

int a=151;
int b=121;
int k=Math.abs(a-b);
int j= a+b;
double k1=(double)(k);
double j1= (double) (j);
double c=Math.ceil(k1/2) + Math.floor(j1/2);
int c1= (int) (c);
System.out.println(" Max value = " + c1);

Думаю, ми можемо просто помножити числа на їх побітове порівняння, наприклад:

int max=(a>b)*a+(a<=b)*b;