Ziel einer Rosetta Stone Challenge ist es, Lösungen in möglichst vielen Sprachen zu schreiben. Zeigen Sie Ihre Programmiervielsprachigkeit!

Die Herausforderung

Ihre Herausforderung besteht darin, ein Programm zu implementieren, das eine Liste von Zahlen eingibt und die Regel ausgibt, die zum Generieren jeder aufeinanderfolgenden Zahl in der Reihe in so vielen Programmiersprachen wie möglich verwendet wird . Sie dürfen jede Art von Standardbibliotheksfunktion verwenden, die Ihre Sprache hat, da dies meistens ein Sprachschaufenster ist.

Was ist eine "Serie"?

Eine Reihe ist eine geordnete Liste von ganzen Zahlen. Jede fortlaufende Nummer in der Serie kann durch Anwenden einer einfachen Regel auf die vorherige Nummer in der Serie generiert werden. Bei dieser Herausforderung besteht die Regel darin, die Zahl mit einer Konstanten zu multiplizieren und dann eine zweite Konstante hinzuzufügen. Beide Konstanten können beliebige Ganzzahlen sein. Das Ziel dieser Herausforderung ist die Ausgabe dieser beiden Konstanten.

Für die Serie 2 5 11kann die Regel als geschrieben werden 2 1. Dies bedeutet, dass jede Zahl die vorherige Zahl ist, mal 2 plus 1. Eine wichtige Tatsache ist, dass die meisten Serien genau eine Regel haben. Einige Serien haben entweder eine unendliche Zahl oder gar keine, aber Sie müssen sich nicht damit befassen.

Eingang

Die Eingabe ist eine Liste von drei verschiedenen Ganzzahlen, die die Zahlen in der Sequenz sind. Die Zahlen können entweder durch Leerzeichen, Kommas oder Zeilenumbrüche getrennt sein. Bitte geben Sie an, welche. Ich werde bei dieser Einschränkung flexibel sein, da bestimmte Sprachen Eingabebeschränkungen aufweisen können. Hier sind vier Beispiele für Eingaben:

0 7 14
2 5 11
2 0 -4
5 -19  77

Ausgabe

Es werden zwei Ganzzahlen ausgegeben, die die Regel darstellen, die zum Generieren der Serie verwendet wird. Die erste Zahl ist die multiplikative Konstante, während die zweite Zahl die additive Konstante ist. Die Ausgabe kann durch Leerzeichen, Kommas oder Zeilenumbrüche getrennt formatiert werden. Auch bei dieser Einschränkung bin ich flexibel. Hier sind die entsprechenden Beispiele für die Ausgabe:

1 7
2 1
2 -4
-4 1

Das objektiv gewinnende Kriterium

Als objektives Gewinnkriterium gilt: Jede Sprache stellt einen eigenen Wettbewerb dar, wer den kürzesten Beitrag schreiben kann, aber der Gesamtsieger wäre die Person, die die meisten dieser Teilwettbewerbe gewinnt. Dies bedeutet, dass eine Person, die in vielen ungewöhnlichen Sprachen antwortet, einen Vorteil erzielen kann. Code-Golf ist vor allem dann ein Tiebreak, wenn es mehr als eine Lösung in einer Sprache gibt: Die Person mit dem kürzesten Programm bekommt für diese Sprache Anerkennung.

Regeln, Einschränkungen und Hinweise

Ihr Programm kann in jeder Sprache geschrieben werden, die vor dem 9. April 2012 existierte. Ich muss mich auch darauf verlassen, dass die Community einige Antworten validiert, die in einer der ungewöhnlicheren / esoterischeren Sprachen geschrieben wurden, da es unwahrscheinlich ist, dass ich sie testen kann Sie.

Aktuelle Rangliste

Dieser Abschnitt wird regelmäßig aktualisiert, um die Anzahl der Sprachen und die jeweils führenden Personen anzuzeigen.

