El objetivo de Rosetta Stone Challenge es escribir soluciones en tantos idiomas como sea posible. ¡Muestra tu programación multilingüismo!

El reto

Su desafío es implementar un programa que ingrese una lista de números y genere la regla utilizada para generar cada número sucesivo de la serie, en tantos lenguajes de programación como sea posible . Puede usar cualquier tipo de función de biblioteca estándar que tenga su idioma, ya que esto es principalmente un escaparate de idiomas.

¿Qué es una "serie"?

Una serie es una lista ordenada de enteros. Cada número sucesivo de la serie se puede generar aplicando una regla simple al número anterior de la serie. En este desafío, la regla consiste en multiplicar el número por una constante y luego agregar una segunda constante. Ambas constantes pueden ser cualquier número entero. El objetivo de este desafío es generar esas dos constantes.

Para la serie 2 5 11, la regla se puede escribir como 2 1. Esto significa que cada número es el número anterior, multiplicado por 2, más 1. Un hecho importante es que la mayoría de las series tienen exactamente una regla. Algunas series tienen un número infinito o ninguno, pero no tendrá que lidiar con esto.

Entrada

La entrada será una lista de tres enteros diferentes que son los números en la secuencia. Los números pueden ser espacios, comas o líneas nuevas delimitadas, pero especifique cuál. Voy a ser flexible en esta limitación porque ciertos idiomas pueden tener restricciones de entrada. Aquí hay cuatro ejemplos de entrada:

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

Salida

La salida será dos enteros que representan la regla utilizada para generar la serie. El primer número será la constante multiplicativa, mientras que el segundo número será la constante aditiva. El formato de la salida puede ser espacio, coma o nueva línea delimitada. Soy flexible en esta limitación también. Estos son los ejemplos correspondientes de salida:

1 7
2 1
2 -4
-4 1

El criterio objetivo ganador

En cuanto a un criterio ganador objetivo, aquí está: cada idioma es una competencia separada en cuanto a quién puede escribir la entrada más corta, pero el ganador general sería la persona que gana la mayoría de estas subcompeticiones. Esto significa que una persona que responde en muchos idiomas poco comunes puede obtener una ventaja. Code-golf es principalmente un factor decisivo para cuando hay más de una solución en un idioma: la persona con el programa más corto obtiene crédito por ese idioma.

Reglas, restricciones y notas

Su programa se puede escribir en cualquier idioma que existiera antes del 9 de abril de 2012. También tendré que confiar en la comunidad para validar algunas respuestas escritas en algunos de los idiomas más infrecuentes / esotéricos, ya que es poco probable que pueda evaluar ellos.

Tabla de clasificación actual

Esta sección se actualizará periódicamente para mostrar la cantidad de idiomas y quién lidera cada uno.

• AWK (32) - mellamokb
• bash (31) - Peter Taylor
• Befunge (29) - Howard
• bc (39) - kernigh
• brainfuck (174) - CMP
• C (78) - l0n3_shArk
• C ++ (96) - leftaroundabout
• Lisp común (88) - kernigh
• Capilla Cray (59) - Kyle Kanos
• csh (86) - kernigh
• Cuda (301) - Leftaroundabout
• dc (30) - kernigh
• LOTE DE DOS (54) - mellamokb
• Elemento (27) - Howard
• es (95) - kernigh
• Factor (138) - kernigh
• Felix (86) - kirbyfan64sos
• Fortran (44) - Kyle Kanos
• Ir (101) - Howard
• GolfScript (16) - Howard
• Golflua (44) - Kyle Kanos
• Haskell (35) - Leftaroundabout
• J (23) - Gareth
• Java (141) - Howard
• JavaScript (47) - mellamokb
• Julia (71) - ML
• Lua (51) - Howard
• Mercurio (319) - Leftaroundabout
• MoonScript (48) - kirbyfan64sos
• Nimrod (146) - Leftaroundabout
• Búho (22) - res
• Pascal (88) - leftaroundabout
• 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
• Rubí (44) - Howard
• Scala (102) - Gareth
• SQL (57) - Aman ZeeK Verma
• TI-83 BASIC (25) - mellamokb
• Máquina de registro ilimitada (285) - Paxinum
• VBA (57) - Gaffi
• Espacio en blanco (123) - res
• zsh (62) - kernigh

Ranking de usuarios actuales

Los rangos iguales se ordenan alfabéticamente.

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. a la izquierda (6): C ++ (96), Cuda (301), Haskell (35), Mercurio (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): Capilla Cray (59), Fortran (44), Golflua (44)

7. res (3): Búho (22), R (50), Espacio en blanco (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): máquina de registro ilimitada (285)

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

16. tmartin (1): Q (36)

