L'objectif d'un Rosetta Stone Challenge est d'écrire des solutions dans autant de langues que possible. Montrez votre multilinguisme de programmation!

Le défi

Votre défi est d'implémenter un programme qui entrera une liste de nombres et sortira la règle utilisée pour générer chaque numéro successif de la série, dans autant de langages de programmation que possible . Vous êtes autorisé à utiliser n'importe quelle sorte de fonction de bibliothèque standard de votre langue, car il s'agit principalement d'une vitrine de langue.

Qu'est-ce qu'une "série"?

Une série est une liste ordonnée d'entiers. Chaque numéro successif de la série peut être généré en appliquant une règle simple au numéro précédent de la série. Dans ce défi, la règle consiste à multiplier le nombre par une constante, puis à ajouter une deuxième constante. Les deux constantes peuvent être n'importe quel entier. Le but de ce défi est de produire ces deux constantes.

Pour la série 2 5 11, la règle peut s'écrire 2 1. Cela signifie que chaque nombre est le nombre précédent, multiplié par 2, plus 1. Un fait important est que la plupart des séries ont exactement une règle. Certaines séries ont un nombre infini ou pas du tout, mais vous n'aurez pas à vous en occuper.

Contribution

L'entrée sera une liste de trois entiers différents qui sont les nombres de la séquence. Les nombres peuvent être séparés par des espaces, des virgules ou des sauts de ligne, mais veuillez préciser lesquels. Je vais être flexible sur cette limitation car certaines langues peuvent avoir des restrictions d'entrée. Voici quatre exemples de saisie:

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

Production

La sortie sera constituée de deux entiers qui représentent la règle utilisée pour générer la série. Le premier nombre sera la constante multiplicative, tandis que le deuxième nombre sera la constante additive. Le formatage de la sortie peut être délimité par des espaces, des virgules ou des sauts de ligne. Je suis également flexible sur cette limitation. Voici les exemples de sortie correspondants:

1 7
2 1
2 -4
-4 1

Le critère de gain objectif

En ce qui concerne un critère de gain objectif, le voici: chaque langue est une compétition distincte pour savoir qui peut écrire la plus courte inscription, mais le gagnant général serait la personne qui remporte le plus de ces sous-compétitions. Cela signifie qu'une personne qui répond dans de nombreuses langues rares peut bénéficier d'un avantage. Le code-golf est surtout un bris d'égalité lorsqu'il y a plus d'une solution dans une langue: la personne avec le programme le plus court obtient un crédit pour cette langue.

Règles, restrictions et notes

Votre programme peut être écrit dans n'importe quelle langue qui existait avant le 9 avril 2012. Je devrai également compter sur la communauté pour valider certaines réponses écrites dans certaines des langues les plus rares / ésotériques, car il est peu probable que je puisse tester leur.

Classement actuel

Cette section sera périodiquement mise à jour pour montrer le nombre de langues et qui mène dans chacune.

• AWK (32) - mellamokb
• bash (31) - Peter Taylor
• Befunge (29) - Howard
• bc (39) - kernigh
• enculé (174) - CMP
• C (78) - l0n3_shArk
• C ++ (96) - à gauche
• Lisp commun (88) - kernigh
• Chapelle de Cray (59) - Kyle Kanos
• csh (86) - kernigh
• Cuda (301) - à gauche
• dc (30) - kernigh
• DOS BATCH (54) - mellamokb
• Élément (27) - Howard
• es (95) - kernigh
• Facteur (138) - kernigh
• Félix (86) - kirbyfan64sos
• Fortran (44) - Kyle Kanos
• Aller (101) - Howard
• GolfScript (16) - Howard
• Golflua (44) - Kyle Kanos
• Haskell (35) - à gauche
• J (23) - Gareth
• Java (141) - Howard
• JavaScript (47) - mellamokb
• Julia (71 ans) - ML
• Lua (51 ans) - Howard
• Mercure (319) - à gauche
• MoonScript (48) - kirbyfan64sos
• Nimrod (146) - à gauche
• Chouette (22) - res
• Pascal (88) - à gauche
• 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
• Rubis (44) - Howard
• Scala (102) - Gareth
• SQL (57) - Aman ZeeK Verma
• TI-83 BASIC (25) - mellamokb
• Machine d'enregistrement illimitée (285) - Paxinum
• VBA (57) - Gaffi
• Espace (123) - res
• zsh (62) - kernigh

Classements des utilisateurs actuels

Les rangs égaux sont triés par ordre alphabétique.

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): Chapelle de Cray (59), Fortran (44), Golflua (44)

7. res (3): Chouette (22), R (50), Blanc (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): enculé (174)

12. Gaffi (1): VBA (57)

13. l0n3_shArk (1): C (78)

14. Paxinum (1): Machine d'enregistrement illimitée (285)

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

16. tmartin (1): Q (36)

GolfScript, 16 caractères

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

L'entrée est donnée sous forme de liste séparée par des espaces.