• AWK (32) - Mellamokb
• Bash (31) - Peter Taylor
• Befunge (29) - Howard
• bc (39) - Kernigh
• Gehirnfick (174) - CMP
• C (78) - 10n3_shArk
• C ++ (96) - links herum
• Common Lisp (88) - Kernigh
• Cray Chapel (59) - Kyle Kanos
• csh (86) - Kernigh
• Cuda (301) - links in der Nähe
• dc (30) - kernigh
• DOS BATCH (54) - Mellamokb
• Element (27) - Howard
• es (95) - Kernigh
• Faktor (138) - Kernigh
• Felix (86) - kirbyfan64sos
• Fortran (44) - Kyle Kanos
• Geh (101) - Howard
• GolfScript (16) - Howard
• Golflua (44) - Kyle Kanos
• Haskell (35) - links in der Nähe
• J (23) - Gareth
• Java (141) - Howard
• JavaScript (47) - mellamokb
• Julia (71) - ML
• Lua (51) - Howard
• Mercury (319) - links herum
• MoonScript (48) - kirbyfan64sos
• Nimrod (146) - links herum
• Eule (22) - res
• Pascal (88) - links herum
• Perl (57) - Gareth
• PHP (61) - Mellamokb
• PicoLisp (72) - Kernigh
• Piet (56) - ML
• PostScript (61) - Howard
• Python (40) - Howard
• Q (36) -Tmartin
• QBasic (34) -Mellamokb
• R (50) - res
• Ruby (44) - Howard
• Scala (102) - Gareth
• SQL (57) - Aman ZeeK Verma
• TI-83 BASIC (25) - Mellamokb
• Unbegrenzte Registermaschine (285) - Paxinum
• VBA (57) - Gaffi
• Leerzeichen (123) - res
• zsh (62) - Kernigh

Aktuelle Benutzerrankings

Gleiche Ränge werden alphabetisch sortiert.

1. Howard (9): Befunge (29), Element (27), Go (101), GolfScript (16), Java (141), Lua (51), PostScript, (61) Python, (40) Ruby (44)

2. Kernigh (8): bc (39), Common Lisp (88), csh (86), dc (30), es (95), Faktor (138), PicoLisp (72), zsh (62)

3. links um (6): C ++ (96), Cuda (301), Haskell (35), Mercury (319), Nimrod (146), Pascal (88)

4. Mellamokb (6): AWK (32), DOS BATCH (54), JavaScript (47), PHP (61), QBasic (34), TI-83 BASIC (41)

5. Gareth (3): J (23), Perl (57), Scala (102)

6. Kyle Kanos (3): Cray Chapel (59), Fortran (44), Golflua (44)

7. res (3): Eule (22), R (50), Leerzeichen (123)

8. kirbyfan64sos (2): Felix (86), MoonScript (48)

9. ML (2): Julia (71), Piet (56)

10. Aman Zeek Verma (1): SQL (57)

11. CMP (1): Brainfuck (174)

12. Gaffi (1): VBA (57)

13. l0n3_shArk (1): C (78)

14. Paxinum (1): Unbegrenzte Registermaschine (285)

15. Peter Taylor (1): Bash (31)

16. tmartin (1): Q (36)

GolfScript, 16 Zeichen

~1$- 1$3$-/.p@*-

Die Eingabe erfolgt als durch Leerzeichen getrennte Liste.

JavaScript, 56 Zeichen

p=prompt;x=alert;a=p();b=p();x(m=(p()-b)/(b-a));x(b-a*m)

Die Eingabe erfolgt bei Aufforderung.

Ruby, 44 Zeichen

a,b,c=eval("[#{gets}]");m=c-b;p m/=b-a,b-m*a

Die Eingabe erfolgt hier als kommagetrennte Liste.

Python, 40 Zeichen

a,b,c=input();m=c-b;m/=b-a;print m,b-m*a

Die Eingabe wird erneut durch Kommas getrennt.

Java, 141 Zeichen

enum E{E;static int s(){return new java.util.Scanner(System.in).nextInt();}{int a=s(),b=s(),m=s()-b;m/=b-a;System.out.print(m+" "+(b-a*m));}}

Eingabe durch Zeilenvorschub getrennt.

Lua, 51 Zeichen

r=io.read
a,b=r(),r()
m=(r()-b)/(b-a)
print(m,b-m*a)

Eingabe durch Zeilenvorschub getrennt.

Go, 101 Zeichen

package main
import"fmt"
var a,b,c int
func main(){fmt.Scan(&a,&b,&c)
c-=b
c/=b-a
fmt.Print(c,b-a*c)}

Eingabe durch Zeilenvorschub getrennt.

