Как лучше организовать структуру данного кода?

Question

[randomguyasking]

Посоветуйте как лучше организовать данный код. Задача по сути простая:
Дано A, B, C - числовые переменные. Между ними могут быть следующие отношения:
A > B > C
A < B < C
Также дана числовая переменная X. Эта переменная может быть равна A, B, C (3 варианта), может быть в интервалах между ними (2 варианта), и выходить за грани (быть меньше A, или больше C (2 варианта)). Итого 7 вариантов. Учитывая, что может быть как A > B > C так и A < B < C умножаем кол-во вариантов на 2, итого 14 возможных вариантов для X.
Я решил эту задачу только с помощью if'ов:

if (A < B && B < C) {
  if (X < A) { 
    // что-то делаем
  }
  if (X == A) {
    // делаем другое
  }
  if (X > A && X < B) {
    // делаем третье
  }
  // и так далее, все 14 вариантов вхождения для X
}

Этот код работает, но он довольно громоздкий (куча if'ов) и не очень читается (в реальности названия переменных другие и кода больше). Как можно по-другому организовать такой код? Возможно ли здесь подобрать структуру данных, которая сделает код более лаконичным и простым? Или по-другому описать условные проверки?

Comments

[twobomb]

Лучше так и делать, вам всеравно нужно на каждое условие какие-то действия прописывать.

[Сергей Соколов]

if (X > A && X < B) { тут лишняя проверка X > A, если использовать else

Answer 1

[Сергей Соколов]

Если действия симметричны, т.е. при X > (C > B > A) действия те же, что при X > (A > B > C),
можно привести переменные к однозначно возрастающему варианту — поменять местами A и C если A > C.
Так вариантов останется 7.

if (A > C) [A, C] = [C, A]; // поменять местами значения A и C
                            // теперь точно A < B < C
if (X < A) {          // вар. 0
} else if (X == A) {  // вар. 1 
} else if (X < B) {   // вар. 2
} else if (X == B) {  // вар. 3
} else if (X < C) {   // вар. 4
} else if (X == C) {  // вар. 5
} else { // X > C     // вар. 6
}

Ещё один способ — с бинарным деревом, который интуитивно но неправильно пытался подсказать xmoonlight
Всего есть 2 * 7 = 14 вариантов. Гипотеза о том, что действия зеркальны для двух вариантов A > B > C и A < B < C вроде бы подтвердилась, поэтому оставлю первый шаг, где меняем местами A и C, чтобы последовательность точно была возрастающей.

Остаётся 7 вариантов. Достаточно 3 битов, чтобы закодировать любой из них. Каждый бит это ответ на 1 вопрос, проверка одного условия. Т.е. достаточно всего трёх if'ов для определения нужного блока кода:

0  1  2  3  4  5  6 
---o-----o-----o---   
   A     B     C      

0  1  0  1  0  1  0  1
0  0  1  1  0  0  1  1
0  0  0  0  1  1  1  1

Примерно так:

if (A > C) [A, C] = [C, A]; // поменять местами значения A и C
                            // теперь точно A < B < C
if (X > B) {
  if (X > C) {    // вар. 6
  } else {
    if (X == C) { // вар. 5
    } else {      // вар. 4
    }
  }
} else {
  if (X > A) {
    if (X == B) { // вар. 3
    } else {      // вар. 2
    }
  } else {
    if (X == A) { // вар. 1
    } else {      // вар. 0
    }
  }
}

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

Comments

[xmoonlight]

Этот ответ не самый лучший.
Почему? Здесь используется каскад из условий.
И в данной задаче данный подход будет работать медленнее ровно в 3 раза "дерева" условий, указанного в моём ответе.
Поэтому, если скорость работы кода - важна, то стоит обратить на это внимание!

[randomguyasking]

Сергей Соколов
Да, действия симметричны. Я не сразу это увидел, поскольку задание мне было поставлено в не самом удобочитаемом виде. Пришлось составить таблицу и расписать все действия для кадого условия, и только тогда я увидел симметрию. Сей факт + ваш совет позвоилили мне значительно сократить код.

Answer 2

[Михаил Ушенин]

Все ваши случаи можно представить себе на координатной прямой и сопоставить каждый из них с числом на этой прямой. Например, если A < B < C, то числа будут положительными, а если A > B > C, то отрицательными (A ближе к нулевой отметке, а C — дальше; чем X дальше от нуля, тем его абсолютное значение больше).

A > B > C > X = -7
A > B > X == C = -6
A > B > X > C = -5
A > X == B > C = -4
A > X > B > C = -3
X == A > B > C = -2
X > A > B > C = -1
0
X < A < B < C = 1
X == A < B < C = 2
A < X < B < C = 3
A < X == B < C = 4
A < B < X < C = 5
A < B < X == C = 6
A < B < C < X = 7

Можно написать функцию, которая определит числовой индекс для каждого из этих случаев. Потом передаёте X, A, B и C в эту функцию, получаете числовой индекс конкретного случая и организуете свой код с помощью switch (case_id). Тогда в нём не будет множества условий сравнения 4 чисел, а только номера случаев, соответствующих разным числам на воображаемой координатной прямой.

Возможно, такая математическая абстракция вам будет нагляднее.

Ещё вариант: возвращать в такой вспомогательной функции не число, а строковый идентификатор вида "A < X < B < C" или "A > X == B > C". Т. е. возвращаемая функцией строка будет выглядеть так, как бы вы написали условие в понятном для себя виде. Свой рабочий код можно затем точно так же организовать средствами switch, только вместо числовых идентификаторов (которые я описал в начале) нужно использовать строковые (с понятными обозначениями условий) — по ним будет легко понять, какой случай в данный момент обрабатывается вашим кодом.

Чтобы избежать опечаток в написании строковых идентификаторов, сохраните их в константы и используйте константы вместо строк — их легко вставлять в код, если в вашем редакторе или IDE есть функция автодополнения.

Answer 3

[xmoonlight]

Скажу сразу, что ответ Сергей Соколов представляет из себя крайне медленное по производительности решение и в целом, его ответ нелогичен и даже ошибочен!
В нём много излишних условий и проверок, которые попросту неверно изначально были им спроектированы логически, что привело к хаосу в его коде.
Он попытался его поправить, используя мой ответ, но, к сожалению, это так и не спасло ситуацию.

Правильно делать так:

/* проверяем все центры */
1. X==A
2. X==B
3. X==C

/* проверяем левую ветку: X<B */
4. X<A
5. else ... //X>A

/* проверяем правую ветку: else */
6. X<C
7. else ... //X>C

При таком подходе затрачиваемое время работы кода на сопоставление X к нужному значению (A,B,C) или диапазону - МИНИМАЛЬНО и ОПТИМАЛЬНО.

Comments

[Сергей Соколов]

/* левая ветка: X<B */

это не комментарий, а ещё она проверка
и может быть вариант A > B > C
Получается 9, а не 7 условий, не работающих в половине случаев.

[xmoonlight]

Сергей Соколов, Про коменты - это для понимания ветвления, разумеется с проверками. Условия просто разграничивают диапазоны.
А сами функции в них задаются потом.
И в обе стороны всё будет работать во всех случаях.

randomguyasking, Можно брать B за 0, и проводить проверку по модулю.
Тогда будет 4 условия.

И советую вначале проверять предложенные решения прежде, чем тупо верить комментам Сергей Соколов и подобным.

[Сергей Соколов]

xmoonlight, не будет в обоих случаях работать, т.к. условия для A и C разные.
Советую думать. Потом утверждать. В любом случае, думать, больше думать.

[xmoonlight]

Сергей Соколов, в моём ответе показано просто ветвление диапазонов: ветки - разные, а что в них будет вызываться (функции обработки) - зависит от конкретной задачи.
Если дерево симметрично относительно B, то вызывается одна и та же функция в левой и правой ветке и тогда не нужно никаких доп. преобразований для одинаковой работы алгоритма в обе стороны.
Верно же?

[Сергей Соколов]

ТС уже в формулировке вопроса привёл разумный подход, рассматривая возможные диапазоны последовательно: X от минимальных значений и по возрастанию.

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

[xmoonlight]

Сергей Соколов, 1.

не будет в обоих случаях работать, т.к. условия для A и C разные.

2.

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

Я не понял:
1. В каком пункте твоя правда?
2. Чем именно ответ плох?

Усложнения - здесь меньше, чем в твоём ответе, где ты делаешь аж целых ВОСЕМЬ! проверок!
Я же делаю - всего 7!
Итог: моя разбивка диапазонов самая логичная, т.к. решает задачу и имеет минимальное количество ветвлений и сравнений.

И поэтому, я не могу понять логику твоего первого коментария под моим ответом...

[Сергей Соколов]

/* левая ветка: X<B */
4. X<A

Здесь ошибка, т.к. может быть A > B > C
Отсутствует проверка отношений A и С — кто больше?

[xmoonlight]

Сергей Соколов, я понял...
Я подразумевал, что заранее на числовой прямой A,B и C - всегда стоят в порядке возрастания перед началом всех проверок.

[Сергей Соколов]

Я дополнил свой ответ тем, что ты имеешь в виду, но плохо реализуешь.

[xmoonlight]

Сергей Соколов, ответ я прочитал: логика - описана текстом нормально, но код ты крайне непонятно запутал...

Я же как раз делаю проще: вначале все "попадания", потом - все "промахи".
И главное - это сработает быстрее, т.к. проверка на полное совпадение "===" проходит быстрее, чем проверка неравенства (>,<,etc.), и после - там остаётся максимум! всего 2 неравенства.

PS: И, хотя, это уже оптимизация производительности, моё решение будет работать быстрее твоего в любом случае...

[Сергей Соколов]

xmoonlight, jsPerf или не было.

[xmoonlight]

Сергей Соколов, NOT jsPerf или не было. ;) Откуда js вдруг?!))
Не веришь? Бери и проверяй сам на любом языке... (результат - будет схожим).

