Aufgabe:

Ihr Programm erhält einen korrekten , positiven einfachen Bruch im Format <numerator>/<denominator>.

Für diese Eingabe müssen zwei Brüche gefunden werden.

1. Ein Bruchteil, der kleiner als die Eingabe ist.
2. Ein Bruchteil, der größer als die Eingabe ist.

Beide Brüche müssen einen niedrigeren Nenner als die Eingabe haben. Von allen möglichen Brüchen sollten sie den geringsten Unterschied zur Eingabe aufweisen.

Ausgabe:

Die Ausgabe Ihres Programms muss sein:

• Ein Bruch, der im Format kleiner als die Eingabe ist <numerator>/<denominator> .
• Gefolgt von einem Leerzeichen (ASCII-Code 32).
• Gefolgt von einem Bruch, der größer als die Eingabe ist, im Format <numerator>/<denominator>.

Wie folgt:

«fraction that is < input» «fraction that is > input»

Regeln:

• Alle ausgegebenen Brüche müssen in niedrigsten Ausdrücken angegeben werden .
• Alle ausgegebenen Brüche müssen richtige Brüche sein.
• Wenn keine korrekten Brüche möglich sind, die nach den Regeln zulässig sind, müssen Sie 0anstelle eines Bruches <input und ausgeben1 > anstelle eines Bruchs> eine Eingabe vornehmen.
• Sie können wählen, ob Sie den Bruch als Befehlszeilenargument erhalten möchten (z. B. yourprogram.exe 2/5 ) oder zur Eingabe durch den Benutzer .
• Sie können davon ausgehen, dass Ihr Programm keine ungültigen Eingaben erhält.
• Der kürzeste Code (in Bytes, in jeder Sprache) gewinnt.

• Alle nicht standardmäßigen Befehlszeilenargumente (Argumente, die normalerweise nicht zum Ausführen eines Skripts erforderlich sind) werden auf die Gesamtzahl der Zeichen angerechnet.

• Was Ihr Programm nicht tun darf :

  • Abhängig von externen Ressourcen.
  • Hängen Sie davon ab, einen bestimmten Dateinamen zu haben.
  • Geben Sie etwas anderes als die erforderliche Ausgabe aus.
  • Es dauert außergewöhnlich lange zu laufen. Wenn Ihr Programm für Brüche mit einem 6-stelligen Zähler und Nenner länger als eine Minute läuft (z. B.179565/987657 ) auf dem Computer eines durchschnittlichen Heimanwenders ausgeführt wird, ist es ungültig.
  • Ausgabefraktionen mit 0als Nenner. Sie können nicht durch Null teilen.
  • Brüche mit 0als Zähler ausgeben. Ihr Programm muss 0anstelle eines Bruchs ausgegeben werden.
  • Reduzieren Sie einen eingegebenen Bruch. Wenn der als Eingabe angegebene Bruch reduzierbar ist, müssen Sie den als Eingabe angegebenen Bruch verwenden.
• Ihr Programm darf nicht in einer Programmiersprache geschrieben sein, für die es vor Veröffentlichung dieser Herausforderung keinen öffentlich verfügbaren Compiler / Interpreter gab.

Beispiele:

Eingabe: 2/5
Ausgabe: 1/3 1/2

Eingabe: 1/2
Ausgabe: 0 1

Eingabe: 5/9
Ausgabe: 1/2 4/7

Eingabe: 1/3
Ausgabe: 0 1/2

Eingabe: 2/4
Ausgabe: 1/3 2/3

Eingabe: 179565/987657
Ausgabe: 170496/937775 128779/708320

Salbei - 119 117

x,X=map(int,raw_input().split('/'))
a=0
A=c=C=1
while C<X:exec("ab,,AB"[c*X>C*x::2]+"=c,C");c=a+b;C=A+B
print a/A,b/B

Salbei wird nur in der letzten Zeile benötigt, die sich um die Ausgabe kümmert. Alles andere funktioniert auch in Python.

Ersetzen Sie raw_input()durch sys.argv[1], um die Eingabe von einem Befehlszeilenargument anstelle einer Eingabeaufforderung lesen zu lassen. Die Zeichenanzahl wird dadurch nicht geändert. (Funktioniert nicht in Python, ohne sysvorher importiert zu haben .)

Dies konstruiert im wesentlichen rekursiv das jeweilige Farey-Sequenz Verwendung von Medianten der vorhandenen Elemente, beschränkt sich jedoch auf diejenigen Elemente, die der Eingabe am nächsten liegen. Aus einer anderen Sicht führt es eine Suche nach verschachtelten Intervallen für die jeweiligen Farey-Sequenzen durch.

Auf meinem Computer werden alle Beispiele in weniger als einer Sekunde korrekt verarbeitet.