Fortran, 90 Zeichen

      PROGRAM X
      READ(*,*)I,J,K
      K=(K-J)/(J-I)
      WRITE(*,*)K,J-I*K
      END

Eingabe durch Zeilenvorschub getrennt.

Befunge, 29 Zeichen

&01p&:11p:&-01g11g-/:.01g*-.@

PostScript, 61 Zeichen

2 5 14
1 index sub 1 index 3 index sub idiv dup = 3 2 roll mul sub =

Eule, 23 Zeichen

<%<%<$-1`4'-/%.32)2'*-.

Eingabe durch Zeilenvorschub getrennt.

Element , 27 Zeichen

_-a;_3:'-_+"a~+/2:`a~*+\ ``

Eingabe durch Zeilenvorschub getrennt.

Brainfuck - 174

,>,>,<[>->+>+<<<-]>>>[<<<+>>>-]<<<<[>>>->+<<<<-]>>>>[<<<<+>>>>-]<<[->-
[>+>>]>[+[-<+>]>+>>]<<<<<]>>>[<<<+>>>-]<[-]<[-]<.[>>+<<-]>>[<<<<[>>+>+
<<<-]>>>[<<<+>>>-]>-]<<[<->-]<.

Piet - 82?

Ich bin mir nicht sicher, wie ich hier Golf messen soll. Ich werde mit der Gesamtbildgröße (in Codels) gehen. Meine ist 41x2:

Befunge - 34

&00p&10p&10g-10g00g-/:.00g*10g\-.@

Englisch - 278

The multiplier is the quotient of the difference of the second 
and third values and the second and first values. 
To generate a new term, multiply the current term by the multiplier
and add the difference of the first value and the product of the 
multiplier and the second value.

Ich bin mir nicht sicher, ob das zählt, dachte aber, ich würde es versuchen. Es ist bemerkenswert schwierig, auch einen einfachen Algorithmus genau zu beschreiben. Ich wünsche mir, dass Englisch eine Art Gruppierungssymbol unterstützt, um den Vorrang einzurichten.

QBasic, 42

INPUT "",a,b,c
m=(c-b)/(b-a)
PRINT m;b-m*a

Benötigt Eingabe mit Komma, Ausgabe mit Leerzeichen (ist das in Ordnung?)

Mercury, 319

:-module r.
:-interface.
:-import_module io,list,int,char,string.
:-pred main(io::di,io::uo)is det.
:-implementation.
main(!IO):-io.read_line_as_string(J,!IO),(if J=ok(I),[A,B,C]=list.map(string.det_to_int,string.words_separator(char.is_whitespace,I)),M=(C-B)/(B-A)then io.format("%d %d",[i(M),i(B-M*A)],!IO)else true).

Haskell, 85 81

f[a,b,c]|m<-(c-b)`div`(b-a)=[m,b-m*a]
main=getLine>>=mapM_ print.f.map read.words

Jetzt Eingaben mit Leerzeichen, Ausgaben mit Zeilenumbrüchen.

C 80

main(a,b,c,m){scanf("%d %d %d",&a,&b,&c);m=(c-b)/(b-a);printf("%d %d",m,b-m*a);}

C ++, 96

#include<iostream>
main(){int a,b,c,m;std::cin>>a>>b>>c;m=(c-b)/(b-a);std::cout<<m<<' '<<b-m*a;}

Nimrod, 146

import strutils
var
 q:array[0..3,int]
 b,m:int
for i in 0..2:q[i]=ParseInt(readLine(stdin))
b=q[1]
m=(q[2]-b)div(b-q[0])
echo($m,",",$(b-m*q[0]))

Eingabe mit Zeilenumbrüchen, Ausgabe mit Komma.

Dieser zählt nicht, aber ich glaube, dass er irgendwie noch passt:

Mathematischer Satz, 713 Zeichen von LaTeX

\documentclass{article}\usepackage{amsmath}\usepackage{amsthm}\begin{document}Theorem: for a sequence $(a_i)_i$ of integers with $a_2\neq a_1$ where $a_3-a_2$ is divisible by $a_2-a_1$, $m:=\frac{a_3-a_2}{a_2-a_1},\ p:=a_2-m\cdot a_1$ give rise to a sequence\[b_i:=\begin{cases}a_1&\text{for }i=1\\b_{i-1}\cdot m+p&\text{else}\end{cases}\] such that $b_i=a_i\ \forall i\leq 3$.

