Rosetta Stone Challenge: encuentra la regla para una serie

15

El objetivo de Rosetta Stone Challenge es escribir soluciones en tantos idiomas como sea posible. ¡Muestra tu programación multilingüismo!

El reto

Su desafío es implementar un programa que ingrese una lista de números y genere la regla utilizada para generar cada número sucesivo de la serie, en tantos lenguajes de programación como sea posible . Puede usar cualquier tipo de función de biblioteca estándar que tenga su idioma, ya que esto es principalmente un escaparate de idiomas.

¿Qué es una "serie"?

Una serie es una lista ordenada de enteros. Cada número sucesivo de la serie se puede generar aplicando una regla simple al número anterior de la serie. En este desafío, la regla consiste en multiplicar el número por una constante y luego agregar una segunda constante. Ambas constantes pueden ser cualquier número entero. El objetivo de este desafío es generar esas dos constantes.

Para la serie 2 5 11, la regla se puede escribir como 2 1. Esto significa que cada número es el número anterior, multiplicado por 2, más 1. Un hecho importante es que la mayoría de las series tienen exactamente una regla. Algunas series tienen un número infinito o ninguno, pero no tendrá que lidiar con esto.

Entrada

La entrada será una lista de tres enteros diferentes que son los números en la secuencia. Los números pueden ser espacios, comas o líneas nuevas delimitadas, pero especifique cuál. Voy a ser flexible en esta limitación porque ciertos idiomas pueden tener restricciones de entrada. Aquí hay cuatro ejemplos de entrada:

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

Salida

La salida será dos enteros que representan la regla utilizada para generar la serie. El primer número será la constante multiplicativa, mientras que el segundo número será la constante aditiva. El formato de la salida puede ser espacio, coma o nueva línea delimitada. Soy flexible en esta limitación también. Estos son los ejemplos correspondientes de salida:

1 7
2 1
2 -4
-4 1

El criterio objetivo ganador

En cuanto a un criterio ganador objetivo, aquí está: cada idioma es una competencia separada en cuanto a quién puede escribir la entrada más corta, pero el ganador general sería la persona que gana la mayoría de estas subcompeticiones. Esto significa que una persona que responde en muchos idiomas poco comunes puede obtener una ventaja. Code-golf es principalmente un factor decisivo para cuando hay más de una solución en un idioma: la persona con el programa más corto obtiene crédito por ese idioma.

Reglas, restricciones y notas

Su programa se puede escribir en cualquier idioma que existiera antes del 9 de abril de 2012. También tendré que confiar en la comunidad para validar algunas respuestas escritas en algunos de los idiomas más infrecuentes / esotéricos, ya que es poco probable que pueda evaluar ellos.


Tabla de clasificación actual

