任务

编写一个函数L（），该函数采用两个（x，y）形式的两个Tuple参数作为坐标，并以（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个字符

非常坦率的。定义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）可以从堆栈中弹出（顺序与之相反）当然-这是一个堆栈）。

测试用例（另存为“ linear.dc”并运行dc linear.dc）：

[sysxly-rlx- / dlx * lyr-] sL＃定义L宏

10＃将x1推入堆栈
22.5＃将y1推入堆栈
5＃将x2推入堆栈
12.5＃将y2推入堆栈

lLx＃调用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 ₂ *渐变）
• -从（y ₂）减去（x ₂ *梯度）

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在System名称空间中放入了简短的用法，但是最好完全限定名称并节省使用名称空间的时间。保存了括号。还可以节省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;
}

苹果Swift 95 86

这可能是PCG.SE上的第一个Swift条目？

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

我认为该语言不会对Code Golf社区产生太大的影响。

Golfscript：25个字节

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

由于该函数需要命名为“ L”，因此我在本地将其另存为“ L.gs”。

@Dennis在这篇文章中解释的问题是，我们需要欺骗Golfscript使用有理数而不是整数。因此，如果您愿意接受golfscript表示法的输入X1 Y1 X2 Y2 ，则此方法有效

# 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]

如果您不使用Tuple，则可以将其降至43，这是很多人正在做的...

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）