Proof: $i=1$ is trivial,\[\begin{aligned}b_2=&b_1\cdot m+p=a_1\frac{a_3-a_2}{a_2-a_1}+a_2-\frac{a_1a_3-a_1a_2}{a_2-a_1}=a_2,\\b_3=&b_2\cdot m+p=\frac{a_2a_3-a_2^2}{a_2-a_1}+a_2-\frac{a_1a_3-a_2^2}{a_2-a_1}\\=&\frac{a_2a_3-a_1a_3+(a_2-a_1)a_2-a_2^2+a_1a_2}{a_2-a_1}\\=&\frac{a_2-a_1a_3+0}{a_2-a_1}=a_3.\end{aligned}\]\qed\end{document}

Pascal, 90 88

program r;var a,b,c:integer;begin;read(a,b,c);c-=b;c:=c div(b-a);write(c,' ',b-c*a);end.

Cuda, 301

#include<stdio.h>
__global__ void r(int*q){if(!(blockIdx.x|threadIdx.x)){q[1]-=*q;q[1]/=(*q-q[2]);*q-=q[1]*q[2];}}
main(){int p[3],*q;scanf("%d%d%d",p+2,p,p+1);cudaMalloc(&q,24);cudaMemcpy(q,p,24,cudaMemcpyHostToDevice);r<<<1,1>>>(q);cudaMemcpy(p,q,24,cudaMemcpyDeviceToHost);printf("%d %d",p[1],*p);}

AWK, 35 Zeichen

{m=($3-$2)/($2-$1);print m,$2-$1*m}

• Eingabeformat: 2 0 -4

bc, 39 Zeichen

define f(a,b,c){
m=(c-b)/(b-a)
m
b-a*m}