Esta sección se actualizará periódicamente para mostrar la cantidad de idiomas y quién lidera cada uno.

  • AWK (32) - mellamokb
  • bash (31) - Peter Taylor
  • Befunge (29) - Howard
  • bc (39) - kernigh
  • brainfuck (174) - CMP
  • C (78) - l0n3_shArk
  • C ++ (96) - leftaroundabout
  • Lisp común (88) - kernigh
  • Capilla Cray (59) - Kyle Kanos
  • csh (86) - kernigh
  • Cuda (301) - Leftaroundabout
  • dc (30) - kernigh
  • LOTE DE DOS (54) - mellamokb
  • Elemento (27) - Howard
  • es (95) - kernigh
  • Factor (138) - kernigh
  • Felix (86) - kirbyfan64sos
  • Fortran (44) - Kyle Kanos
  • Ir (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) - Leftaroundabout
  • MoonScript (48) - kirbyfan64sos
  • Nimrod (146) - Leftaroundabout
  • Búho (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
  • Rubí (44) - Howard
  • Scala (102) - Gareth
  • SQL (57) - Aman ZeeK Verma
  • TI-83 BASIC (25) - mellamokb
  • Máquina de registro ilimitada (285) - Paxinum
  • VBA (57) - Gaffi
  • Espacio en blanco (123) - res
  • zsh (62) - kernigh

Ranking de usuarios actuales

Los rangos iguales se ordenan alfabéticamente.

  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. a la izquierda (6): C ++ (96), Cuda (301), Haskell (35), Mercurio (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): Capilla Cray (59), Fortran (44), Golflua (44)

  7. res (3): Búho (22), R (50), Espacio en blanco (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áquina de registro ilimitada (285)

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

  16. tmartin (1): Q (36)

PhiNotPi
fuente
No se ve como la gente realmente leer las etiquetas, u otras descripciones ...
dejó de turno counterclockwis
@leftaroundabout: ¿Por qué dices eso? Soy consciente (por ejemplo) de que mi solución no tiene entrada de matriz y planeo arreglarla más tarde. Y soy demasiado vago para publicar más de una solución en este momento :) Según el Criterio de Object Winning, code-golf es el desempate para dos publicaciones con el mismo idioma, por lo tanto, he incluido el recuento de caracteres para facilitar referencia en caso de que alguien más publique una solución de JavaScript. De hecho, este puede ser uno de esos raros momentos en que una pregunta merece tanto el code-golf y code-challenge etiquetas .
mellamokb
Sí, tienes razón: alguien también tiene que hacer los idiomas no inusuales.
dejó de girar en sentido contrario a las agujas del reloj el
3
Siempre que mantenga la tabla de clasificación actual en el mismo formato estándar que el anterior, puede usar esto para generar las puntuaciones de cada usuario: jsfiddle.net/bk2WM/2
mellamokb
1
Mi nueva versión ( jsfiddle.net/bk2WM/4 ) proporciona una salida sin formato (en el área de texto) que puede copiar / pegar en una publicación, y la formatea como lo hice en mi publicación. Siéntase libre de cambiar / jugar con el diseño.
mellamokb

Respuestas:

9

GolfScript, 16 caracteres

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

La entrada se da como una lista separada por espacios.

JavaScript, 56 caracteres

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

La entrada se da en el indicador.

Ruby, 44 caracteres.

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

La entrada se da aquí como una lista separada por comas.

Python, 40 caracteres

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

La entrada está nuevamente separada por comas.

Java, 141 caracteres

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

Entrada separada por nueva línea.

Lua, 51 caracteres

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

Entrada separada por nueva línea.

Go, 101 caracteres

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

Entrada separada por nueva línea.

Fortran, 90 caracteres

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

Entrada separada por nueva línea.

Befunge, 29 personajes

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

PostScript, 61 caracteres

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

Búho, 23 personajes

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

Entrada separada por nueva línea.

Elemento , 27 caracteres.

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

Entrada separada por nueva línea.

Howard
fuente
Robo desvergonzado de mi solución de JavaScript;)
mellamokb
1
Bueno, dos pueden jugar a este juego ...: P
mellamokb
@mellamokb Buen uno. Pero ya voté tu respuesta ;-) Entonces, lo que nos queda: vencer a los 48 personajes ...
Howard
2
Wow, jugaste golf en mi idioma. Me siento honrado. También me siento obligado a vencerte. :)
PhiNotPi
1
Sobre su solución Element, parece que la última marca `no es necesaria. ¿Es este un error de su parte o un error en mi intérprete que publiqué en Pastebin? Ah, y tengo una solución de 27 caracteres.
PhiNotPi
8

Brainfuck - 174

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

Piet - 82?

No estoy seguro de cómo medir el golf competitivo aquí. Voy a ir con el tamaño total de la imagen (en codeles) El mío es 41x2: ingrese la descripción de la imagen aquí

Befunge - 34

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

Inglés - 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.

No estoy seguro de si esto cuenta, pero pensé en intentarlo. Es notablemente difícil describir incluso un algoritmo simple con precisión. Desearía que el inglés admitiera algún tipo de símbolo de agrupación para establecer la precedencia.

captncraig
fuente
Conécteme a un intérprete (uno completo que comprenda todo el idioma y que no solo esté orientado a resolver este problema) y puedo aceptarlo.
PhiNotPi
ummm, worldinterpreting.com ?
captncraig
1
Está bien, otra persona ha escrito una prueba matemática en LaTeX. No contaba, pero se suma a la variedad.
PhiNotPi
Si pruebo su solución Piet con npiet obtengo este resultado: D:\Software\Programming\Piet\npiet-1.3a-win32>npiet series2.png ? 5 ? -19 ? 77 05 La solución debería ser-4 1
ML
La imagen que publicaste no funciona a menos que la crezcas un píxel (¡no códec!) En el lado derecho. 461 píxeles no son divisibles por 11, que es un tamaño de codel bastante inusual, por cierto;)
ML
8

QBasic, 42

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

Requiere entrada con comas, salidas con espacios (¿está bien?)


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

Ahora entradas con espacios, salidas con líneas nuevas.


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

Entrada con líneas nuevas, salida con coma.


Este no contará, pero creo que todavía encaja de alguna manera:

Teorema matemático, 713 caracteres de 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}

Salida de la solución de teorema matemático LaTeX


Mientras estamos escribiendo := definiciones ...

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);}
dejó de girar en sentido antihorario
fuente
1
Puede guardar dos caracteres en la solución C eliminando my reutilizando c, y otros dos utilizando en c-=b;c/=b-a;lugar de c=(c-b)/(b-a);.
Peter Taylor
En la solución C, no necesita los espacios en la scanf()cadena de formato.
Reto Koradi
7

AWK, 35 caracteres

{m=($3-$2)/($2-$1);print m,$2-$1*m}
  • Formato de entrada: 2 0 -4

aC, 39 caracteres

define f(a,b,c){
m=(c-b)/(b-a)
m
b-a*m}
  • Formato de entrada: z=f(2, 0, -4)
  • La entrada es una bcexpresión. Despuésbc leer el archivo fuente, lee la entrada estándar. Es por eso que la entrada debe verse como una llamada de función.
  • Yo uso OpenBSD bc, que requiere una nueva línea después de {.

Lisp común, 88 caracteres

(let*((a(read))(b(read))(c(read))(m(/(- c b)(- b a))))(format
t "~A ~A" m (- b(* a m))))
  • Formato de entrada: 2 0 -4

csh, 86 caracteres

set i=(`cat`)
@ m=($i[3] - $i[2]) / ($i[2] - $i[1])
@ n=$i[2] - $i[1] * $m
echo $m $n
  • Formato de entrada: 2 0 -4
  • El 86o carácter es una nueva línea al final del archivo. cshes el único idioma para el que cuento la nueva línea al final del archivo. Esto se debe a que cshnunca ejecuta el último comando a menos que haya nueva línea allí.
  • set i=($<)no funciona, porque $<no tiene división de palabras.

dc, 30 caracteres

?scsbsalclb-lbla-/psmlblalm*-p
  • Formato de entrada: 2 0 _4donde _está el guión bajo.

es, 95 caracteres

i=(`cat)
b=$i(2)
m=`{expr \( $i(3) - $b \) / \( $b - $i(1) \)}
echo $m `{expr $b - $i(1) \* $m}
  • Formato de entrada: 2 0 -4
  • eses el caparazón extensible de Paul Haahr y Byron Rakitzis.