GolfScript, 16 caracteres

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

La entrada se da como una lista separada por espacios.

JavaScript, 56 caracteres

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

La entrada se da en el indicador.

Ruby, 44 caracteres.

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

La entrada se da aquí como una lista separada por comas.

Python, 40 caracteres

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

La entrada está nuevamente separada por comas.

Java, 141 caracteres

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

Entrada separada por nueva línea.

Lua, 51 caracteres

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

Entrada separada por nueva línea.

Go, 101 caracteres

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

Entrada separada por nueva línea.

Fortran, 90 caracteres

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

Entrada separada por nueva línea.

Befunge, 29 personajes

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

PostScript, 61 caracteres

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

Búho, 23 personajes

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

Entrada separada por nueva línea.

Elemento , 27 caracteres.

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

Entrada separada por nueva línea.

Brainfuck - 174

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

Piet - 82?

No estoy seguro de cómo medir el golf competitivo aquí. Voy a ir con el tamaño total de la imagen (en codeles) El mío es 41x2:

Befunge - 34

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

Inglés - 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.

No estoy seguro de si esto cuenta, pero pensé en intentarlo. Es notablemente difícil describir incluso un algoritmo simple con precisión. Desearía que el inglés admitiera algún tipo de símbolo de agrupación para establecer la precedencia.

QBasic, 42

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

Requiere entrada con comas, salidas con espacios (¿está bien?)

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

Ahora entradas con espacios, salidas con líneas nuevas.

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

Entrada con líneas nuevas, salida con coma.

Este no contará, pero creo que todavía encaja de alguna manera:

Teorema matemático, 713 caracteres de 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 caracteres

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

• Formato de entrada: 2 0 -4

aC, 39 caracteres

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

• Formato de entrada: z=f(2, 0, -4)
• La entrada es una bcexpresión. Despuésbc leer el archivo fuente, lee la entrada estándar. Es por eso que la entrada debe verse como una llamada de función.
• Yo uso OpenBSD bc, que requiere una nueva línea después de {.

Lisp común, 88 caracteres

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

• Formato de entrada: 2 0 -4

csh, 86 caracteres

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

• Formato de entrada: 2 0 -4
• El 86o carácter es una nueva línea al final del archivo. cshes el único idioma para el que cuento la nueva línea al final del archivo. Esto se debe a que cshnunca ejecuta el último comando a menos que haya nueva línea allí.
• set i=($<)no funciona, porque $<no tiene división de palabras.

dc, 30 caracteres

?scsbsalclb-lbla-/psmlblalm*-p

• Formato de entrada: 2 0 _4donde _está el guión bajo.

es, 95 caracteres

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

• Formato de entrada: 2 0 -4
• eses el caparazón extensible de Paul Haahr y Byron Rakitzis.

Factor, 138 caracteres

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 ]

• Formato de entrada: 2 0 -4

PicoLisp, 74 72 caracteres

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

• Formato de entrada: 2 0 -4
• EDITAR: Perdió 2 personajes al cambiar a(read)b(read)c(read)a r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 caracteres

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

• Formato de entrada: 2ENTER 0ENTER ¯4ENTER, donde ¯es el menos unario de la calculadora.
• Conté caracteres Unicode; →(la flecha derecha) cuenta como U + 2192. Por ejemplo, la calculadora cuenta Input Acomo 2 caracteres, pero yo cuento Input Acomo 7 caracteres. También cuento :como 1 personaje.
• EDITAR: he contado mal: hay 61, no 63, caracteres.

zsh, 62 caracteres

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

• Formato de entrada: 2 0 -4

AWK (32)

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

Demostración: http://ideone.com/kp0Dj

golpe (38)

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

Demostración: http://ideone.com/tzFi8

DOS / LOTE (54 55 )

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

Toma los parámetros como una lista de argumentos separados por espacios.

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

Demostración: http://jsfiddle.net/BT8bB/6/

PHP (61 77 )

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

Demostración: 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

Sí, el paréntesis derecho faltante es a propósito. Es una técnica de optimización bien conocida que cerrar los paréntesis antes de una operación STO no es necesario en la programación básica de TI-83.

Espacio en blanco, 123

E / S está separada por nueva línea. (Para obtener el código fuente, ingrese al modo de edición y copie el espacio en blanco entre las etiquetas de formato previo; o, vea el en línea formato previo ejemplo en en Ideone ).

Explicación, donde S, T, L representa espacio, tabulación, salto de línea:

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)

La E / S está separada por espacios.

Búho

--- 22 ---

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

E / S está separada por nueva línea.

--- 19 --- (si esta versión está permitida; pero creo que es una trampa, ya que \ es el código ejecutable):

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

