Rosetta Stone挑战赛的目标是用尽可能多的语言编写解决方案。炫耀您的编程多语言！

挑战

您面临的挑战是实现一种程序，该程序将以尽可能多的编程语言输入一个数字列表，并输出用于生成该系列中每个连续数字的规则。您可以使用您的语言具有的任何标准库函数，因为这主要是语言展示。

什么是“系列”？

系列是整数的有序列表。通过将简单规则应用于序列中的先前编号，可以生成序列中的每个连续编号。在此挑战中，规则包括将数字乘以一个常数，然后加上第二个常数。这两个常数可以是任何整数。挑战的目标是输出这两个常数。

对于该系列2 5 11，该规则可以写为2 1。这意味着每个数字都是前一个数字乘以2，再加上1。一个重要的事实是，大多数序列只有一个规则。某些系列具有无限数或根本没有数字，但是您不必处理这个问题。

输入值

输入将是三个不同整数的列表，它们是序列中的数字。这些数字可以用空格，逗号或换行符分隔，但请指定。由于某些语言可能会有输入限制，因此我将对此限制保持灵活性。这是四个输入示例：

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

输出量

输出将是两个整数，代表用于生成序列的规则。第一个数字将是乘法常数，而第二个数字将是加法常数。输出的格式可以用空格，逗号或换行符分隔。我对此限制也很灵活。以下是相应的输出示例：

1 7
2 1
2 -4
-4 1

客观取胜标准

关于客观的获胜标准，这是：关于谁可以写得最短的条目，每种语言都是一个单独的竞赛，但是总的获胜者将是赢得这些子竞赛中最多的人。这意味着以多种不同寻常的语言回答的人可以获得优势。当一种语言中有多个解决方案时，代码高尔夫球通常是决胜局：程序最短的人会获得该语言的荣誉。

规则，限制和注释

您的程序可以用2012年4月9日之前存在的任何语言编写。由于我不太可能进行测试，因此我还必须依靠社区来验证使用某些较不常见/深奥的语言编写的答复。他们。

现任排行榜

本节将定期更新以显示语言的数量以及每种语言的领先者。

• AWK（32）-mellamokb
• bash（31）-彼得·泰勒
• Befunge（29）-霍华德
• 卑诗省（39）-kernigh
• 操脑（174）-CMP
• C（78）-l0n3_shArk
• C ++（96）-左右左右
• 常见的Lisp（88）-kernigh
• 克雷教堂（59）-凯尔·卡诺斯（Kyle Kanos）
• csh（86）-kernigh
• CUDA（301）-到处走走
• 直流（30）-克力
• DOS批处理（54）-mellamokb
• 元素（27）-霍华德
• es（95）-kernigh
• 因素（138）-kernigh
• 费利克斯（86）-kirbyfan64sos
• Fortran（44）-凯尔·卡诺斯（Kyle Kanos）
• 去（101）-霍华德
• GolfScript（16）-霍华德
• Golflua（44）-凯尔·卡诺斯（Kyle Kanos）
• 哈斯克尔（35）-到处走走
• J（23）-加雷斯
• Java（141）-霍华德
• JavaScript（47）-mellamokb
• 朱莉娅（71）-ML
• 卢阿（51）-霍华德
• 水星（319）-左转左右
• MoonScript（48）-kirbyfan64sos
• 猎人（146）-到处走走
• 猫头鹰（22）-res
• 帕斯卡（88）-到处走走
• Perl（57）-加雷斯
• PHP（61）-mellamokb
• PicoLisp（72）-克恩格
• 皮耶（56）-毫升
• PostScript（61）-霍华德
• Python（40）-霍华德
• Q（36）-马丁
• QBasic（34）-mellamokb
• R（50）-分辨率
• 红宝石（44）-霍华德
• 斯卡拉（102）-加雷斯
• SQL（57）-Aman ZeeK Verma
• TI-83 BASIC（25）-mellamokb
• 无限注册机（285）-Paxinum
• VBA（57）-加菲
• 空格（123）-res
• zsh（62）-kernigh

当前用户排名

等级均按字母顺序排序。

1. 霍华德（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），因子（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. 加雷斯（3）：J（23），Perl（57），Scala（102）