Factor, 138 caracteres

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 de entrada: 2 0 -4

PicoLisp, 74 72 caracteres

(in()(let(r read a(r)b(r)c(r)m(/(- c b)(- b a)))(print
m (- b(* a m)))))
  • Formato de entrada: 2 0 -4
  • EDITAR: Perdió 2 personajes al cambiar a(read)b(read)c(read)a r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 caracteres

:Input A
:Input B
:Input C
:(C-B)/(B-A)→M
:Disp M
:Disp B-A*M
  • Formato de entrada: 2ENTER 0ENTER ¯4ENTER, donde ¯es el menos unario de la calculadora.
  • Conté caracteres Unicode; (la flecha derecha) cuenta como U + 2192. Por ejemplo, la calculadora cuenta Input Acomo 2 caracteres, pero yo cuento Input Acomo 7 caracteres. También cuento :como 1 personaje.
  • EDITAR: he contado mal: hay 61, no 63, caracteres.

zsh, 62 caracteres

i=(`cat`)
((b=i[2],m=(i[3]-b)/(b-i[1]),n=b-i[1]*m))
echo $m $n
  • Formato de entrada: 2 0 -4
kernigh
fuente
7

AWK (32)

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

Demostración: http://ideone.com/kp0Dj


golpe (38)

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