• Eingabeformat: z=f(2, 0, -4)
• Die Eingabe ist ein bcAusdruck. Nach dem bcLesen der Quelldatei wird die Standardeingabe gelesen. Aus diesem Grund muss die Eingabe wie ein Funktionsaufruf aussehen.
• Ich benutze OpenBSD bc, das nach dem einen Zeilenumbruch benötigt {.

Common Lisp, 88 Zeichen

(let*((a(read))(b(read))(c(read))(m(/(- c b)(- b a))))(format
t "~A ~A" m (- b(* a m))))

• Eingabeformat: 2 0 -4

csh, 86 zeichen

set i=(`cat`)
@ m=($i[3] - $i[2]) / ($i[2] - $i[1])
@ n=$i[2] - $i[1] * $m
echo $m $n

• Eingabeformat: 2 0 -4
• Das 86. Zeichen steht am Ende der Datei in Zeilenumbrüchen. cshist die einzige Sprache, für die ich Zeilenumbruch am Ende der Datei zähle. Dies liegt daran, dass cshder letzte Befehl nur ausgeführt wird, wenn eine neue Zeile vorhanden ist.
• set i=($<)funktioniert nicht, weil $<es keine wortteilung gibt.

Gleichstrom, 30 Zeichen

?scsbsalclb-lbla-/psmlblalm*-p

• Eingabeformat:, 2 0 _4wo _ist der Unterstrich.

es, 95 Zeichen

i=(`cat)
b=$i(2)
m=`{expr \( $i(3) - $b \) / \( $b - $i(1) \)}
echo $m `{expr $b - $i(1) \* $m}

• Eingabeformat: 2 0 -4
• esist die erweiterbare Schale von Paul Haahr und Byron Rakitzis.

Faktor 138 Zeichen

USING: eval formatting io kernel locals math ;
contents eval( -- a b c ) [let :> ( a b c )
c b - b a - / dup a * b swap - "%d %d" printf ]

• Eingabeformat: 2 0 -4

PicoLisp, 74 72 Zeichen

(in()(let(r read a(r)b(r)c(r)m(/(- c b)(- b a)))(print
m (- b(* a m)))))

• Eingabeformat: 2 0 -4
• BEARBEITEN: 2 Zeichen durch Ändern a(read)b(read)c(read)von verloren r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 Zeichen

:Input A
:Input B
:Input C
:(C-B)/(B-A)→M
:Disp M
:Disp B-A*M

• Eingabeformat: 2ENTER 0ENTER ¯4ENTER, wobei ¯das unäre Minus des Rechners ist.
• Ich habe Unicode-Zeichen gezählt. →(der rechte Pfeil) zählt als U + 2192. Zum Beispiel zählt der Rechner Input Aals 2 Zeichen, aber ich zähle Input Aals 7 Zeichen. Ich zähle auch :als 1 Charakter.
• EDIT: Ich habe falsch gezählt: Es gibt 61, nicht 63 Zeichen.

zsh, 62 Zeichen

i=(`cat`)
((b=i[2],m=(i[3]-b)/(b-i[1]),n=b-i[1]*m))
echo $m $n

• Eingabeformat: 2 0 -4

AWK (32)

{m=$3-$2;print m/=$2-$1,$2-$1*m}

Demo: http://ideone.com/kp0Dj

Bash (38)

awk '{m=$3-$2;print m/=$2-$1,$2-$1*m}'

Demo: http://ideone.com/tzFi8

DOS / BATCH (54 55 )

set/a m=(%3-%2)/(%2-%1)&set/a n=%2-%m%*%1&echo %m% %n%

Nimmt Parameter als durch Leerzeichen getrennte Liste von Argumenten.

Java (143 185 )

enum R{R;{int a=0,b=0,c,i=2;for(;(c=new java.util.Scanner(System.in).nextInt()+b*--i)+i>=c;b=c)a+=c*i;c/=b-a;System.out.print(c+" "+(b-a*c));}}

JavaScript (48 61 67 )

p=prompt;m=p(b=p(a=p()))-b;alert([m/=b-a,b-a*m])

Demo: http://jsfiddle.net/BT8bB/6/

PHP (61 77 )

<?list(,$a,$b,$c)=$argv;$c-=$b;echo($c/=$b-$a).' '.$b-=$c*$a;

Demo: http://ideone.com/CEgke

QBasic (34)

INPUT a,b,c
m=(c-b)/(b-a)
?m;b-m*a

TI-83 Basic (25 41 )

:Prompt A,B,C
:(C-B)/(B-A
:Disp Ans,B-AAns

Ja, die fehlende rechte Klammer ist absichtlich. Es ist eine bekannte Optimierungstechnik, dass das Schließen der Klammern vor einer STO-Operation in der TI-83 Basic-Programmierung nicht erforderlich ist.

Leerzeichen, 123

E / A ist durch Zeilenumbrüche getrennt. (Um den Quellcode zu erhalten, rufen Sie den Bearbeitungsmodus auf und kopieren Sie das Leerzeichen zwischen den vorformatierten Tags. Alternativ können Sie das Online- Beispiel bei Ideone lesen .)

Erklärung, wobei S, T, L für Leerzeichen, Tabulator, Zeilenvorschub steht:

Pseudocode     Whitespace
----------     ----------
push 0         SS SSL
readn          TLTT
push 1         SS STL
readn          TLTT
push 2         SS STSL
dup            SLS
readn          TLTT
retr           TTT
push 1         SS STL
retr           TTT
-              TSST
push 1         SS STL
retr           TTT
push 0         SS SSL
retr           TTT
-              TSST
/              TSTS
dup            SLS
outn           TLST
push 10        SS STSTSL
outc           TLSS
push 0         SS SSL
retr           TTT
*              TSSL
push 1         SS STL
retr           TTT
swap           SLT
-              TSST
outn           TLST
exit           LLL

R 50

x=scan(n=3);y=diff(x);z=y[2]/y[1];c(z,x[2]-x[1]*z)

I / O ist durch Leerzeichen getrennt.

Eule

--- 22 ---

< <%<-2`2`-/%.10)2'*-.

E / A ist durch Zeilenumbrüche getrennt.

--- 19 --- (wenn diese Version erlaubt ist; aber ich denke es betrügt, da der \ ausführbarer Code ist):

1`-1`3`-/%.32)2'*-.

E / A ist durch Leerzeichen getrennt. Befehlszeilenverwendung: owl prog 5 19\ 77(das \ fungiert in Owl als unärmeres Minus für Postfix).

J, 23 Zeichen

(],1{x-0{x*])%~/2-/\x=:

Verwendung:

   (],1{x-0{x*])%~/2-/\x=: 5 _19 77
_4 1

Negative Zahlen werden in J durch Unterstriche dargestellt.

PHP, 88 Zeichen

<?php
list($x,$y,$z)=split(' ',fgets(STDIN));
$a=($z-$y)/($y-$x);
echo$a." ".($y-$a*$x);

Scala, 102 Zeichen

val x=readLine.split(" ").toList.map(_.toInt)
val a=(x(2)-x(1))/(x(1)-x(0))
print(a+" "+(x(1)-x(0)*a))

Perl, 57 Zeichen

s!(.+) (.+) (.+)!$a=($3-$2)/($2-$1);$a." ".($2-$1*$a)!e

Benötigt die Option '-p', für die ich 2 Zeichen hinzugefügt habe. Nimmt an, dass die Eingabe gültig ist, um einige Zeichen zu speichern.

Alle meine Antworten enthalten durch Leerzeichen getrennte Zahlen.

PHP, 74 , 72 , 69

<?fscanf(STDIN,'%d%d%d',$a,$b,$c);echo($d=($c-$b)/($b-$a)).' '.($b-$d*$a);

Wenn die Eingabe als Argumente übergeben wird:

<?echo($d=($argv[3]-$argv[2])/($b=$argv[2]-$a=$argv[1])).' '.($b-$d*$a);

Nun, wie @mellamokb vorschlug, mit $ n = $ argv:

<?$n=$argv;echo($d=($n[3]-$n[2])/($b=$n[2]-$a=$n[1])).' '.($b-$d*$a);

C 77 , 78

main(a,b,c,d){printf("%d %d",d=(c-b)/(b-a),b-d*a,scanf("%d%d%d",&a,&b,&c));}

^ funktioniert nicht so, hier ist das Zeug: [Danke an @ugoren, dass er es zur Kenntnis genommen hat]

main(a,b,c,d){printf("%d %d",d,b-a*(d=(c-b)/(b-a)),scanf("%d%d%d",&a,&b,&c));}

VBA, 57 Zeichen

Sub x(a,b,c)
y=(c-b)/(b-a)
MsgBox y & " " & b-a*y
End Sub

( Dies ist im Grunde das Gleiche wie bei den anderen 'BASIC'-Funktionen, aber ich habe dort draußen bereits keine VBA-Einreichungen gesehen. )

Bash (42 Zeichen)

Pure Bash:

((m=($3-$2)/($2-$1),c=$2-m*$1));echo $m $c

Bash (31 Zeichen)

Beschuss mit etwas anderem:

owl -p"<%<%<$-1`4'-/%.32)2'*-."

(Basierend auf Howards OWL-Implementierung )

Dies ist (nicht optimierter) Code für die unlimitierte Registermaschine, der hier beschrieben wird: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

Der Eingang sollte sich in den Registern 1,2 und 3 befinden, und der Ausgang sollte sich nach Abschluss des Programms in den Registern 1 und 2 befinden. Nicht negative und nicht ganzzahlige Zahlen werden nicht behandelt, aber die Eingaben 0,7,14 und 2,5,11 werden korrekt behandelt.

Zero[8] Trans[2,11] Jump[3,11,7] Succ[11] Succ[8] Jump[11,11,3] Zero[5] Trans[1,12] Jump[2,12,13] Succ[12] Succ[5] Jump[12,12,9] Zero[17] Trans[8,13] Jump[13,17,25] Zero[16] Trans[5,14] Jump[13,14,22] Succ[14] Succ[16] Jump[14,14,18] Succ[9] Trans[16,13] Jump[17,17,15] Zero[6] Zero[20] Jump[9,6,40] Zero[7] Trans[1,21] Jump[20,7,36] Succ[21] Trans[21,19] Trans[19,21] Succ[7] Jump[7,7,30] Trans[21,18] Trans[18,20] Succ[6] Jump[6,6,27] Trans[20,4] Zero[10] Trans[4,15] Jump[2,15,47] Succ[15] Succ[10] Jump[15,15,43] Trans[9,1] Trans[10,2]

BEARBEITEN: durch Entfernen von Klammern und Kürzen von Anweisungsnamen:

URM 285

Z8 T2,11 J3,11,7 S11 S8 J11,11,3 Z5 T1,12 J2,12,13 S12 S5 J12,12,9 Z17 T8,13 J13,17,25 Z16 T5,14 J13,14,22 S14 S16 J14,14,18 S9 T16,13 J17,17,15 Z6 Z20 J9,6,40 Z7 T1,21 J20,7,36 S21 T21,19 T19,21 S7 J7,7,30 T21,18 T18,20 S6 J6,6,27 T20,4 Z10 T4,15 J2,15,47 S15 S10 J15,15,43 T9,1 T10,2

DOS-BATCH, 98

@ECHO OFF&SET/P p=&SET/P q=&SET/P r=&SET/A m=(%r%-%q%)/(%q%-%p%)&SET/A n=%q%-%p%*%m%&ECHO %m% %n%

Eingabe in separaten Zeilen

Bash, 51

m=$((($3 - $2)/($2 - $1)))
echo $m $(($2 - $m*$1))

Beispiel: sh prog.sh 2 0 -4 (durch Leerzeichen getrennte Argumente)

Perl, 84

@s=split(/ /,<STDIN>);$m=($s[2]-$s[1])/($s[1]-$s[0]);print $m." ".($s[1]-$s[0]*$m);

Java, 297

import java.util.*;public class A{public static void main(String a[]){StringTokenizer s=new StringTokenizer(new Scanner(System.in).nextLine());int i=4;int[] p=new int[i];while(i-->1)p[3-i]=Integer.parseInt(s.nextToken());p[3]=(p[2]-p[1])/(p[1]-p[0]);System.out.print(p[3]+" "+(p[1]-p[0]*p[3]));}}

Durch Leerzeichen getrennte Eingabe, durch Leerzeichen getrennte Ausgabe.

SQL, 57

select (&3-&2)/(&2-&1),&2-((&3-&2)/(&2-&1)*&1) from dual

Dies ist ein trauriger Eintrag, aber "nur" löst den Zweck. Die Abfrage bindet die Eingabe zur Laufzeit. 1,2,3 sind Variablen in der Reihenfolge der Eingabe.

Q, 36

{a,x[2]-x[1]*a:%[x[2]-x 1;x[1]-x 0]}

Verwendung

q){a,x[2]-x[1]*a:%[x[2]-x 1;x[1]-x 0]}each(0 7 14;2 5 11;2 0 -4;5 -19 77)
1  7 
2  1 
2  -4
-4 1

