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

객관적인 승리 기준

객관적인 승리 기준은 다음과 같습니다. 각 언어는 가장 짧은 참가작을 작성할 수있는 사람에 대한 별도의 경쟁이지만 전체 우승자는 이러한 하위 경쟁을 가장 많이이기는 사람이됩니다. 이것은 많은 다른 언어로 대답하는 사람이 이점을 얻을 수 있음을 의미합니다. 코드 골프는 대부분 하나의 언어로 된 솔루션이있을 때 가장 큰 걸림돌입니다.

규칙, 제한 및 참고

귀하의 프로그램은 2012 년 4 월 9 일 이전에 존재했던 어떤 언어로도 작성 될 수 있습니다. 또한 저는 테스트를 할 수 없기 때문에 좀 더 흔하지 않은 / 비어적인 언어로 작성된 응답을 확인하기 위해 커뮤니티에 의존해야합니다 그들.

현재 리더 보드

이 섹션은 정기적으로 업데이트되어 언어의 수와 각 언어를 구사하는 사람을 보여줍니다.

• AWK (32)-멜라 모브
• bash (31)-피터 테일러
• 베 펀지 (29)-하워드
• 기원전 (39)-커니
• brainfuck (174)-CMP
• C (78)-l0n3_sh 아크
• C ++ (96)-좌회전
• 커먼 리스프 (88)-Kernigh
• 크레이 채플 (59)-카일 카 노스
• csh (86)-커니
• Cuda (301)-좌회전
• 직류 (30)-커니
• 도스 배치 (54)-Mellamokb
• 요소 (27)-하워드
• es (95)-커니
• 요인 (138)-커니
• 펠릭스 (86)-커비 팬
• 포트란 (44)-카일 카 노스
• 이동 (101)-하워드
• GolfScript (16)-하워드
• 골프 루아 (44)-카일 카 노스
• 하스켈 (35)-좌회전
• J (23)-가레스
• 자바 (141)-Howard
• 자바 스크립트 (47)-mellamokb
• 줄리아 (71)-ML
• 루아 (51)-하워드
• 머큐리 (319)-좌회전
• MoonScript (48)-커비 팬 64 소
• 님로드 (146)-좌회전
• 올빼미 (22)-입술
• 파스칼 (88)-좌회전
• 펄 (57)-가레스
• PHP (61)-멜라 모브
• 피코 리스프 (72)-Kernigh
• 피에트 (56)-ML
• 포스트 스크립트 (61)-Howard
• 파이썬 (40)-하워드
• Q (36)-타마린
• QBasic (34)-멜라 모브
• R (50)-입술
• 루비 (44)-하워드
• 스칼라 (102)-가레스
• SQL (57)-아만 지크 베르 마
• TI-83 기본 (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), Common 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), 펄 (57), 스칼라 (102)

6. 카일 카 노스 (3) : 크레이 채플 (59), 포트란 (44), 골프 루아 (44)

7. 해상도 (3) : 올빼미 (22), R (50), 공백 (123)

8. kirbyfan64sos (2) : Felix (86), MoonScript (48)

9. ML (2) : 줄리아 (71), 피에트 (56)

10. Aman Zeek verma (1) : SQL (57)

11. CMP (1) : 뇌 성교 (174)

12. 개피 (1) : VBA (57)

13. 방주 (1) : C (78)

14. Paxinum (1) : 무제한 등록기 (285)

15. 피터 테일러 (1) : 배쉬 (31)

16. tmartin (1) : Q (36)

GolfScript, 16 자

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

입력은 공백으로 구분 된 목록으로 제공됩니다.

자바 스크립트, 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

입력은 다시 쉼표로 구분됩니다.

자바, 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*-.@

포스트 스크립트, 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입니다.

베 펀지-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.

