Rosetta Stone Challenge: Trouvez la règle pour une série

15

L'objectif d'un Rosetta Stone Challenge est d'écrire des solutions dans autant de langues que possible. Montrez votre multilinguisme de programmation!

Le défi

Votre défi est d'implémenter un programme qui entrera une liste de nombres et sortira la règle utilisée pour générer chaque numéro successif de la série, dans autant de langages de programmation que possible . Vous êtes autorisé à utiliser n'importe quelle sorte de fonction de bibliothèque standard de votre langue, car il s'agit principalement d'une vitrine de langue.

Qu'est-ce qu'une "série"?

Une série est une liste ordonnée d'entiers. Chaque numéro successif de la série peut être généré en appliquant une règle simple au numéro précédent de la série. Dans ce défi, la règle consiste à multiplier le nombre par une constante, puis à ajouter une deuxième constante. Les deux constantes peuvent être n'importe quel entier. Le but de ce défi est de produire ces deux constantes.

Pour la série 2 5 11, la règle peut s'écrire 2 1. Cela signifie que chaque nombre est le nombre précédent, multiplié par 2, plus 1. Un fait important est que la plupart des séries ont exactement une règle. Certaines séries ont un nombre infini ou pas du tout, mais vous n'aurez pas à vous en occuper.

Contribution

L'entrée sera une liste de trois entiers différents qui sont les nombres de la séquence. Les nombres peuvent être séparés par des espaces, des virgules ou des sauts de ligne, mais veuillez préciser lesquels. Je vais être flexible sur cette limitation car certaines langues peuvent avoir des restrictions d'entrée. Voici quatre exemples de saisie:

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

Production

La sortie sera constituée de deux entiers qui représentent la règle utilisée pour générer la série. Le premier nombre sera la constante multiplicative, tandis que le deuxième nombre sera la constante additive. Le formatage de la sortie peut être délimité par des espaces, des virgules ou des sauts de ligne. Je suis également flexible sur cette limitation. Voici les exemples de sortie correspondants:

1 7
2 1
2 -4
-4 1

Le critère de gain objectif

En ce qui concerne un critère de gain objectif, le voici: chaque langue est une compétition distincte pour savoir qui peut écrire la plus courte inscription, mais le gagnant général serait la personne qui remporte le plus de ces sous-compétitions. Cela signifie qu'une personne qui répond dans de nombreuses langues rares peut bénéficier d'un avantage. Le code-golf est surtout un bris d'égalité lorsqu'il y a plus d'une solution dans une langue: la personne avec le programme le plus court obtient un crédit pour cette langue.

Règles, restrictions et notes

Votre programme peut être écrit dans n'importe quelle langue qui existait avant le 9 avril 2012. Je devrai également compter sur la communauté pour valider certaines réponses écrites dans certaines des langues les plus rares / ésotériques, car il est peu probable que je puisse tester leur.


Classement actuel

Cette section sera périodiquement mise à jour pour montrer le nombre de langues et qui mène dans chacune.

  • AWK (32) - mellamokb
  • bash (31) - Peter Taylor
  • Befunge (29) - Howard
  • bc (39) - kernigh
  • enculé (174) - CMP
  • C (78) - l0n3_shArk
  • C ++ (96) - à gauche
  • Lisp commun (88) - kernigh
  • Chapelle de Cray (59) - Kyle Kanos
  • csh (86) - kernigh
  • Cuda (301) - à gauche
  • dc (30) - kernigh
  • DOS BATCH (54) - mellamokb
  • Élément (27) - Howard
  • es (95) - kernigh
  • Facteur (138) - kernigh
  • Félix (86) - kirbyfan64sos
  • Fortran (44) - Kyle Kanos
  • Aller (101) - Howard
  • GolfScript (16) - Howard
  • Golflua (44) - Kyle Kanos
  • Haskell (35) - à gauche
  • J (23) - Gareth
  • Java (141) - Howard
  • JavaScript (47) - mellamokb
  • Julia (71 ans) - ML
  • Lua (51 ans) - Howard
  • Mercure (319) - à gauche
  • MoonScript (48) - kirbyfan64sos
  • Nimrod (146) - à gauche
  • Chouette (22) - res
  • Pascal (88) - à gauche
  • 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
  • Rubis (44) - Howard
  • Scala (102) - Gareth
  • SQL (57) - Aman ZeeK Verma
  • TI-83 BASIC (25) - mellamokb
  • Machine d'enregistrement illimitée (285) - Paxinum
  • VBA (57) - Gaffi
  • Espace (123) - res
  • zsh (62) - kernigh