JavaScript, 56 caractères

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

L'entrée est donnée à l'invite.

Ruby, 44 caractères

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

L'entrée est ici donnée sous forme de liste séparée par des virgules.

Python, 40 caractères

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

L'entrée est à nouveau séparée par des virgules.

Java, 141 caractères

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

Entrée séparée par un retour à la ligne.

Lua, 51 caractères

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

Entrée séparée par un retour à la ligne.

Allez, 101 caractères

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

Entrée séparée par un retour à la ligne.

Fortran, 90 caractères

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

Entrée séparée par un retour à la ligne.

Befunge, 29 personnages

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

PostScript, 61 caractères

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

Chouette, 23 caractères

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

Entrée séparée par un retour à la ligne.

Élément , 27 caractères

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

Entrée séparée par un retour à la ligne.

Brainfuck - 174

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

Piet - 82?

Je ne sais pas comment mesurer le golf compétitif ici. Je vais aller avec la taille totale de l'image (en codels) Le mien est 41x2:

Befunge - 34

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

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

Je ne sais pas si cela compte, mais j'ai pensé que je pourrais essayer. Il est remarquablement difficile de décrire avec précision même un algorithme simple. J'aimerais que l'anglais soutienne une sorte de symbole de regroupement pour établir la priorité.

QBasic, 42

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

Nécessite une entrée avec des virgules, des sorties avec des espaces (est-ce correct?)

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

Maintenant entrées avec espaces, sorties avec sauts de ligne.

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

Entrée w / sauts de ligne, sortie virgule.

Celui-ci ne comptera pas, mais je pense qu'il s'intègre toujours d'une certaine manière:

Théorème mathématique, 713 caractères 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 caractères

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

• Format d'entrée: 2 0 -4

bc, 39 caractères

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

• Format d'entrée: z=f(2, 0, -4)
• L'entrée est une bcexpression. Après avoir bclu le fichier source, il lit l'entrée standard. C'est pourquoi l'entrée doit ressembler à un appel de fonction.
• J'utilise OpenBSD bc, qui nécessite une nouvelle ligne après le {.

Lisp commun, 88 caractères

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

• Format d'entrée: 2 0 -4

csh, 86 caractères

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

• Format d'entrée: 2 0 -4
• Le 86ème caractère est une nouvelle ligne à la fin du fichier. cshest la seule langue pour laquelle je compte la nouvelle ligne à la fin du fichier. En effet, n'exécute cshjamais la dernière commande à moins qu'il n'y ait un saut de ligne.
• set i=($<)ne fonctionne pas, car $<n'a pas de fractionnement de mot.

dc, 30 caractères

?scsbsalclb-lbla-/psmlblalm*-p

• Format d'entrée:, 2 0 _4où _est le trait de soulignement.

es, 95 caractères

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

• Format d'entrée: 2 0 -4
• esest la coque extensible de Paul Haahr et Byron Rakitzis.

Facteur, 138 caractères

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 d'entrée: 2 0 -4

PicoLisp, 74 72 caractères

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

• Format d'entrée: 2 0 -4
• EDIT: perdu 2 caractères en changeant a(read)b(read)c(read)en r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 caractères

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

• Format d'entrée: 2ENTER 0ENTER ¯4ENTER, où ¯est le moins unaire de la calculatrice.
• J'ai compté les caractères Unicode; →(la flèche droite) compte pour U + 2192. Par exemple, la calculatrice compte Input Apour 2 caractères, mais je compte Input Apour 7 caractères. Je compte également :pour 1 caractère.
• EDIT: J'ai mal compté: il y a 61, pas 63, caractères.

zsh, 62 caractères

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

• Format d'entrée: 2 0 -4

AWK (32)

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

Démo: http://ideone.com/kp0Dj

bash (38)

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

Démo: http://ideone.com/tzFi8

DOS / LOT (54 55 )

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

Prend les paramètres comme une liste d'arguments séparés par des espaces.

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

Démo: http://jsfiddle.net/BT8bB/6/

PHP (61 77 )

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

Démo: 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

Oui, la parenthèse droite manquante est intentionnelle. C'est une technique d'optimisation bien connue que la fermeture des parenthèses avant une opération STO n'est pas nécessaire dans la programmation de base de la TI-83.

Espace, 123

Les E / S sont séparées par des sauts de ligne. (Pour obtenir le code source, entrez en mode édition et copiez l'espace blanc entre les balises préformatées; ou, consultez l' exemple en ligne sur Ideone .)

Explication, où S, T, L représente l'espace, la tabulation, le saut de ligne:

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)

Les E / S sont séparées par des espaces.

Hibou

--- 22 ---

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

Les E / S sont séparées par des sauts de ligne.

