Celem Stone Rosetta Challenge jest pisanie rozwiązań w jak największej liczbie języków. Pochwal się swoją wielojęzycznością programistyczną!

Wyzwanie

Twoim wyzwaniem jest wdrożenie programu, który wprowadzi listę liczb i wyświetli regułę stosowaną do generowania każdej kolejnej liczby w szeregu, w jak największej liczbie języków programowania . Możesz używać dowolnej standardowej funkcji biblioteki, którą posiada Twój język, ponieważ jest to głównie prezentacja języka.

Co to jest „seria?”

Seria to uporządkowana lista liczb całkowitych. Każdy kolejny numer w serii można wygenerować, stosując prostą regułę do poprzedniego numeru w serii. W tym wyzwaniu reguła polega na pomnożeniu liczby przez stałą, a następnie dodaniu drugiej stałej. Obie stałe mogą być dowolnymi liczbami całkowitymi. Celem tego wyzwania jest uzyskanie tych dwóch stałych.

W przypadku serii 2 5 11regułę można zapisać jako 2 1. Oznacza to, że każda liczba jest poprzednią liczbą, razy 2, plus 1. Ważnym faktem jest to, że większość serii ma dokładnie jedną regułę. Niektóre serie mają albo nieskończoną liczbę, albo wcale, ale nie będziesz musiał sobie z tym poradzić.

Wejście

Dane wejściowe będą listą trzech różnych liczb całkowitych, które są liczbami w sekwencji. Liczby mogą być spacjami, przecinkami lub znakami nowej linii, ale proszę podać, które. Będę elastyczny w kwestii tego ograniczenia, ponieważ niektóre języki mogą mieć ograniczenia wprowadzania. Oto cztery przykłady danych wejściowych:

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

Wynik

Wyjściowe będą dwie liczby całkowite, które reprezentują regułę użytą do wygenerowania szeregu. Pierwsza liczba będzie stałą multiplikatywną, a druga liczba będzie stałą addytywną. Formatowanie wyniku może być spacją, przecinkiem lub znakiem nowej linii. Jestem również elastyczny w kwestii tego ograniczenia. Oto odpowiednie przykłady wyników:

1 7
2 1
2 -4
-4 1

Kryterium zwycięskiego celu

Jeśli chodzi o obiektywne kryterium wygranej, oto on: Każdy język to osobny konkurs na to, kto może napisać najkrótszą pracę, ale ogólnym zwycięzcą byłaby osoba, która wygra najwięcej z tych pod-konkursów. Oznacza to, że osoba, która odpowiada w wielu nietypowych językach, może zyskać przewagę. Code-golf jest przeważnie rozstrzygający, gdy istnieje więcej niż jedno rozwiązanie w języku: osoba z najkrótszym programem otrzymuje kredyt za ten język.

Reguły, ograniczenia i uwagi

Twój program może być napisany w dowolnym języku, który istniał przed 9 kwietnia 2012 r. Będę również musiał polegać na społeczności, aby zweryfikować niektóre odpowiedzi napisane w niektórych bardziej rzadkich / ezoterycznych językach, ponieważ jest mało prawdopodobne, że będę w stanie przetestować im.

Aktualny ranking

Ta sekcja będzie okresowo aktualizowana, aby pokazać liczbę języków i kto prowadzi w każdym z nich.

