Cóż, chociaż wyzwanie to okazało się ogromnym sukcesem, okazało się również, że jego rozwiązanie było bardzo trywialne. Dlatego dla tych, którzy szukają większego wyzwania, stworzyłem kontynuację tego wyzwania, w którym musisz teraz policzyć liczbę unikalnych prostokątów. Sprawdź to!

Teraz, dla tych z Was, którzy chcą rozwiązać to wyzwanie, nadchodzi.

Cóż, tak naprawdę nie mamy takiego wyzwania, więc proszę bardzo.

Rozważ tę 3 x 3siatkę prostokątów:

Ile jest prostokątów? Cóż, licząc wizualnie, widzimy, że w rzeczywistości są 36prostokąty, w tym cała płaszczyzna, wszystkie pokazane na animowanym pliku GIF poniżej:

Zadanie

Liczenie prostokątów, jak pokazano powyżej, jest zadaniem. Innymi słowy, biorąc pod uwagę 2 całkowite większe niż lub równe 0, mi n, w których moznacza się szerokość i nreprezentuje wysokość, moc całkowitą liczbę prostokątów w tej m x nsiatce prostokątów.

Zasady

• Zastosowanie jakichkolwiek wbudowanych rozwiązań, które bezpośrednio rozwiązują ten problem, jest wyraźnie zabronione.

• Wyzwanie to nie polega na znalezieniu najkrótszej odpowiedzi, ale na znalezieniu najkrótszej odpowiedzi w każdym języku. Dlatego żadna odpowiedź nie zostanie zaakceptowana.

• Standardowe luki są zabronione.

Przypadki testowe

Przedstawione w formacie Array of Integers Input -> Integer Output:

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

Referencje

• http://oeis.org/A096948

Pamiętaj, to jest gra w golfa , więc wygrywa najkrótszy kod!

Python, 22 bajty

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

Formuła m*n*(m+1)*(n+1)/4jest skracana za pomocą komplementu bitowego ~m=-(m+1), wyrażając (m+1)*(n+1)jako ~m*~n.

Dlaczego liczba prostokątów m*n*(m+1)*(n+1)/4? Każdy prostokąt jest określony przez wybór dwóch linii poziomych (góra i dół) i dwóch linii pionowych (lewa i prawa). Istnieją m+1linie poziome, z których wybieramy podzbiór dwóch odrębnych. Tak więc liczba wyborów jest taka choose(m+1,2), jaka jest m*(m+1)/2. Pomnożenie przez n*(n+1)/2wybór linii pionowych daje wynik.

Galaretka , 4 bajty

RS€P

Wypróbuj online!

Alternatywnie, również 4 bajty

pP€S

Wypróbuj online!

JavaScript (ES6), 17 bajtów

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

Rozwidlenie tej odpowiedzi .

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

Mathematica, 15 bajtów

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

Jest to funkcja bez nazwy, która przyjmuje dwa argumenty liczb całkowitych i zwraca liczbę prostokątów.

Wyjaśnienie

Implementacja jest zasadniczo bardzo golfową formą iloczynu dwóch trójkątnych liczb. Może warto przeczytać sekcję „Sekwencje argumentów” w tym poście, aby poznać szczegóły, ale postaram się streścić tutaj sedno.

##rozwija się do sekwencji wszystkich argumentów. Jest to podobne do rozpryskiwania w innych językach. Na przykład, jeśli argumentami są 3i 4, to {1, 2, ##, 5}da ci {1, 2, 3, 4, 5}. Ale to nie działa tylko na listach, ale w jakimkolwiek wyrażeniu, np. f[1, 2, ##, 5]Byłoby również f[1, 2, 3, 4, 5].

Staje się to interesujące, gdy łączysz się ##z operatorami. Wszystkie operatory w Mathematica są po prostu krótkimi rękami, aby uzyskać f[...]podobne wyrażenie (być może zagnieżdżone). Np. a+bJest Plus[a, b]i a-bfaktycznie reprezentuje Plus[a, Times[-1, b]]. Teraz, gdy łączysz się ##z operatorami, Mathematica najpierw rozszerza operatory, traktując je ##jak pojedynczy operand, i rozwija je tylko na końcu. Wstawiając ##w odpowiednie miejsca, możemy zatem użyć go zarówno do pomnożenia, jak i dodania operandów.

Zróbmy to dla powyższego kodu:

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

Po rozwinięciu do pełnej formy otrzymujemy:

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

Wstawmy argumenty funkcji ai b:

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

A teraz przekształcamy go z powrotem w standardowy zapis matematyczny:

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

Trochę przestawienia pokazuje, że jest to wynik liczb trójkątnych:

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

Ciekawostka: ta implementacja jest tak Golfy, to ta sama długość jak wbudowany do obliczania jednego numeru trójkątny PolygonalNumber.

C, 25 bajtów

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

Wersja purystyczna (27):

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

Wersja ISO (35):

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

Meduza , 16 bajtów