Hier ist eine ungolfed Version:

x,X = map(Integer,sys.argv[1].split('/'))
x = x/X
a = 0
c = b = 1
while c.denominator() < X:
    if c > x:
        b = c
    else:
        a = c
    c = ( a.numerator() + b.numerator() ) / ( a.denominator() + b.denominator() )
print a,b

Python 2.7 - 138

x,y=n,d=map(int,raw_input().split('/'))
while y:x,y=y,x%y
def f(p,a=d):
 while(a*n+p)%d:a-=1
 print`(a*n+p)/d`+('/'+`a`)*(a>1),
f(-x);f(x)

Ich habe mit der offensichtlichen Brute-Force-Lösung begonnen, aber mir wurde klar, dass ich, da das OP Instanzen mit sechsstelligen Zählern und Nennern in weniger als einer Minute lösen wollte, eine bessere Lösung brauche, als Billionen von Möglichkeiten auszuprobieren. Ich habe auf der Wikipedia-Seite eine nützliche Formel für die Farey-Sequenz gefunden: Wenn a / b, c / d Nachbarn in einer der Farey-Sequenzen sind, mita/b<c/d , dannb*c-a*b=1 . Die while-Schleife in f in meinem Programm erweitert diese Tatsache auf nicht reduzierte Zahlen, wobei die gcd verwendet wird, die die andere while-Schleife berechnet.

Ich habe das schon ziemlich hart gespielt, aber ich würde gerne Vorschläge hören.

Bearbeitungen:

166-> 162: Entfernt aund baus dem äußeren Programm. Sie waren unnötig.
162-> 155: str()-> ``
155-> 154: Hinzugefügt k.
154-> 152: Wurde xaus der Funktion entfernt und stattdessen als Argument übergeben.
152-> 150: Hat aeinen Standardwert angegeben, anstatt ihn als Argument zu übergeben.
150-> 146: Die Initialisierung von xund wurde geändert y.
146-> 145: entfernt k.
145-> 144: Geändert ... und ... oder ... zu (..., ...) [...], wodurch Platz gespart wird.
144-> 138: Geändert (..., ...) [...] zu ... + ... * (...). Vielen Dank an @ mbomb007.

Testfälle:

2/5
1/3 1/2

1/2
0 1

2/4
1/3 2/3

179565/987657
170496/937775 128779/708320

12345678/87654321
12174209/86436891 11145405/79132382

Der vorletzte Test dauerte auf meinem Computer weniger als eine Sekunde, während der letzte etwa 5-10 Sekunden dauerte.

Mathematica, 163 Bytes

{a,b}=FromDigits/@InputString[]~StringSplit~"/";r=Range[b-1];""<>Riffle[#~ToString~InputForm&/@(#@DeleteCases[#2[a/b*r]/r,a/b]&@@@{{Max,Floor},{Min,Ceiling}})," "]

Dies wird durch die Eingabe- / Ausgabeanforderung als Benutzereingabe und Zeichenfolgen stark eingeschränkt. Der Umgang mit Streichern ist in Mathematica sehr umständlich (zumindest, wenn Sie Golf spielen möchten). Wenn ich das in Mathematica auf natürliche Weise mache (nur mit ganzen Zahlen und Rationen), würde ich das wahrscheinlich auf 50% der Größe reduzieren.

Es kann 6-stellige Zahlen in ein paar Sekunden auf meinem Computer machen.

Etwas besser lesbar (allerdings nicht wirklich ungolfed):

{a, b} = FromDigits /@ InputString[]~StringSplit~"/";
r = Range[b - 1];
"" <> Riffle[#~ToString~
     InputForm & /@ (#[DeleteCases[#2[a/b*r]/r, a/b]] & @@@ {{Max, 
       Floor}, {Min, Ceiling}}), " "]

Zum Spaß, wenn man dies "auf natürliche Weise" macht, dh als Funktion, die Zähler und Nenner nimmt und zwei Rationen zurückgibt, sind dies nur 84 Zeichen (meine 50% -Schätzung war also eigentlich ziemlich nahe):

f[a_,b_]:=#@DeleteCases[#2[a/b*(r=Range[b-1])]/r,a/b]&@@@{{Max,Floor},{Min,Ceiling}}

Julia - 127 125 Bytes

