L'obiettivo di una Rosetta Stone Challenge è scrivere soluzioni in quante più lingue possibile. Mostra il tuo multilinguismo di programmazione!

La sfida

La tua sfida è quella di implementare un programma che inserirà un elenco di numeri e produca la regola usata per generare ogni numero successivo nella serie, nel maggior numero di linguaggi di programmazione possibile . Puoi usare qualsiasi tipo di funzione di libreria standard nella tua lingua, poiché questa è principalmente una vetrina linguistica.

Che cos'è una "serie?"

Una serie è un elenco ordinato di numeri interi. Ogni numero successivo nella serie può essere generato applicando una semplice regola al numero precedente nella serie. In questa sfida, la regola consiste nel moltiplicare il numero per una costante e quindi aggiungere una seconda costante. Entrambe le costanti possono essere qualsiasi numero intero. L'obiettivo di questa sfida è produrre queste due costanti.

Per la serie 2 5 11, la regola può essere scritta come 2 1. Ciò significa che ogni numero è il numero precedente, per 2, più 1. Un fatto importante è che la maggior parte delle serie ha esattamente una regola. Alcune serie hanno un numero infinito o nessuna, ma non dovrai occupartene.

Ingresso

L'input sarà un elenco di tre diversi numeri interi che sono i numeri nella sequenza. I numeri possono essere delimitati da spazio, virgola o newline, ma specificare quale. Sarò flessibile su questa limitazione perché alcune lingue potrebbero avere restrizioni di input. Ecco quattro esempi di input:

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

Produzione

L'output sarà di due numeri interi che rappresentano la regola utilizzata per generare la serie. Il primo numero sarà la costante moltiplicativa, mentre il secondo numero sarà la costante additiva. La formattazione dell'output può essere delimitata da spazio, virgola o newline. Sono flessibile anche su questa limitazione. Ecco gli esempi corrispondenti di output:

1 7
2 1
2 -4
-4 1

Il criterio vincente dell'obiettivo

Per quanto riguarda un criterio obiettivo vincente, eccolo qui: ogni lingua è una competizione separata su chi può scrivere la voce più breve, ma il vincitore generale sarebbe la persona che vince la maggior parte di queste sotto-competizioni. Ciò significa che una persona che risponde in molte lingue non comuni può ottenere un vantaggio. Il code-golf è principalmente un tiebreak per quando c'è più di una soluzione in una lingua: la persona con il programma più corto ottiene credito per quella lingua.

Regole, restrizioni e note

Il tuo programma può essere scritto in qualsiasi lingua esistente prima del 9 aprile 2012. Dovrò anche fare affidamento sulla comunità per convalidare alcune risposte scritte in alcune delle lingue più insolite / esoteriche, poiché è improbabile che io sia in grado di testare loro.

Classifica attuale

Questa sezione verrà periodicamente aggiornata per mostrare il numero di lingue e chi guida in ciascuna di esse.

• AWK (32) - mellamokb
• bash (31) - Peter Taylor
• Befunge (29) - Howard
• bc (39) - kernigh
• brainfuck (174) - CMP
• C (78) - l0n3_shArk
• C ++ (96) - leftaroundabout
• Common Lisp (88) - kernigh
• Cray Chapel (59) - Kyle Kanos
• csh (86) - kernigh
• Cuda (301) - leftaroundabout
• dc (30) - kernigh
• DOS BATCH (54) - mellamokb
• Element (27) - Howard
• es (95) - kernigh
• Fattore (138) - kernigh
• Felix (86) - kirbyfan64sos
• Fortran (44) - Kyle Kanos
• Go (101) - Howard
• GolfScript (16) - Howard
• Golflua (44) - Kyle Kanos
• Haskell (35) - leftaroundabout
• J (23) - Gareth
• Java (141) - Howard
• JavaScript (47) - mellamokb
• Julia (71) - ML
• Lua (51) - Howard
• Mercurio (319) - circa
• MoonScript (48) - kirbyfan64sos
• Nimrod (146) - leftaroundabout
• Owl (22) - res
• Pascal (88) - leftaroundabout
• Perl (57) - Gareth
• PHP (61) - mellamokb
• PicoLisp (72) - kernigh
• Piet (56) - ML
• PostScript (61) - Howard
• Python (40) - Howard
• Q (36) - tmartin
• QBasic (34) - mellamokb
• R (50) - res
• Ruby (44) - Howard
• Scala (102) - Gareth
• SQL (57) - Aman ZeeK Verma
• TI-83 BASIC (25) - mellamokb
• Unlimited Register Machine (285) - Paxinum
• VBA (57) - Gaffi
• Spazio bianco (123) - res
• zsh (62) - kernigh

Classifiche utente corrente

I gradi uguali sono ordinati alfabeticamente.

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): Cray Chapel (59), Fortran (44), Golflua (44)

