Fractions intermédiaires

Le défi:

Vous devrez créer du code qui prend au moins 3 entrées; 2 entiers et "une représentation de fraction" - quel que soit le type qui convient à votre langue pour représenter les incréments de fraction) ie. Si vous choisissez une chaîne, l'entrée serait "1/4" ou vous pourriez choisir 2 entrées entières supplémentaires ou un tuple ou w / e.

L'entrée peut être n'importe où raisonnable (STDIN, arguments de fonction, à partir d'un fichier, etc.), tout comme la sortie (STDOUT, valeur de retour de fonction, dans un fichier, etc.)

Règles:

1. La "fraction" d'entrée sera toujours une fraction valide, inférieure à 1; exemple "1/4"
2. Le deuxième entier d'entrée aura toujours une valeur plus élevée que le premier entier. IE, le premier entier d'entrée aura toujours une valeur inférieure à la seconde.
3. Les entiers d'entrée peuvent être négatifs.
4. Les fractions produites doivent être réduites autant que possible (simplifiées)

Le code devra sortir chaque "étape de fraction" entre les 2 nombres par incréments de la fraction d'entrée.

Le code doit être un programme ou une fonction comme indiqué ici

Exemple 1:

Contribution: -2,3,"1/2"

Production:

 -2
 -3/2 
 -1 
 -1/2 
  0 
  1/2 
  1 
  3/2  
  2 
  5/2 
  3

Exemple 2:

Contribution: 1,2,"2/3"

Production:

1
5/3
2

ou

1
4/3
2

Remarque: le comptage peut commencer dans les deux sens (merci @Mego)

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

Octave, 34 30 octets

@(a,b,c)rats(union([a:c:b],b))

Prend maintenant la fraction comme une expression numérique plutôt que comme numérateur et dénominateur séparés.

Échantillon sur ideone

Mathematica, 16 octets

Range@##⋃{#2}&

Une fonction sans nom qui prend deux entiers et un nombre rationnel et renvoie une liste de nombres, par exemple:

Range@##⋃{#2}&[-2, 3, 1/2]
(* {-2, -(3/2), -1, -(1/2), 0, 1/2, 1, 3/2, 2, 5/2, 3} *)

Mathematica Rangefait exactement ce que le défi demande, sauf qu'il omet la limite supérieure si la différence entre la limite inférieure et la limite supérieure n'est pas exactement un multiple de la taille du pas. Par conséquent, nous prenons le Union(en utilisant ⋃) avec la liste contenant uniquement la limite supérieure qui garantit qu'elle apparaît exactement une fois. Notez que Unioncela triera le résultat mais nous voulons qu'il soit trié de toute façon, car la taille de l'étape est toujours positive. De plus, puisque nous travaillons avec des justifications, elles sont automatiquement réduites autant que possible.

T-SQL 2012+, 831 535 477 270 246 240 219 octets

Veuillez noter qu'il s'agit d'une doublure - sql n'a pas de fonction intégrée pour réduire la fraction. Peut ne pas être la meilleure langue pour ce type de question. Il est lisible par l'homme (en quelque sorte - par rapport à certaines autres langues).

DECLARE @f INT=-5,@t INT=3,@n INT=3,@ INT=8;

WITH C as(SELECT
top((@t*@-@f*@)/@n+1)ROW_NUMBER()OVER(ORDER BY @)M
FROM sys.messages)SELECT(SELECT
IIF(V%@=0,LEFT(V/@,9),CONCAT(V/MAX(M),'/',ABS(@)/MAX(M)))FROM c
WHERE V%M=0AND @%M=0)FROM(SELECT
@f*@+@n*~-M V FROM c)k

Essayez-le en ligne

Python 2, 81 octets

from fractions import*
a,b,c=map(Fraction,input())
while a<b:print a;a+=c
print b

Essayez-le en ligne

Haskell, 31 26 octets

f a b c=min[b]$a:f(a+c)b c

Évaluation paresseuse FTW! Démo:

*Main> import Data.Ratio
*Main Data.Ratio> f (-2) 3 (1%2)
[(-2) % 1,(-3) % 2,(-1) % 1,(-1) % 2,0 % 1,1 % 2,1 % 1,3 % 2,2 % 1,5 % 2,3 % 1]
*Main Data.Ratio> f 1 2 (2%3)
[1 % 1,5 % 3,2 % 1]

(J'ai d'abord été tenté par la [a,a+c..b]notation de Haskell , mais elle a quelques bizarreries qui nécessitent quelque chose comme f a b c|l<-[a,a+c..b-c/2]=l++[b|last l<b]41 octets ou f a b c=[x|x<-[a,a+c..],x<b]++[b]33.)

MATL , 16 15 octets

3$:3Gvu9X10ZGZD

Cela peut échouer pour les très grands dénominateurs. J'espère que le format de sortie est acceptable.

Essayez-le en ligne!

3$:    % take three inputs and generate range
3G     % push third input again
v      % vertically concatenate. Gives vertical array as output 
u      % get unique elements (i.e. remove the last one if it is repeated)
9X1    % predefined literal 'rat'
0ZG    % set rational format
ZD     % display using that format

Rubis , 32 54 48 octets

->a,b,c{(a..b).step(c){|x|p x%1>0?x:x.to_i};p b}

Cette solution est basée sur la réponse Python de Mego et suppose que ce csera toujours un Rationalformat de fraction de Ruby. Essayez-le en ligne!

Edit: correction d'un bug où les entiers n'étaient pas présentés comme des entiers. -6 octets grâce à Not That Charles et MegaTom.

Les fonctions sont appelées de cette façon:

> f=->a,b,c{(a..b).step(c){|x|p x%1>0?x:x.to_i};p b}
> f[1,4,Rational(2,3)]
1
(5/3)
(7/3)
3
(11/3)
4

Julia, 14 octets

f(a,b,c)=a:c:b

Ceci est similaire à la réponse Mathematica, sauf que les plages de Julia sont déjà au format souhaité, donc elles sont encore plus courtes. Renvoie également une collection de nombres. Exemple de sortie:

11-element StepRange{Rational{Int64},Rational{Int64}}:
 -3//1,-5//2,-2//1,-3//2,-1//1,-1//2,0//1,1//2,1//1,3//2,2//1

Notez que les entiers sont affichés avec 1 dans le dénominateur, et une double barre oblique est utilisée pour les fractions. Pour obtenir la sortie exactement telle que définie dans la question, il faut un peu plus de code:

f(a,b,c)=map(x->println(x.num,x.den<2?"":"/$(x.den)"),a:c:b)

Matlab avec Symbolic Toolbox / Octave avec SymPy, 27 octets

Merci à @sanchises d'avoir signalé une erreur, maintenant corrigée

@(a,b,c)sym(union(a:c:b,b))

Il s'agit d'une fonction anonyme. Pour l'appeler, affectez-le à une variable ou utilisez ans.

Exemple:

>> @(a,b,c)sym(union(a:c:b,b))
ans = 
    @(a,b,c)sym(union(a:c:b,b))
>> ans(-2,3,1/2)
ans =
[ -2, -3/2, -1, -1/2, 0, 1/2, 1, 3/2, 2, 5/2, 3]

Javascript, 108 90 86   81 octets

(a,b,n,d)=>{var s="";for(a=a*d;a<b*d;a+=n)s+=(a%d?a+"/"+d:a/d)+" ";s+=b;return s}

Une fonction anonyme. Après affectation à une variable nommée avec un espace blanc:

var f=(a,b,n,d)=>
{ var s="";
  for(a=a*d; a<b*d; a+=n)
    s+= (a%d ? a + "/" + d : a/d) + " ";
  s+=b;
  return s
}

Exemples de tests:

console.log(f(1,2,1,8)); //writes:
1 9/8 10/8 11/8 12/8 13/8 14/8 15/8 2

console.log(f(-3,3,4,7)); // writes:
-3 -17/7 -13/7 -9/7 -5/7 -1/7 3/7 1 11/7 15/7 19/7 3 

Une approche impérative utilisant javascript, pas de récursivité, bibliothèque ou programmation fonctionnelle.

Smalltalk - 89 octets

Pour une fois, Smalltalk est presque compétitif!

Number extend[p:e q:i[|h|self to:e by:i do:[:x|h:=x. x printNl].h=e ifFalse:[e printNl]]]

Appelez comme ceci:

> 2 p:5 q:1/2
2
5/2
3
7/2
4
9/2
5

> 1 p:2 q:2/3
1
5/3
2

R - 71 octets

Suppose que vous avez déjà installé le MASSpackage

f=function(x,y,z)MASS::fractions(union(seq(x,y,eval(parse(text=z))),y))

> f(1, 2, '1/3')
[1]   1 4/3 5/3   2
> f(2, 5, '1/2')
[1]   2 5/2   3 7/2   4 9/2   5

Pyret, 56 octets

{(b,e,n,d):link(e,map(_ / d,range(b * d, e * d))).sort()}

Prend le début (b), la fin (e), le numérateur (n) et le dénominateur (d). Crée une plage d'entiers, les divise et ajoute la fin à la liste (en liant puis en triant).