Frações intermediárias

O desafio:

Você precisará criar um código que leve pelo menos três entradas; 2 números inteiros e "uma representação de fração" - qualquer que seja o tipo que se adequa ao seu idioma para representar os incrementos de fração), ie. Se você escolher uma string, a entrada será "1/4" ou você poderá escolher 2 entradas inteiras extras ou uma tupla ou w / e.

A entrada pode ser razoável em qualquer lugar (STDIN, argumentos de função, de um arquivo, etc.), assim como a saída (STDOUT, valor de retorno da função para um arquivo, etc.)

Regras:

1. A "fração" de entrada sempre será uma fração válida, menor que 1; exemplo "1/4"
2. O segundo número inteiro de entrada sempre terá um valor mais alto que o primeiro número inteiro. Ou seja, o primeiro número inteiro de entrada sempre terá um valor menor que o segundo.
3. Os números inteiros de entrada podem ser negativos.
4. As frações produzidas devem ser reduzidas o máximo possível (simplificado)

O código precisará gerar cada "passo de fração" entre os 2 números em incrementos da fração de entrada.

O código deve ser um programa ou função, conforme indicado aqui

Exemplo 1:

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

Resultado:

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

Exemplo 2:

Entrada: 1,2,"2/3"

Resultado:

1
5/3
2

ou

1
4/3
2

Nota: A contagem pode começar em qualquer direção (obrigado @Mego)

Isso é código-golfe , então a resposta mais curta em bytes vence.

Oitava, 34 30 bytes

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

Agora leva a fração como uma expressão numérica em vez de numerador e denominador separados.

Amostra em ideone

Mathematica, 16 bytes

Range@##⋃{#2}&

Uma função sem nome que pega dois números inteiros e um número racional e retorna uma lista de números, por exemplo:

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

O Mathematica Rangefaz exatamente o que o desafio pede, exceto que omite o limite superior se a diferença entre o limite inferior e o superior não for exatamente um múltiplo do tamanho da etapa. Portanto, pegamos o Union(usando ⋃) com a lista que contém apenas o limite superior, o que garante que ele apareça exatamente uma vez. Observe que Unionclassificará o resultado, mas queremos que seja classificado de qualquer maneira, pois o tamanho da etapa é sempre positivo. Além disso, como estamos trabalhando com argumentos, eles são automaticamente reduzidos o máximo possível.

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

Observe que este é um liner - o sql não possui função de compilação para reduzir a fração. Pode não ser o melhor idioma para esse tipo de pergunta. É legível por humanos (mais ou menos - em comparação com alguns dos outros 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

Experimente online

Python 2, 81 bytes

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

Experimente online

Haskell, 31 26 bytes

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

Avaliação preguiçosa FTW! Demo:

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

(Fui inicialmente tentado pela [a,a+c..b]notação de Haskell , mas ela tem algumas peculiaridades que exigem algo como f a b c|l<-[a,a+c..b-c/2]=l++[b|last l<b]41 bytes ou f a b c=[x|x<-[a,a+c..],x<b]++[b]33.)

MATL , 16 15 bytes

3$:3Gvu9X10ZGZD

Isso pode falhar para denominadores muito grandes. Espero que o formato de saída seja aceitável.

Experimente online!

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}

Essa solução é baseada na resposta Python do Mego e assume que csempre será um Rationalformato de fração de Ruby. Experimente online!

Editar: Corrigido um erro em que números inteiros não eram apresentados como números inteiros. -6 bytes graças a Not That Charles e MegaTom.

As funções são chamadas desta maneira:

> 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

Isso é semelhante à resposta do Mathematica, exceto que os intervalos de Julia já estão no formato desejado, portanto é ainda mais curto. Também retorna uma coleção de números. Exemplo de saída:

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

Observe que os números inteiros são exibidos com 1 no denominador e uma barra dupla é usada para frações. Para obter a saída exatamente como definido na pergunta, é necessário mais código:

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

Matlab com caixa de ferramentas simbólica / oitava com SymPy, 27 bytes

Obrigado a @sanchises por apontar um erro, agora corrigido

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

Esta é uma função anônima. Para chamá-lo, atribua a uma variável ou use ans.

Exemplo:

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

Uma função anônima. Após a atribuição a uma variável nomeada com espaço em branco:

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
}

Exemplos de teste:

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 

Uma abordagem imperativa usando javascript, sem recursão, biblioteca ou programação funcional.

Smalltalk - 89 bytes

Pela primeira vez, o Smalltalk é quase competitivo!

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

Ligue assim:

> 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

Supõe que você já instalou o MASSpacote

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 no início (b), final (e), numerador (n) e denominador (d). Cria um intervalo de números inteiros, divide-os e anexa o final da lista (vinculando e classificando).