6. 凯尔·卡诺斯（Kyle Kanos）（3）：克雷教堂（Cray Chapel）（59），福尔特拉（Fortran）（44），戈尔夫鲁阿（Golflua）（44）

7. res（3）：猫头鹰（22），R（50），空格（123）

8. kirbyfan64sos（2）：Felix（86），MoonScript（48）

9. 毫升（2）：朱莉娅（71），皮耶特（56）

10. Aman Zeek Verma（1）：SQL（57）

11. CMP（1）：操脑（174）

12. 加菲（1）：VBA（57）

13. l0n3_shArk（1）：C（78）

14. Paxinum（1）：无限注册机（285）

15. 彼得·泰勒（1）：重击（31）

16. mart（1）：问（36）

GolfScript，16个字符

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

输入以空格分隔的列表形式给出。

JavaScript，56个字符

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

输入在提示符下给出。

Ruby，44个字符

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

输入在此处以逗号分隔的列表形式给出。

Python，40个字符

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

输入再次用逗号分隔。

Java，141个字符

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

输入以换行符分隔。

Lua，51个字符

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

输入以换行符分隔。

前进101个字符

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

输入以换行符分隔。

Fortran，90个字符

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

输入以换行符分隔。

Befunge，29个字符

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

PostScript，61个字符

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

猫头鹰，23个字符

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

输入以换行符分隔。

元素，27个字符

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

输入以换行符分隔。

操脑-174

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

皮特-82？

不确定如何在这里衡量竞争性高尔夫。我要使用总图像大小（以编码表示）我的图像是41x2：

Befunge-34

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

英语-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.

不知道这是否有价值，但以为我会试一试。即使是简单的算法也很难准确描述。Kinda希望英语支持某种分组符号来建立优先级。

QBasic，42岁

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

需要用逗号输入，用空格输出（可以吗？）

水星，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).

哈斯克尔， 85 81

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

现在输入带空格，输出带换行符。

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

宁录（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]))

输入w /换行符，输出逗号。

这个不算数，但我觉得它仍然在某种程度上适合：

数学定理，LaTeX的713个字符

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

帕斯卡 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个字符

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

• 输入格式： 2 0 -4

公元前39个字符

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

• 输入格式： z=f(2, 0, -4)
• 输入是一个 bc表达式。后bc读取源文件，它会读取标准输入。这就是为什么输入必须看起来像函数调用的原因。
• 我使用的是OpenBSD bc，在{。

普通Lisp，88个字符

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

• 输入格式： 2 0 -4

csh，86个字符

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

• 输入格式： 2 0 -4
• 文件末尾第86个字符是换行符。 csh是我在文件末尾计算换行符的唯一语言。这是因为csh除非存在换行符，否则永远不要运行最后一个命令。
• set i=($<) 不起作用，因为 $<没有分词。

dc，30个字符

?scsbsalclb-lbla-/psmlblalm*-p

• 输入格式： 2 0 _4，_下划线。

es，95个字符

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

• 输入格式： 2 0 -4
• es是可扩展的外壳 Paul Haahr和Byron Rakitzis。

因子138个字符

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 ]

• 输入格式： 2 0 -4

PicoLisp，74个72个字符

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

• 输入格式： 2 0 -4
• 编辑：更改a(read)b(read)c(read)为，丢失2个字符r read a(r)b(r)c(r)。

TI-83 BASIC，63 61个字符

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

• 输入格式：2ENTER 0ENTER ¯4ENTER，其中¯是计算器的一进制减号。
• 我数过Unicode字符；→（向右箭头）计为U + 2192。例如，计算器算作Input A2个字符，但我算作Input A7个字符。我也算: 1个字符。
• 编辑：我算错了：有61个字符，而不是63个字符。

zsh，62个字符

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

• 输入格式： 2 0 -4

AWK（32）

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

演示：http：//ideone.com/kp0Dj

重击（38）

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

演示：http：//ideone.com/tzFi8

DOS /批次（54 55）

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

将参数作为以空格分隔的参数列表。

爪哇（143185）

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

演示：http : //jsfiddle.net/BT8bB/6/

PHP（61 77）

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

演示：http：//ideone.com/CEgke

QBasic（34）

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

TI-83基础（25 41）

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

是的，缺少右括号是故意的。这是一项众所周知的优化技术，在TI-83 Basic编程中，无需在STO操作之前关闭括号。

