Mục tiêu của Thử thách Rosetta Stone là viết các giải pháp bằng càng nhiều ngôn ngữ càng tốt. Thể hiện đa ngôn ngữ lập trình của bạn!

Các thách thức

Thách thức của bạn là triển khai một chương trình sẽ nhập danh sách các số và đưa ra quy tắc được sử dụng để tạo từng số liên tiếp trong chuỗi, bằng càng nhiều ngôn ngữ lập trình càng tốt . Bạn được phép sử dụng bất kỳ loại chức năng thư viện tiêu chuẩn nào mà ngôn ngữ của bạn có, vì đây chủ yếu là một ngôn ngữ giới thiệu.

Một "loạt" là gì?

Một loạt là một danh sách các số nguyên. Mỗi số liên tiếp trong chuỗi có thể được tạo bằng cách áp dụng quy tắc đơn giản cho số trước đó trong chuỗi. Trong thử thách này, quy tắc bao gồm nhân số với một hằng số, sau đó thêm hằng số thứ hai. Cả hai hằng số có thể là bất kỳ số nguyên nào. Mục tiêu của thử thách này là xuất ra hai hằng số đó.

Đối với loạt 2 5 11, quy tắc có thể được viết là 2 1. Điều này có nghĩa là mỗi số là số trước đó, lần 2, cộng với 1. Một thực tế quan trọng là hầu hết các chuỗi có chính xác một quy tắc. Một số loạt có một số lượng vô hạn hoặc không có gì cả, nhưng bạn sẽ không phải đối phó với điều này.

Đầu vào

Đầu vào sẽ là một danh sách gồm ba số nguyên khác nhau là các số trong chuỗi. Các số có thể là dấu cách, dấu phẩy hoặc dòng mới, nhưng vui lòng chỉ định số nào. Tôi sẽ linh hoạt về giới hạn này vì một số ngôn ngữ nhất định có thể có những hạn chế đầu vào. Dưới đây là bốn ví dụ về đầu vào:

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

Đầu ra

Đầu ra sẽ là hai số nguyên biểu thị quy tắc được sử dụng để tạo chuỗi. Số thứ nhất sẽ là hằng số nhân, còn số thứ hai sẽ là hằng số cộng. Định dạng của đầu ra có thể là dấu cách, dấu phẩy hoặc dòng mới được phân tách. Tôi linh hoạt về giới hạn này là tốt. Dưới đây là các ví dụ tương ứng của đầu ra:

1 7
2 1
2 -4
-4 1

Tiêu chí chiến thắng khách quan

Đối với một tiêu chí chiến thắng khách quan, đây là: Mỗi ngôn ngữ là một cuộc thi riêng biệt để ai có thể viết bài dự thi ngắn nhất, nhưng người chiến thắng chung cuộc sẽ là người chiến thắng hầu hết các cuộc thi phụ này. Điều này có nghĩa là một người trả lời bằng nhiều ngôn ngữ không phổ biến có thể đạt được lợi thế. Code-golf chủ yếu là một công cụ bẻ khóa khi có nhiều hơn một giải pháp trong một ngôn ngữ: người có chương trình ngắn nhất được tín dụng cho ngôn ngữ đó.

Quy tắc, hạn chế và ghi chú

Chương trình của bạn có thể được viết bằng bất kỳ ngôn ngữ nào tồn tại trước ngày 9 tháng 4 năm 2012. Tôi cũng sẽ phải dựa vào cộng đồng để xác thực một số câu trả lời được viết bằng một số ngôn ngữ không phổ biến / bí truyền hơn, vì tôi không thể kiểm tra họ

Bảng xếp hạng hiện tại

Phần này sẽ được cập nhật định kỳ để hiển thị số lượng ngôn ngữ và những người đang dẫn đầu trong mỗi ngôn ngữ.