Classements des utilisateurs actuels

Les rangs égaux sont triés par ordre alphabétique.

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

  7. res (3): Chouette (22), R (50), Blanc (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): enculé (174)

  12. Gaffi (1): VBA (57)

  13. l0n3_shArk (1): C (78)

  14. Paxinum (1): Machine d'enregistrement illimitée (285)

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

  16. tmartin (1): Q (36)

PhiNotPi
la source
Il ne semble pas que les gens lisent réellement les balises ou d'autres descriptions ...
cessé de tourner dans le sens inverse des aiguilles d'une montre le
@leftaroundabout: Pourquoi dites-vous cela? Je suis conscient (par exemple) que ma solution ne prend pas d'entrée de tableau et je prévois de la corriger plus tard. Et je suis trop paresseux pour poster plus d'une solution pour le moment :) Selon le critère de gain d'objet, le code-golf est le bris d'égalité pour deux messages avec la même langue, donc j'ai inclus le nombre de caractères pour facile référence au cas où quelqu'un d'autre publierait une solution JavaScript. Cela peut en fait être l'un de ces rares moments où une question mérite à la fois les balises code-golf et code-challenge .
mellamokb
Oui, vous avez raison: quelqu'un doit également faire les langues non inhabituelles.
cessé de tourner dans le sens inverse des aiguilles d'une montre le
3
Tant que vous conservez le classement actuel dans le même format standard que ci-dessus, vous pouvez l'utiliser pour générer les scores de chaque utilisateur: jsfiddle.net/bk2WM/2
mellamokb
1
Ma dernière version ( jsfiddle.net/bk2WM/4 ) fournit une sortie brute (dans la zone de texte) que vous pouvez copier / coller dans une publication et la formate comme je l'ai fait dans ma publication. N'hésitez pas à changer / jouer avec la mise en page.
mellamokb

Réponses:

9

GolfScript, 16 caractères

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

L'entrée est donnée sous forme de liste séparée par des espaces.

JavaScript, 56 caractères

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

L'entrée est donnée à l'invite.

Ruby, 44 caractères

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

L'entrée est ici donnée sous forme de liste séparée par des virgules.

Python, 40 caractères

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

L'entrée est à nouveau séparée par des virgules.

Java, 141 caractères

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

Entrée séparée par un retour à la ligne.

Lua, 51 caractères

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

Entrée séparée par un retour à la ligne.

Allez, 101 caractères

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

Entrée séparée par un retour à la ligne.

Fortran, 90 caractères

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

Entrée séparée par un retour à la ligne.

Befunge, 29 personnages

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

PostScript, 61 caractères

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

Chouette, 23 caractères

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

Entrée séparée par un retour à la ligne.

Élément , 27 caractères

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

Entrée séparée par un retour à la ligne.

