У Барда я спрашивал

[vak]

На собеседованиях я часто спрашиваю программистов, как сложить на Си два целых числа. Проверим, как с этим справится Гугл Бард.

Please create a function "int add(int a, int b)", which adds two integer numbers and avoids undefined behavior.

Мгновенный ответ:

Sure, here is the C function int add(int a, int b) that adds two integer numbers and avoids undefined behavior:

int add(int a, int b) {
  int sum;

  /* Check for overflow */
  if (a > 0 && b > 0 && (a > INT_MAX - b)) {
    /* Overflow detected */
    return INT_MAX;
  } else if (a < 0 && b < 0 && (a < INT_MIN - b)) {
    /* Overflow detected */
    return INT_MIN;
  }

  /* Add the two numbers */
  sum = a + b;

  return sum;
}

This function first checks for overflow by comparing the two numbers to the maximum and minimum values for an integer. If either number is greater than the maximum value or less than the minimum value, then the function returns INT_MAX or INT_MIN, respectively. Otherwise, the two numbers are added together and the result is returned.

This function avoids undefined behavior by checking for overflow before adding the two numbers. If overflow is detected, the function returns a safe value instead of crashing or producing unexpected results.

За последние несколько лет ни от кого из сапиенсов я не получал настолько быстрый и исчерпывающий ответ. Но продолжим:

Please create a few tests for this function.

Пауза чуть подольше:

Sure, here are a few tests for the add() function:

#include <stdio.h>

int add(int a, int b);

int main() {
  int expected, actual;

  /* Positive numbers */
  expected = 10;
  actual = add(5, 5);
  if (expected != actual) {
    printf("add(5, 5) expected %d, got %d\n", expected, actual);
    return 1;
  }

  /* Negative numbers */
  expected = -10;
  actual = add(-5, -5);
  if (expected != actual) {
    printf("add(-5, -5) expected %d, got %d\n", expected, actual);
    return 1;
  }

  /* Overflow */
  expected = INT_MAX;
  actual = add(INT_MAX - 1, 1);
  if (expected != actual) {
    printf("add(INT_MAX - 1, 1) expected %d, got %d\n", expected, actual);
    return 1;
  }

  /* Underflow */
  expected = INT_MIN;
  actual = add(INT_MIN + 1, -1);
  if (expected != actual) {
    printf("add(INT_MIN + 1, -1) expected %d, got %d\n", expected, actual);
    return 1;
  }

  return 0;
}

These tests cover a variety of cases, including positive numbers, negative numbers, overflow, and underflow. If all of these tests pass, then it is likely that the add() function is working correctly.

Неплохо, но я же дотошный, продолжаю усугублять.

Please use Googletest for tests.

Этого Барда ничем не проймёшь.

Sure, here are the same tests written using GoogleTest:

#include <gtest/gtest.h>

int add(int a, int b);

TEST(AddTest, Positive) {
  EXPECT_EQ(10, add(5, 5));
}

TEST(AddTest, Negative) {
  EXPECT_EQ(-10, add(-5, -5));
}

TEST(AddTest, Overflow) {
  EXPECT_EQ(INT_MAX, add(INT_MAX - 1, 1));
}

TEST(AddTest, Underflow) {
  EXPECT_EQ(INT_MIN, add(INT_MIN + 1, -1));
}

These tests are written using the GoogleTest framework, which provides a more structured and organized way to write tests. The EXPECT_EQ() macro asserts that the two arguments are equal. If they are not equal, the test will fail.

These tests can be run using the gtest command-line tool. For example, to run all of the tests, you would use the following command:

gtest add_test.cc

If all of the tests pass, then the output will be:

[==========] Running 4 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 4 tests from AddTest
[ RUN      ] AddTest.Positive
[       OK ] AddTest.Positive (0 ms)
[ RUN      ] AddTest.Negative
[       OK ] AddTest.Negative (0 ms)
[ RUN      ] AddTest.Overflow
[       OK ] AddTest.Overflow (0 ms)
[ RUN      ] AddTest.Underflow
[       OK ] AddTest.Underflow (0 ms)
[----------] 4 tests from AddTest (0 ms total)

[----------] No test cases ran.
[----------] No assertions have been violated.

[==========] 4 tests passed.

Ну что сказать. Искусственный интеллект становится реальным помощником программисту.

Comments

[chabapok]

у меня тут было время, я эту задачу крутил... А она именно так звучит? Способов я нашел дохрена, но у меня всегда пара чисел "лишних" остается, для которых не получается выполнить требуемое условие.

такое можно сделать по модулю некоторых простых чисел. Например по модулю 73 имеем: 27*27=72. А 72 по модулю 73 ведет себя как -1. Поэтому, если у нас арифметика по модулю 73, то такое делается умножением на 27.

Поэтому везде, где по модулю "p" выражение (p-1) имеет корень квадратный, такое делается просто умножением на соответствующее число. Как считать символы лежандра и корни по модулю - относительно легко найти в гугле.

Но в арифметике по модулю 2^n такой финт уже не прокатывает.

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

[ichthuss]

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

[chabapok]

"найти причину по которой можно отлынивать от работы" - как вопрос на собеседовании. Офигенно %)

[ichthuss]

А зачем фирме работник, который возьмется за заведомо невыполнимое и предсказуемо запорет?

[chabapok]

Концепция хорошая, другое дело что в нашем несовершенном мире такое редко случается. Обычно если задача изначально выглядит решаемой, то нужно сначала приложить определенные усилия, чтобы понять, что это не так. После этого надо задуматься "а что делать?", возможно обсудить с начальством/коллегами, и обычно что-то делать все же нужно, иначе заказчик же не заплатит.

Так что довольно часто частичное решение лучше полного нерешения. Возьмем, например, деление. Если ты начнешь отлынивать от работы по причине "понимаете, в знаменателе может же быть 0, так что задача деления чисел нерешаема" - то тебя не поймут

Но принципиально же f:int32->int32 не отличается от f(a,b) = a/b . Так что, написать программу, которая бросает исключение при недопустимых входных данных - это вроде бы ок.

Тут важно не стать заложником своих ожиданий. Например, если ты ожидал, что человек откажется выполнять задание - а он выдал результат, бросающий исключение, то это вобщем-то можно считать равноценным решением. Хотя в некоторых случаях надо предварительно дообсудить, и только потом делать.

- - -

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

[ichthuss]

Ну, собственно, если бы мне задали такую задачку, я бы сказал: в строгом виде она нерешаема. Если хотите, могу привести доказательство нерешаемости, а если хотите, могу написать реализацию, работающаю для всего множества за исключением двух заданных чисел x и -x.

Кстати, совершенно аналогичная, часто встречающаяся и имеющая значительные последствия ошибка: попытка парсить XML регулярными выражениями.

[chabapok]

Задачи в стиле "парсить XML регулярными выражениями" имеют больше не практическую, а учебную пользу. Если возвести в степень абсурда: погуглите "написала тетрис на sed".

[ichthuss]

Я sed'ом пользовался немного, но говорят, что он тьюринг-полный, то есть любая в принципе решаемая задача решаема на sed'е. Регулярные выражения, напротив, годятся только для разбора регулярного языка. Язык, не являющийся регулярным - тот же XML - регексами корректно распарсить нельзя в принципе. Иными словами, какое регулярное выражение ни возьми, обязательно существует такой корректный XML, который этот регекс не распарсит.