• AWK (32) - mellamokb
• bash (31) - Peter Taylor
• Befunge (29) - Howard
• bc (39) - hạt nhân
• brainfuck (174) - CMP
• C (78) - l0n3_shArk
• C ++ (96) - vòng xoay trái
• Lisp thường gặp (88) - hạt nhân
• Nhà nguyện Cray (59) - Kyle Kanos
• csh (86) - hạt nhân
• Cuda (301) - vòng xoay trái
• dc (30) - hạt nhân
• BATCH DOS (54) - mellamokb
• Yếu tố (27) - Howard
• es (95) - hạt nhân
• Yếu tố (138) - hạt nhân
• Felix (86) - kirbyfan64sos
• Fortran (44) - Kyle Kanos
• Đi (101) - Howard
• GolfScript (16) - Howard
• Golflua (44) - Kyle Kanos
• Haskell (35) - vòng xoay trái
• J (23) - Gareth
• Java (141) - Howard
• JavaScript (47) - mellamokb
• Julia (71) - ML
• Lua (51) - Howard
• Sao Thủy (319) - vòng xoay trái
• MoonScript (48) - kirbyfan64sos
• Nimrod (146) - vòng xoay trái
• Cú (22) - độ phân giải
• Pascal (88) - vòng xoay trái
• Perl (57) - Gareth
• PHP (61) - mellamokb
• PicoLisp (72) - hạt nhân
• Thành phố (56) - ML
• PostScript (61) - Howard
• Con trăn (40) - Howard
• Q (36) - tmartin
• QBasic (34) - mellamokb
• R (50) - độ phân giải
• Ruby (44) - Howard
• Scala (102) - Gareth
• SQL (57) - Verma Aman ZeeK
• TI-83 CƠ BẢN (25) - mellamokb
• Máy đăng ký không giới hạn (285) - Paxinum
• VBA (57) - Gaffi
• Khoảng trắng (123) - độ phân giải
• zsh (62) - hạt nhân

Xếp hạng người dùng hiện tại

Xếp hạng bằng nhau được sắp xếp theo thứ tự abc.

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): Nhà nguyện Cray (59), Fortran (44), Golflua (44)

7. độ phân giải (3): Cú (22), R (50), Khoảng trắng (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): brainfuck (174)

12. Gaffi (1): VBA (57)

13. l0n3_shArk (1): C (78)

14. Paxinum (1): Máy đăng ký không giới hạn (285)

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

16. tmartin (1): Q (36)

GolfScript, 16 ký tự

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

Đầu vào được đưa ra dưới dạng danh sách phân tách không gian.

JavaScript, 56 ký tự

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

Đầu vào được đưa ra trên dấu nhắc.

Ruby, 44 ký tự

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

Đầu vào ở đây được đưa ra dưới dạng danh sách được phân tách bằng dấu phẩy.

Con trăn, 40 ký tự

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

Đầu vào lại được phân tách bằng dấu phẩy.

Java, 141 ký tự

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

Đầu vào được phân tách bằng dòng mới.

Lua, 51 ký tự

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

Đầu vào được phân tách bằng dòng mới.

Đi, 101 ký tự

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

Đầu vào được phân tách bằng dòng mới.

Fortran, 90 ký tự

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

Đầu vào được phân tách bằng dòng mới.

Befunge, 29 ký tự

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

PostScript, 61 ký tự

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

Cú, 23 ký tự

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

Đầu vào được phân tách bằng dòng mới.

Yếu tố , 27 ký tự

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

Đầu vào được phân tách bằng dòng mới.

Brainfuck - 174

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

Thành phố - 82?

Không chắc chắn làm thế nào để đo golf cạnh tranh ở đây. Tôi sẽ đi với tổng kích thước hình ảnh (tính theo codel) Của tôi là 41x2:

Befunge - 34

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

Tiếng anh - 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.

Không chắc chắn nếu điều này được tính, nhưng nghĩ rằng tôi sẽ cho nó một shot. Thật khó để mô tả chính xác ngay cả một thuật toán đơn giản. Kinda muốn tiếng Anh hỗ trợ một số loại biểu tượng nhóm để thiết lập quyền ưu tiên.

QBasic, 42

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

Yêu cầu đầu vào bằng dấu phẩy, đầu ra có dấu cách (điều này có ổn không?)

Thủy ngân, 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

Bây giờ đầu vào với không gian, đầu ra với dòng mới.

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

Đầu vào w / dòng mới, dấu phẩy đầu ra.

Điều này sẽ không được tính, nhưng tôi cảm thấy nó vẫn phù hợp theo một cách nào đó:

Định lý toán học, 713 ký tự của 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 ký tự

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

• Định dạng đầu vào: 2 0 -4

bc, 39 ký tự

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