• AWK (32) - mellamokb
• bash (31) - Peter Taylor
• Befunge (29) - Howard
• bc (39) - kernigh
• brainfuck (174) - CMP
• C (78) - 10n3_shArk
• C ++ (96) - po lewej stronie
• Common Lisp (88) - kernigh
• Cray Chapel (59) - Kyle Kanos
• csh (86) - kernigh
• Cuda (301) - po lewej stronie
• dc (30) - kernigh
• DOS BATCH (54) - mellamokb
• Element (27) - Howard
• es (95) - kernigh
• Współczynnik (138) - kernigh
• Felix (86) - kirbyfan64sos
• Fortran (44) - Kyle Kanos
• Idź (101) - Howard
• GolfScript (16) - Howard
• Golflua (44) - Kyle Kanos
• Haskell (35) - po lewej stronie
• J (23) - Gareth
• Java (141) - Howard
• JavaScript (47) - mellamokb
• Julia (71) - ML
• Lua (51) - Howard
• Rtęć (319) - po lewej stronie
• MoonScript (48) - kirbyfan64sos
• Nimrod (146) - po lewej stronie
• Owl (22) - res
• Pascal (88) - po lewej stronie
• Perl (57) - Gareth
• PHP (61) - mellamokb
• PicoLisp (72) - kernigh
• Piet (56) - ML
• PostScript (61) - Howard
• Python (40) - Howard
• Q (36) - tartinina
• QBasic (34) - mellamokb
• R (50) - res
• Ruby (44) - Howard
• Scala (102) - Gareth
• SQL (57) - Aman ZeeK Verma
• TI-83 BASIC (25) - mellamokb
• Nieograniczona rejestracja maszyny (285) - Paxinum
• VBA (57) - Gaffi
• Biała spacja (123) - res
• zsh (62) - kernigh

Aktualne rankingi użytkowników

Równe stopnie są sortowane alfabetycznie.

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), Factor (138), PicoLisp (72), zsh (62)

3. leftroundabout (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): Owl (22), R (50), Whitespace (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): Unlimited Register Machine (285)

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

16. tmartin (1): Q (36)

GolfScript, 16 znaków

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

Dane wejściowe są podawane jako lista oddzielona spacjami.

JavaScript, 56 znaków

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

Dane wejściowe są podawane na monit.

Ruby, 44 znaki

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

Dane wejściowe podano tutaj jako listę oddzieloną przecinkami.

Python, 40 znaków

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

Dane wejściowe są ponownie oddzielone przecinkami.

Java, 141 znaków

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

Wejście oddzielone znakiem nowej linii.

Lua, 51 znaków

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

Wejście oddzielone znakiem nowej linii.

Idź, 101 znaków

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

Wejście oddzielone znakiem nowej linii.

Fortran, 90 znaków

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

Wejście oddzielone znakiem nowej linii.

Befunge, 29 znaków

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

PostScript, 61 znaków

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

Sowa, 23 znaki

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

Wejście oddzielone znakiem nowej linii.

Element , 27 znaków

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

Wejście oddzielone znakiem nowej linii.

Brainfuck - 174

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

Piet - 82?

Nie jestem pewien, jak mierzyć tutaj konkurencyjny golf. Idę z całkowitym rozmiarem obrazu (w kodach) Mój jest 41x2:

Befunge - 34

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

Angielski - 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.

Nie jestem pewien, czy to się liczy, ale pomyślałem, że dam temu szansę. Niezwykle trudno jest dokładnie opisać nawet prosty algorytm. Trochę życzę, aby angielski wspierał jakiś symbol grupowania w celu ustalenia pierwszeństwa.

QBasic, 42

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

Wymaga wprowadzenia przecinków, danych wyjściowych ze spacjami (czy to w porządku?)

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

Teraz dane wejściowe ze spacjami, dane wyjściowe z nowymi liniami.

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

Wejście w / nowe linie, przecinek wyjściowy.

Ten nie będzie się liczył, ale wydaje mi się, że nadal pasuje w jakiś sposób:

Twierdzenie matematyczne, 713 znaków 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 znaków

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

• Format wejściowy: 2 0 -4

bc, 39 znaków

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