Fortran 44

read*,i,j,k;k=(k-j)/(j-i);print*,k,j-i*k;end

Die Eingabe erfolgt in einer einzelnen Zeile (durch Kommas oder Leerzeichen getrennt).

Cray Chapel 59

var i,j,k:int;read(i,j,k);k=(k-j)/(j-i);write(k," ",j-i*k);

Die Eingabe erfolgt in einer einzelnen Zeile, keine neue Zeile (fügen Sie dazu 2 Zeichen hinzu, indem Sie writelnanstelle von verwenden write).

Golflua 44

r=I.r;a,b=r(),r();m=(r()-b)/(b-a);w(m,b-m*a)

Eingabe mit Zeilenumbruch, Ausgabe mit Leerzeichen

Julia, 71 Zeichen

Durch Leerzeichen getrennte Ein- und Ausgabe.

i,j,k=int(split(readline(STDIN)));println("$(l=div(k-j,j-i)) $(j-i*l)")

Beispiel für Ein- und Ausgabe:

julia> i,j,k=int(split(readline(STDIN)));println("$(l=div(k-j,j-i)) $(j-i*l)")
5 -19 77
-4 1

Piet, 86 60 56 Codels (14x4), Codelgröße 10 für bessere Sichtbarkeit

Ich könnte die Anzahl der Codels sogar um satte 35% reduzieren. Ich habe kein so gutes Ergebnis erwartet. Das Programm rückwärts zu programmieren war, wie ich erwartet hatte, ziemlich erfolgreich. Ich bezweifle, dass es kürzer sein kann, aber ich wäre wirklich interessiert, wenn jemand eine kleinere Lösung finden könnte.

