Kesirler arasında

Meydan okuma:

En az 3 giriş alan kod oluşturmanız gerekir; 2 tamsayı ve "kesir temsili" - hangi tip kesir artışlarını temsil etmek için dilinize uyuyorsa). Dizeyi seçerseniz giriş "1/4" olur veya 2 ekstra tamsayı girişi veya bir tuple veya w / e seçebilirsiniz.

Girdi makul herhangi bir yerde olabilir (STDIN, işlev bağımsız değişkenleri, bir dosyadan vb.) Ve böylece çıktı alabilir (STDOUT, işlev döndürme değeri, bir dosyaya vb.)

Kurallar:

1. "Kesir" girişi her zaman geçerli bir kesir, 1'den az olacaktır; örnek "1/4"
2. İkinci giriş tamsayısının her zaman ilk tamsayıdan daha yüksek bir değeri olacaktır. IE ilk giriş tamsayı her zaman ikinciden daha düşük bir değere sahip olacaktır.
3. Giriş tam sayıları negatif olabilir.
4. Çıkarılan fraksiyonlar mümkün olduğunca azaltılmalıdır (basitleştirilmiş)

Kodun, 2 sayı arasındaki her "kesir basamağı" nı, girdi kesirinin artışları olarak vermesi gerekecektir.

Kod, burada belirtildiği gibi bir program veya işlev olmalıdır

Örnek 1:

Giriş: -2,3,"1/2"

Çıktı:

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

Örnek 2:

Giriş: 1,2,"2/3"

Çıktı:

1
5/3
2

veya

1
4/3
2

Not: Sayma her iki yönden de başlayabilir (teşekkür ederim @Mego)

Bu kod golf , bu yüzden bayttaki en kısa cevap kazanır.

Oktav, 34 30 bayt

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

Şimdi kesiri, ayrı bir pay ve payda yerine sayısal bir ifade olarak alır.

İdeone hakkında örnek

Mathematica, 16 bayt

Range@##⋃{#2}&

İki tamsayı ve rasyonel bir sayı alan ve bir sayı listesi döndüren adsız bir işlev, örneğin:

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

Mathematica's Rangezorluğun sorduğunu tam olarak yapar, ancak alt ve üst sınır arasındaki fark adım büyüklüğünün katı değilse üst sınırı atlar. Bu nedenle Union(kullanarak ⋃) sadece üst sınırı içeren listeyi alırız, bu da tam olarak bir kez görünmesini sağlar. Sonucu Unionsıralayacağına dikkat edin, ancak adım boyutu her zaman pozitif olduğundan, yine de sıralanmasını istiyoruz. Ayrıca rasyonellerle çalıştığımız için, otomatik olarak mümkün olduğunca azaltılır.

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

Lütfen bunun tek bir astar olduğunu unutmayın - sql kesiri azaltmak için fonksiyona sahip değildir. Bu tür bir soru için en iyi dil olmayabilir. İnsan tarafından okunabilir (diğer dillerden bazılarına kıyasla).

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

Çevrimiçi deneyin

Python 2, 81 bayt

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

Çevrimiçi deneyin

Haskell, 31 26 bayt

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

Tembel değerlendirme 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]

(Başlangıçta Haskell'in [a,a+c..b]gösterimi beni cezbediyordu, ancak f a b c|l<-[a,a+c..b-c/2]=l++[b|last l<b]41 bayt veya f a b c=[x|x<-[a,a+c..],x<b]++[b]33 gibi bir şey gerektiren bazı tuhaflıklar var. )

MATL , 16 15 bayt

3$:3Gvu9X10ZGZD

Bu çok büyük paydalar için başarısız olabilir. Umarım çıktı formatı kabul edilebilir.

Çevrimiçi deneyin!

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

Yakut , 32 54 48 bayt

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

Bu çözüm Mego'nun Python cevabına dayanmaktadır ve cher zaman RationalRuby'nin kesir formatı olacağını varsayar . Çevrimiçi deneyin!

Düzenleme: Tamsayıların tamsayılar gibi sunulmadığı bir hata düzeltildi. Not That Charles ve MegaTom sayesinde -6 bayt.

Fonksiyonlar bu şekilde çağrılır:

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

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

Bu Mathematica cevabına benzer, ancak Julia'nın aralıkları zaten istenen formattadır, bu yüzden daha da kısadır. Ayrıca bir sayı koleksiyonu döndürür. Örnek çıktı:

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

Tamsayıların paydada 1 ile görüntülendiğini ve kesirler için çift eğik çizgi kullanıldığını unutmayın. Çıktıyı tam olarak soruda tanımlandığı gibi almak için biraz daha kod gerekir:

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

Sembolik Araç Kutulu Matlab / SymPy'li Oktav, 27 bayt

@Sanchises bir hatayı işaret ettiği için teşekkürler, şimdi düzeltildi

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

Bu anonim bir işlevdir. Bunu çağırmak için bir değişkene atayın veya kullanın ans.

Misal:

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

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

Anonim bir işlev. Beyaz boşluklu adlandırılmış bir değişkene atandıktan sonra:

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
}

Test örnekleri:

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 

Javascript, özyineleme yok, kütüphane veya fonksiyonel programlama kullanarak zorunlu bir yaklaşım.

Smalltalk - 89 bayt

Bir kere Smalltalk neredeyse rekabetçi!

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

Bu şekilde arayın:

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

MASSPaketi zaten yüklediğinizi varsayar

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

Piret, 56 bayt

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

(B), son (e), pay (n) ve paydayı (d) alır. Bir dizi tamsayı oluşturur, bunları böler ve sonuna listeyi ekler (bağlayıp sıralayarak).