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

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

Ну, у нас пока нет такой задачи, так что мы здесь.

Рассмотрим эту 3 x 3сетку прямоугольников:

Сколько есть прямоугольников? Что ж, считая визуально, мы можем видеть, что на самом деле есть 36прямоугольники, включая всю плоскость, которые все показаны в анимированном GIF ниже:

Задание

Подсчет прямоугольников, как показано выше, является задачей. Другими словами, учитывая, что 2 целых числа больше или равны 0, mи n, где mпредставляет ширину и nвысоту, выведите общее количество прямоугольников в этомm x n сетке прямоугольников.

правила

• Использование любых встроенных программ, которые непосредственно решают эту проблему, явно запрещено.

• Эта задача не в том, чтобы найти самый короткий ответ, а в том, чтобы найти самый короткий ответ на каждом языке. Поэтому ответ не будет принят.

• Стандартные лазейки запрещены.

Тестовые случаи

Представлено в формате Array of Integers Input -> Integer Output:

[0,0] -> 0
[1,1] -> 1
[3,3] -> 36 (Visualized above)
[4,4] -> 100
[6,7] -> 588

Ссылки

• http://oeis.org/A096948

Помните, это код-гольф , поэтому выигрывает самый короткий код!

Python, 22 байта

lambda m,n:m*~m*n*~n/4

Формула m*n*(m+1)*(n+1)/4сокращается с использованием битового дополнения ~m=-(m+1), выраженного (m+1)*(n+1)как ~m*~n.

Почему количество прямоугольников m*n*(m+1)*(n+1)/4? Каждый прямоугольник определяется выбором двух горизонтальных линий (сверху и снизу) и двух вертикальных линий (слева и справа). Есть m+1горизонтальные линии, из которых мы выбираем подмножество двух разных. Так что количество вариантов есть choose(m+1,2), которое есть m*(m+1)/2. Умножение на n*(n+1)/2выбор для вертикальных линий дает результат.

Желе , 4 байта

RS€P

Попробуйте онлайн!

Кроме того, также 4 байта

pP€S

Попробуйте онлайн!

Javascript (ES6), 17 байт

m=>n=>m*n*~m*~n/4

Вилка этого ответа .

f=m=>n=>m*n*~m*~n/4
alert(f(prompt())(prompt()))

Mathematica, 15 байт

##(1##+##+1)/4&

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

объяснение

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

##расширяется до последовательности всех аргументов. Это похоже на сплаттинг на других языках. Например, если аргументы есть 3и 4, то {1, 2, ##, 5}даст вам {1, 2, 3, 4, 5}. Но это не только работает в списках, но в любом выражении, например f[1, 2, ##, 5], также будетf[1, 2, 3, 4, 5] .

Это становится интересным, когда вы объединяетесь ##с операторами. Все операторы в Mathematica - это просто короткие f[...]выражения для некоторого подобного выражения (возможно, вложенного). Например, a+bэто Plus[a, b]и есть на a-bсамом деле Plus[a, Times[-1, b]]. Теперь, когда вы объединяете ##с операторами, Mathematica сначала расширяет операторы, обрабатывая их ##как один операнд, и расширяет их только в конце. Вставляя ##в правильные места, мы можем использовать его как для умножения, так и для добавления операндов.

Давайте сделаем это для кода выше:

##(1##+##+1)/4

Развернув его до полной формы, мы получим следующее:

