Zwischenfraktionen

Die Herausforderung:

Sie müssen Code erstellen, der mindestens 3 Eingaben akzeptiert. 2 Ganzzahlen und "eine Bruchdarstellung" - welcher Typ auch immer für Ihre Sprache zur Darstellung der Bruchinkremente geeignet ist. Wenn Sie eine Zeichenfolge auswählen, ist die Eingabe "1/4", oder Sie können 2 zusätzliche Ganzzahleingaben oder ein Tupel oder w / e auswählen.

Die Eingabe kann überall sinnvoll sein (STDIN, Funktionsargumente, aus einer Datei usw.) und kann daher ausgegeben werden (STDOUT, Funktionsrückgabewert, in eine Datei usw.).

Regeln:

1. Der eingegebene "Bruch" ist immer ein gültiger Bruch, kleiner als 1; Beispiel "1/4"
2. Die zweite Ganzzahl hat immer einen höheren Wert als die erste Ganzzahl. IE die erste Ganzzahl hat immer einen niedrigeren Wert als die zweite.
3. Die Eingabe-Ganzzahlen können negativ sein.
4. Ausgegebene Brüche sollten so weit wie möglich reduziert werden (vereinfacht)

Der Code muss jeden "Bruchschritt" zwischen den beiden Zahlen in Schritten des eingegebenen Bruches ausgeben.

Der Code sollte ein Programm oder eine Funktion sein, wie hier angegeben

Beispiel 1:

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

Ausgabe:

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

Beispiel 2:

Eingang: 1,2,"2/3"

Ausgabe:

1
5/3
2

oder

1
4/3
2

Hinweis: Die Zählung kann aus beiden Richtungen erfolgen (danke @Mego)

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Oktave, 34-30 Bytes

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

Nimmt nun den Bruch als numerischen Ausdruck und nicht als getrennten Zähler und Nenner.

Probe auf Ideone

Mathematica, 16 Bytes

Range@##⋃{#2}&

Eine unbenannte Funktion, die zwei Ganzzahlen und eine rationale Zahl verwendet und eine Liste von Zahlen zurückgibt, z.

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

Mathematics Rangemacht genau das, was die Herausforderung verlangt, außer dass die Obergrenze weggelassen wird, wenn der Unterschied zwischen Unter- und Obergrenze nicht genau ein Vielfaches der Schrittgröße ist. Deshalb nehmen wir die Union(using ⋃) mit der Liste, die nur die obere Schranke enthält, was sicherstellt, dass sie genau einmal vorkommt. Beachten Sie, dass Uniondas Ergebnis sortiert wird, aber wir möchten, dass es trotzdem sortiert wird, da die Schrittgröße immer positiv ist. Da wir auch mit Rationalen arbeiten, werden diese automatisch so weit wie möglich reduziert.

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

Bitte beachten Sie, dass dies ein Einzeiler ist - SQL hat keine eingebaute Funktion, um den Anteil zu reduzieren. Ist möglicherweise nicht die beste Sprache für diese Art von Fragen. Es ist vom Menschen lesbar (im Vergleich zu einigen anderen Sprachen).

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

Probieren Sie es online aus

Python 2, 81 Bytes

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

Probieren Sie es online aus

Haskell, 31 26 Bytes

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

Faule Bewertung 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]

(Ich war anfangs von Haskells [a,a+c..b]Notation versucht , aber es hat einige Macken, die so etwas wie f a b c|l<-[a,a+c..b-c/2]=l++[b|last l<b]für 41 Bytes oder f a b c=[x|x<-[a,a+c..],x<b]++[b]für 33 erfordern .)

MATL , 16 15 Bytes

3$:3Gvu9X10ZGZD

Dies kann bei sehr großen Nennern fehlschlagen. Ich hoffe das Ausgabeformat ist akzeptabel.

Probieren Sie es 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}

Diese Lösung basiert auf Megos Python-Antwort und geht davon aus, dass dies cimmer eine sein wirdRational Ruby-Bruchformat handelt. Probieren Sie es online!

Bearbeiten: ein Fehler behoben, durch den Ganzzahlen nicht wie Ganzzahlen dargestellt wurden. -6 Bytes dank Not That Charles und MegaTom.

Die Funktionen werden folgendermaßen aufgerufen:

> 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

Dies ähnelt der Mathematica-Antwort, außer dass Julias Bereiche bereits im gewünschten Format vorliegen und daher noch kürzer sind. Gibt auch eine Sammlung von Zahlen zurück. Beispielausgabe:

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

Beachten Sie, dass die Ganzzahlen im Nenner mit 1 angezeigt werden und für Brüche ein doppelter Schrägstrich verwendet wird. Um die Ausgabe genau wie in der Frage definiert zu erhalten, ist etwas mehr Code erforderlich:

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

Matlab mit Symbolic Toolbox / Octave mit SymPy, 27 Bytes

Vielen Dank an @sanchises für den Hinweis auf einen Fehler, der jetzt behoben wurde

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

Dies ist eine anonyme Funktion. Um es aufzurufen, weisen Sie es einer Variablen zu oder verwenden Sieans .

Beispiel:

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

Eine anonyme Funktion. Nach der Zuweisung zu einer benannten Variablen mit Leerzeichen:

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
}

Testbeispiele:

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 

Ein zwingender Ansatz, der Javascript, keine Rekursion, Bibliothek oder funktionale Programmierung verwendet.

Smalltalk - 89 Bytes

Ausnahmsweise ist Smalltalk fast konkurrenzfähig!

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

Rufen Sie wie folgt an:

> 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

Angenommen, Sie haben das MASSPaket bereits installiert

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

Nimmt Anfang (b), Ende (e), Zähler (n) und Nenner (d) auf. Erstellt einen Bereich von Ganzzahlen, teilt diese durch und hängt das Ende an die Liste an (durch Verknüpfen und anschließendes Sortieren).