Howard
la source
Vol sans vergogne
1
Eh bien deux peuvent jouer à ce jeu ...: P
mellamokb
@mellamokb Nice one. Mais j'ai déjà voté positivement ;-) Alors ce qui nous reste: battre les 48 caractères ...
Howard
2
Wow, vous avez joué au golf dans ma langue. Je suis honoré. Je me sens aussi obligé de te battre. :)
PhiNotPi
1
Concernant votre solution Element, il semble que la dernière marque `ne soit pas nécessaire. Est-ce une erreur de votre part ou une erreur dans mon interprète que j'ai posté sur Pastebin? Oh, et j'ai une solution à 27 caractères.
PhiNotPi
8

Brainfuck - 174

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

Piet - 82?

Je ne sais pas comment mesurer le golf compétitif ici. Je vais aller avec la taille totale de l'image (en codels) Le mien est 41x2: entrez la description de l'image ici

Befunge - 34

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

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

Je ne sais pas si cela compte, mais j'ai pensé que je pourrais essayer. Il est remarquablement difficile de décrire avec précision même un algorithme simple. J'aimerais que l'anglais soutienne une sorte de symbole de regroupement pour établir la priorité.

captncraig
la source
Liez-moi à un interprète (complet qui comprend toute la langue et n'est pas uniquement destiné à résoudre ce problème) et je peux l'accepter.
PhiNotPi
ummm, worldinterpreting.com ?
captncraig
1
C'est bon, une autre personne a écrit une preuve mathématique dans LaTeX. Cela ne comptait pas, mais ajoute à la variété.
PhiNotPi
Si j'essaye votre solution Piet avec npiet j'obtiens ce résultat: D:\Software\Programming\Piet\npiet-1.3a-win32>npiet series2.png ? 5 ? -19 ? 77 05 La solution devrait être-4 1
ML
L'image que vous avez publiée ne fonctionne que si vous l'agrandissez d'un pixel (pas de codel!) Sur le côté droit. 461 pixels ne sont pas divisibles par 11, ce qui est d'ailleurs une taille de codel assez inhabituelle;)
ML
8

QBasic, 42

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

Nécessite une entrée avec des virgules, des sorties avec des espaces (est-ce correct?)


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

Maintenant entrées avec espaces, sorties avec sauts de ligne.


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

Entrée w / sauts de ligne, sortie virgule.


Celui-ci ne comptera pas, mais je pense qu'il s'intègre toujours d'une certaine manière:

Théorème mathématique, 713 caractères 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}

Sortie de la solution de théorème mathématique LaTeX


Pendant que nous rédigeons des :=définitions ...

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);}
a cessé de tourner dans le sens antihoraire
la source
1
Vous pouvez enregistrer deux caractères dans la solution C en éliminant met en réutilisant c, et deux autres en utilisant c-=b;c/=b-a;au lieu de c=(c-b)/(b-a);.
Peter Taylor
Dans la solution C, vous n'avez pas besoin des espaces dans la scanf()chaîne de format.
Reto Koradi
7

AWK, 35 caractères

{m=($3-$2)/($2-$1);print m,$2-$1*m}
  • Format d'entrée: 2 0 -4

bc, 39 caractères

define f(a,b,c){
m=(c-b)/(b-a)
m
b-a*m}
  • Format d'entrée: z=f(2, 0, -4)
  • L'entrée est une bcexpression. Après avoir bclu le fichier source, il lit l'entrée standard. C'est pourquoi l'entrée doit ressembler à un appel de fonction.
  • J'utilise OpenBSD bc, qui nécessite une nouvelle ligne après le {.

Lisp commun, 88 caractères

(let*((a(read))(b(read))(c(read))(m(/(- c b)(- b a))))(format
t "~A ~A" m (- b(* a m))))
  • Format d'entrée: 2 0 -4

csh, 86 caractères

set i=(`cat`)
@ m=($i[3] - $i[2]) / ($i[2] - $i[1])
@ n=$i[2] - $i[1] * $m
echo $m $n
  • Format d'entrée: 2 0 -4
  • Le 86ème caractère est une nouvelle ligne à la fin du fichier. cshest la seule langue pour laquelle je compte la nouvelle ligne à la fin du fichier. En effet, n'exécute cshjamais la dernière commande à moins qu'il n'y ait un saut de ligne.
  • set i=($<)ne fonctionne pas, car $<n'a pas de fractionnement de mot.

dc, 30 caractères

?scsbsalclb-lbla-/psmlblalm*-p
  • Format d'entrée:, 2 0 _4_est le trait de soulignement.

es, 95 caractères

i=(`cat)
b=$i(2)
m=`{expr \( $i(3) - $b \) / \( $b - $i(1) \)}
echo $m `{expr $b - $i(1) \* $m}
  • Format d'entrée: 2 0 -4
  • esest la coque extensible de Paul Haahr et Byron Rakitzis.

Facteur, 138 caractères

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 ]
  • Format d'entrée: 2 0 -4

PicoLisp, 74 72 caractères

(in()(let(r read a(r)b(r)c(r)m(/(- c b)(- b a)))(print
m (- b(* a m)))))
  • Format d'entrée: 2 0 -4
  • EDIT: perdu 2 caractères en changeant a(read)b(read)c(read)en r read a(r)b(r)c(r).

TI-83 BASIC, 63 61 caractères

:Input A
:Input B
:Input C
:(C-B)/(B-A)→M
:Disp M
:Disp B-A*M
  • Format d'entrée: 2ENTER 0ENTER ¯4ENTER, où ¯est le moins unaire de la calculatrice.
  • J'ai compté les caractères Unicode; (la flèche droite) compte pour U + 2192. Par exemple, la calculatrice compte Input Apour 2 caractères, mais je compte Input Apour 7 caractères. Je compte également :pour 1 caractère.
  • EDIT: J'ai mal compté: il y a 61, pas 63, caractères.

zsh, 62 caractères

i=(`cat`)
((b=i[2],m=(i[3]-b)/(b-i[1]),n=b-i[1]*m))
echo $m $n
  • Format d'entrée: 2 0 -4
