Fracciones intermedias

El reto:

Deberá crear un código que tome al menos 3 entradas; 2 enteros y "una representación de fracción" - el tipo que se adapte a su idioma para representar los incrementos de fracción) es decir. Si elige una cadena, la entrada sería "1/4" o podría elegir 2 entradas enteras adicionales o una tupla o w / e.

La entrada puede ser razonable (STDIN, argumentos de función, desde un archivo, etc.) y, por lo tanto, puede salir (STDOUT, valor de retorno de función, a un archivo, etc.)

Reglas:

1. La "fracción" de entrada siempre será una fracción válida, menor que 1; ejemplo "1/4"
2. El segundo entero de entrada siempre tendrá un valor más alto que el primer entero. Es decir, el primer entero de entrada siempre tendrá un valor más bajo que el segundo.
3. Los enteros de entrada pueden ser negativos.
4. Las fracciones producidas deben reducirse tanto como sea posible (simplificado)

El código deberá generar cada "paso de fracción" entre los 2 números en incrementos de la fracción de entrada.

El código debe ser un programa o función como se indica aquí

Ejemplo 1:

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

Salida:

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

Ejemplo 2

Entrada: 1,2,"2/3"

Salida:

1
5/3
2

o

1
4/3
2

Nota: El conteo puede comenzar desde cualquier dirección (gracias @Mego)

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Octava, 34 30 bytes

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

Ahora toma la fracción como una expresión numérica en lugar de un numerador y un denominador separados.

Muestra sobre ideona

Mathematica, 16 bytes

Range@##⋃{#2}&

Una función sin nombre que toma dos enteros y un número racional y devuelve una lista de números, por ejemplo:

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

Mathematica's Rangehace exactamente lo que pide el desafío, excepto que omite el límite superior si la diferencia entre el límite inferior y el superior no es exactamente un múltiplo del tamaño del paso. Por lo tanto, tomamos el Union(usar ⋃) con la lista que contiene solo el límite superior, lo que garantiza que aparezca exactamente una vez. Tenga en cuenta que Unionclasificará el resultado, pero queremos ordenarlo de todos modos, ya que el tamaño del paso siempre es positivo. Además, dado que estamos trabajando con racionales, se reducen automáticamente tanto como sea posible.

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

Tenga en cuenta que este es un trazador de líneas: sql no tiene una función integrada para reducir la fracción. Puede que no sea el mejor idioma para este tipo de preguntas. Es legible para los humanos (más o menos, en comparación con algunos de los otros idiomas).

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

Pruébalo en línea

Python 2, 81 bytes

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

Pruébalo en línea

Haskell, 31 26 bytes

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

Evaluación perezosa FTW! Manifestación:

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

(Inicialmente me sentí tentado por la [a,a+c..b]notación de Haskell , pero tiene algunas peculiaridades que requieren algo así como f a b c|l<-[a,a+c..b-c/2]=l++[b|last l<b]41 bytes o f a b c=[x|x<-[a,a+c..],x<b]++[b]33).

MAT , 16 15 bytes

3$:3Gvu9X10ZGZD

Esto puede fallar para denominadores muy grandes. Espero que el formato de salida sea aceptable.

Pruébalo en línea!

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

Ruby , 32 54 48 bytes

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

Esta solución se basa en la respuesta Python de Mego y supone que csiempre será un Rationalformato de fracción de Ruby. Pruébalo en línea!

Editar: se corrigió un error por el cual los enteros no se presentaban como enteros. -6 bytes gracias a Not That Charles y MegaTom.

Las funciones se llaman de esta manera:

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

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

Esto es similar a la respuesta de Mathematica, excepto que los rangos de Julia ya están en el formato deseado, por lo que es aún más corto. También devuelve una colección de números. Salida de ejemplo:

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

Tenga en cuenta que los enteros se muestran con 1 en el denominador, y se utiliza una barra doble para las fracciones. Para obtener el resultado exactamente como se define en la pregunta, se requiere más código:

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

Matlab con caja de herramientas simbólica / octava con SymPy, 27 bytes

Gracias a @sanchises por señalar un error, ahora corregido

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

Esta es una función anónima. Para llamarlo, asígnelo a una variable o useans .

Ejemplo:

>> @(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 bytes

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

Una función anónima. Después de la asignación a una variable con nombre con espacio en blanco:

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
}

Ejemplos de prueba:

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 

Un enfoque imperativo que utiliza JavaScript, sin recursividad, biblioteca o programación funcional.

Smalltalk - 89 bytes

¡Por una vez Smalltalk es casi competitivo!

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

Llama así:

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

Asume que ya ha instalado el MASSpaquete

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 bytes

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

Toma en principio (b), final (e), numerador (n) y denominador (d). Crea un rango de enteros, los divide y agrega el final a la lista (al vincular y luego ordenar).