Die Abfrage gibt nicht an, ob das Programm nach der Anzeige des Ergebnisses angehalten werden muss, sodass mein kleinstes (56 Codel) Programm gültig sein sollte. Nachdem das Ergebnis angezeigt wurde, kehrt es zum Anfang zurück und fordert ein neues Triplett von ganzen Zahlen an. Aufgrund der engen Packung gibt es keinen Platz für die Ausgabe von zwei Zeilenumbrüchen, aber das ist mit dem npiet-Interpreter kein Problem, da er immer ein '?' wenn es auf die Eingabe wartet.

Es gibt zwei mögliche Größen, um eine Loop-Version zu erstellen, aber eine Version, die nur einmal ausgeführt wird, ist nur in einem Programm möglich, das mindestens 64 Codel (16x4) groß ist. Die folgenden Versionen zeigen den Grund. Vielleicht ist es auch für diejenigen interessant, die mit Piet vertraut sind.

Die letzte, dichteste 56-Codel-Version mit einer Schleife :

Zweite Version (60 Codels), mit einer Schleife

Wenn die 56-Codel-Version gegen die Regeln verstößt, ist hier die endgültige 64-Codel-Version, die nur einmal ausgeführt wird :

Meine erste Version (86 Codels)

Eingabe und Ausgabe sind durch Zeilenumbrüche getrennt.

