Целью Rosetta Stone Challenge является написание решений на максимально возможном количестве языков. Покажите свое программирование многоязычия!

Соревнование

Ваша задача - реализовать программу, которая будет вводить список чисел и выводить правило, используемое для генерации каждого последующего числа в серии, на максимально возможном количестве языков программирования . Вам разрешается использовать любую стандартную библиотечную функцию, имеющуюся в вашем языке, поскольку это в основном демонстрация языка.

Что такое "серия"?

Серия - это упорядоченный список целых чисел. Каждое последующее число в серии можно сгенерировать, применив простое правило к предыдущему номеру в серии. В этой задаче правило состоит в умножении числа на константу и последующем добавлении второй константы. Обе константы могут быть любыми целыми числами. Цель этой задачи - вывести эти две константы.

Для серии 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

Объективный критерий победы

Что касается объективного критерия выигрыша, то здесь: каждый язык - это отдельное соревнование в отношении того, кто может написать самую короткую запись, но общим победителем будет тот, кто выиграет большинство из этих подконкурсов. Это означает, что человек, который отвечает на многих необычных языках, может получить преимущество. Code-golf - это, в основном, тай-брейк, когда на языке существует более одного решения: человек с самой короткой программой получает кредит на этот язык.

Правила, ограничения и примечания

Ваша программа может быть написана на любом языке, существовавшем до 9 апреля 2012 года. Мне также придется полагаться на сообщество для проверки некоторых ответов, написанных на некоторых из более необычных / эзотерических языков, поскольку я вряд ли смогу протестировать их.

Текущий список лидеров

Этот раздел будет периодически обновляться, чтобы показать количество языков и лидирующих в каждом.

• AWK (32) - мелламокб
• Баш (31) - Питер Тейлор
• Befunge (29) - Говард
• до н.э (39) - Kernigh
• Брейнфук (174) - CMP
• C (78) - l0n3_shArk
• C ++ (96)
• Common Lisp (88) - Kernigh
• Cray Chapel (59) - Кайл Канос
• csh (86) - керни
• Куда (301)
• DC (30) - Kernigh
• DOS BATCH (54) - мелламокб
• Элемент (27) - Говард
• es (95) - керни
• Коэффициент (138) - Керни
• Феликс (86) - kirbyfan64sos
• Фортран (44) - Кайл Канос
• Go (101) - Говард
• GolfScript (16) - Говард
• Golflua (44) - Кайл Канос
• Хаскелл (35)
• J (23) - Гарет
• Ява (141) - Говард
• JavaScript (47) - мелламокб
• Юлия (71) - ML
• Луа (51) - Говард
• Меркурий (319)
• MoonScript (48) - kirbyfan64sos
• Нимрод (146)
• Сова (22) - отдых
• Паскаль (88)
• Perl (57) - Гарет
• PHP (61) - мелламокб
• PicoLisp (72) - Kernigh
• Пит (56) - ML
• PostScript (61) - Говард
• Питон (40) - Говард
• Q (36) - tmartin
• QBasic (34) - mellamokb
• R (50) - рез
• Рубин (44) - Ховард
• Скала (102) - Гарет
• SQL (57) - Аман ЗееК Верма
• TI-83 BASIC (25) - мелламокб
• Неограниченная регистрация машины (285) - Paxinum
• VBA (57) - Гаффи
• Пробелы (123) - res
• зш (62) - керни

Рейтинг текущих пользователей

Равные ранги отсортированы по алфавиту.

1. Говард (9): Befunge (29), Элемент (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. вокруг (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), Скала (102)

6. Кайл Канос (3): Cray Chapel (59), Фортран (44), Гольфлуа (44)

7. разрешение (3): сова (22), R (50), пробел (123)

8. kirbyfan64sos (2): Феликс (86), MoonScript (48)

9. ML (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): bash (31)

16. tmartin (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)}

Ввод разделен переводом строки.

Фортран, 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~*+\ ``

Ввод разделен переводом строки.

Brainfuck - 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).

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

Теперь вводы с пробелами, выходы с символами новой строки.

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

С ++, 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

до н.э., 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=($<)не работает, потому что $<не имеет разделения слов.

30 символов

?scsbsalclb-lbla-/psmlblalm*-p

• Формат ввода:, 2 0 _4где _подчеркивание.

эс, 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это расширяемая оболочка Пола Хаара и Байрона Ракициса.

Фактор, 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
• РЕДАКТИРОВАТЬ: потерял 2 символов, изменив a(read)b(read)c(read)на 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, где ¯унарный минус калькулятора.
• Я посчитал символы Юникода; →(стрелка вправо) считается как U + 2192. Например, калькулятор считается Input Aкак 2 символа, но я считаю Input Aкак 7 символов. Я также считаю :как 1 символ.
• РЕДАКТИРОВАТЬ: я не учел: есть 61, а не 63, персонажи.

зш, 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 / BATCH (54 55 )

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

Принимает параметры как разделенный пробелами список аргументов.

Ява (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

ТИ-83 Базовый (25 41 )

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

Да, пропущена правильная скобка специально. Это хорошо известный метод оптимизации, заключающийся в том, что закрытие скобок перед операцией STO не требуется при программировании TI-83 Basic.

Пробел, 123

Ввод / вывод разделены переводом строки. (Чтобы получить исходный код, войдите в режим редактирования и скопируйте пробел между предварительно отформатированными тегами; или посмотрите онлайн- пример на 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)

Ввод / вывод разделен пробелом.

Сова

--- 22 ---

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

Ввод / вывод разделены переводом строки.

--- 19 --- (если эта версия разрешена; но я думаю, что она обманывает, поскольку \ - исполняемый код):

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

Ввод / вывод разделен пробелом. Использование командной строки: 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);

Скала, 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);

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

( Это в основном то же самое, что и другие «ОСНОВНЫЕ» функции, но я уже не видел ни одного представления VBA. )

Баш (42 символа)

Чистая Баш:

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

Баш (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

ДОС-БАТА, 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);

Ява, 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

Фортран 44

read*,i,j,k;k=(k-j)/(j-i);print*,k,j-i*k;end

Ввод будет в одной строке (через запятую или через пробел)

Cray Chapel 59

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

Ввод будет в одной строке, без новой строки (добавьте 2 символа для этого, используя writelnвместо 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 кодов (16x4). Версии ниже показывают причину. Может быть, это также интересно для тех, кто знаком с Питом.

Финальная, наиболее плотно упакованная версия 56 кода с циклом :

Вторая версия (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 10 (\ n), очевидно, требуется всего 7 кодов, по сравнению с ASCII 32 (), который требует 8 кодов или даже ASCII 40 (,), который требует 9 кодов.

Кодирование в обратном направлении от результата к первому вводу - отличный способ сократить использование кодела для операций 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

Феликс (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)")