Tra le frazioni

La sfida:

Dovrai creare un codice che impieghi almeno 3 input; 2 numeri interi e "una rappresentazione della frazione" - qualunque sia il tipo adatto alla tua lingua per rappresentare gli incrementi della frazione). Se scegli la stringa, l'input sarà "1/4" o potresti scegliere 2 ingressi interi extra o una tupla o w / e.

L'input può essere ovunque ragionevole (STDIN, argomenti di funzione, da un file, ecc.), Così come l'output (STDOUT, valore di ritorno della funzione, in un file, ecc.)

Regole:

1. La "frazione" di input sarà sempre una frazione valida, inferiore a 1; esempio "1/4"
2. Il secondo numero intero di input avrà sempre un valore superiore rispetto al primo numero intero. Vale a dire il primo numero intero di input avrà sempre un valore inferiore rispetto al secondo.
3. Gli interi di input possono essere negativi.
4. Le frazioni emesse dovrebbero essere ridotte il più possibile (semplificato)

Il codice dovrà generare ogni "passaggio di frazione" tra i 2 numeri con incrementi della frazione di input.

Il codice dovrebbe essere un programma o una funzione come indicato qui

Esempio 1:

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

Produzione:

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

Esempio 2:

Ingresso: 1,2,"2/3"

Produzione:

1
5/3
2

o

1
4/3
2

Nota: il conteggio può iniziare da entrambe le direzioni (grazie @Mego)

Questo è code-golf , quindi vince la risposta più breve in byte.

Ottava, 34 30 byte

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

Ora prende la frazione come espressione numerica anziché come numeratore e denominatore separati.

Campione su ideone

Mathematica, 16 byte

Range@##⋃{#2}&

Una funzione senza nome che accetta due numeri interi e un numero razionale e restituisce un elenco di numeri, ad esempio:

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

Mathematica Rangefa esattamente quello che chiede la sfida, tranne per il fatto che omette il limite superiore se la differenza tra limite inferiore e superiore non è esattamente un multiplo della dimensione del gradino. Quindi prendiamo il Union(usando ⋃) con la lista contenente solo il limite superiore che assicura che appaia esattamente una volta. Si noti che Unionordinerà il risultato ma lo vogliamo ordinato comunque, poiché la dimensione del passo è sempre positiva. Inoltre, dal momento che stiamo lavorando con razionali, vengono automaticamente ridotti il ​​più possibile.

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

Si prega di notare che si tratta di una riga: sql non ha una funzione integrata per ridurre la frazione. Potrebbe non essere la lingua migliore per questo tipo di domanda. È leggibile dall'uomo (tipo di - rispetto ad alcune delle altre lingue).

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

Provalo online

Python 2, 81 byte

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

Provalo online

Haskell, 31 26 byte

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

Valutazione pigra 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]

(Inizialmente sono stato tentato dalla [a,a+c..b]notazione di Haskell , ma ha alcune stranezze che richiedono qualcosa di simile f a b c|l<-[a,a+c..b-c/2]=l++[b|last l<b]per 41 byte o f a b c=[x|x<-[a,a+c..],x<b]++[b]per 33.)

MATL , 16 15 byte

3$:3Gvu9X10ZGZD

Questo potrebbe non riuscire per denominatori molto grandi. Spero che il formato di output sia accettabile.

Provalo 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

Rubino , 32 54 48 byte

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

Questa soluzione si basa sulla risposta Python di Mego e presuppone che csarà sempre un Rationalformato di frazione di Ruby. Provalo online!

Modifica: risolto un bug in cui gli interi non venivano presentati come interi. -6 byte grazie a Not That Charles e MegaTom.

Le funzioni vengono chiamate in questo modo:

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

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

Questo è simile alla risposta di Mathematica, tranne per il fatto che le gamme di Julia sono già nel formato desiderato, quindi è ancora più breve. Restituisce anche una raccolta di numeri. Esempio di output:

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

Si noti che gli interi vengono visualizzati con 1 nel denominatore e per le frazioni viene utilizzata una doppia barra. Per ottenere l'output esattamente come definito nella domanda richiede altro codice:

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

Matlab con Symbolic Toolbox / Octave con SymPy, 27 byte

Grazie a @sanchises per aver segnalato un errore, ora corretto

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

Questa è una funzione anonima. Per chiamarlo, assegnarlo a una variabile o utilizzare ans.

Esempio:

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

(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 funzione anonima. Dopo l'assegnazione a una variabile denominata con spazi bianchi:

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
}

Esempi di test:

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 approccio imperativo che utilizza javascript, nessuna ricorsione, libreria o programmazione funzionale.

Smalltalk - 89 byte

Per una volta Smalltalk è quasi competitivo!

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

Chiama in questo modo:

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

Presuppone che tu abbia già installato il MASSpacchetto

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 byte

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

Comprende inizio (b), fine (e), numeratore (n) e denominatore (d). Crea un intervallo di numeri interi, li divide e li aggiunge alla fine (collegando e quindi ordinando).