Demostración: http://ideone.com/tzFi8


DOS / LOTE (54 55 )

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

Toma los parámetros como una lista de argumentos separados por espacios.


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

Demostración: http://jsfiddle.net/BT8bB/6/


PHP (61 77 )

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

Demostración: 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í, el paréntesis derecho faltante es a propósito. Es una técnica de optimización bien conocida que cerrar los paréntesis antes de una operación STO no es necesario en la programación básica de TI-83.

mellamokb
fuente
1
El JS One no funciona para mí en Firefox: recibo un error que pno está definido. ¿La especificación JS dice que los argumentos de la función deben evaluarse antes de que se resuelva la función?
Peter Taylor
Hmm Sí, estás en lo correcto. De acuerdo con las especificaciones, no debería funcionar, como se explica en esta pregunta SO similar: stackoverflow.com/questions/9941736/… . Se supone que las funciones están vinculadas antes de evaluar sus argumentos, y Chrome aparentemente lo hace en orden inverso.
mellamokb
He intentado durante mucho tiempo superar la solución Java más alta con un enfoque completamente diferente que puedes ver arriba. 143 es lo más cerca que he podido llegar. Alguien tiene alguna idea, por favor envíe mi camino!
mellamokb
6

Espacio en blanco, 123

    





















E / S está separada por nueva línea. (Para obtener el código fuente, ingrese al modo de edición y copie el espacio en blanco entre las etiquetas de formato previo; o, vea el en línea formato previo ejemplo en en Ideone ).

Explicación, donde S, T, L representa espacio, tabulación, salto de línea:

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)

La E / S está separada por espacios.


Búho

--- 22 ---

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

E / S está separada por nueva línea.

--- 19 --- (si esta versión está permitida; pero creo que es una trampa, ya que \ es el código ejecutable):

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

La E / S está separada por espacios. Uso de la línea de comandos: owl prog 5 19\ 77(el \ actúa como un postfix unario menos en Owl).

res
fuente
Con su entrada de Owl, puedo suspender el juicio de su solución de 19 caracteres ya que su solución de 22 caracteres ya está ganando por el idioma.
PhiNotPi
5

J, 23 caracteres

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

Uso:

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

Los números negativos están representados por guiones bajos en J.

PHP, 88 caracteres

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

Scala, 102 caracteres

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 caracteres

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

Requiere la opción '-p', para lo cual he agregado 2 caracteres. Asume que la entrada es válida para guardar algunos caracteres.

Todas mis respuestas toman números separados por espacios.

Gareth
fuente
Acerca de los programas J ... ¿Se permite que la entrada se codifique directamente en el archivo fuente en lugar de solicitarla al usuario?
res
@res Lo he dado tal como lo invocaría en la línea de comando. Agregar 1!:1]3a la derecha de la expresión leerá la entrada de STDIN. Creo que ha habido discusión sobre meta o en comentarios a algunas respuestas J sobre si esto debería permitirse o no. Soy algo ambivalente: disfruto descubriendo cómo hacer que J haga lo que quiero en el espacio más pequeño, tomaré la penalización de 6 caracteres por la entrada de STDIN si eso es lo que todos quieren.
Gareth el
Estaba pensando que si se permite para J, entonces otras entradas podrían acortarse de manera similar. (Por cierto, no pude hacer que tu expresión sugerida funcione, pero (],1{x-0{x*])%~/2-/\x=:".1!:1]1parece estar bien en el modo de consola.)
res
@res Oh sí, olvidé convertir de una cadena a una lista de números (¿aunque el 3 al final normalmente funciona bien para mí?)
Gareth
Si convierte el Perl en una subrutina en lugar de un programa completo, puede ($a=($_[1]-pop)/($_[0]-$_[1])).$/.($_[1]-$_[0]*$a)
reducirlo
4

PHP, 74,72 , 69

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

Cuando la entrada se pasa como argumentos:

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

Ahora, como sugirió @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));}

^ no funciona así, estas son las cosas: [gracias a @ugoren por haberlo notado]