• Định dạng đầu vào: z=f(2, 0, -4)
• Đầu vào là một bcbiểu thức. Sau khi bcđọc tệp nguồn, nó đọc đầu vào tiêu chuẩn. Đây là lý do tại sao đầu vào phải trông giống như một cuộc gọi chức năng.
• Tôi sử dụng OpenBSD bc, yêu cầu một dòng mới sau {.

Lisp thông thường, 88 ký tự

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

• Định dạng đầu vào: 2 0 -4

csh, 86 ký tự

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

• Định dạng đầu vào: 2 0 -4
• Ký tự thứ 86 là dòng mới ở cuối tập tin. cshlà ngôn ngữ duy nhất mà tôi đếm dòng mới ở cuối tập tin. Điều này là do cshkhông bao giờ chạy lệnh cuối cùng trừ khi có dòng mới.
• set i=($<)không hoạt động, vì $<không có từ tách.

dc, 30 ký tự

?scsbsalclb-lbla-/psmlblalm*-p

• Định dạng đầu vào : 2 0 _4, đâu _là dấu gạch dưới.

es, 95 ký tự

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

• Định dạng đầu vào: 2 0 -4
• eslà vỏ mở rộng của Paul Haahr và Byron Rakitzis.

Yếu tố, 138 ký tự

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 ]

• Định dạng đầu vào: 2 0 -4

PicoLisp, 74 72 ký tự

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

• Định dạng đầu vào: 2 0 -4
• EDIT: Mất 2 ký tự bằng cách thay đổi a(read)b(read)c(read)thành r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 ký tự

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

• Định dạng đầu vào: 2ENTER 0ENTER ¯4ENTER, ¯là điểm trừ đơn nhất của máy tính.
• Tôi đã đếm các ký tự Unicode; →(mũi tên phải) được tính là U + 2192. Ví dụ: máy tính được tính Input Alà 2 ký tự, nhưng tôi tính Input Alà 7 ký tự. Tôi cũng tính :như 1 ký tự.
• EDIT: Tôi đã nhầm lẫn: có 61, không phải 63, ký tự.

zsh, 62 ký tự

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

• Định dạng đầu vào: 2 0 -4

AWK (32)

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

Bản trình diễn: http://ideone.com/kp0Dj

bash (38)

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

Bản trình diễn: http://ideone.com/tzFi8

DOS / BATCH (54 55 )

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

Lấy tham số làm danh sách các đối số được phân tách bằng dấu cách.

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

Bản trình diễn: http://jsfiddle.net/BT8bB/6/

PHP (61 77 )

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

Bản trình diễn: http://ideone.com/CEgke

QBasic (34)

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

TI-83 cơ bản (25 41 )

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

Có, dấu ngoặc đơn bên phải bị thiếu là có chủ đích. Đây là một kỹ thuật tối ưu hóa nổi tiếng, việc đóng dấu ngoặc đơn trước khi vận hành STO là không cần thiết trong lập trình TI-83 Basic.

Khoảng trắng, 123

I / O được phân tách dòng mới. (Để có được mã nguồn, hãy vào chế độ chỉnh sửa và sao chép khoảng trắng giữa các thẻ preformat; hoặc, xem trực tuyến ví dụ tại Ideone .)

Giải thích, trong đó S, T, L đại diện cho Space, 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)

I / O được phân tách bằng dấu cách.

Cú

--- 22 ---

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

I / O được phân tách dòng mới.

--- 19 --- (nếu phiên bản này được cho phép; nhưng tôi nghĩ đó là gian lận, vì \ là mã thực thi):

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

I / O được phân tách bằng dấu cách. Sử dụng dòng lệnh: owl prog 5 19\ 77(\ đóng vai trò là một dấu trừ đơn vị hậu tố trong Owl).

J, 23 ký tự

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

Sử dụng:

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

Số âm được biểu thị bằng dấu gạch dưới trong J.

PHP, 88 ký tự

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

Scala, 102 ký tự

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 ký tự

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

Yêu cầu tùy chọn '-p', mà tôi đã thêm 2 ký tự. Giả sử rằng đầu vào là hợp lệ để lưu một số ký tự.

Tất cả các câu trả lời của tôi mất không gian số.

PHP, 74,72 , 69

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

Khi đầu vào được truyền dưới dạng đối số:

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

Bây giờ, như @mellamokb đã đề xuất, sử dụng $ 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));}

^ không hoạt động như vậy, đây là nội dung: [cảm ơn @ugoren đã thông báo]

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 ký tự

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

( Điều này về cơ bản giống như các chức năng 'BASIC' khác, nhưng tôi chưa thấy bất kỳ bài nộp VBA nào ngoài đó. )

bash (42 ký tự)

Bash tinh khiết:

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

bash (31 ký tự)

Tách ra một cái gì đó khác:

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

(Dựa trên triển khai OWL của Howard )

Đây là mã (không được tối ưu hóa) cho máy đăng ký không giới hạn, được mô tả ở đây: http://www.proofwiki.org/wiki/DefDef:Unlrict_Register_Machine