空白123

I / O以换行符分隔。（要获取源代码，请进入编辑模式并在预格式化标签之间复制空格；或者，请参见Ideone上的在线示例。）

说明，其中S，T，L表示Space，Tab，换行：

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

R，50

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

I / O以空格分隔。

猫头鹰

--- 22 ---

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

I / O以换行符分隔。

--- 19 ---（如果允许使用此版本；但是我认为它是作弊的，因为\是可执行代码）：

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

I / O以空格分隔。命令行用法：owl prog 5 19\ 77（\用作Owl中的后缀一元减号）。

J，23个字符

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

用法：

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

负数由J中的下划线表示。

PHP，88个字符

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

Scala，102个字符

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个字符

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

需要'-p'选项，为此我添加了2个字符。假定输入有效以保存一些字符。

我所有的答案都用空格分隔。

PHP，74,72，69

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

当输入作为参数传递时：

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

现在，按照@mellamokb的建议，使用$ 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));}

^不起作用，这里是东西：[感谢@ugoren引起注意]

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个字符

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

（这基本上与其他“ BASIC”功能相同，但是我还没有看到任何VBA提交。）

bash（42个字符）

纯重击：

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

bash（31个字符）

炮轰其他：

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

（基于霍华德的OWL实现）

这是不受限制的注册机的（未优化）代码，在这里进行描述：http : //www.proofwiki.org/wiki/Definition :Unlimited_Register_Machine

程序完成后，输入应在寄存器1,2和3中，输出应在寄存器1、2中。非负数和非整数均未处理，但正确处理了输入0,7,14和2,5,11。

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]

编辑：通过删除括号，并缩短指令名称：

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%

分行输入

Bash，51岁

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

范例： sh prog.sh 2 0 -4 空格分隔的参数）

Perl，84岁

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

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

空格分隔的输入，空格分隔的输出。

SQL，57

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

这是一个悲伤的词条，但是“公正”解决了这个目的。查询绑定输入在运行时1,2,3是按输入顺序的变量。

问36

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

用法

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

输入将在一行中（逗号或空格分隔）

克雷教堂 59

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

输入将在单行中，没有换行符（通过使用writeln代替，添加2个字符write）。

Golflua 44

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

换行符分隔的输入，空格分隔的输出

朱莉娅，71个字符

用空格分隔的输入和输出。

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

输入和输出示例：

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

彼得， 86 60 56个编解码器（14x4），编解码器大小为10，以提高可视性

实际上，我可以将编解码器的数量减少35％。我没想到会有这么好的结果。如我所料，将程序反向编码非常成功。我怀疑它会比这更短，但是如果有人可以找到更小的解决方案，我将非常感兴趣。

挑战没有说明程序在显示结果后是否必须停止，因此我最小的程序（56个编解码器）应该有效。显示结果后，它只是循环回到开头，要求一个新的三元组整数。由于紧凑的包装，两个换行符的输出没有位置，但是npiet解释器没有问题，因为它总是打印'？' 如果等待输入。

构建循环版本有两种可能的大小，但是只能在至少64个Codel（16x4）大的程序中运行一次的版本。以下版本显示了原因。对于熟悉Piet的人来说，这也许也很有趣。

最终的，最紧密包装的56 Codel版本，带有一个循环：

第二版（60个代码），带有循环

如果56个编解码器版本违反规则，则这是最终的64个编解码器版本，仅运行一次：

我的第一个版本（86种编码）

输入和输出以换行符分隔。

输入和输出示例：

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

对于循环版本，看起来有点难看：

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?

我之所以选择换行符作为分隔符，是因为与ASCII 32（）只需8个编码，甚至ASCII 40（，）只需9个编码相比，编码ASCII 10（\ n）显然只需要7个编码。

从结果向后编码到第一个输入是减少ROL操作使用代码的好方法。堆栈开头和结尾的顺序是已知的，其余的可以很容易地手工完成。

这是我编写的简写形式的64个Codel程序的文本版本（带堆栈）。较短的程序只是不会终止，而是循环回到开头。

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个字符，换行符分隔的输入，空格分隔的输出）

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

Felix（86个字符，换行符分隔输入，逗号分隔输出）

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

朱莉娅（84个字符，以空格分隔的输入，以空格分隔的输出）

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