• Format wejściowy: z=f(2, 0, -4)
• Dane wejściowe są bcwyrażeniem. Po bcodczytaniu pliku źródłowego odczytuje standardowe wejście. Dlatego dane wejściowe muszą wyglądać jak wywołanie funkcji.
• Używam OpenBSD bc, który wymaga nowej linii po {.

Common Lisp, 88 znaków

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

• Format wejściowy: 2 0 -4

csh, 86 znaków

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

• Format wejściowy: 2 0 -4
• 86. znak jest znakiem nowej linii na końcu pliku. cshjest jedynym językiem, dla którego liczę znak nowej linii na końcu pliku. Jest tak, ponieważ cshnigdy nie uruchamia ostatniego polecenia, chyba że jest tam nowy wiersz.
• set i=($<)nie działa, ponieważ $<nie ma podziału słów.

dc, 30 znaków

?scsbsalclb-lbla-/psmlblalm*-p

• Format wejściowy:, 2 0 _4gdzie _jest podkreślenie.

es, 95 znaków

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

• Format wejściowy: 2 0 -4
• esjest rozszerzalną powłoką autorstwa Paula Haahra i Byrona Rakitzisa.

Współczynnik, 138 znaków

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 ]

• Format wejściowy: 2 0 -4

PicoLisp, 74 72 znaków

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

• Format wejściowy: 2 0 -4
• EDYCJA: Straciłem 2 znaki, zmieniając a(read)b(read)c(read)na r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 znaków

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

• Format wejściowy: 2ENTER 0ENTER ¯4ENTER, gdzie ¯jest jednostkowym minusem kalkulatora.
• Policzyłem znaki Unicode; →(prawa strzałka) liczy się jako U + 2192. Na przykład kalkulator liczy się Input Ajako 2 znaki, ale liczę Input Ajako 7 znaków. Liczę również :jako 1 znak.
• EDYCJA: Źle przeliczyłem: jest 61, a nie 63 znaków.

zsh, 62 znaki

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

• Format wejściowy: 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%

Pobiera parametry jako rozdzieloną spacjami listę argumentów.

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

Tak, brakujący nawias prawy jest celowy. Jest to dobrze znana technika optymalizacji, polegająca na tym, że zamykanie nawiasów przed operacją STO nie jest konieczne w programowaniu podstawowym TI-83.

Biała spacja, 123

I / O jest oddzielony znakiem nowej linii. (Aby uzyskać kod źródłowy, przejdź do trybu edycji i skopiuj spację między tagami preformat; lub zobacz przykład online w Ideone .)

Objaśnienie, gdzie S, T, L reprezentuje spację, tabulator, podawanie linii:

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)

We / wy jest rozdzielone spacjami.

Sowa

--- 22 ---

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

I / O jest oddzielony znakiem nowej linii.

--- 19 --- (jeśli ta wersja jest dozwolona; ale myślę, że to oszustwo, ponieważ \ jest kodem wykonywalnym):

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

We / wy jest rozdzielone spacjami. Wykorzystanie w wierszu polecenia: owl prog 5 19\ 77(\ działa jako unfiks jednorazowy minus w Sowie).

J, 23 znaki

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

Stosowanie:

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

Liczby ujemne są reprezentowane przez podkreślenia w J.

PHP, 88 znaków

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

Scala, 102 znaki

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 znaków

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

Wymaga opcji „-p”, do której dodałem 2 znaki. Zakłada, że ​​dane wejściowe są prawidłowe, aby zapisać niektóre znaki.

Wszystkie moje odpowiedzi zajmują liczby oddzielone spacjami.

PHP, 74,72 , 69

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

Gdy dane wejściowe są przekazywane jako argumenty:

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

Teraz, jak sugerował @mellamokb, używając $ 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));}

^ nie działa, oto rzeczy: [dzięki @ugoren za zwrócenie na to uwagi]

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 znaków

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

( Jest to w zasadzie to samo co inne funkcje „BASIC”, ale nie widziałem już żadnych zgłoszeń VBA ).

bash (42 znaki)

Pure Bash:

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

bash (31 znaków)

Ucieczka do czegoś innego:

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

(Na podstawie implementacji OWL Howarda )

Jest to (niezoptymalizowany) kod dla nieograniczonej maszyny rejestrującej, opisany tutaj: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

Wejście powinno znajdować się w rejestrze 1,2 i 3, a wyjście będzie w rejestrze 1, 2 po zakończeniu programu. Liczby nieujemne i liczby całkowite nie są obsługiwane, ale dane wejściowe 0,7,14 i 2,5,11 są obsługiwane poprawnie.

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]