Times[##, Plus[Times[1, ##], ##, 1], Rational[1/4]]

Давайте вставим аргументы функции aи b:

Times[a, b, Plus[Times[1, a, b], a, b, 1], Rational[1/4]]

А теперь мы конвертируем его обратно в стандартную математическую запись:

a * b * (a * b + a + b + 1) / 4

Небольшая перестановка показывает, что это произведение треугольных чисел:

a * b * (a + 1) * (b + 1) / 4
(a * (a + 1) / 2) * (b * (b + 1) / 2)
T(a) * T(b)

Забавный факт: эта реализация настолько игривая, она имеет ту же длину, что и встроенная для вычисления одного треугольного числа PolygonalNumber.

C, 25 байтов

#define r(x,y)x*y*~x*~y/4

Пуристическая версия (27):

r(x,y){return x*y*~x*~y/4;}

Версия ISO-er (35):

#define r(x,y)((x)*(y)*~(x)*~(y)/4)

Медуза , 16 байт

p|%/**+1
  4  Ei

Формат ввода есть [x y], вывод - это просто результат.

Попробуйте онлайн!

Альтернативное решение с тем же количеством байтов:

pm%/*[*i
  4  +1

объяснение

Время дать медузу представление, которого она заслуживает! :)

Медуза - это язык Згарба , основанный на его 2D-синтаксисе . Семантика в значительной степени вдохновлена ​​J, но синтаксис - произведение искусства. Все функции являются отдельными символами и расположены на сетке. Функции берут свои аргументы из следующего токена к югу и востоку от них и возвращают результат к северу и западу. Это позволит вам создать интересную сеть вызовов функций, где вы будете повторно использовать значения, передавая их в несколько функций из разных направлений.

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

p(|( /*(i*(i+1)) % 4 ))

Давайте рассмотрим код снизу вверх. Ввод получает от i, который, следовательно, оценивается в [x y].

+На вершине этого получает этот вход вместе с буквальным 1и , следовательно , увеличивает оба элемента , чтобы дать [(x+1) (y+1)](большинство операций нанизаны автоматически над списками).

Другое значение iотправляется влево, но Eраскол является восточным аргументом север и запад. Это означает, что входные данные на *самом деле являются фактическими, [x y]и [(x+1) (y+1)]поэтому это вычисляется [x*(x+1) y*(y+1)].

Следующий *шаг на самом деле изменяется предшествующим, /что превращает его в операцию сгиба. Складывание *пары просто умножает это, так что мы получаем x*(x+1)*y*(y+1).

Теперь %это просто деление, поэтому оно вычисляет x*(x+1)*y*(y+1)/4. К сожалению, это приводит к плавающему значению, поэтому нам нужно округлить его с одинарным |. Наконец, передается это значение, pкоторое печатает конечный результат.

R, 40 35 байт

Ну что ж, пора прыгать в глубокий конец! Вот мой код R , вдохновленный ответом @xnor:

a=scan();(n=a[1])*(m=a[2])*(n+1)*(m+1)/4 

РЕДАКТИРОВАТЬ : В этой версии R будет запрашивать ввод дважды.

(n=scan())*(m=scan())*(n+1)*(m+1)/4

CJam, 12 10 байт

2 байта сохранены благодаря Мартину.

{_:)+:*4/}

Попробуйте онлайн!

Это блок, который берет список из 2 элементов из стека и оставляет решение в стеке. Используется полная программа для тестирования: riari+{_:)+:*4/}~.

Основано на выдающемся решении xnor Python.

Объяснение:

{_:)+:*4/}
{        } -- Define a block
 _:)       -- Duplicate list, increment all values in new list
    +      -- Join the two lists
     :*    -- Fold multiply over all 4 elements
       4/  -- Divide by 4

Matlab, 23 19 байт

@(x)prod([x/2,x+1])

Реализация формулы m*n*(m+1)*(n+1)/4
использования:ans([m,n])

MATL , 6 байтов

tQ*2/p

Ввод является массивом формы [m,n].

Попробуйте онлайн!

объяснение

Прямые вычисления по формуле m*(m+1)*n*(n+1)/4.

t     % Input array [m,n] implicitly. Duplicate
Q     % Add 1 to each entry of the copy: gives [m+1,n+1]
*     % Multiply element-wise: gives [m*(m+1),n*(n+1)]
2/    % Divide each entry by 2: [m*(m+1)/2,n*(n+1)/2]
p     % Product of the two entries: m*(m+1)*n*(n+1)/4. Display implicitly

J, 8 байт

2*/@:!>:

Использование:

   f =: 2*/@:!>:
   f 0 0
0
   f 3 3
36

Java 7, 39 38 байт

int c(int a,int b){return~a*a*b*~b/4;}

Ява 8, 26 25 19 18 17 байт

a->b->a*~a*b*~b/4

Основано на превосходном ответе @xnor . Несколько байтов сохранено благодаря @DavidConrad . Попробуй это здесь.

Тестовый код (Java 7):

Попробуй это здесь.

class M{
  static int c(int a,int b){return~a*a*b*~b/4;}

  public static void main(String[] a){
    System.out.println(c(0, 0));
    System.out.println(c(1, 1));
    System.out.println(c(3, 3));
    System.out.println(c(4, 4));
    System.out.println(c(6, 7));
  }
}

Выход:

0
1
36
100
588

Рубин, 22 байта

Кража уловки @ xnor и создание лямбды

r=->(m,n){m*n*~m*~n/4}

Пример вызова:

r[6,7]     # => 588

Или как процесс, также 22 байта:

proc{|m,n|m*n*~m*~n/4}

Который мы могли бы тогда назвать:

proc{|m,n|m*n*~m*~n/4}.call(6,7)     # => 588

Лабиринт , 13 11 байт

*?;*_4/!
):

