Die Aufgabe

Schreiben Sie eine Funktion L (), die zwei Tupelargumente von Koordinaten in der Form (x, y) verwendet und ihre jeweilige lineare Funktion in der Form (a, c) zurückgibt, wobei a der Koeffizient des x-Terms und c ist ist der y-Achsenabschnitt.

Sie können davon ausgehen, dass die Eingabe keine Linie senkrecht zur x-Achse ist und dass die beiden Eingaben separate Punkte sind.

Wertung 

Dies ist Code Golf: Das kürzeste Programm gewinnt.

Bitte beachten Sie: Keine Verwendung mathematischer Funktionen außer den Basisoperatoren (+, -, /, *).

Beispiel

Hier ist meine Lösung ohne Golf in 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)

Ausgabe:

>>> 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 char

Ziemliech direkt. Definiert ein dyadisches Verb L, das als verwendet werden soll (x1,y1) L (x2,y2).

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

Erläuterung:

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

Beispiele:

   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 Bytes

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

Definiert ein Makro Lso, dass (x ₁ , y ₁ , x ₂ , y ₂ ) vor dem Aufruf in dieser Reihenfolge auf den Stapel verschoben werden soll und nach dem Aufruf L(a, c) aus dem Stapel entfernt werden kann (in umgekehrter Reihenfolge von) Natürlich - es ist ein Stapel).

Testfall (als "linear.dc" speichern und ausführen dc linear.dc):

[sysxly-rlx- / dlx * lyr-] sL # L-Makro definieren

10 # Schieben Sie x1 auf den Stapel
22.5 # Schieben Sie y1 auf den Stapel
5 # Schieben Sie x2 auf den Stapel
12.5 # Schieben Sie y2 auf den Stapel

lLx # L-Makro aufrufen
f # Den Stapel entleeren

Ausgabe ist:

$ dc linear.dc 
2.5
2
$ 

Erklärung des L-Makros:

• sypop y _{2 um sich} zu yregistrieren
• sxpop x _{2 um sich} zu xregistrieren
• lySchieberegistery (y ₂ ) ,
• -subtrahiere y ₂ von y ₁
• rTauschen Sie (y ₁ - y ₂ ) und x ₁ auf dem Stapel
• lxDruckregister x(x ₂ )
• -subtrahiere x ₂ von x ₁
• /Teilen Sie (y ₁ - y ₂ ) durch (x ₁ - x ₂ ), um den Gradienten zu erhalten
• d doppelter Farbverlauf
• lxDruckregister x(x ₂ )
• *multipliziere (x ₂ ) mit dem Gradienten
• lySchieberegistery (y ₂ ) ,
• rTauschen Sie (y ₂ ) und (x ₂ * Gradient) auf dem Stapel
• -subtrahiere (x ₂ * Gradient) von (y ₂ )

Haskell, 41 Zeichen

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

Hier gibt es nicht viel zu spielen. Es ist so ziemlich das, was Sie normalerweise ohne Leerzeichen schreiben würden.

Mathematica, 55 38 Bytes

Dies war überraschend lang (diese lästigen langen Funktionsnamen ...). BEARBEITEN: Der Ansatz für den Achsenabschnitt wurde geändert (inspiriert von der eigenen Antwort des OP). Es stellte sich heraus, dass es nicht die klügste Idee war, es direkt zu berechnen.

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

Verwenden Sie wie

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

Dank Mathematica können Sie auch das allgemeine Ergebnis erhalten:

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

(Dieses letzte Beispiel zeigt, wie ich dies ursprünglich implementiert hatte.)

Nur für das Protokoll

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

das ist technisch korrekt.

JavaScript, 62 48

Vielen Dank an @Michael für das Golfen mit ES 6.

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

Alte Version:

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

Beispieleingabe:

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

Beispielausgabe:

[0.14285714285714285, 0]

Für die Aufzeichnung:

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 Bytes

Dies ist nicht nur die Funktion und wird vollständig selbst kompiliert. Ich hatte Lden SystemNamespace zum Kurzschließen der Verwendung eingefügt, aber es ist besser, sich vollständig zu qualifizieren und bei der Verwendung eines Namespace zu sparen. Die Klammern wurden gespeichert. Auch eine Ersparnis von return new z[]inreturn 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 Bytes

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

Anwendungsbeispiel:

> 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 (war 106)

Verbessert: Danke für deine Kommentare.

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

Golf:

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

Quelle

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

Dies ist möglicherweise der erste Swift-Eintrag auf 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])}

Ich sehe diese Sprache nicht als großen Erfolg für die Code Golf Community.

Golfscript: 25 Bytes

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

Da die Funktion 'L' heißen muss, habe ich sie lokal als 'L.gs' gespeichert.

Der Haken, wie von @Dennis in diesem Beitrag erklärt , ist, dass wir Golfscript dazu bringen müssen, rationale Zahlen anstelle von ganzen Zahlen zu verwenden. Dies funktioniert also, wenn Sie bereit sind, Eingaben in der Golfscript-Notation zu akzeptierenX1 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 Zeichen

Fast identisch mit der JavaScript-Antwort:

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

Python3 - 64 57 Bytes

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

Sie können es auf 43 reduzieren, wenn Sie Tuple nicht verwenden, was viele Leute tun ...

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

PHP (75 Zeichen)

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

Prüfung : print_r(L([0,0],[7,1]));

Ausgabe :

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

(danke @ace)