Nun, obwohl sich diese Herausforderung als großer Erfolg herausstellte, erwies es sich auch als sehr trivial zu lösen. Daher habe ich für diejenigen, die nach einer größeren Herausforderung suchen, eine Fortsetzung dieser Herausforderung erstellt, in der Sie nun die Anzahl der eindeutigen Rechtecke zählen müssen. Hör zu!

Nun, für diejenigen unter Ihnen, die diese Herausforderung lösen möchten, ist es an der Zeit.

Nun, eine solche Herausforderung haben wir noch nicht wirklich, also machen wir uns auf den Weg.

Betrachten Sie dieses 3 x 3Raster von Rechtecken:

Wie viele Rechtecke gibt es? Wenn wir visuell zählen, können wir sehen, dass es tatsächlich 36Rechtecke gibt, einschließlich der gesamten Ebene selbst, die alle im folgenden animierten GIF gezeigt werden:

Die Aufgabe

Das Zählen von Rechtecken wie oben gezeigt ist die Aufgabe. Mit anderen Worten, wenn 2 ganze Zahlen größer oder gleich 0sind mund nwobei mdie Breite und ndie Höhe dargestellt werden, wird die Gesamtzahl der Rechtecke in diesem m x nRechteckraster ausgegeben .

Regeln

• Die Verwendung von eingebauten Funktionen, die dieses Problem direkt lösen, ist ausdrücklich untersagt.

• Bei dieser Herausforderung geht es nicht darum, die kürzeste Antwort zu finden, sondern die kürzeste Antwort in jeder Sprache. Daher wird keine Antwort akzeptiert.

• Standardlücken sind verboten.

Testfälle

Präsentiert im Format Array of Integers Input -> Integer Output:

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

Verweise

• http://oeis.org/A096948

Denken Sie daran, das ist Code-Golf , also gewinnt der kürzeste Code!

Python, 22 Bytes

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

Die Formel m*n*(m+1)*(n+1)/4wird mit dem Bitkomplement gekürzt ~m=-(m+1), ausgedrückt (m+1)*(n+1)als ~m*~n.

Warum ist die Anzahl der Rechtecke m*n*(m+1)*(n+1)/4? Jedes Rechteck wird durch die Auswahl von zwei horizontalen Linien (oben und unten) und zwei vertikalen Linien (links und rechts) festgelegt. Es gibt m+1horizontale Linien, von denen wir eine Teilmenge von zwei verschiedenen auswählen. Also die Anzahl der Auswahlmöglichkeiten ist choose(m+1,2), was ist m*(m+1)/2. Multiplizieren mit den n*(n+1)/2Auswahlmöglichkeiten für vertikale Linien ergibt das Ergebnis.

Gelee , 4 Bytes

RS€P

Probieren Sie es online!

Alternativ auch 4 Bytes

pP€S

Probieren Sie es online!

Javascript (ES6), 17 Byte

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

Eine Gabelung dieser Antwort .

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

Mathematica, 15 Bytes

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

Dies ist eine unbenannte Funktion, die zwei Ganzzahlargumente verwendet und die Anzahl der Rechtecke zurückgibt.

Erläuterung

Die Implementierung ist im Grunde eine sehr golfene Form des Produkts der beiden Dreieckszahlen. Es könnte sich lohnen, den Abschnitt "Folgen von Argumenten" in diesem Beitrag zu lesen, um Einzelheiten zu erfahren, aber ich werde versuchen, das Wesentliche hier zusammenzufassen.

##wird zu einer Folge aller Argumente erweitert. Dies ähnelt dem Aufteilen in andere Sprachen. Zum Beispiel, wenn die Argumente 3und sind 4, dann {1, 2, ##, 5}werden Sie geben {1, 2, 3, 4, 5}. Dies funktioniert aber nicht nur in Listen, sondern in jedem beliebigen Ausdruck, zB f[1, 2, ##, 5]auch f[1, 2, 3, 4, 5].

