O objetivo do Rosetta Stone Challenge é escrever soluções no maior número possível de idiomas. Mostre seu multilinguismo de programação!

O desafio

Seu desafio é implementar um programa que insira uma lista de números e produza a regra usada para gerar cada número sucessivo da série, no maior número possível de linguagens de programação . Você tem permissão para usar qualquer tipo de função de biblioteca padrão que seu idioma possua, pois essa é principalmente uma demonstração de idioma.

O que é uma "série"?

Uma série é uma lista ordenada de números inteiros. Cada número sucessivo da série pode ser gerado aplicando uma regra simples ao número anterior da série. Nesse desafio, a regra consiste em multiplicar o número por uma constante e adicionar uma segunda constante. Ambas as constantes podem ser qualquer número inteiro. O objetivo deste desafio é produzir essas duas constantes.

Para a série 2 5 11, a regra pode ser escrita como2 1 . Isso significa que cada número é o número anterior, vezes 2, mais 1. Um fato importante é que a maioria das séries tem exatamente uma regra. Algumas séries têm um número infinito ou nenhum, mas você não precisará lidar com isso.

Entrada

A entrada será uma lista de três números inteiros diferentes, que são os números na sequência. Os números podem ser delimitados por espaço, vírgula ou nova linha, mas especifique quais. Eu serei flexível nessa limitação porque certos idiomas podem ter restrições de entrada. Aqui estão quatro exemplos de entrada:

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

Resultado

A saída será dois números inteiros que representam a regra usada para gerar a série. O primeiro número será a constante multiplicativa, enquanto o segundo número será a constante aditiva. A formatação da saída pode ser delimitada por espaço, vírgula ou nova linha. Também sou flexível nessa limitação. Aqui estão os exemplos correspondentes de saída:

1 7
2 1
2 -4
-4 1

O Critério Vencedor Objetivo

Quanto a um critério de vitória objetivo, aqui está: Cada idioma é uma competição separada sobre quem pode escrever a entrada mais curta, mas o vencedor geral será a pessoa que vencer a maioria dessas subcompetições. Isso significa que uma pessoa que responde em muitos idiomas incomuns pode obter uma vantagem. O código-golfe é principalmente um desempate quando existe mais de uma solução em um idioma: a pessoa com o programa mais curto recebe crédito por esse idioma.

Regras, restrições e notas

Seu programa pode ser escrito em qualquer idioma que existia antes de 9 de abril de 2012. Também terei que confiar na comunidade para validar algumas respostas escritas em alguns dos idiomas mais incomuns / esotéricos, pois é improvável que eu possa testar eles.

Classificação atual

Esta seção será atualizada periodicamente para mostrar o número de idiomas e quem lidera em cada um.

• AWK (32) - mellamokb
• bash (31) - Peter Taylor
• Befunge (29) - Howard
• bc (39) - kernigh
• cérebro (174) - CMP
• C (78) - l0n3_shArk
• C ++ (96) - leftaroundabout
• Lisp comum (88) - kernigh
• Capela de Cray (59) - Kyle Kanos
• csh (86) - São Paulo
• Cuda (301) - leftaroundabout
• dc (30) - kernigh
• DOS BATCH (54) - mellamokb
• Elemento (27) - Howard
• es (95) - kernigh
• Fator (138) - kernigh
• Felix (86) - kirbyfan64sos
• Fortran (44) - Kyle Kanos
• Go (101) - Howard
• Golfe (16) - Howard
• Golfe (44) - Kyle Kanos
• Haskell (35) - leftaroundabout
• J (23) - Gareth
• Java (141) - Howard
• JavaScript (47) - mellamokb
• Julia (71) - ML
• Lua (51) - Howard
• Mercúrio (319) - leftaroundabout
• MoonScript (48) - kirbyfan64sos
• Nimrod (146) - leftaroundabout
• Coruja (22) - res
• Pascal (88) - leftaroundabout
• Perl (57) - Gareth
• PHP (61) - mellamokb
• PicoLisp (72) - rio de janeiro
• Piet (56) - ML
• PostScript (61) - Howard
• Python (40) - Howard
• Q (36) - tmartin
• QBasic (34) - mellamokb
• R (50) - res
• Rubi (44) - Howard
• Scala (102) - Gareth
• SQL (57) - Aman ZeeK Verma
• TI-83 BASIC (25) - mellamokb
• Máquina de registro ilimitado (285) - Paxinum
• VBA (57) - Gaffi
• Espaço em branco (123) - res
• zsh (62) - São Paulo