kernigh
la source
7

AWK (32)

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

Démo: http://ideone.com/kp0Dj


bash (38)

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

Démo: http://ideone.com/tzFi8


DOS / LOT (54 55 )

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

Prend les paramètres comme une liste d'arguments séparés par des espaces.


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

Démo: http://jsfiddle.net/BT8bB/6/


PHP (61 77 )

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

Démo: 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

Oui, la parenthèse droite manquante est intentionnelle. C'est une technique d'optimisation bien connue que la fermeture des parenthèses avant une opération STO n'est pas nécessaire dans la programmation de base de la TI-83.

mellamokb
la source
1
Le JS ne fonctionne pas pour moi dans Firefox - je reçois une erreur qui pn'est pas définie. La spécification JS indique-t-elle que les arguments de la fonction doivent être évalués avant la résolution de la fonction?
Peter Taylor
Hmm. Oui tu as raison. Selon la spécification, cela ne devrait pas fonctionner, comme expliqué dans cette question SO similaire: stackoverflow.com/questions/9941736/… . Les fonctions sont censées être liées avant que leurs arguments soient évalués, et Chrome le fait apparemment dans l'ordre inverse.
mellamokb
J'ai essayé longtemps et dur de battre la solution Java la plus élevée par une approche complètement différente que vous pouvez voir ci-dessus. 143 est le plus proche que j'ai pu obtenir. N'importe qui a des idées, envoyez-moi mon chemin!
mellamokb
6

Espace, 123

    





















Les E / S sont séparées par des sauts de ligne. (Pour obtenir le code source, entrez en mode édition et copiez l'espace blanc entre les balises préformatées; ou, consultez l' exemple en ligne sur Ideone .)

Explication, où S, T, L représente l'espace, la tabulation, le saut de ligne:

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)

Les E / S sont séparées par des espaces.


Hibou

--- 22 ---

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

Les E / S sont séparées par des sauts de ligne.