Попробуйте онлайн!

объяснение

Это также вычисляет произведение треугольных чисел, как и большинство ответов. Ведущий блок 2x2 представляет собой небольшой цикл:

*?
):

На первой итерации *ничего не делает, так что реальный порядок циклов такой:

?   Read integer N from STDIN or 0 at EOF and push onto stack. If 0, exit the loop.
:   Duplicate N.
)   Increment.
*   Multiply to get N*(N+1).

Оставшийся код просто линейный:

;   Discard the zero that terminated the loop.
*   Multiply the other two values.
_4  Push a 4.
/   Divide.
!   Print.

Затем Лабиринт пытается выполнить /снова, что завершает программу из-за деления на ноль.

Пайк, 6 байт

mh+Bee

Попробуй это здесь!

mh     -    map(increment, input)
  +    -   ^ + input
   B   -  product(^)
    ee - ^ \ 4

05AB1E, 4 байта

€LOP

объяснение

Использует формулу, описанную в A096948

      # Implicit input, ex: [7,6]
€L    # Enumerate each, [[1,2,3,4,5,6,7],[1,2,3,4,5,6]]
  O   # Sum, [28,21]
   P  # Product, 588
      # Implicit display

Принимает ввод как [n, m] .

Попробуйте онлайн

Пиф, 8 6 байтов

Два байта сохранены благодаря @DenkerAffe.

*FmsSd

Ввод ожидается в виде списка [m,n]. Попробуйте это здесь .

Объяснение:

          Implicit assignment of Q to eval(input).
*         Multiplication.
 F        Splat the following sequence onto the arguments of the previous function.
  m       Map the following function of d over Q (Q is implicitly added to the end).
   s      Reduce the following list with addition, initial value of 0.
    Sd    Return range(1,d+1).

C #, 19 байт

(n,m)=>m*n*~m*~n/4;

Анонимная функция, основанная на ответе @ xnor.

Луа, 74 63 байта

x,y=...n=0 for i=1,y do for j=i,i*x,i do n=n+j end end print(n)

Функция принимает входные данные в качестве числовых параметров.

Из-за того, как реализован Lua, технически это функция с переменными аргументами, которую можно вызвать, обернув ее в оператор «function» или загрузив ее из исходного кода с помощью «loadstring»

Чеддер , 23 байта

m->n->m*(m+1)*n*(n+1)/4

Brain-Flak , 84 80 байтов

({}<>)({({})<({}[()])>}{})<>({({})<({}[()])>}{}[()]){<>(({}))<>({}[()])}<>({{}})

Попробуйте онлайн!

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

К сожалению, кажется, что это невозможно, бесконечно зацикливаясь на 0 0тестовом примере, но все остальные работают нормально.

Выпуклый, 7 байт

Я знаю, что это может быть меньше, я просто не могу понять, как еще ...

_:)+×½½

Попробуйте онлайн! , Использует кодировку CP-1252.

APL (Дьялог) , 9 байт

×/+/∘⍳¨∘⊢

Попробуйте онлайн!

Пыть , 3 байта

←△Π

Объяснение:

←       Get input
 △      Get triangle numbers
  Π     Array product
        Implicit output

Попробуйте онлайн!