Ich habe dies aus mathematischer Sicht angegangen, um die Notwendigkeit von Schleifen zu vermeiden, sodass dieser Code für große Eingaben recht schnell ausgeführt wird (Hinweis: Wenn a / b die Eingabe ist, muss a * b in Int64 passen (Int32 auf 32-Bit-Systemen). , andernfalls werden unsinnige Antworten generiert - wenn a und b in Int32 (Int16 auf 32-Bit-Systemen) beide ausgedrückt werden können, treten keine Probleme auf.

UPDATE: Es besteht keine Notwendigkeit mehr, einen Backslash für div zu überladen, indem ÷ verwendet wird, was 2 Bytes einspart.

a,b=int(split(readline(),"/"));k=gcd(a,b);f=b-invmod(a÷k,b÷k);d=2b-f-b÷k;print(a*d÷b,d<2?" ":"/$d ",a*f÷b+1,"/$f"^(f>1))

Ungolfed:

a,b=int(split(readline(),"/")) # Read in STDIN in form a/b, convert to int
k=gcd(a,b)           # Get the greatest common denominator
f=b-invmod(a÷k,b÷k)  # Calculate the denominator of the next biggest fraction
d=2b-f-b÷k           # Calculate the denominator of the next smallest fraction
print(a*d÷b,d<2?" ":"/$d ",a*f÷b+1,"/$f"^(f>1)) # Calculate numerators and print

Grundidee: Finde das größte d und f kleiner als b, das ad-bc = gcd (a, b) (das nächstkleinere) und be-af = gcd (a, b) (das nächstgrößere) erfüllt, und berechne dann c und e aus Dort. Die resultierende Ausgabe ist c / de / f, es sei denn, d oder f sind 1. In diesem Fall wird / d oder / f weggelassen.

Interessanterweise bedeutet dies, dass der Code auch für positive nicht ordnungsgemäße Brüche funktioniert, solange die Eingabe keine ganze Zahl ist (d. H. Gcd (a, b) = a).

Auf meinem System nimmt die Eingabe 194857602/34512958303keine wahrnehmbare Zeit in Anspruch171085289/30302433084 23772313/4210525219

JavaScript, 131

Mit fetter Pfeilnotation und evalAufrufen:

m=>{for(e=eval,n=e(m),i=p=0,q=1;++i</\d+$/.exec(m);)if(n*i>(f=n*i|0))g=f+1,p=f/i>e(p)?f+'/'+i:p,q=g/i<e(q)?g+'/'+i:q;return p+' '+q}

Der 179565/987657Stresstest dauert ca. 35 Sekunden Firefox , unter Chrome noch viel mehr (~ 6 Minuten)

Schnellere Methode und ohne evalund fette Pfeilnotation

for(n=eval(m=prompt(a=i=p=0,b=c=d=q=1));++i<m.match(/\d+$/);)if(n*i>(f=n*i|0))g=f+1,p=f*c>i*a?(a=f)+'/'+(c=i):p,q=g*d<i*b?(b=g)+'/'+(d=i):q;alert(p+' '+q)

Der 179565/987657Stresstest dauert ca. 5 Sekunden.

Nicht golfen:

m=prompt(); //get input
a=0; c=1; //first fraction
b=1; d=1; //second fraction
n=eval(m); //evaluate input
for (i=1; i<m.match(/\d+$/); i++) { //loop from 1 to input denominator
  f=Math.floor(n*i);
  if (n*i > f) { //if fraction not equal to simplification of input
    g=f+1; // f/i and g/i are fractions closer to input
    if (f/i>a/c) a=f, c=i;
    if (g/i<b/d) b=g; d=i; 
  }
}
alert(a+'/'+c+' '+b+'/'+d); //output values handling 0 and 1 correctly

Perl, 142 Bytes (155 ohne CPAN)

use bare A..Z;$/="/";N=<>;D=<>;F=N/D;K=G=1;for$H(1..D){J<F&&J>E?(E,I):J>F&&J<G?(G,K):()=(J=$_/H,"$_/$H")for(Z=int F*H)..Z+1}print I||0," $K\n"

Oder wenn CPAN-Module nicht erlaubt sind / 3-4 mal schnellerer Code benötigt wird:

$/="/";$N=<>;$D=<>;$F=$N/$D;$g=$G=1;for$d(1..$D){$f<$F&&$f>$E?($E,$e):$f>$F&&$f<$G?($G,$g):()=($f=$_/$d,"$_/$d")for($z=int$F*$d)..$z+1}print$e||0," $g\n"

Die erste Version dauert auf meinem Computer 9,55 Sekunden, die zweite Version 2,44 Sekunden.

Weniger unleserlich:

($N, $D) = split(m[/], <>);
$F = $N / $D;
$G = 1;
foreach $d (1 .. $D) {
    $z = int $F * $d;
    foreach $_ ($z .. $z + 1) {
        $f = $_ / $d;
        ($f < $F && $f > $E ? ($E, $e) :
        ($f > $F && $f < $G ? ($G, $g) : ())) = ($f, "$_/$d");
    }
}
print $e || 0, ' ', $g || 1, "\n";