Ціль 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

Об'єктивний критерій виграшу

Що стосується об'єктивного критерію виграшу, то ось він: Кожна мова - це окремий конкурс щодо того, хто може написати найкоротший запис, але загальним переможцем буде та людина, яка виграє більшість із цих підконкурсів. Це означає, що людина, яка відповідає на багатьох незвичайних мовах, може отримати перевагу. Код-гольф здебільшого є кравателем, коли в мові існує більше одного рішення: людина, яка має найкоротшу програму, отримує заслуги за цю мову.

Правила, обмеження та примітки

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

Поточна таблиця лідерів

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

• AWK (32) - мелламокб
• баш (31) - Пітер Тейлор
• Бефудж (29) - Говард
• bc (39) - керніг
• мозковий ебать (174) - CMP
• C (78) - l0n3_shArk
• C ++ (96) - ліворуч
• Лист звичайний (88) - керніг
• Каплиця Cray (59) - Кайл Канос
• csh (86) - керніг
• Куда (301) - ліворуч
• dc (30) - керніг
• DOS BATCH (54) - меламокб
• Елемент (27) - Говард
• es (95) - керніг
• Фактор (138) - керніг
• Фелікс (86) - кірбіфан64сос
• Фортран (44) - Кайл Канос
• Іди (101) - Говард
• GolfScript (16) - Говард
• Гольфлуа (44) - Кайл Канос
• Haskell (35) - ліворуч
• J (23) - Гарет
• Ява (141) - Говард
• JavaScript (47) - mellamokb
• Юлія (71) - ML
• Луа (51) - Говард
• Ртуть (319) - ліворуч
• MoonScript (48) - kirbyfan64sos
• Німрод (146) - ліворуч
• Сова (22) - рез
• Паскаль (88) - ліворуч
• Перл (57) - Гарет
• PHP (61) - мелламокб
• PicoLisp (72) - керніг
• Піт (56) - ML
• PostScript (61) - Говард
• Пітон (40) - Говард
• Q (36) - тмартін
• QBasic (34) - мелламокб
• R (50) - розд
• Рубі (44) - Говард
• Скала (102) - Гарет
• SQL (57) - Aman ZeeK Verma
• TI-83 BASIC (25) - меламокб
• Необмежена реєстраційна машина (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), звичайний Lisp (88), csh (86), dc (30), es (95), factor (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), Scala (102)

6. Кайл Канос (3): Каплиця Cray (59), Fortran (44), Golflua (44)

7. res (3): Сова (22), R (50), пробіли (123)

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

9. ML (2): Джулія (71), Піт (56)

10. Верман Aman Zeek (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. 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

Введення тут подано у вигляді списку, розділеного комами.

Пітон, 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)

Введення розділено новим рядком.

Перехід, 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

Тепер входи з пробілами, виходи з новими рядками.

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 / нові рядки, вихідна кома.

Цей не рахуватиметься, але я вважаю, що він все ще в деякій мірі вписується:

Математична теорема, 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, для якого потрібен новий рядок після {.

Лист звичайний, 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де _підкреслення.

ес, 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
• EDIT: втрачено 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, де ¯це унарний мінус калькулятора.
• Я порахував символи Unicode; →(стрілка праворуч) вважається U + 2192. Наприклад, калькулятор вважає Input A2 символи, але я рахую Input Aяк 7 символів. Я також вважаю :1 символом.
• EDIT: Я зробив неправильний аналіз: є 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 / BATCH (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 Basic (25 41 )

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

Так, права кругла дужка відсутня за призначенням. Це добре відома методика оптимізації, що в програмуванні TI-83 Basic не потрібно закривати дужки перед операцією STO.

Пробіл, 123

Введення / виведення розділено новим рядком. (Щоб отримати вихідний код, введіть режим редагування та скопіюйте пробіл між тегами попереднього формату; або, перегляньте Інтернет формату Приклад в на Ideone .)

Пояснення, де S, T, L являє пробіл, Tab, Linefeed:

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

Негативні числа представлені підкресленнями Дж.

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

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

баш (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]

EDIT: видалення брекетів та скорочення назв інструкцій:

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%

Введіть в окремих рядках

Баш, 51

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

Приклад: sh prog.sh 2 0 -4 (аргументи, розділені пробілом)

Перл, 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);

Введення буде в одному рядку, без нового рядка (додайте для цього два знаки, використовуючи writelnзамість 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 коделів (14х4), розмір коделу 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)")