--- 19 --- (si cette version est autorisée; mais je pense que c'est de la triche, car le \ est du code exécutable):

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

Les E / S sont séparées par des espaces. Utilisation de la ligne de commande: owl prog 5 19\ 77(le \ agit comme un moins unaire postfixe dans Owl).

res
la source
Avec votre entrée Owl, je peux suspendre le jugement de votre solution à 19 caractères car votre solution à 22 caractères est déjà gagnante pour la langue.
PhiNotPi
5

J, 23 caractères

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

Usage:

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

Les nombres négatifs sont représentés par des traits de soulignement dans J.

PHP, 88 caractères

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

Scala, 102 caractères

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 caractères

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

Nécessite l'option '-p', pour laquelle j'ai ajouté 2 caractères. Suppose que l'entrée est valide pour enregistrer certains caractères.

Toutes mes réponses prennent des nombres séparés par des espaces.

Gareth
la source
À propos des programmes J ... L'entrée peut-elle être codée directement dans le fichier source au lieu de la demander à l'utilisateur?
res
@res Je l'ai donné exactement comme je l'invoquerais sur la ligne de commande. L'ajout 1!:1]3à droite de l'expression lira l'entrée de STDIN. Je pense qu'il y a eu des discussions sur les méta ou dans les commentaires de certaines réponses J pour savoir si cela devrait être autorisé ou non. Je suis quelque peu ambivalent - j'aime trouver comment faire en sorte que J fasse ce que je veux dans le plus petit espace, je prendrai la pénalité de 6 caractères pour l'entrée de STDIN si c'est ce que tout le monde veut.
Gareth
Je pensais que si c'était autorisé pour J, alors d'autres entrées pourraient être raccourcies de la même manière. (BTW, je n'ai pas réussi à faire fonctionner votre expression suggérée, mais cela (],1{x-0{x*])%~/2-/\x=:".1!:1]1semble correct en mode console.)
res
@res Oh oui, j'ai oublié de convertir une chaîne en une liste de nombres (bien que le 3 à la fin fonctionne normalement bien pour moi?)
Gareth
Si vous faites de Perl un sous-programme plutôt qu'un programme complet, vous pouvez le réduire à 50 octets (et aucun indicateur de ligne de commande n'est nécessaire):($a=($_[1]-pop)/($_[0]-$_[1])).$/.($_[1]-$_[0]*$a)
msh210
4

PHP, 74,72 , 69

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

Lorsque l'entrée est passée comme arguments:

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

Maintenant, comme @mellamokb l'a suggéré, en utilisant $ 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));}

^ ne fonctionne pas, voici le truc: [merci à @ugoren de l'avoir signalé]

main(a,b,c,d){printf("%d %d",d,b-a*(d=(c-b)/(b-a)),scanf("%d%d%d",&a,&b,&c));}
l0n3sh4rk
la source
+1 Wow, je ne savais pas que tu pouvais fscanfet scanfsans espaces. Impressionnant!
mellamokb
1
Dans votre deuxième solution PHP, ne pouviez-vous pas enregistrer quelques caractères supplémentaires en renommant $argv, c'est- $n=$argvà- dire au début?
mellamokb
@ mellamokb- ouais! Je n'y ai pas pensé! Merci! :)
l0n3sh4rk
Votre code C ne fonctionne pas (j'ai essayé sur Linux). Je m'appuie sur un ordre d'évaluation des paramètres très étrange - pourquoi serait- scanfil fait en premier, puis d=..ensuite b-d*a?
ugoren
1
D'après ce que je peux dire, cela "arrive" arbitrairement à fonctionner dans la plupart des environnements (ex: ideone.com/I2cPg ), mais l'ordre d'évaluation des paramètres en C est un comportement indéfini, et donc techniquement ne devrait pas être invoqué: orangejuiceliberationfront .com /…
mellamokb
3

VBA, 57 caractères

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

( C'est essentiellement la même chose que les autres fonctions `` BASIC '', mais je n'ai pas vu de soumissions VBA déjà. )

Gaffi
la source
Vous pouvez supprimer 8 octets en remplaçant la ligne 3 parDebug.?y;b-a*y
Taylor Scott
3

bash (42 caractères)

Bash pur:

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

bash (31 caractères)

Passer à autre chose:

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

(Basé sur l' implémentation OWL de Howard )

Peter Taylor
la source
3

Il s'agit d'un code (non optimisé) pour la machine à registres illimités, décrit ici: http://www.proofwiki.org/wiki/Definition:Unlimited_Register_Machine

L'entrée doit être dans les registres 1,2 et 3, et la sortie sera dans le registre 1, 2 une fois le programme terminé. Les nombres non négatifs et non entiers ne sont pas traités, mais les entrées 0,7,14 et 2,5,11 sont traitées correctement.

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: en supprimant les crochets et en raccourcissant les noms des instructions:

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

Per Alexandersson
la source
(+1) Mais ... "Les nombres non négatifs et non entiers ne sont pas traités" ... Je pense que vous voulez dire que les nombres négatifs ne sont pas traités. (L'OP indique que toutes les entrées et sorties sont des nombres entiers.)
res
Ah, je n'ai pas lu que la sortie était un entier ...
Per Alexandersson
Dois-je compter cela par le nombre de caractères ou par le nombre d'instructions?
PhiNotPi
Peut-être compter les personnages dans la version éditée ...
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%

Entrée sur des lignes séparées

Bash, 51

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

Exemple: sh prog.sh 2 0 -4 (arguments séparés par des espaces)

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

Entrée séparée par l'espace, sortie séparée par l'espace.

SQL, 57

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

C'est une entrée triste, mais «juste» résout le but. La requête lie l'entrée à l'exécution 1,2,3 sont des variables dans l'ordre d'entrée.

Aman ZeeK Verma
la source
Même si d'autres ont déjà battu votre bashsolution, je voulais juste suggérer que vous auriez pu supprimer tous ces espaces supplémentaires et enregistrer 6 caractères.
mellamokb
Merci mellamokb, je m'en suis rendu compte, je l'ai en quelque sorte ignoré plus tard. De plus, je me déteste de ne pas penser à votre solution dos / batch, qui aurait dû me claquer la tête..args ahh!
Aman ZeeK Verma
2

Q, 36

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

usage

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
la source
2

Fortran 44

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

L'entrée se fera sur une seule ligne (séparée par des virgules ou des espaces)

Chapelle de Cray 59

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

L'entrée se fera sur une seule ligne, pas de nouvelle ligne (ajoutez 2 caractères pour cela en utilisant writeln à la place dewrite ).

Golflua 44

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

Entrée délimitée par une nouvelle ligne, sortie délimitée par un espace

Kyle Kanos
la source
2

Julia, 71 caractères

Entrée et sortie délimitées par des espaces.

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

Exemple d'entrée et de sortie:

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 codels (14x4), taille de codel 10 pour une meilleure visibilité

Je pourrais en fait réduire la quantité de codels de 35%. Je ne m'attendais pas à un si bon résultat. Comme je m'y attendais, le codage à rebours de ce programme a été assez réussi. Je doute que cela puisse être plus court que cela, mais je serais vraiment intéressé si quelqu'un pouvait trouver une solution plus petite.

Le défi ne précise pas si le programme doit s'arrêter après avoir montré le résultat, donc mon plus petit programme (56 codel) doit être valide. Il revient simplement au début après avoir montré le résultat, demandant un nouveau triplet d'entiers. En raison de l'emballage serré, il n'y a pas de place pour la sortie de deux caractères de nouvelle ligne, mais cela ne pose aucun problème avec l'interpréteur npiet, car il affiche toujours un «? s'il attend l'entrée.

Il existe deux tailles possibles pour créer une version en boucle, mais une version qui ne s'exécute qu'une seule fois n'est possible que dans un programme d'au moins 64 codels (16x4). Les versions ci-dessous montrent la raison. C'est peut-être aussi intéressant pour ceux qui connaissent Piet.

La version finale, la plus compacte de 56 codels, avec une boucle :

Trouver la règle pour les codels A Series 56

Deuxième version (60 codels), avec une boucle

Trouver la règle pour les codels A Series 60

Si la version 56 codel est contraire aux règles, voici la version 64 codel finale, exécutée une seule fois :

Rechercher la règle pour une série 64, exécutée une fois

Ma première version (86 codels)

Trouver la règle pour les codels A Series 86

L'entrée et la sortie sont délimitées par des sauts de ligne.

Exemple d'entrée et de sortie:

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

Pour les versions en boucle, un peu plus laid:

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?

J'ai choisi la nouvelle ligne comme délimiteur car le codage ASCII 10 (\ n) n'a évidemment besoin que de 7 codels, par rapport à ASCII 32 () qui a besoin de 8 codels ou même ASCII 40 (,) qui a besoin de 9 codels.

Le codage en arrière du résultat à la première entrée est un excellent moyen de réduire l'utilisation du codel pour les opérations ROL. L'ordre de pile au début et à la fin est connu, le reste se fait facilement à la main.

Voici une version texte du programme 64 codel (avec pile), dans ma sténographie inventée. Les programmes plus courts ne s'arrêtent tout simplement pas mais retournent au début.

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
la source
1

MoonScript (48 caractères, entrée délimitée par une nouvelle ligne, sortie délimitée par un espace)

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

Felix (86 caractères, entrée délimitée par une nouvelle ligne, sortie délimitée par des virgules)

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

Julia (84 caractères, entrée délimitée par un espace, sortie délimitée par un espace)

a,b,c=tuple(map(int,split(readline(STDIN)))...)
m=(c-b)/(b-a)
println("$m $(b-m*a)")
kirbyfan64sos
la source
Votre solution Julia génère une erreur. ERREUR: BoundsError () dans indexed_next à tuple.jl: 19 (se répète 2 fois) lors du chargement de d: \ codegolf \ series.jl, dans l'expression commençant à la ligne 1
ML
@ML C'est bizarre. Peut-être que quelque chose a changé dans la dernière version de Julia. Je vais l'essayer.
kirbyfan64sos
Si je l'essaye dans la console, j'obtiens l'erreur immédiatement après la première ligne. D'une manière ou d'une autre, la ligne crée un tuple, c'est toujours (a, b, 0) Si je l'inclus via un fichier .jl, cela crée la sortie, mais renvoie l'erreur si j'appuie sur Entrée pour récupérer le Julia REPL. julia> include ("happy_birthday_codegolf.jl") 5 -19 77 -4 1 ERREUR: BoundsError () dans indexed_next à tuple.jl: 19 (se répète 2 fois) lors du chargement de d: \ codegolf \ series.jl, dans l'expression à partir de ligne 1 Existe-t-il un moyen d'insérer des sauts de ligne dans les commentaires? Désolé pour le bazar.
ML
@ML Le mettre dans un fichier et l'exécuter via julia file.jldonne-t-il la même erreur?
kirbyfan64sos
Je suppose que ce n'est pas lisible dans mon désordre d'une réponse ci-dessus. Oui, j'ai essayé à la fois la console et l'inclure via un fichier .jl. "Si je l'inclus via un fichier .jl, cela crée la sortie, mais génère l'erreur si j'appuie sur Entrée pour récupérer Julia REPL." Si je lance votre exemple via un fichier .jl, le programme attend une entrée avant julia> REPL / prompt revient.
ML