p|%/**+1
  4  Ei

Format wejściowy jest taki [x y], że wynik jest tylko wynikiem.

Wypróbuj online!

Alternatywne rozwiązanie, ta sama liczba bajtów:

pm%/*[*i
  4  +1

Wyjaśnienie

Czas, aby dać meduzom wstęp, na który zasługuje! :)

Meduza jest Zgarb język jest oparty na jego wyzwanie 2D, składnia . Semantyka jest w dużej mierze inspirowana przez J, ale składnia jest dziełem sztuki. Wszystkie funkcje są pojedynczymi znakami rozmieszczonymi na siatce. Funkcje pobierają argumenty od następnego tokena na południe i wschód od nich i zwracają wynik na północ i zachód. To pozwala ci stworzyć interesującą sieć wywołań funkcji, w których ponownie wykorzystujesz wartości, przekazując je do kilku funkcji z wielu kierunków.

Jeśli zignorujemy fakt, że niektóre tokeny w powyższym programie są operatorami specjalnymi (funkcje wyższego poziomu), powyższy program zostałby napisany mniej więcej tak:

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

Przejdźmy do kodu od dołu do góry. Dane wejściowe są zasilane przez i, który w związku z tym ocenia [x y].

Na +wierzchu otrzymuje to wejście wraz z literałem 1i dlatego zwiększa oba elementy, aby dać [(x+1) (y+1)](większość operacji jest automatycznie dzielona na listy).

Druga wartość ijest wysyłana w lewo, ale Epodziały to argument wschodni na północ i zachód. Oznacza to, że wejścia na prawo *są w rzeczywistości [x y]i [(x+1) (y+1)]tak tego oblicza [x*(x+1) y*(y+1)].

Następny w *górę jest faktycznie modyfikowany przez poprzedni, /który zamienia go w operację składania. Złożenie *pary po prostu ją zwielokrotnia, więc otrzymujemy x*(x+1)*y*(y+1).

Teraz %jest tylko podział, więc oblicza x*(x+1)*y*(y+1)/4. Niestety skutkuje to liczbą zmiennoprzecinkową, więc musimy zaokrąglić ją za pomocą unarnego |. Na koniec podawana jest ta wartość, do pktórej wypisywany jest wynik końcowy.

R, 40 35 bajtów

Czas wskoczyć na głęboki koniec! Oto mój kod R , inspirowany odpowiedzią @xnor:

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

EDYCJA : W tej wersji R zapyta dwukrotnie o dane wejściowe.

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

CJam, 12 10 bajtów

2 bajty zapisane dzięki Martinowi.

{_:)+:*4/}

Wypróbuj online!

Jest to blok, który pobiera listę 2 elementów ze stosu i pozostawia rozwiązanie na stosie. Użytkowa pełny program do testowania: riari+{_:)+:*4/}~.

Oparty na wyjątkowym rozwiązaniu Python dla xnor.

Wyjaśnienie:

{_:)+:*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 bajtów

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

Implementacja formuły m*n*(m+1)*(n+1)/4
Zastosowanie:ans([m,n])

MATL , 6 bajtów

tQ*2/p

Dane wejściowe to tablica formularza [m,n].

Wypróbuj online!

Wyjaśnienie

Bezpośrednie obliczenia na podstawie formuły 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 bajtów

2*/@:!>:

Stosowanie:

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

Java 7, 39 38 bajtów

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

Java 8, 26 25 19 18 17 bajtów

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

Na podstawie doskonałej odpowiedzi @xnor . Wiele bajtów zapisanych dzięki @DavidConrad . Wypróbuj tutaj.

Kod testowy (Java 7):

Wypróbuj tutaj.

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));
  }
}

Wydajność:

0
1
36
100
588

Ruby, 22 bajty

Kradnąc sztuczkę @ Xnora i robiąc dźgnięcie-lambda:

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

Przykładowe wywołanie:

r[6,7]     # => 588

Lub jako proc, również 22 bajty:

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

Które moglibyśmy następnie nazwać:

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

Labirynt , 13 11 bajtów

*?;*_4/!
):

Wypróbuj online!

Wyjaśnienie

To również oblicza iloczyn liczb trójkątnych, jak większość odpowiedzi. Wiodący blok 2x2 to mała pętla:

*?
):

Przy pierwszej iteracji *nic nie robi, więc prawdziwa kolejność pętli jest następująca:

?   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).

Pozostały kod jest po prostu liniowy:

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

Labirynt następnie próbuje wykonać /ponownie, co kończy program z powodu dzielenia przez zero.

Pyke, 6 bajtów

mh+Bee

Wypróbuj tutaj!

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

05AB1E, 4 bajty

€LOP

Wyjaśnienie

Korzysta ze wzoru opisanego w 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

Przyjmuje dane jako [n, m] .

Wypróbuj online

Pyth, 8 6 bajtów

Dwa bajty zapisane dzięki @DenkerAffe.

*FmsSd

Dane wejściowe są oczekiwane jako lista podobna do [m,n]. Wypróbuj tutaj .

Wyjaśnienie:

          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 bajtów

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

Anonimowa funkcja oparta na odpowiedzi @ xnor.

Lua, 74 63 bajtów

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

Funkcja przyjmuje dane wejściowe jako parametry liczbowe.

Ze względu na sposób implementacji Lua jest to technicznie funkcja ze zmiennymi argumentami, którą można wywołać, zawijając ją w instrukcji „function” lub ładując ją z kodu źródłowego za pomocą „loadstring”

Cheddar , 23 bajty

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

Brain-Flak , 84 80 bajtów

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

Wypróbuj online!

Prawdopodobnie bardzo nieoptymalny, szczególnie ze względu na ponowne użycie kodu w odniesieniu do liczb trójkątów, ale przynajmniej mamy rozwiązanie Brain-Flak, które działa.

Niestety wydaje się, że zawodzi, nieskończenie zapętlając się z przypadkiem 0 0testowym, ale wszystkie inne działają dobrze.

Wypukły, 7 bajtów

Wiem, że może być mniejszy, po prostu nie wiem, jak ...

_:)+×½½

Wypróbuj online! . Wykorzystuje kodowanie CP-1252.

APL (Dyalog) , 9 bajtów

×/+/∘⍳¨∘⊢

Wypróbuj online!

Pyt , 3 bajty

←△Π

Wyjaśnienie:

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

Wypróbuj online!