Beispiel für Ein- und Ausgabe:

D:\codegolf\npiet-1.3a-win32>npiet ml_series.png
? 5
? -19
? 77
-4
1

Für geloopte Versionen, die etwas hässlicher aussehen:

D:\codegolf\npiet-1.3a-win32>npiet ml_series_56_codels.png"
? 5
? -19
? 77
-4
1? 5
? -19
? 77
-4
1? 5
? -19
? 77
-4
1?

Ich habe Newline als Trennzeichen gewählt, weil die Codierung von ASCII 10 (\ n) offensichtlich nur 7 Codels benötigt, im Vergleich zu ASCII 32 (), das 8 Codels benötigt, oder sogar ASCII 40 (,), das 9 Codels benötigt.

Das Zurückcodieren vom Ergebnis zur ersten Eingabe ist eine gute Möglichkeit, den Codelverbrauch für ROL-Operationen zu reduzieren. Die Stapelreihenfolge am Anfang und am Ende ist bekannt, der Rest wird einfach von Hand erledigt.

Hier ist eine Textversion des 64-Codel-Programms (mit Stapel) in meiner erfundenen Kurzform. Die kürzeren Programme werden nicht beendet, sondern kehren zum Anfang zurück.

NOP ADD DIV GRT DUP INC END
 0   +   /   >   =   c   ~
PSH SUB MOD PTR ROL OUN
 X   -   %   #   @   N
POP MUL NOT SWI INN OUC
 ?   *   !   $   n   C

                   1
        1    1   2 2     1                   a,b,c: input for series
      5 5  3 3 c c cb  3 3                       D: c-b
    b b bb b bbb b bcD D Da                      E: b-a
   bb b bb b baa a aaa a abE F                   F: D/E, (c-b)/(b-a), mul. const.
  bbb b ba a abb b bbb b bDDFFF    5             G: a*F, a(c-b)/(b-a)
 aaaa a aa a aaa a aaa a aaaaaaG  55 10          H: b-G, b-a*F, add. const.
aaaaa a ab b bbb b bbb b bbbbbbbH HH  H H
n=n==5X1X@3X1X@n2X1X@-3X1X@-/=N*-5X=  + CN~
| |            |     |     || |||\____/ ||
| |            |     |     || |||  |    |+———— output add. const.
| |            |     |     || |||  |    +————— output newline character
| |            |     |     || |||  +—————————— 5 DUP + =10, ASCII for \n
| |            |     |     || ||+————————————— H, add. const.
| |            |     |     || |+—————————————— G
| |            |     |     || +——————————————— output mul. const.
| |            |     |     |+————————————————— F, mul. const.
| |            |     |     +—————————————————— E
| |            |     +———————————————————————— D
| |            +—————————————————————————————— input c
| +——————————————————————————————————————————— input b
+————————————————————————————————————————————— input a

MoonScript (48 Zeichen, durch Zeilenumbrüche und Leerzeichen getrennte Ausgabe)

r=io.read
a,b=r!,r!
m=(r!-b)/(b-a)
print m,b-m*a

Felix (86 Zeichen, durch Zeilenumbrüche und durch Kommas getrennte Ausgabe)

gen r()=>int $ readln stdin;
var a,b=r(),r();
var m=(r()-b)/(b- a);
println(m,b- m*a);

Julia (84 Zeichen, durch Leerzeichen begrenzte Eingabe, durch Leerzeichen begrenzte Ausgabe)

a,b,c=tuple(map(int,split(readline(STDIN)))...)
m=(c-b)/(b-a)
println("$m $(b-m*a)")