--- 19 --- (si cette version est autorisée; mais je pense que c'est de la triche, car le \ est du code exécutable):

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

Les E / S sont séparées par des espaces. Utilisation de la ligne de commande: owl prog 5 19\ 77(le \ agit comme un moins unaire postfixe dans Owl).

J, 23 caractères

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

Usage:

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

Les nombres négatifs sont représentés par des traits de soulignement dans J.

PHP, 88 caractères

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

Scala, 102 caractères

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 caractères

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

Nécessite l'option '-p', pour laquelle j'ai ajouté 2 caractères. Suppose que l'entrée est valide pour enregistrer certains caractères.

Toutes mes réponses prennent des nombres séparés par des espaces.

PHP, 74,72 , 69

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

Lorsque l'entrée est passée comme arguments:

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

Maintenant, comme @mellamokb l'a suggéré, en utilisant $ 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));}

^ ne fonctionne pas, voici le truc: [merci à @ugoren de l'avoir signalé]

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 caractères

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

( C'est essentiellement la même chose que les autres fonctions `` BASIC '', mais je n'ai pas vu de soumissions VBA déjà. )

bash (42 caractères)

Bash pur:

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

bash (31 caractères)

Passer à autre chose:

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

(Basé sur l' implémentation OWL de Howard )

Il s'agit d'un code (non optimisé) pour la machine à registres illimités, décrit ici: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

L'entrée doit être dans les registres 1,2 et 3, et la sortie sera dans le registre 1, 2 une fois le programme terminé. Les nombres non négatifs et non entiers ne sont pas traités, mais les entrées 0,7,14 et 2,5,11 sont traitées correctement.

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: en supprimant les crochets et en raccourcissant les noms des instructions:

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%

Entrée sur des lignes séparées

Bash, 51

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

Exemple: sh prog.sh 2 0 -4 (arguments séparés par des espaces)

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

Entrée séparée par l'espace, sortie séparée par l'espace.

SQL, 57

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

C'est une entrée triste, mais «juste» résout le but. La requête lie l'entrée à l'exécution 1,2,3 sont des variables dans l'ordre d'entrée.

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

L'entrée se fera sur une seule ligne (séparée par des virgules ou des espaces)

Chapelle de Cray 59

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

L'entrée se fera sur une seule ligne, pas de nouvelle ligne (ajoutez 2 caractères pour cela en utilisant writeln à la place dewrite ).

Golflua 44

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

Entrée délimitée par une nouvelle ligne, sortie délimitée par un espace

Julia, 71 caractères

Entrée et sortie délimitées par des espaces.

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

Exemple d'entrée et de sortie:

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), taille de codel 10 pour une meilleure visibilité

Je pourrais en fait réduire la quantité de codels de 35%. Je ne m'attendais pas à un si bon résultat. Comme je m'y attendais, le codage à rebours de ce programme a été assez réussi. Je doute que cela puisse être plus court que cela, mais je serais vraiment intéressé si quelqu'un pouvait trouver une solution plus petite.

Le défi ne précise pas si le programme doit s'arrêter après avoir montré le résultat, donc mon plus petit programme (56 codel) doit être valide. Il revient simplement au début après avoir montré le résultat, demandant un nouveau triplet d'entiers. En raison de l'emballage serré, il n'y a pas de place pour la sortie de deux caractères de nouvelle ligne, mais cela ne pose aucun problème avec l'interpréteur npiet, car il affiche toujours un «? s'il attend l'entrée.

Il existe deux tailles possibles pour créer une version en boucle, mais une version qui ne s'exécute qu'une seule fois n'est possible que dans un programme d'au moins 64 codels (16x4). Les versions ci-dessous montrent la raison. C'est peut-être aussi intéressant pour ceux qui connaissent Piet.

La version finale, la plus compacte de 56 codels, avec une boucle :

Deuxième version (60 codels), avec une boucle

Si la version 56 codel est contraire aux règles, voici la version 64 codel finale, exécutée une seule fois :

Ma première version (86 codels)

L'entrée et la sortie sont délimitées par des sauts de ligne.

Exemple d'entrée et de sortie:

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

Pour les versions en boucle, un peu plus laid:

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?

J'ai choisi la nouvelle ligne comme délimiteur car le codage ASCII 10 (\ n) n'a évidemment besoin que de 7 codels, par rapport à ASCII 32 () qui a besoin de 8 codels ou même ASCII 40 (,) qui a besoin de 9 codels.

Le codage en arrière du résultat à la première entrée est un excellent moyen de réduire l'utilisation du codel pour les opérations ROL. L'ordre de pile au début et à la fin est connu, le reste se fait facilement à la main.

Voici une version texte du programme 64 codel (avec pile), dans ma sténographie inventée. Les programmes plus courts ne s'arrêtent tout simplement pas mais retournent au début.

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 caractères, entrée délimitée par une nouvelle ligne, sortie délimitée par un espace)

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

Felix (86 caractères, entrée délimitée par une nouvelle ligne, sortie délimitée par des virgules)

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

Julia (84 caractères, entrée délimitée par un espace, sortie délimitée par un espace)

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