main(a,b,c,d){printf("%d %d",d,b-a*(d=(c-b)/(b-a)),scanf("%d%d%d",&a,&b,&c));}
l0n3sh4rk
fuente
+1 Wow, no sabía que podías fscanfy scanfsin espacios. ¡Increíble!
mellamokb
1
En su segunda solución PHP, ¿no podría guardar algunos caracteres más cambiando el nombre $argv, es decir, $n=$argval principio?
mellamokb
@ mellamokb- ¡sí! ¡No pensé en eso! ¡Gracias! :)
l0n3sh4rk
Su código C no funciona (lo intenté en Linux). Confío en un orden de evaluación de parámetros muy extraño: ¿por qué se scanfharía primero y d=..luego b-d*a?
ugoren
1
Por lo que puedo decir, esto simplemente "sucede" de manera arbitraria en la mayoría de los entornos (por ejemplo, ideone.com/I2cPg ), pero el orden de evaluación de parámetros en C es un comportamiento indefinido, por lo que técnicamente no se debe confiar en él: orangejuiceliberationfront .com / ...
mellamokb
3

VBA, 57 caracteres

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

( Esto es básicamente lo mismo que las otras funciones 'BÁSICAS', pero ya no vi ningún envío de VBA ) .

Gaffi
fuente
Puede soltar 8 bytes cambiando la línea 3 aDebug.?y;b-a*y
Taylor Scott
3

bash (42 caracteres)

Golpe puro:

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

bash (31 caracteres)

Desplazándose a otra cosa:

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

(Basado en la implementación de Howard OWL )

Peter Taylor
fuente
3

Este es un código (no optimizado) para la máquina de registro no limitada, que se describe aquí: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

La entrada debe estar en el registro 1,2 y 3, y la salida estará en el registro 1, 2 después de que el programa haya terminado. Los números no negativos y no enteros no se manejan, pero las entradas 0,7,14 y 2,5,11 se manejan correctamente.

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]

EDITAR: eliminando paréntesis y acortando nombres de instrucciones:

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

Por Alexandersson
fuente
(+1) Pero ... "No se manejan números no negativos y no enteros" ... Creo que quiere decir que no se manejan números negativos . (El OP dice que todas las entradas y salidas son enteras.)
res
Ah, no leyó que la producción fue número entero ...
Per Alexandersson
¿Debo contar esto por el recuento de caracteres o por el número de instrucciones?
PhiNotPi
Tal vez cuente los personajes en la versión editada ...
Per Alexandersson
3

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%

Entrada en líneas separadas

Bash, 51

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

Ejemplo: sh prog.sh 2 0 -4 (argumentos separados por espacios)

Perl, 84

@s=split(/ /,&lt;STDIN&gt;);$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]));}}

Entrada separada por espacios, salida separada por espacios.

SQL, 57

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

Esta es una entrada triste, pero 'solo' resuelve el propósito. La consulta vincula la entrada en tiempo de ejecución 1,2,3 son variables en orden de entrada.

Aman ZeeK Verma
fuente
Aunque otros ya superaron su bashsolución, solo quería sugerirle que podría haber eliminado todos esos espacios adicionales y haber guardado 6 caracteres.
mellamokb
Gracias mellamokb, me di cuenta de eso, simplemente lo ignoré más tarde. Además, me odio de no pensar en su solución de dos / lote, que debería haber hecho clic en mi cabeza ... ¡Args, ah!
Aman ZeeK Verma
2

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
tmartin
fuente
2

Fortran 44

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

La entrada estará en una sola línea (coma o espacio separado)

Capilla Cray 59

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

La entrada será en una sola línea, sin nueva línea (agregue 2 caracteres para eso usando writelnen lugar de write).

Golflua 44

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

Entrada delimitada de nueva línea, salida delimitada por espacios

Kyle Kanos
fuente
2

Julia, 71 caracteres

Entrada y salida delimitadas por espacios.

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

Ejemplo de entrada y salida:

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 60 56 codeles (14x4), codel tamaño 10 para una mejor visibilidad

De hecho, podría reducir la cantidad de codeles en un enorme 35%. No esperaba un resultado tan bueno. Codificar este programa al revés fue, como esperaba, bastante exitoso. Dudo que pueda ser más corto que esto, pero estaría realmente interesado si alguien pudiera encontrar una solución más pequeña.