Đầu vào phải ở thanh ghi 1,2 và 3, và đầu ra sẽ ở thanh ghi 1, 2 sau khi chương trình hoàn thành. Các số không âm và không nguyên không được xử lý, nhưng các đầu vào 0,7,14 và 2,5,11 được xử lý chính xác.

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: bằng cách loại bỏ nước lợ và rút ngắn tên hướng dẫn:

ĐÔM 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%

Nhập vào các dòng riêng biệt

Bash, 51

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

Thí dụ : sh prog.sh 2 0 -4 (đối số được phân tách bằng dấu cách)

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

Không gian ngăn cách đầu vào, không gian đầu ra tách biệt.

SQL, 57

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

Đây là một mục buồn, nhưng "chỉ" giải quyết mục đích. Truy vấn liên kết đầu vào trong thời gian chạy 1,2,3 là các biến theo thứ tự đầu vào.

Q, 36

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

sử dụng

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

Pháo đài 44

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

Đầu vào sẽ ở trong một dòng (dấu phẩy hoặc dấu cách)

Nhà nguyện Cray 59

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

Đầu vào sẽ ở trên một dòng, không có dòng mới (thêm 2 ký tự cho nó bằng cách sử dụng writelnthay chowrite ).

Golf 44

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

Đầu vào được phân tách bằng dòng mới, đầu ra được phân tách bằng dấu cách

Julia, 71 nhân vật

Không gian giới hạn đầu vào và đầu ra.

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

Ví dụ đầu vào và đầu ra:

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

Thành phố 86 60 56 codel (14x4), codel size 10 để nhìn rõ hơn

Tôi thực sự có thể thu nhỏ số lượng tiền mã hóa bằng một con số khổng lồ 35%. Tôi không mong đợi một kết quả tốt như vậy. Mã hóa chương trình này ngược, như tôi mong đợi, khá thành công. Tôi nghi ngờ nó có thể ngắn hơn thế này, nhưng tôi sẽ thực sự quan tâm nếu có ai có thể tìm ra giải pháp nhỏ hơn.

Thử thách không nêu rõ nếu chương trình phải dừng lại sau khi hiển thị kết quả, vì vậy chương trình nhỏ nhất (56 codel) của tôi sẽ hợp lệ. Nó chỉ lặp lại từ đầu sau khi hiển thị kết quả, yêu cầu một bộ ba số nguyên mới. Do đóng gói chặt chẽ, không có chỗ cho đầu ra của hai ký tự dòng mới, nhưng điều đó không có vấn đề gì với trình thông dịch npiet, bởi vì nó luôn in một '?' nếu nó chờ đầu vào.

Có hai kích thước có thể để xây dựng một phiên bản lặp, nhưng một phiên bản chỉ chạy một lần chỉ có thể có trong một chương trình có ít nhất 64 codel (16x4) lớn. Các phiên bản dưới đây cho thấy lý do. Có lẽ nó cũng thú vị đối với những người quen thuộc với Piet.

Phiên bản 56 codel cuối cùng, được đóng gói chặt chẽ nhất, với một vòng lặp :

Phiên bản thứ hai (60 codel), với một vòng lặp

Nếu phiên bản codel 56 trái với quy tắc, thì đây là phiên bản 64 codel cuối cùng, chỉ chạy một lần :

Phiên bản đầu tiên của tôi (86 codel)

Đầu vào và đầu ra được phân định dòng mới.

Ví dụ đầu vào và đầu ra:

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

Đối với các phiên bản lặp, trông hơi xấu hơn:

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?

Tôi đã chọn dòng mới là dấu phân cách vì mã hóa ASCII 10 (\ n) rõ ràng chỉ cần 7 codel, so với ASCII 32 () cần 8 codel hoặc thậm chí ASCII 40 (,) cần 9 codel.

Mã hóa ngược từ kết quả đến đầu vào đầu tiên là một cách tuyệt vời để giảm việc sử dụng codel cho các hoạt động ROL. Thứ tự ngăn xếp ở đầu và cuối được biết đến, phần còn lại dễ dàng được thực hiện bằng tay.

Đây là một phiên bản văn bản của chương trình 64 codel (có stack), trong phần tốc ký được tạo ra của tôi. Các chương trình ngắn hơn không kết thúc mà lặp lại từ đầu.

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 ký tự, đầu vào được phân tách bằng dòng mới, đầu ra được phân tách bằng dấu cách)

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

Felix (86 ký tự, đầu vào được phân tách bằng dòng mới, đầu ra được phân cách bằng dấu phẩy)

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

Julia (84 ký tự, đầu vào được phân tách bằng dấu cách, đầu ra được phân tách bằng dấu cách)

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