7. res (3): Gufo (22), R (50), Spazio bianco (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): Unlimited Register Machine (285)

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

16. tmartin (1): Q (36)

GolfScript, 16 caratteri

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

L'input viene fornito come elenco separato da spazi.

JavaScript, 56 caratteri

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

L'input viene fornito al prompt.

Rubino, 44 ​​caratteri

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

L'input viene qui fornito come elenco separato da virgole.

Python, 40 caratteri

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

L'input è di nuovo separato da virgola.

Java, 141 caratteri

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

Input separato da newline.

Lua, 51 personaggi

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

Input separato da newline.

Vai, 101 caratteri

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

Input separato da newline.

Fortran, 90 caratteri

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

Input separato da newline.

Befunge, 29 personaggi

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

PostScript, 61 caratteri

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

Gufo, 23 caratteri

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

Input separato da newline.

Elemento , 27 caratteri

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

Input separato da newline.

Brainfuck - 174

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

Piet - 82?

Non sono sicuro di come misurare il golf competitivo qui. Vado con la dimensione totale dell'immagine (in codici) Il mio è 41x2:

Befunge - 34

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

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

Non sono sicuro se questo conta, ma ho pensato di provarlo. È straordinariamente difficile descrivere accuratamente anche un semplice algoritmo. Vorrei che l'inglese sostenesse una sorta di simbolo di raggruppamento per stabilire la precedenza.

QBasic, 42

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

Richiede input con virgole, output con spazi (va bene?)

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

Ora input con spazi, output con newline.

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

Input w / newline, output virgola.

Questo non conta, ma sento che si adatta ancora in qualche modo:

Teorema matematico, 713 personaggi di 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 caratteri

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

• Formato di input: 2 0 -4

bc, 39 caratteri

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

• Formato di input: z=f(2, 0, -4)
• L'input è a bc un'espressione. Dopo aver bcletto il file di origine, legge l'input standard. Questo è il motivo per cui l'input deve apparire come una chiamata di funzione.
• Uso OpenBSD bc, che richiede una nuova riga dopo il{ .

Lisp comune, 88 caratteri

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

• Formato di input: 2 0 -4

csh, 86 caratteri

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

• Formato di input: 2 0 -4
• L'86 ° carattere è newline alla fine del file. cshè l'unica lingua per la quale conto newline alla fine del file. Questo è perchécsh non viene mai eseguito l'ultimo comando a meno che newline non sia presente.
• set i=($<) non funziona, perché $< non ha suddivisione di parole.

dc, 30 caratteri

?scsbsalclb-lbla-/psmlblalm*-p

• Formato di input:, 2 0 _4dov'è _il carattere di sottolineatura.

es, 95 caratteri

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

• Formato di input: 2 0 -4
• esè il guscio estensibile di Paul Haahr e Byron Rakitzis.

Fattore, 138 caratteri

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 ]

• Formato di input: 2 0 -4

PicoLisp, 74 72 caratteri

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

• Formato di input: 2 0 -4
• EDIT: Hai perso 2 personaggi cambiando a(read)b(read)c(read)in r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 caratteri

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

• Formato di input: 2ENTER 0ENTER ¯4ENTER, dove ¯è il meno unario della calcolatrice.
• Ho contato i caratteri Unicode; →(la freccia destra) conta come U + 2192. Ad esempio, la calcolatrice conta Input Acome 2 caratteri, ma io conto Input Acome 7 caratteri. Conto anche :come 1 personaggio.
• EDIT: Ho contato male: ci sono 61, non 63 caratteri.

zsh, 62 caratteri

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

• Formato di input: 2 0 -4

AWK (32)

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

Demo: http://ideone.com/kp0Dj

bash (38)

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

Demo: http://ideone.com/tzFi8

DOS / BATCH (54 55 )

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

Accetta i parametri come elenco di argomenti separato da spazi.

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

Demo: http://jsfiddle.net/BT8bB/6/

PHP (61 77 )

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

Demo: 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

Sì, la parentesi destra mancante è apposta. È una tecnica di ottimizzazione ben nota che non è necessario chiudere le parentesi prima di un'operazione STO nella programmazione base TI-83.

Spazio bianco, 123

L'I / O è separato da newline. (Per ottenere il codice sorgente, entra in modalità modifica e copia lo spazio bianco tra i tag preformat; oppure, vedi l' esempio online su Ideone .)

Spiegazione, dove S, T, L rappresentano Spazio, Tab, Avanzamento riga:

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)

L'I / O è separato dallo spazio.

Gufo

--- 22 ---

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

L'I / O è separato da newline.

--- 19 --- (se questa versione è consentita; ma penso che stia tradendo, poiché il \ è codice eseguibile):

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