El desafío no establece si el programa tiene que detenerse después de mostrar el resultado, por lo que mi programa más pequeño (56 codel) debería ser válido. Simplemente vuelve al principio después de mostrar el resultado, solicitando un nuevo triplete de enteros. Debido al apretado empaquetado, no hay lugar para la salida de dos caracteres de nueva línea, pero eso no es problema con el intérprete npiet, porque siempre imprime un '?' si espera entrada

Hay dos tamaños posibles para construir una versión en bucle, pero una versión que se ejecuta solo una vez solo es posible en un programa que tenga al menos 64 codeles (16x4) de gran tamaño. Las versiones a continuación muestran el motivo. Quizás también sea interesante para aquellos que están familiarizados con Piet.

La versión final de 56 codeles más compacta, con un bucle :

Encuentre la regla para los códecs de la serie 56

Segunda versión (60 codeles), con un bucle

Encuentre la regla para los códeles de la serie 60

Si la versión 56 codel está en contra de las reglas, aquí está la versión final 64 codel, que se ejecuta solo una vez :

Encuentra la regla para una serie 64, corre una vez

Mi primera versión (86 codeles)

Encuentre la regla para los códeles de la serie 86

La entrada y la salida están delimitadas por nueva línea.

Ejemplo de entrada y salida:

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

Para las versiones en bucle, parece un poco más feo:

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?

Elegí nueva línea como delimitador porque la codificación ASCII 10 (\ n) obviamente solo necesita 7 códeles, en comparación con ASCII 32 () que necesita 8 códeles o incluso ASCII 40 (,) que necesita 9 códeles.

La codificación hacia atrás desde el resultado hasta la primera entrada es una excelente manera de reducir el uso de codeles para las operaciones ROL. El orden de la pila al principio y al final se conoce, el resto se hace fácilmente a mano.

Aquí hay una versión de texto del programa 64 codel (con pila), en mi taquigrafía inventada. Los programas más cortos simplemente no terminan sino que vuelven al principio.

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
ML
fuente
1

MoonScript (48 caracteres, entrada delimitada por nueva línea, salida delimitada por espacios)

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

Felix (86 caracteres, entrada delimitada por nueva línea, salida delimitada por comas)

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

Julia (84 caracteres, entrada delimitada por espacios, salida delimitada por espacios)

a,b,c=tuple(map(int,split(readline(STDIN)))...)
m=(c-b)/(b-a)
println("$m $(b-m*a)")
kirbyfan64sos
fuente
Su solución de Julia arroja un error. ERROR: BoundsError () en indexed_next en tuple.jl: 19 (se repite 2 veces) al cargar d: \ codegolf \ series.jl, en la expresión que comienza en la línea 1
ML
@ML Eso es raro. Podría ser algo que cambió en la versión más nueva de Julia. Lo intentaré.
kirbyfan64sos
Si lo pruebo en la consola, aparece el error inmediatamente después de la primera línea. De alguna manera, la línea crea una tupla, eso es siempre (a, b, 0). Si la incluyo a través de un archivo .jl, crea la salida, pero arroja el error si presiono Intro para recuperar Julia REPL. julia> include ("happy_birthday_codegolf.jl") 5 -19 77 -4 1 ERROR: BoundsError () en indexed_next en tuple.jl: 19 (se repite 2 veces) al cargar d: \ codegolf \ series.jl, en la expresión que comienza en línea 1 ¿Hay alguna forma de insertar saltos de línea en los comentarios? Perdón por el desastre.
ML
@ML ¿Colocarlo en un archivo y ejecutarlo a través julia file.jldel mismo error?
kirbyfan64sos
Supongo que no es legible en mi lío de una respuesta anterior. Sí, probé tanto la consola como incluyéndola a través de un archivo .jl. "Si lo incluyo a través de un archivo .jl, entonces crea la salida, pero arroja el error si presiono enter para recuperar Julia REPL". Si ejecuto su ejemplo a través del archivo .jl, el programa espera alguna entrada antes julia> REPL / prompt vuelve.
ML