이것이 중요한지는 확실하지 않지만, 나는 그것을 쏠 것이라고 생각했습니다. 간단한 알고리즘조차도 정확하게 설명하기는 매우 어렵습니다. 킨다는 영어가 우선 순위를 정하기 위해 어떤 종류의 그룹화 기호를 지원했으면 좋겠다.

Q 기본, 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]))

개행 / 입력 쉼표로 입력하십시오.

이것은 중요하지 않지만 여전히 어떤 식 으로든 적합하다고 생각합니다.

수학 정리, 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.

쿠다, 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, 그 뒤에 개행이 필요합니다 {.

일반적인 리스프, 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
• esPaul 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 기본, 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 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

도스 / 배치 (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));}}

자바 스크립트 (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

Q 베이직 (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 기본 프로그래밍에서는 STO 작업 전에 괄호를 닫을 필요가 없다는 것은 잘 알려진 최적화 기법입니다.

공백, 123

I / O는 줄 바꿈으로 구분됩니다. (소스 코드를 얻으려면 편집 모드로 들어가서 사전 형식 태그 사이에 공백을 복사하십시오. 또는 Ideone 의 온라인 예를 참조하십시오. .)

S, T, L은 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는 공백으로 구분됩니다.

올빼미

--- 22 ---

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

I / O는 줄 바꿈으로 구분됩니다.

--- 19 --- (이 버전이 허용된다면; \는 실행 코드이기 때문에 부정 행위라고 생각합니다) :

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

I / O는 공백으로 구분됩니다. 명령 줄 사용법 : owl prog 5 19\ 77(\는 올빼미에서 접두사 단항 빼기 역할을합니다).

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

펄, 57 자

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

2자를 추가 한 '-p'옵션이 필요합니다. 입력이 일부 문자를 저장하는 데 유효하다고 가정합니다.

모든 대답은 공백으로 구분 된 숫자를 사용합니다.

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

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]

편집 : brackes를 제거하고 명령 이름을 단축하여 :

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 (공백으로 구분 된 인수)

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

포트란 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);

입력은 줄 바꿈이 아닌 한 줄로 이루어집니다 (2 문자를 사용하여 추가하십시오) 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 개 코덱 (14x4), 코덱 크기 10

실제로 코덱의 양을 ​​35 % 나 줄일 수있었습니다. 나는 좋은 결과를 기대하지 않았다. 이 프로그램을 거꾸로 코딩하면 예상대로 성공했습니다. 나는 이것이 이것보다 짧을 수는 있지만, 더 작은 해결책을 찾을 수 있다면 정말로 관심이있을 것입니다.

결과를 보여준 후 프로그램을 중지해야하는지에 대한 문제는 명시되어 있지 않으므로 가장 작은 (56 코덱) 프로그램이 유효해야합니다. 결과를 보여준 후 처음으로 돌아가서 정수의 새로운 삼중 항을 요구합니다. 밀집된 패킹으로 인해 두 개의 줄 바꾸기 문자를 출력 할 수있는 공간이 없지만 항상 '?'를 인쇄하기 때문에 npiet 인터프리터에는 아무런 문제가 없습니다. 입력을 기다리는 경우

루프 된 버전을 빌드 할 수있는 두 가지 크기가 있지만 한 번만 실행되는 버전은 최소 64 개 코덱 (16x4) 인 프로그램에서만 가능합니다. 아래 버전은 이유를 보여줍니다. 어쩌면 Piet에 익숙한 사람들에게도 흥미로울 것입니다.

루프와 함께 가장 엄격하게 압축 된 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)을 코딩하는 데는 8 개의 코덱이 필요한 ASCII 32 () 또는 9 개의 코덱이 필요한 ASCII 40 (,)에 비해 분명히 7 개의 코덱 만 필요하기 때문에 줄 바꿈 문자를 구분 기호로 선택했습니다.

결과에서 첫 번째 입력으로 거꾸로 코딩하면 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);

Julia (84 자, 공백으로 구분 된 입력, 공백으로 구분 된 출력)

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