La E / S está separada por espacios. Uso de la línea de comandos: owl prog 5 19\ 77(el \ actúa como un postfix unario menos en Owl).

J, 23 caracteres

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

Uso:

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

Los números negativos están representados por guiones bajos en J.

PHP, 88 caracteres

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

Scala, 102 caracteres

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 caracteres

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

Requiere la opción '-p', para lo cual he agregado 2 caracteres. Asume que la entrada es válida para guardar algunos caracteres.

Todas mis respuestas toman números separados por espacios.

PHP, 74,72 , 69

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

Cuando la entrada se pasa como argumentos:

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

Ahora, como sugirió @mellamokb, usando $ 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));}

^ no funciona así, estas son las cosas: [gracias a @ugoren por haberlo notado]

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 caracteres

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

( Esto es básicamente lo mismo que las otras funciones 'BÁSICAS', pero ya no vi ningún envío de VBA ) .

bash (42 caracteres)

Golpe puro:

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

bash (31 caracteres)

Desplazándose a otra cosa:

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

(Basado en la implementación de Howard OWL )

Este es un código (no optimizado) para la máquina de registro no limitada, que se describe aquí: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

La entrada debe estar en el registro 1,2 y 3, y la salida estará en el registro 1, 2 después de que el programa haya terminado. Los números no negativos y no enteros no se manejan, pero las entradas 0,7,14 y 2,5,11 se manejan correctamente.

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]

EDITAR: eliminando paréntesis y acortando nombres de instrucciones:

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%

Entrada en líneas separadas

Bash, 51

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

Ejemplo: sh prog.sh 2 0 -4 (argumentos separados por espacios)

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

Entrada separada por espacios, salida separada por espacios.

SQL, 57

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

Esta es una entrada triste, pero 'solo' resuelve el propósito. La consulta vincula la entrada en tiempo de ejecución 1,2,3 son variables en orden de entrada.

Q, 36

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

uso

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

La entrada estará en una sola línea (coma o espacio separado)

Capilla Cray 59

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

La entrada será en una sola línea, sin nueva línea (agregue 2 caracteres para eso usando writelnen lugar de write).

Golflua 44

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

Entrada delimitada de nueva línea, salida delimitada por espacios

Julia, 71 caracteres

Entrada y salida delimitadas por espacios.

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

Ejemplo de entrada y salida:

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 60 56 codeles (14x4), codel tamaño 10 para una mejor visibilidad

De hecho, podría reducir la cantidad de codeles en un enorme 35%. No esperaba un resultado tan bueno. Codificar este programa al revés fue, como esperaba, bastante exitoso. Dudo que pueda ser más corto que esto, pero estaría realmente interesado si alguien pudiera encontrar una solución más pequeña.

El desafío no establece si el programa tiene que detenerse después de mostrar el resultado, por lo que mi programa más pequeño (56 codel) debería ser válido. Simplemente vuelve al principio después de mostrar el resultado, solicitando un nuevo triplete de enteros. Debido al apretado empaquetado, no hay lugar para la salida de dos caracteres de nueva línea, pero eso no es problema con el intérprete npiet, porque siempre imprime un '?' si espera entrada

Hay dos tamaños posibles para construir una versión en bucle, pero una versión que se ejecuta solo una vez solo es posible en un programa que tenga al menos 64 codeles (16x4) de gran tamaño. Las versiones a continuación muestran el motivo. Quizás también sea interesante para aquellos que están familiarizados con Piet.

La versión final de 56 codeles más compacta, con un bucle :

Segunda versión (60 codeles), con un bucle

Si la versión 56 codel está en contra de las reglas, aquí está la versión final 64 codel, que se ejecuta solo una vez :

Mi primera versión (86 codeles)

La entrada y la salida están delimitadas por nueva línea.

Ejemplo de entrada y salida:

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

Para las versiones en bucle, parece un poco más feo:

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?

Elegí nueva línea como delimitador porque la codificación ASCII 10 (\ n) obviamente solo necesita 7 códeles, en comparación con ASCII 32 () que necesita 8 códeles o incluso ASCII 40 (,) que necesita 9 códeles.

La codificación hacia atrás desde el resultado hasta la primera entrada es una excelente manera de reducir el uso de codeles para las operaciones ROL. El orden de la pila al principio y al final se conoce, el resto se hace fácilmente a mano.

Aquí hay una versión de texto del programa 64 codel (con pila), en mi taquigrafía inventada. Los programas más cortos simplemente no terminan sino que vuelven al principio.

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 caracteres, entrada delimitada por nueva línea, salida delimitada por espacios)

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

Felix (86 caracteres, entrada delimitada por nueva línea, salida delimitada por comas)

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

Julia (84 caracteres, entrada delimitada por espacios, salida delimitada por espacios)

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