Rosetta Stone Challengeの目標は、可能な限り多くの言語でソリューションを作成することです。プログラミングの多言語性を自慢しましょう！

チャレンジ

あなたの課題は、可能な限り多くのプログラミング言語で、数字のリストを入力し、シリーズ内の連続する各数字を生成するために使用されるルールを出力するプログラムを実装することです。これは主に言語のショーケースであるため、言語が持つあらゆる種類の標準ライブラリ関数を使用できます。

「シリーズ」とは何ですか？

シリーズは、整数の順序付きリストです。シリーズ内の連続する各番号は、シリーズ内の前の番号に単純なルールを適用することで生成できます。この課題では、ルールは数値に定数を乗算し、2番目の定数を追加することで構成されます。両方の定数は任意の整数にすることができます。この課題の目標は、これら2つの定数を出力することです。

シリーズの2 5 11場合、ルールはとして記述できます2 1。つまり、各数値は前の数値に2を足したものに1を足したものになります。重要な事実は、ほとんどのシリーズには1つのルールしかありません。一部のシリーズには無限の数があるか、まったくありませんが、これに対処する必要はありません。

入力

入力は、シーケンス内の数字である3つの異なる整数のリストになります。数字は、スペース、コンマ、または改行区切りのいずれかです。ただし、どちらを指定してください。特定の言語には入力制限があるため、この制限に柔軟に対応します。入力の4つの例を次に示します。

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

出力

出力は、シリーズの生成に使用されるルールを表す2つの整数になります。最初の数値は乗法定数であり、2番目の数値は加法定数です。出力のフォーマットは、スペース、コンマ、または改行区切りにすることができます。この制限にも柔軟に対応できます。出力の対応する例を次に示します。

1 7
2 1
2 -4
-4 1

目標達成基準

客観的な勝利基準については、次のとおりです。各言語は、最短のエントリを書くことができる人に関する個別の競争ですが、全体的な勝者は、これらのサブ競争のほとんどに勝った人になります。これは、多くの一般的でない言語で答える人が有利になることを意味します。Code-golfは、言語に複数の解決策がある場合の大部分のタイブレーカーです。最短のプログラムを持っている人は、その言語の信用を得ます。

ルール、制限、および注意

あなたのプログラムは、2012年4月9日より前に存在した任意の言語で作成できます。また、テストすることはできないため、より一般的ではない/難解な言語で作成されたいくつかの応答を検証するために、コミュニティに頼る必要がありますそれら。

現在のリーダーボード

このセクションは定期的に更新され、言語の数と各言語のリーダーを示します。

• AWK（32）-メラモク
• bash（31）-ピーター・テイラー
• Befunge（29）-ハワード
• bc（39）-カーニグ
• brainfuck（174）-CMP
• C（78）-l0n3_shArk
• C ++（96）-leftaroundabout
• Common Lisp（88）-カーニグ
• クレイチャペル（59）-カイルカノス
• csh（86）-カーニグ
• クーダ（301）-leftaroundabout
• dc（30）-カーニグ
• DOSバッチ（54）-mellamokb
• 要素（27）-ハワード
• ES（95）-カーニグ
• 係数（138）-カーニグ
• フェリックス（86）-kirbyfan64sos
• Fortran（44）-カイルカノス
• Go（101）-ハワード
• GolfScript（16）-ハワード
• Golflua（44）-カイルカノス
• ハスケル（35）-leftaroundabout
• J（23）-ガレス
• Java（141）-ハワード
• JavaScript（47）-mellamokb
• ジュリア（71）-ML
• ルア（51）-ハワード
• マーキュリー（319）-leftaroundabout
• MoonScript（48）-kirbyfan64sos
• ニムロッド（146）-leftaroundabout
• フクロウ（22）-解像度
• パスカル（88）-leftaroundabout
• Perl（57）-ガレス
• PHP（61）-mellamokb
• PicoLisp（72）-カーニグ
• ピート（56）-ML
• PostScript（61）-ハワード
• Python（40）-ハワード
• Q（36）-マーティン
• QBasic（34）-mellamokb
• R（50）-解像度
• ルビー（44）-ハワード
• スカラ（102）-ガレス
• SQL（57）-アマンジークバーマ
• TI-83ベーシック（25）-mellamokb
• 無制限の登録マシン（285）-Paxinum
• VBA（57）-ガフィ
• 空白（123）-解像度
• zsh（62）-カーニグ