Classificação do usuário atual

Classificações iguais são classificadas em ordem alfabética.

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

2. kernigh (8): bc (39), Lisp comum (88), csh (86), dc (30), es (95), fator (138), PicoLisp (72), zsh (62)

3. leftroundabout (6): C ++ (96), Cuda (301), Haskell (35), Mercúrio (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): Capela Cray (59), Fortran (44), Golflua (44)

7. res (3): Coruja (22), R (50), Espaço em branco (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): foda cerebral (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): festança (31)

16. tmartin (1): Q (36)

GolfScript, 16 caracteres

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

A entrada é fornecida como lista separada por espaço.

JavaScript, 56 caracteres

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

A entrada é dada no prompt.

Ruby, 44 caracteres

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

A entrada é fornecida aqui como lista separada por vírgula.

Python, 40 caracteres

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

A entrada é novamente separada por vírgula.

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 nova linha.

Lua, 51 caracteres

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

Entrada separada por nova linha.

Vá, 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 nova linha.

Fortran, 90 caracteres

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

Entrada separada por nova linha.

Befunge, 29 caracteres

&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 =

Coruja, 23 caracteres

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

Entrada separada por nova linha.

Elemento , 27 caracteres

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

Entrada separada por nova linha.

Brainfuck - 174

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

Piet - 82?

Não sei como medir o golfe competitivo aqui. Eu vou com o tamanho total da imagem (em codels) O meu é 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.

Não tenho certeza se isso conta, mas pensei em tentar. É notavelmente difícil descrever até mesmo um algoritmo simples com precisão. Meio que gostaria que o inglês apoiasse algum tipo de símbolo de agrupamento para estabelecer precedência.

QBasic, 42

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

Requer entrada com vírgulas, saídas com espaços (isso está ok?)

Mercúrio, 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

Agora entradas com espaços, saídas com novas linhas.

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 com novas linhas, vírgula de saída.

Este não conta, mas sinto que ainda se encaixa de alguma forma:

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

bc, 39 caracteres

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

• Formato de entrada: z=f(2, 0, -4)
• A entrada é uma bcexpressão. Depois de bcler o arquivo de origem, ele lê a entrada padrão. É por isso que a entrada deve se parecer com uma chamada de função.
• Eu uso o OpenBSD bc, que requer uma nova linha após o {.

Lisp comum, 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
• O 86º caractere é nova linha no final do arquivo. cshé o único idioma para o qual conto nova linha no final do arquivo. Isso ocorre porque cshnunca executa o último comando, a menos que haja nova linha.
• set i=($<)não funciona, porque $<não possui divisão de palavras.

dc, 30 caracteres

?scsbsalclb-lbla-/psmlblalm*-p

• Formato de entrada:, 2 0 _4onde _está o sublinhado.

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
• esé a concha extensível de Paul Haahr e Byron Rakitzis.

Fator, 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
• EDIT: perdeu 2 caracteres mudando a(read)b(read)c(read)para 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, onde ¯é o menos unário da calculadora.
• Contei caracteres Unicode; →(a seta à direita) conta como U + 2192. Por exemplo, a calculadora conta Input Acom 2 caracteres, mas conto Input Acom 7 caracteres. Eu também conto :como 1 caractere.
• EDIT: Eu contei errado: existem 61, não 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}

Demonstração: http://ideone.com/kp0Dj

bash (38)

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

Demonstração: 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 parâmetros como lista de argumentos separados por espaço.

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

Demonstração: http://jsfiddle.net/BT8bB/6/

PHP (61 77 )

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

Demonstração: http://ideone.com/CEgke

QBasic (34)

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

TI-83 Básico (25 41 )

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

Sim, o parêntese certo ausente está de propósito. É uma técnica de otimização conhecida que fechar os parênteses antes de uma operação STO não é necessário na programação básica da TI-83.

Espaço em branco, 123

A E / S é separada por nova linha. (Para obter o código-fonte, entre no modo de edição e copie o espaço em branco entre as tags de pré-formato; ou consulte o exemplo online em Ideone .)

