ถึงแม้ว่าความท้าทายนี้จะกลายเป็นความสำเร็จที่ยิ่งใหญ่ แต่มันก็กลายเป็นเรื่องเล็กน้อยที่จะแก้ไข ดังนั้นสำหรับผู้ที่มองหาความท้าทายมากขึ้นฉันได้สร้างภาคต่อของความท้าทายซึ่งตอนนี้คุณต้องนับจำนวนสี่เหลี่ยมที่ไม่ซ้ำกัน ลองดูสิ!

ทีนี้สำหรับคนที่คุณต้องการแก้ไขปัญหานี้มาถึงแล้ว

เรายังไม่มีการท้าทายเช่นนี้ดังนั้นเราจึงไป

ลองพิจารณา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)

สนุกจริง: การดำเนินการนี้เพื่อให้ golfy 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

คำอธิบาย

ได้เวลาแนะนำแมงกะพรุนที่สมควรได้รับ! :)

แมงกะพรุนเป็นZgarbภาษา 's ขึ้นอยู่กับความท้าทาย 2D ไวยากรณ์ของเขา ความหมายส่วนใหญ่ได้รับแรงบันดาลใจจากเจ แต่ไวยากรณ์เป็นงานศิลปะ ฟังก์ชั่นทั้งหมดเป็นตัวอักษรเดียวและวางบนตาราง ฟังก์ชั่นใช้การโต้แย้งของพวกเขาจากโทเค็นถัดไปทางทิศใต้และทิศตะวันออกของพวกเขาและส่งกลับผลเหนือและตะวันตก สิ่งนี้ช่วยให้คุณสร้างเว็บการเรียกใช้ฟังก์ชันที่น่าสนใจซึ่งคุณสามารถนำค่ามาใช้ใหม่โดยส่งผ่านไปยังฟังก์ชั่นต่างๆจากหลายทิศทาง

หากเราเพิกเฉยต่อความจริงที่ว่าโทเค็นบางตัวในโปรแกรมด้านบนเป็นตัวดำเนินการพิเศษ(ฟังก์ชั่นระดับสูงกว่า) โปรแกรมด้านบนจะเขียนอะไรแบบนี้ในภาษาที่มีเหตุผล:

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 ไบต์ด้วย Martin

{_:)+:*4/}

ลองออนไลน์!

นี่คือบล็อกที่ใช้รายการของ 2 องค์ประกอบจากสแต็กและปล่อยให้โซลูชันบนสแต็ก riari+{_:)+:*4/}~โปรแกรมเต็มรูปแบบที่ใช้งานได้สำหรับการทดสอบ:

อ้างอิงจากโซลูชัน python ที่ยอดเยี่ยมของ xnor

คำอธิบาย:

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

Java 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 และสร้าง stabby-lambda:

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

ตัวอย่างการโทร:

r[6,7]     # => 588

หรือเป็น proc ขนาด 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.

จากนั้นเขาวงกตก็พยายามที่จะดำเนินการ/อีกครั้งซึ่งจะยุติโปรแกรมเนื่องจากการหารด้วยศูนย์

Pyke ขนาด 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]

ลองออนไลน์

Pyth, 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

Lua, 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 นี่คือฟังก์ชันทางเทคนิคโดยมีตัวแปร args ซึ่งสามารถเรียกได้โดยการตัดคำสั่งในคำสั่ง "ฟังก์ชัน" หรือโหลดจากซอร์สโค้ดโดยใช้ "loadstring"

Cheddar , 23 ไบต์

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

Brain-Flak , 84 80 ไบต์

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

ลองออนไลน์!

น่าจะเป็นวิธีย่อยที่ดีที่สุดโดยเฉพาะอย่างยิ่งเพราะมีการนำรหัสมาใช้เกี่ยวกับตัวเลขสามเหลี่ยม แต่อย่างน้อยเราก็มีวิธีแก้ปัญหา Brain-Flak ที่ใช้งานได้

น่าเศร้าที่ดูเหมือนว่าจะล้มเหลวโดยการวนซ้ำอย่างไม่มีที่สิ้นสุดกับ0 0testcase แต่คนอื่น ๆ ทั้งหมดทำงานได้ดี

นูน 7 ไบต์

ฉันรู้ว่ามันเล็กกว่านี้ฉันแค่คิดไม่ออกว่า ...

_:)+×½½

ลองออนไลน์! . ใช้การเข้ารหัส CP-1252

APL (Dyalog)ขนาด 9 ไบต์

×/+/∘⍳¨∘⊢

ลองออนไลน์!

Pyt , 3 ไบต์

←△Π

คำอธิบาย:

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

ลองออนไลน์!