Dies wird interessant, wenn Sie ##mit Operatoren kombinieren . Alle Operatoren in Mathematica sind nur kurze Hände für einen f[...]ähnlichen Ausdruck (möglicherweise verschachtelt). ZB a+bist Plus[a, b]und a-btatsächlich darstellt Plus[a, Times[-1, b]]. Wenn Sie nun ##mit Operatoren kombinieren , besteht Mathematica darin, die Operatoren zuerst zu erweitern, ##wie einen einzelnen Operanden zu behandeln und sie erst am Ende zu erweitern. Durch Einfügen ##an der richtigen Stelle können wir sie daher sowohl zum Multiplizieren als auch zum Addieren der Operanden verwenden.

Machen wir das für den obigen Code:

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

Wenn wir es zu seiner vollen Form erweitern, erhalten wir Folgendes:

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

Fügen wir die Funktionsargumente ein aund b:

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

Und jetzt konvertieren wir es zurück in die mathematische Standardnotation:

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

Eine kleine Umordnung zeigt, dass dies das Produkt der Dreieckszahlen ist:

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

Tolles Faktum: Diese Implementierung ist so golfen, dass sie die gleiche Länge wie die integrierte für die Berechnung einer einzelnen Dreieckszahl hat PolygonalNumber.

C 25 Bytes

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

Puristische Version (27):

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

ISO-er-Version (35):

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

Qualle , 16 Bytes

p|%/**+1
  4  Ei

Eingabeformat ist [x y], Ausgabe ist nur das Ergebnis.

Probieren Sie es online!

Alternative Lösung, gleiche Byteanzahl:

pm%/*[*i
  4  +1

Erläuterung

Zeit, Jellyfish die Einführung zu geben, die es verdient! :)

Qualle ist Zgarbs Sprache basierend auf seiner 2D-Syntax-Herausforderung . Die Semantik ist weitgehend von J inspiriert, aber die Syntax ist ein Kunstwerk. Alle Funktionen sind Einzelzeichen und in einem Raster angeordnet. Funktionen nehmen ihre Argumente vom nächsten Token nach Süden und Osten und geben das Ergebnis nach Norden und Westen zurück. Auf diese Weise können Sie ein interessantes Netz von Funktionsaufrufen erstellen, in dem Sie Werte wiederverwenden, indem Sie sie aus mehreren Richtungen in mehrere Funktionen übertragen.

Wenn wir die Tatsache ignorieren, dass einige der Token im obigen Programm spezielle Operatoren (übergeordnete Funktionen) sind, würde das obige Programm in einer vernünftigen Sprache geschrieben:

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

Lassen Sie uns den Code von unten nach oben durchgehen. Die Eingabe wird von der eingespeist i, die daher zu auswertet [x y].

Die +darüberliegende Seite empfängt diese Eingabe zusammen mit dem Literal 1und erhöht daher beide Elemente, um etwas zu ergeben [(x+1) (y+1)](die meisten Operationen werden automatisch über Listen geführt).

Der andere Wert von iwird nach links gesendet, aber die ETeilung ist das östliche Argument nach Norden und Westen. Das heißt, die Eingaben rechts *sind tatsächlich [x y]und [(x+1) (y+1)]dies wird berechnet [x*(x+1) y*(y+1)].

Das nächste *wird durch das vorhergehende geändert, /was es zu einer Faltoperation macht. Das Umklappen *eines Paares multipliziert es einfach, so dass wir erhalten x*(x+1)*y*(y+1).

Jetzt %wird nur noch die Division berechnet x*(x+1)*y*(y+1)/4. Leider führt dies zu einem Float, so dass wir es mit dem Unary abrunden müssen |. Abschließend wird dieser Wert eingegeben, auf pden das Endergebnis gedruckt wird.

R, 40 35 Bytes

Nun, es ist Zeit, in die Tiefe zu springen! Hier ist mein R- Code, inspiriert von @xnor answer:

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

BEARBEITEN : In dieser Version wird R zweimal nach Eingaben fragen.

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

CJam, 12 10 Bytes

2 Bytes gespart dank Martin.

{_:)+:*4/}

Probieren Sie es online!

Dies ist ein Block, der eine Liste von 2 Elementen aus dem Stapel entnimmt und die Lösung auf dem Stapel belässt. Nutzbare vollständiges Programm für die Prüfung: riari+{_:)+:*4/}~.

Basierend auf der herausragenden Python-Lösung von xnor.

Erläuterung:

{_:)+:*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 Bytes

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

Die Umsetzung der Formel m*n*(m+1)*(n+1)/4
Verbrauch:ans([m,n])

MATL , 6 Bytes

tQ*2/p

Die Eingabe ist ein Array des Formulars [m,n].

Probieren Sie es online!

Erläuterung

Direkte Berechnung basierend auf der Formel 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 Bytes

2*/@:!>:

Verwendung:

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

Java 7, 39 38 Bytes

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

Java 8, 26 25 19 18 17 Bytes

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

Basierend auf der ausgezeichneten Antwort von @xnor . Mehrere Bytes dank @DavidConrad gespeichert . Probieren Sie es hier aus.

Testcode (Java 7):

Probieren Sie es hier aus.

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

Ausgabe:

0
1
36
100
588

Ruby, 22 Bytes

@ Xnors Trick stehlen und ein Stabby-Lambda machen:

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

Beispielaufruf:

r[6,7]     # => 588

Oder als proc, auch 22 bytes:

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

Was wir dann nennen könnten:

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

Labyrinth , 13 11 Bytes

*?;*_4/!
):

Probieren Sie es online!

Erläuterung

Dies berechnet auch das Produkt der Dreieckszahlen wie die meisten Antworten. Der führende 2x2 Block ist eine kleine Schleife:

*?
):

Bei der ersten Iteration *wird nichts ausgeführt, sodass die tatsächliche Schleifenreihenfolge wie folgt lautet:

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

Der verbleibende Code ist nur linear:

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

Labyrinth versucht dann /erneut auszuführen , was das Programm aufgrund einer Division durch Null beendet.

Pyke, 6 Bytes

mh+Bee

Probieren Sie es hier aus!

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

05AB1E, 4 Bytes

€LOP

Erläuterung

Verwendet die in A096948 beschriebene Formel

      # 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

Übernimmt die Eingabe als [n, m] .

Probieren Sie es online aus

Pyth, 8 6 Bytes

Zwei Bytes gespart dank @DenkerAffe.

*FmsSd

Die Eingabe wird als Liste wie erwartet [m,n]. Probieren Sie es hier aus .

Erläuterung:

          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 Bytes

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

Eine anonyme Funktion basierend auf der Antwort von @ xnor.

Lua, 74 63 Bytes

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

Die Funktion übernimmt die Eingabe als Zahlenparameter.

Aufgrund der Art und Weise, wie Lua implementiert ist, handelt es sich technisch gesehen um eine Funktion mit variablen Argumenten, die aufgerufen werden kann, indem sie in eine "function" -Anweisung eingeschlossen oder mit "loadstring" aus dem Quellcode geladen wird.

Cheddar , 23 Bytes

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

Brain-Flak , 84 80 Bytes

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

Probieren Sie es online!

Wahrscheinlich sehr suboptimal, vor allem wegen der Wiederverwendung des Codes in Bezug auf Dreieckszahlen, aber zumindest haben wir eine Brain-Flak-Lösung, die funktioniert.

Leider scheint es durch die Endlosschleife mit dem 0 0Testfall zu scheitern, aber alle anderen funktionieren einwandfrei.

Konvex, 7 Bytes

Ich weiß, dass dies kleiner sein kann, ich kann nur nicht herausfinden, wie noch ...

_:)+×½½

Probieren Sie es online! . Verwendet die CP-1252-Codierung.

APL (Dyalog) , 9 Bytes

×/+/∘⍳¨∘⊢

Probieren Sie es online!

Pyt , 3 Bytes

←△Π

Erläuterung:

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

Probieren Sie es online!