EDYCJA: usuwając nawiasy kwadratowe i skracając nazwy instrukcji:

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%

Wprowadź w osobnych wierszach

Bash, 51

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

Przykład: sh prog.sh 2 0 -4 (argumenty rozdzielone spacjami)

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

Wejście oddzielone spacją, wyjście rozdzielone spacją.

SQL, 57

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

To smutny wpis, ale „po prostu” rozwiązuje cel. Zapytanie wiąże dane wejściowe w czasie wykonywania 1,2,3 są zmiennymi w kolejności wprowadzania.

Q, 36

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

stosowanie

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

Dane wejściowe będą w jednym wierszu (oddzielone przecinkami lub spacjami)

Kaplica Crayów 59

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

Dane wejściowe będą w jednym wierszu, bez nowego wiersza (dodaj do tego 2 znaki, używając writeln zamiast write).

Golflua 44

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

Wejście rozdzielane znakiem nowej linii, wyjście rozdzielane spacjami

Julia, 71 znaków

Wejście i wyjście rozdzielane spacjami.

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

Przykładowe dane wejściowe i wyjściowe:

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 kodów (14x4), rozmiar kodu 10 dla lepszej widoczności

Mógłbym faktycznie zmniejszyć liczbę kodów o aż 35%. Nie spodziewałem się tak dobrego wyniku. Kodowanie tego programu wstecz było, jak się spodziewałem, całkiem udane. Wątpię, by mogło być krótsze niż to, ale byłbym naprawdę zainteresowany, gdyby ktokolwiek znalazł mniejsze rozwiązanie.

Wyzwanie nie określa, czy program musi się zatrzymać po wyświetleniu wyniku, więc mój najmniejszy program (56 kodów) powinien być poprawny. Po wyświetleniu wyniku po prostu zapętla się do początku, prosząc o nową triolę liczb całkowitych. Z powodu ciasnego upakowania nie ma miejsca na wyjście dwóch znaków nowego wiersza, ale nie jest to problem z interpreterem npiet, ponieważ zawsze wypisuje „?” jeśli oczekuje na wejście.

Istnieją dwa możliwe rozmiary, aby zbudować zapętloną wersję, ale wersja, która działa tylko raz, jest możliwa tylko w programie o rozmiarze co najmniej 64 kodeli (16 x 4). Poniższe wersje pokazują przyczynę. Może to również interesujące dla tych, którzy znają Pieta.

Ostatnia, najbardziej ciasno upakowana 56 wersja kodu z pętlą :

Druga wersja (60 kodów) z pętlą

Jeśli wersja 56 kodeli jest niezgodna z regułami, oto ostateczna wersja 64 kodela, działająca tylko raz :

Moja pierwsza wersja (86 kodów)

Dane wejściowe i wyjściowe są rozdzielane znakiem nowej linii.

Przykładowe dane wejściowe i wyjściowe:

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

W przypadku zapętlonych wersji wyglądają nieco brzydiej:

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?

Wybrałem znak nowej linii jako separator, ponieważ kodowanie ASCII 10 (\ n) oczywiście wymaga tylko 7 koderów, w porównaniu do ASCII 32 (), który potrzebuje 8 koderów lub nawet ASCII 40 (,), który potrzebuje 9 koderów.

Kodowanie wstecz od wyniku do pierwszego wejścia jest świetnym sposobem na ograniczenie użycia kodera w operacjach ROL. Kolejność stosów na początku i na końcu jest znana, resztę można łatwo wykonać ręcznie.

Oto tekstowa wersja 64-programowego programu kodującego (ze stosem), w moim wymyślonym skrócie. Krótsze programy po prostu się nie kończą, ale wracają do początku.

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 znaków, wejście rozdzielane znakami nowej linii, wyjście rozdzielane znakami spacji)

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

Felix (86 znaków, znak rozdzielany znakiem nowej linii, znak rozdzielany przecinkami)

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

Julia (84 znaków, wejście rozdzielane spacjami, wyjście rozdzielane spacjami)

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