[Сергей Соколов]

xmoonlight, фигня. Ты в любом случае делаешь 3 проверки на строгое равенство и ещё 2 сравнения, итого 5.

Я делаю всего 3. В том числе на строгое равенство.

[xmoonlight]

Сергей Соколов,

Я делаю всего 3. В том числе на строгое равенство.

Ты свой код не понимаешь совсем, по-ходу...
Просто прими своё поражение в плане логики.

[Сергей Соколов]

В моём блестящем решении, достойном интервью в Google, не 3, а не более трёх проверок потребуется, чтобы определить, какой блок кода выполнять при данном X.

В лучшем случае, когда X > C, проверок вообще всего две: X > B и X > C Остальные случаи потребуют ровно 3 сравнения.

Твоё слабенькое решение три попытки тратит уже на проверку равенств с A, B и C. Далее добавляются ещё по 2 проверки на неравенства.

«Удоли»

[xmoonlight]

Сергей Соколов,

В моём блестящем решении, достойном интервью в Google, не 3, а не более трёх проверок потребуется, чтобы определить, какой блок кода выполнять при данном X.

Жжошь!))
Ок... Давай посчитаем, если хочешь))
Неравенство - 2 балла.
Равенство - 1 балл.

Твой вариант:
Лучший случай - 4 балла: два неравенства.
Худший - 5 баллов.
Сумма: 9 баллов.

Мой:
Лучший случай - 1 балл: одно полное совпадение.
Худший - 5 баллов.
Сумма: 6 баллов.

Итог - ясен?

[Сергей Соколов]

xmoonlight, высасываешь из пальца. В 2 раза «дороже» неравенство, чем равенство? Srsly?
Хорошо, вот все варианты, сколько равенств и неравенств:

___   @sergiks   @xmoonlight
Вар.   Р  Н       Р  Н

0      1  2       3  2 
1      1  2       1  0 
2      1  2       3  2  
3      1  2       2  0  
4      1  2       3  2  
5      1  2       3  0  
6      0  2       3  2

       6 14      18  8
        20         26

Твой вариант слишком тяжёл и требователен к вычислениям.
Удоли уже.

[xmoonlight]

Сергей Соколов, твоя таблица - полный бред, т.к. она не учитывает порядок следования и частотность.

И да, повторю: равенство ВСЕГДА! работает быстрее неравенства!

У тебя всегда 2 неравенства в любом случае (против моего одного равенства!) и этим всё сказано.

Твой ответ - неоптимальный.

Answer 4

[Somewhere Intech]

Если действия нельзя как то сгруппировать по условиям, то if ... else пожалуй лучшая конструкция для js.