Explicação, em que S, T, L representa Espaço, Guia, Alimentação de linha:

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)

A E / S é separada por espaço.

Coruja

--- 22 ---

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

A E / S é separada por nova linha.

--- 19 --- (se esta versão for permitida; mas acho que é trapaça, já que o \ é um código executável):

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

A E / S é separada por espaço. Uso da linha de comando: owl prog 5 19\ 77(o \ atua como um postfix unário menos no Owl).

J, 23 caracteres

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

Uso:

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

Os números negativos são representados por sublinhados em 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

Requer a opção '-p', à qual adicionei 2 caracteres. Assume que a entrada é válida para salvar alguns caracteres.

Todas as minhas respostas ocupam espaços separados por números.

PHP, 74,72 , 69

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

Quando a entrada é passada como argumentos:

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

Agora, como @mellamokb sugeriu, 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));}

^ não funciona, então aqui está o seguinte: [obrigado a @ugoren por notá-lo]

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 characters

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

(This is basically the same as the other 'BASIC' functions, but I didn't see any VBA submissions out there already.)

bash (42 chars)

Festa pura:

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

bash (31 chars)

Descascar para outra coisa:

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

(Baseado na implementação de Howard OWL )

Este é um código (não otimizado) para a máquina de registro não limitada, descrita aqui: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

A entrada deve estar no registro 1,2 e 3 e a saída estará no registro 1, 2 após a conclusão do programa. Números não negativos e não inteiros não são manipulados, mas as entradas 0,7,14 e 2,5,11 são manipuladas corretamente.

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]

EDIT: removendo colchetes e encurtando os nomes das instruções:

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 em linhas separadas

Bash, 51

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

Exemplo: sh prog.sh 2 0 -4 (space separated arguments)

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

Space separated input, space separated output.

SQL, 57

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

This is a sad entry, but 'just' solves the purpose. The query binds input at runtime 1,2,3 are variables in order of input.

Q, 36

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

usage

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

Input will be in a single line (comma or space separated)

Cray Chapel 59

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

Input will be on single line, no newline (add 2 chars for that by using writeln in place of write).

Golflua 44

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

Newline delimited input, space delimited output

Julia, 71 characters

Space delimited input and output.

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

Example input and output:

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), codel size 10 for better visibility

I could actually shrink down the amount of codels by a whopping 35%. I didn’t expect such a good outcome. Coding this program backwards was, as I expected, quite successful. I doubt it can be shorter than this, but I would be really interested if anyone could find a smaller solution.

The challenge does not state if the program has to stop after showing the result, so my smallest (56 codel) program should be valid. It just loops back to the beginning after showing the result, asking for a new triplet of integers. Due to the tight packing there is no place for the output of two newline characters, but that is no problem with the npiet interpreter, because it always prints a ‘?’ if it awaits input.

There are two possible sizes to build a looped version, but a version that runs only once is only possible in a program that’s at least 64 codels (16x4) big. The versions below show the reason. Maybe it’s also interesting for those who are familiar with Piet.

The final, most tightly packed 56 codel version, with a loop:

Second version (60 codels), with a loop

Se a versão do 56 codel for contra as regras, aqui está a versão final do 64 codel, executando apenas uma vez :

Minha primeira versão (86 codels)

Entrada e saída são delimitadas por nova linha.

Exemplo de entrada e saída:

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

Para versões em loop, parecendo um pouco mais feias:

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?

Eu escolhi a nova linha como delimitador porque a codificação ASCII 10 (\ n) obviamente precisa de apenas 7 codels, em comparação com a ASCII 32 () que precisa de 8 codels ou até a ASCII 40 (,) que precisa de 9 codels.

A codificação inversa do resultado para a primeira entrada é uma ótima maneira de reduzir o uso do codel para operações de ROL. A ordem das pilhas no início e no final é conhecida, o resto é facilmente feito à mão.

Aqui está uma versão em texto do programa 64 codel (com pilha), na minha abreviação inventada. Os programas mais curtos simplesmente não terminam, mas retornam ao início.

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 nova linha, saída delimitada por espaço)

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

Felix (86 caracteres, entrada delimitada por nova linha, saída delimitada por vírgula)

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 espaço, saída delimitada por espaço)

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