L'I / O è separato dallo spazio. Utilizzo da riga di comando: owl prog 5 19\ 77(il \ funge da postfisso unario meno in Gufo).

J, 23 caratteri

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

Uso:

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

I numeri negativi sono rappresentati da trattini bassi in J.

PHP, 88 caratteri

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

Scala, 102 caratteri

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 caratteri

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

Richiede l'opzione '-p', per la quale ho aggiunto 2 caratteri. Presuppone che l'input sia valido per salvare alcuni caratteri.

Tutte le mie risposte prendono numeri separati da spazi.

PHP, 74,72 , 69

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

Quando l'input viene passato come argomenti:

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

Ora, come suggerito da @mellamokb, usando $ 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));}

^ non funziona così, ecco le cose: [grazie a @ugoren per averlo notato]

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 caratteri

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

( Questo è fondamentalmente lo stesso delle altre funzioni "BASIC", ma non ho visto alcun invio VBA già disponibile. )

bash (42 caratteri)

Bash puro:

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

bash (31 caratteri)

Chiedere a qualcos'altro:

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

(Basato sull'implementazione OWL di Howard )

Questo è un codice (non ottimizzato) per la macchina di registro senza limiti, qui descritto: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

L'ingresso dovrebbe essere nei registri 1,2 e 3 e l'uscita sarà nei registri 1, 2 al termine del programma. I numeri non negativi e non interi non vengono gestiti, ma gli input 0,7,14 e 2,5,11 vengono gestiti correttamente.

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]

MODIFICA: rimuovendo le parentesi e accorciando i nomi delle istruzioni:

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%

Immettere in righe separate

Bash, 51

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

Esempio: sh prog.sh 2 0 -4 (argomenti separati da spazio)

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

Input separato da spazio, output separato da spazio.

SQL, 57

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

Questa è una voce triste, ma "solo" risolve lo scopo. La query associa l'input in fase di esecuzione 1,2,3 sono variabili in ordine di input.

Q, 36

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

uso

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

L'input sarà in una sola riga (separati da virgola o spazio)

Cappella Cray 59

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

L'input sarà su una sola riga, nessuna nuova riga (aggiungi 2 caratteri usando quello writelnal posto di write).

Golflua 44

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

Newline input delimitato, output delimitato da spazi

Julia, 71 caratteri

Input e output delimitati da spazi.

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

Esempio di input e output:

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

Piet, 86 60 56 codici (14x4), dimensione del codice 10 per una migliore visibilità

Potrei effettivamente ridurre la quantità di codici di un enorme 35%. Non mi aspettavo un risultato così buono. Codificare questo programma all'indietro, come mi aspettavo, ebbe un discreto successo. Dubito che possa essere più breve di questo, ma sarei davvero interessato se qualcuno potesse trovare una soluzione più piccola.

La sfida non indica se il programma deve arrestarsi dopo aver mostrato il risultato, quindi il mio programma più piccolo (56 codel) dovrebbe essere valido. Torna indietro all'inizio dopo aver mostrato il risultato, chiedendo una nuova tripletta di numeri interi. A causa del pacchetto stretto non c'è spazio per l'output di due caratteri di nuova riga, ma questo non è un problema con l'interprete npiet, perché stampa sempre un '?' se attende input.

Esistono due dimensioni possibili per creare una versione in loop, ma una versione che viene eseguita una sola volta è possibile solo in un programma di almeno 64 codici (16x4) di grandi dimensioni. Le versioni seguenti mostrano il motivo. Forse è anche interessante per coloro che hanno familiarità con Piet.

L'ultima versione del codice 56, la più stretta, con un loop :

Seconda versione (60 codici), con un ciclo

Se la versione 56 del codice è contraria alle regole, ecco la versione 64 finale del codice, che viene eseguita una sola volta :

La mia prima versione (86 codici)

Input e output sono delimitati da newline.

Esempio di input e output:

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

Per le versioni in loop, un po 'più brutte:

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?

Ho scelto newline come delimitatore perché la codifica ASCII 10 (\ n) richiede ovviamente solo 7 codici, rispetto a ASCII 32 () che richiede 8 codici o anche ASCII 40 (,) che richiede 9 codici.

La codifica all'indietro dal risultato al primo input è un ottimo modo per ridurre l'uso del codice per le operazioni ROL. L'ordine dello stack all'inizio e alla fine è noto, il resto è facilmente eseguibile a mano.

Ecco una versione testuale del programma 64 codel (con stack), nella mia stenografia inventata. I programmi più brevi non terminano ma ritornano all'inizio.

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 caratteri, input delimitato da nuova riga, output delimitato da spazi)

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

Felix (86 caratteri, input delimitato da nuova riga, output delimitato da virgole)

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

Julia (84 caratteri, input delimitato da spazio, output delimitato da spazio)

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