งาน

เขียนฟังก์ชัน L () ที่รับสอง Tuple อาร์กิวเมนต์ของพิกัดในรูปแบบ (x, y) และส่งกลับฟังก์ชันเชิงเส้นตามลำดับในรูปแบบ (a, c) โดยที่ a คือประสิทธิภาพร่วมของเทอม x และ c คือค่าตัดแกน y

คุณสามารถสันนิษฐานได้ว่าอินพุตจะไม่เป็นเส้นตั้งฉากกับแกน x และอินพุตทั้งสองนั้นเป็นจุดแยกต่างหาก

เกณฑ์การให้คะแนน 

นี่คือ Code Golf: โปรแกรมที่สั้นที่สุดชนะ

โปรดทราบ: ไม่มีการใช้ฟังก์ชันทางคณิตศาสตร์ใด ๆ นอกเหนือจากตัวดำเนินการพื้นฐาน (+, -, /, *)

ตัวอย่าง

นี่คือทางออกที่ไม่ตีกอล์ฟของฉันใน Python

def L(Point1, Point2):
    x = 0
    y = 1
    Gradient = (float(Point1[y]) - float(Point2[y])) / (float(Point1[x]) - float(Point2[x]))
    YIntercept = Point1[y] - Gradient * Point1[x] 
    return (Gradient, YIntercept)

เอาท์พุท:

>>> L( (0,0) , (1,1) )
(1.0, 0.0)

>>> L( (0,0) , (2,1) )
(0.5, 0.0)

>>> L( (0,0) , (7,1) )
(0.14285714285714285, 0.0)

>>> L( (10,22.5) , (5,12.5) )
(2.0, 2.5)

J - 23 ถ่าน

ค่อนข้างตรงไปตรงมา กำหนดคำกริยา dyadic ที่จะใช้เป็นL(x1,y1) L (x2,y2)