現在のユーザーランキング

等しいランクはアルファベット順にソートされます。

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）、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. ガレス（3）：J（23）、Perl（57）、Scala（102）

6. カイルカノス（3）：クレイチャペル（59）、フォートラン（44）、ゴルフルア（44）

7. res（3）：フクロウ（22）、R（50）、空白（123）

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

9. ML（2）：ジュリア（71）、ピエト（56）

10. アマン・ジーク・ヴァーマ（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. マーティン（1）：Q（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)

入力はプロンプトに表示されます。

ルビー、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));}}

改行で区切られた入力。

ルア、51文字

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

改行で区切られた入力。

Go、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.

これが重要かどうかはわかりませんが、試してみたいと思いました。単純なアルゴリズムでさえ正確に記述することは非常に困難です。優先順位を確立するために、英語が何らかの種類のグループ化シンボルをサポートすることを願っています。

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

改行付きの入力、出力コンマ。

これは数えませんが、私はそれがまだ何らかの形で収まると感じています：

数学の定理、713文字の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}

パスカル、 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.

クーダ、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

bc、39文字

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

• 入力形式： z=f(2, 0, -4)
• 入力はbc式です。bcソースファイルを読み取った後、標準入力を読み取ります。これが、入力が関数呼び出しのように見える必要がある理由です。
• 私はOpenBSDを使用しbcています{。

Common 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ある拡張可能なシェルは、ポールHaahrバイロン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 Aとしてカウントされますが、7文字としてカウントされます。私も:1文字として数えます。
• 編集：誤算：63ではなく61の文字があります。

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%

スペースで区切られた引数のリストとしてパラメーターを取ります。

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

デモ：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はスペース、タブ、改行を表します。

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文字）

純粋なbash：

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

bash（31文字）

他の何かに砲撃する：

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

（Howardの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-バッチ、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%

別の行に入力

バッシュ、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);

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

スペースで区切られた入力、スペースで区切られた出力。

SQL、57

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

これは悲しいエントリですが、「ちょうど」は目的を解決します。クエリは、実行時の入力をバインドします1,2,3は、入力順の変数です。

Q、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）。

ゴルフルア 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コーデル）プログラムが有効になります。結果を表示した後、最初のループに戻り、整数の新しいトリプレットを要求します。密集しているため、2つの改行文字を出力する場所はありませんが、npietインタープリターでは常に「？」が出力されるため、問題はありません。入力を待っている場合。

ループバージョンを作成するには2つのサイズがありますが、一度だけ実行されるバージョンは、少なくとも64コーデル（16x4）のプログラムでのみ可能です。以下のバージョンはその理由を示しています。ピエトに精通している人にとっても面白いかもしれません。

最後の、最も密集した56コードバージョン、ループ付き：

2番目のバージョン（60コーデル）、ループ付き

56のcodelバージョンがルールに違反している場合、これが最後の64のcodelバージョンで、1回だけ実行されます。

私の最初のバージョン（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 10（\ n）のコーディングには7コーデルしか必要ないため、8コーデルが必要なASCII 32（）または9コーデルが必要なASCII 40（、）に比べて、改行を区切り文字として選択しました。

結果から最初の入力まで逆方向にコーディングすることは、ROL操作で使用されるコーデルを減らす素晴らしい方法です。開始時と終了時のスタック順は既知であり、残りは手作業で簡単に実行できます。

これは、私の作成した速記で、64コードプログラム（スタック付き）のテキストバージョンです。短いプログラムは終了せず、最初にループバックします。

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