L=:%~/@:-,-/@(*|.)%-&{.

คำอธิบาย:

L=:%~/@:-,-/@(*|.)%-&{.  NB. the function L
                    &{.  NB. x coord of both points
                   -     NB. left x minus right x
             ( |.)       NB. flip right argument: (y2,x2)
              *          NB. pointwise multiplication of (x1,y1) and (y2,x2)
          -/@            NB. subtract the two results: (x1*y2)-(y1*x2)
                  %      NB. divide: (x1*y2 - y1*x2)/(x1-x2)
        -                NB. pointwise subtraction
   %~/@:                 NB. divide y difference by x diff: (y1-y2)/(x1-x2)
         ,               NB. append results together
L=:                      NB. assign function to L

ตัวอย่าง:

   L=:%~/@:-,-/@(*|.)%-&{.
   0 0 L 1 1
1 0
   0 0 L 2 1
0.5 0
   0 0 L 7 1
0.142857 0
   10 22.5 L 5 12.5
2 2.5
   0 0 L 0 1  NB. __ is negative infinity
__ 0

GNU dc , 30 24 ไบต์

[sysxly-rlx-/dlx*lyr-]sL

กำหนดมาโครLเช่นว่า (x ₁ , y ₁ , x ₂ , y ₂ ) ควรถูกผลักไปยังสแต็กตามลำดับก่อนที่จะโทรและหลังจากการโทรL(a, c) อาจถูกตอกจากสแต็ก (ในลำดับย้อนกลับของ แน่นอน - มันเป็นสแต็ก)

Testcase (บันทึกเป็น "linear.dc" และเรียกใช้dc linear.dc):

[sysxly-rlx- / dlx * lyr-] sL # กำหนดมาโคร L

10 # กด x1 ไปที่สแต็ก
22.5 # กด y1 ลงในสแต็ก
5 # กด x2 ไปยังสแต็ก
12.5 # กด y2 ไปยังสแต็ก

lLx # Call L มาโคร
f # ถ่ายโอนสแต็ก

ผลลัพธ์คือ:

$ dc linear.dc 
2.5
2
$ 

คำอธิบายของ L มาโคร:

• syป๊อป y ₂เพื่อyลงทะเบียน
• sxป๊อป x ₂เพื่อxลงทะเบียน
• lyกดyลงทะเบียน (y ₂ )
• -ลบ y ₂จาก y ₁
• rสลับ (y ₁ - y ₂ ) และ x ₁บนสแต็ก
• lxกดxลงทะเบียน (x ₂ )
• -ลบ x ₂จาก x ₁
• /หาร (y ₁ - y ₂ ) โดย (x ₁ - x ₂ ) เพื่อไล่ระดับสี
• d การไล่ระดับสีซ้ำกัน
• lxกดxลงทะเบียน (x ₂ )
• *คูณ (x ₂ ) โดยการไล่ระดับสี
• lyกดyลงทะเบียน (y ₂ )
• rสลับ (y ₂ ) และ (x ₂ * gradient) บนสแต็ก
• -ลบ (x ₂ * การไล่ระดับสี) จาก (y ₂ )

Haskell, 41 ตัวอักษร

f(x,y)(u,v)=(a,y-a*x)where a=(y-v)/(x-u)

ไม่มากนักกอล์ฟที่นี่ มันค่อนข้างดีสิ่งที่คุณเขียนตามปกติลบช่องว่าง

Mathematica, 55 38 ไบต์

นี่เป็นเรื่องที่น่าประหลาดใจอย่างมาก (ชื่อฟังก์ชั่นที่น่ารำคาญยาว ... ) แก้ไข:เปลี่ยนวิธีการสกัดกั้นแกน (รับแรงบันดาลใจจากคำตอบของ OP) ปรากฎว่าการคำนวณโดยตรงไม่ใช่ความคิดที่ฉลาดที่สุด

L={g=1/Divide@@(#2-#),#[[2]]-g#[[1]]}&

ใช้เหมือน

L[{10,22.5},{5,12.5}]
> {2., 2.5}

ขอบคุณ Mathematica คุณยังสามารถรับผลทั่วไป:

L[{r,s},{p,q}]
> {(p - r)/(q - s), (q r - p s)/(q - s)}

(ตัวอย่างสุดท้ายนี้แสดงให้เห็นว่าฉันใช้สิ่งนี้มาตั้งแต่แรก)

เพียงเพื่อบันทึก

L[{0,0},{0,1}]
> {ComplexInfinity, Indeterminate}

ซึ่งถูกต้องทางเทคนิค

JavaScript, 62 48

ขอบคุณ @Michael สำหรับการเล่นกอล์ฟด้วย ES 6

L=(a,b)=>[s=(b[1]-a[1])/(b[0]-a[0]),a[1]-s*a[0]]

เวอร์ชั่นเก่า:

function L(a,b){return[s=(b[1]-a[1])/(b[0]-a[0]),a[1]-s*a[0]]}

ตัวอย่างอินพุต:

L([0,0],[7,1])

ตัวอย่างผลลัพธ์:

[0.14285714285714285, 0]

สำหรับบันทึก:

L([0,0],[0,1])
[Infinity, NaN]

Python3 (51)

def L(p,q):x,y=p;X,Y=q;m=(Y-y)/(X-x);return m,y-x*m

C # 105 ไบต์

นี่ไม่ใช่เพียงฟังก์ชั่นและจะรวบรวมอย่างสมบูรณ์ด้วยตัวมันเอง ฉันได้ใส่LในSystemnamespace เพื่อ shorting โดยใช้ แต่มันจะดีกว่าที่จะมีสิทธิ์ได้อย่างเต็มที่และบันทึกเกี่ยวกับการใช้ใน namespace บันทึกวงเล็บ ยังประหยัดจากreturn new z[]เข้าสู่return new[]

using z=System.Single;class P{z[] L(z[]a,z[]b){z c=(a[1]-b[1])/(a[0]-b[0]);return new[]{c,a[1]-c*a[0]};}}

Lua 5.1.4: 66 64 ไบต์

function L(q,w)a=(q[2]-w[2])/(q[1]-w[1])return a,q[2]-a*q[1];end

ตัวอย่างการใช้งาน:

> print(L( {0,0}, {1,0} ))
-0   0
> print(L( {0,0}, {1,1} ))
1    0
> print(L( {0,0}, {7,1} ))
0.14285714285714    0
> print(L( {0,0}, {0,1} ))
-inf   -nan
> print(L( {0,0}, {0,0} ))
-nan   -nan

C ++ 88 (เดิมคือ 106)

ปรับปรุงแล้ว: ขอบคุณสำหรับความคิดเห็นของคุณ

struct t{double x,y;};
t L(t u, t v){u.x=(v.y-u.y)/(v.x-u.x);u.y=v.y-u.x*v.x;return u;}

แข็งแรงเล่นกอล์ฟ:

typedef struct T{double x,y;}t;
t line(t u, t v){t z;z.x=(v.y-u.y)/(v.x-u.x);z.y=v.y-(z.x*v.x);return z;}

แหล่ง

typedef struct T{
    double x,y;
} t;

t line(t u, t v)
{
t z;
z.x=(v.y-u.y)/(v.x-u.x);
z.y=v.y-(z.x*v.x);
return z;
}

Apple Swift 95 86

นี่อาจเป็นรายการ Swift แรกใน PCG.SE

func L(x:Float...)->(Float,Float){var a=(x[3]-x[1])/(x[2]-x[0]);return(a,x[1]-a*x[0])}

ฉันไม่เห็นว่าภาษานี้เป็นที่นิยมอย่างมากในชุมชนรหัสกอล์ฟ

Golfscript: 25 ไบต์

~:y\:x;-\x--1?*.x-1**y+\p

เนื่องจากฟังก์ชั่นจะต้องมีชื่อว่า 'L' ฉันจึงบันทึกเป็น 'L.gs' ในเครื่อง

การจับตามที่อธิบายโดย @Dennis ในโพสต์นี้คือเราจำเป็นต้องหลอกลวง Golfscript ให้ใช้จำนวนตรรกยะแทนจำนวนเต็ม ดังนั้นวิธีนี้จะใช้ได้ถ้าคุณยินดีที่จะรับข้อมูลX1 Y1 X2 Y2 ในเครื่องหมาย Golfscript

# L( (0,0) , (1,1) )
echo "0 0 1 1" | golfscript L.gs
> 1/1
> 0/1
#L( (10,22.5) , (5,12.5) )
echo "10 22 2-1?+ 5 12 2-1?+" | golfscript L.gs
> 2/1
> 5/2

Ruby - 48 ตัวอักษร

เกือบเหมือนคำตอบ JavaScript:

L=->u,v{a,b,c,d=*u,*v;[s=(d-b).fdiv(c-a),b-s*a]}

Python3 - 64 57 ไบต์

def L(q,w):a=(q[1]-w[1])/(q[0]-w[0]);return a,q[1]-a*q[0]

คุณสามารถทำให้มันลดลงเหลือ 43 ถ้าคุณไม่ใช้ Tuple ซึ่งมีหลายคนกำลังทำ ...

def L(x,y,q,w):a=(x-q)/(y-w);return a,y-a*x

PHP (75 ตัวอักษร)

function L($u,$v){return[$s=($v[1]-$u[1])/($v[0]-$u[0]),$v[1]-($s*$v[0])];}

ทดสอบ: print_r(L([0,0],[7,1]));

ผลลัพธ์:

Array
(
    [0] => 0.14285714285714
    [1] => 0
)

(ขอบคุณ @ace)