Quando si converte una frazione in un numero decimale e si desidera memorizzare quel numero, spesso è necessario arrotondarlo perché si desidera utilizzare solo una determinata quantità di memoria. Supponiamo che sia possibile memorizzare solo 5 cifre decimali, quindi 5/3 diventano 1.6667. Se riesci a memorizzare solo 2 cifre decimali, sarà 1,7 (ora supponendo che sia sempre compreso tra 0 e 9.99 ...).

Se ora provi a invertire quel processo con 1.7 e vuoi recuperare la tua frazione, questo può essere difficile, poiché sai che 1.7 è solo un numero arrotondato. Ovviamente puoi provare il 17/10 ma questa è piuttosto una frazione "brutta" rispetto all'elegante 5/3.

Quindi l'obiettivo è ora trovare la frazione a / b con il minimo denominatore b, che si traduce nel numero decimale arrotondato quando arrotondato correttamente.

Dettagli

L'input contiene una stringa con un numero da 1 a 5 cifre compreso tra 0 (incluso) e 10 (escluso) con un '.' dopo la prima cifra. Diciamo che nindica il numero di cifre. L'output deve essere un elenco / matrice di due numeri interi [numerator, denominator]o un tipo di dati razionale (è possibile crearne uno proprio o utilizzare incorporato) in cui il numeratore non è negativo e il denominatore è positivo. Il numeratore / denominatore della frazione deve essere uguale all'input se arrotondato correttamente alle ncifre (il che significa n-1cifre dopo il punto decimale).

Limitazione: è consentita solo un'istruzione loop. Ciò significa che è possibile utilizzare solo una singola istruzione di ciclo (come foro whileo gotoecc. Nonché cicli funzionali come mapo foldche applicano codice a ogni elemento di un elenco / array) nell'intero codice, ma si è liberi di "abusarne" o usa la ricorsione ecc.

Dovresti scrivere una funzione. Se la tua lingua non ha funzioni (o anche se lo è), puoi in alternativa supporre che l'input sia memorizzato in una variabile (o input tramite stdin) e stampare il risultato o scriverlo in un file. Vince il numero più basso di byte.

Arrotondamento

L'arrotondamento dovrebbe seguire le regole di arrotondamento "convenzionali", ovvero se l'ultima cifra che verrà tagliata è 5 o maggiore, arrotonderai per eccesso e arrotonderai per tutti gli altri casi, ad esempio:

4.5494 risulterà quando si arrotondano a

• 1 cifra: 5
• 2 cifre: 4.5
• 3 cifre: 4,55
• 4 cifre: 4.549

Esempi

Si prega di includere i seguenti casi di test e altri "interessanti":

Input 1.7     Output 5/3
Input 0.      Output 0/1
Input 0.001   Output 1/667
Input 3.1416  Output 355/113

CJam, 41 40 36 byte

Q'./1=,:L0\{;)_Qd*mo_d2$/LmOQd-}g'/@

Suppone che la stringa di input sia memorizzata in Q, che è esplicitamente consentito dalla domanda. Provalo online.

Casi test

$ for d in 1.7 0. 0.001 3.1416; do cjam <(echo "\"$d\":Q;
> Q'./1=,:L0\{;)_Qd*mo_d2$/LmOQd-}g'/@
> "); echo; done
5/3
0/1
1/667
355/113

Come funziona

Q'./1=,:L  " Count the number of characters after the dot and store it in L.     ";
0\         " Push 0 (denominator) and swap it with L (dummy value).              ";
{          "                                                                     ";
  ;        " Discard the topmost item from the stack (numerator or dummy value). ";
  )        " Increment the denominator.                                          ";
  _Qd*mo   " Multiply a copy by Double(Q) and round.                             ";
  _d2$/    " Cast a copy to Double and it divide it by the denominator.          ";
  LmO      " Round to L digits.                                                  ";
  Qd       " If the result is not Double(Q),                                     ";
}g         " repeat the loop.                                                    ";
./@        " Push a slash and rotate the denominator on top of it.               ";

T-SQL 254

Mentre T-SQL non è davvero adatto a questo genere di cose, è divertente da provare. Le prestazioni peggiorano tanto più alto è il denominatore. È limitato a un denominatore di 1000.

L'input è una variabile float @

WITH e AS(SELECT *FROM(VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(0))n(n)),t AS(SELECT ROW_NUMBER()OVER(ORDER BY(SELECT \))N FROM e a,e b,e c,e d)SELECT TOP 1concat(n.n,'/',d.n)FROM t d,t n WHERE round(n.n/(d.n+.0),len(parsename(@,1)))=@ ORDER BY d.n,n.n

Una suddivisione della query

WITH                                      -- Start CTE(Common Table Expression)
 e AS(                                    --Create a set of 10 rows
   SELECT *
   FROM(VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(0))n(n)
 ),
 t AS(                                    
   SELECT ROW_NUMBER()OVER(ORDER BY(SELECT \))N 
   FROM e a,e b,e c,e d                   --Cross join e to produce 1000 numbered rows
 )
SELECT 
  TOP 1                                   --Grab first result
  concat(n.n,'/',d.n)                     --Build output
FROM t d,t n                              --Cross join t against itself for denominator and numerator
WHERE round(
  n.n/(d.n+.0),                           --Force float division with +.0
  len(parsename(@,1))                     --Get rounding length
  )=@                                     --Filter where the rounded result = input
ORDER BY d.n,n.n                          --Order by denominator then numerator

Haskell, 62 59

se solo i nomi non fossero così lunghi ...

import Data.Ratio
f s=approxRational(read s)$50/10^length s

questa è una funzione che restituisce un Rationalvalore.

spiegazione: la funzione approxRationalè una funzione che accetta un numero float e un epsilon float e restituisce il più semplice razionale che si trova a distanza epsilon dell'input. in sostanza, restituisce l'approssimazione più semplice del galleggiante a una distanza razionale in un "errore perdonabile".

sfruttiamo questa funzione per il nostro uso. per questo dovremo capire qual è l'area dei galleggianti che arrotondano per eccesso al numero dato. quindi ottenere questo nella approxRationalfunzione ci darà la risposta.

proviamo 1.7, per esempio. il galleggiante più basso che arriva a 1,7 è 1,65. qualsiasi inferiore non arrotonderà a 1.7. allo stesso modo, il limite superiore dei galleggianti che arrotondano a 1,7 è 1,75.
entrambi i limiti sono i limiti sono il numero di ingresso +/- 0,05. si può facilmente dimostrare che questa distanza è sempre 5 * 10 ^ -(the length of the input - 1)(-1 è perché c'è sempre un '.' nell'input). da qui il codice è abbastanza semplice.

casi test:

*Main> map f ["1.7", "0.001", "3.1416"]
[5 % 3,1 % 667,355 % 113]

purtroppo non funziona su "0." perché la funzione parser di Haskell non riconosce .a alla fine di un float. questo può essere risolto per 5 byte sostituendo read scon read$s++"0".

Rubino, 127 125 byte

f=->n{b=q=r=(m=n.sub(?.,'').to_r)/d=10**p=n.count('0-9')-1
b=r if(r=(q*d-=1).round.to_r/d).round(p).to_f.to_s==n while d>1
b}

Definisce una funzione fche restituisce il risultato come a Rational. Ad esempio se aggiungi questo codice

p f["1.7"]
p f["0."]
p f["0.001"]
p f["3.1416"]

Hai capito

(5/3)
(0/1)
(1/667)
(355/113)

Il ciclo supera i denominatori. Sto iniziando con la frazione completa, ad esempio 31416/10000per l'ultimo esempio. Quindi sto diminuendo il denominatore, diminuendo proporzionalmente il numeratore (e arrotondandolo). Se il razionale risultante viene arrotondato allo stesso del numero di input, ricordo una nuova frazione migliore.

Mathematica, 49 53 caratteri

Rationalize[ToExpression@#,5 10^(1-StringLength@#)]&@

Uso:

Rationalize[ToExpression@#,5 10^(1-StringLength@#)]&@"1.7"

Produzione:

5/3

Casi test:

input: 1.7     output: 5/3
input: 0.      output: 0
input: 0.001   output: 1/999
input: 3.1416  output: 355/113

Il caso 0.001 mi sembra strano; poiché la funzione di razionalizzazione non funzionava secondo la sua descrizione, quando non trovò il caso 1/667. Dovrebbe generare il numero con il minimo denominatore che rientra nei limiti specificati.

Python 2.7+, 111 caratteri

Prova che puoi scrivere un codice orribile in qualsiasi lingua:

def f(s):
 t,e,y=float(s),50*10**-len(s),1;n=d=x=0
 while x|y:n,d=n+x,d+y;a=1.*n/d;x,y=a<t-e,a>t+e
 return n,d

Produzione

>>> [f(s) for s in ("1.7", "0.", "0.001", "3.1416")]
[(5, 3), (0, 1), (1, 667), (355, 113)]

APL, 50

2↑⍎⍕(⍎x←⍞){50>|(10*⍴x)×⍺-⍵÷⍨n←⌊.5+⍺×⍵:n ⍵⋄''}¨⍳1e5

Finché non conti eval e toStringcome anelli

Spiegazione

L'approccio consiste nell'iterare da 1 a 10000 come denominatore e calcolare il numeratore che corrisponde maggiormente al float, quindi verificare se l'errore rientra nei limiti. Infine, seleziona la coppia più piccola tra tutte le frazioni trovate.

(⍎x←⍞)Prendi l'input di stringa dallo schermo, assegna a xed eval
⍳1e5Genera array da 1 a 10000
{...}¨Per ogni elemento dell'array, chiama la funzione con esso e (⍎x←⍞)e argomenti (loop)

⍺×⍵Moltiplica gli argomenti
⌊.5+Arrotondare (aggiungendo 0,5 quindi arrotondando per difetto)
n←Assegna a n
⍺-⍵÷⍨Dividi per argomento destro, quindi sottrai dall'argomento sinistro
(10*⍴x)×Moltiplica per 10 alla potenza di "lunghezza di x"
|Prendi valore assoluto
50>Controlla se inferiore a 50 (lunghezza di x2 in più rispetto al numero di dp, quindi utilizzare 50 qui anziché 0,5)
:n ⍵⋄''Se il controllo precedente restituisce true, quindi restituisce l'array di ne l'argomento giusto, altrimenti restituisce stringa vuota.

⍎⍕ toStringe quindi evalper ottenere una matrice di tutti i numeri nella matrice
2↑Seleziona solo i primi 2 elementi, ovvero la prima coppia numeratore-denominatore trovata

GNU dc, 72 byte

Nessun loop - DC non li ha nemmeno. Invece il controllo proviene da una singola macro ricorsiva della coda - idiomatica per dc.

?dXAr^d2*sf*sq1sd0[ld1+sd]sD[r1+r]sN[dlf*ld/1+2/dlq>Ndlq<Dlq!=m]dsmxpldp

Produzione:

$ for n in 1.7 0. 0.001 3.1416; do echo "    n = $n:"; dc unround.dc <<< $n; done
    n = 1.7:
5
3
    n = 0.:
0
1
    n = 0.001:
1
667
    n = 3.1416:
355
113
$ 

Uff. Spiegazione parziale in questa risposta .

Mathematica, 111 personaggi

f=Module[{a=0,b=1,k},While[Round[a/b,10^-(StringLength[#]-2)]!=(k=ToExpression)@#,If[N[a/b]>k@#,b++,a++]];a/b]&

Abbastanza semplice davvero, e non credo che converga ovunque veloce come le altre soluzioni, poiché il numeratore e il denominatore aumentano solo di uno. Volevo principalmente trovare la soluzione semplice a questo. Dovrò vedere le altre risposte e vedere quali cose intelligenti succedono lì.

Produzione

f/@{"1.7","0.0","0.001","3.1416","3.14"}
{5/3, 0, 1/667, 355/113, 22/7}

Qualcuno qui celebra il Pi Approximation Day ?

Applescript,> 300 byte

Volevo farlo in una lingua che fa nativamente il tipo di arrotondamento richiesto. Viene fuori che Applescript si adatta al conto. Poi ho visto l'enum rounding as taught in schoole non ho potuto resistere al suo utilizzo, nonostante la palese incompetenza di Applescript ai fini del golf:

on u(q)
    set n to 0
    set d to 1
    set x to 0
    set AppleScript's text item delimiters to "."
    set f to 10 ^ (q's text item 2's length)
    repeat until x = q as real
        set x to (round n * f / d rounding as taught in school) / f
        if x < q then set n to n + 1
        if x > q then set d to d + 1
    end repeat
    return {n, d}
end u

log my u("1.7")
log my u("0.")
log my u("0.001")
log my u("3.1416")

Questo può essere giocato un po 'di più, ma probabilmente non ne vale la pena.

Produzione:

(*5, 3*)
(*0, 1*)
(*1, 667*)
(*355, 113*)

AC, 151 148 byte

Modifica: versione più veloce e più breve

define f(v){s=scale(x=v);for(i=r=1;i<=10^s;i+=1){t=v*i+1/2;scale=0;p=t/=1;scale=s+1;t=t/i+10^-s/2;scale=s;t=t/1-v;if((t*=-1^(t<0))<r){r=t;n=p;d=i}}}

stesso test case.

Molto è simile alla versione precedente, ma invece di provare tutte le possibili combinazioni n / d, ci arrampichiamo in salita sui residui di v e quozienti all'indietro di multipli m == v * d e denominatori d. Ancora una volta la precisione del calcolo è la stessa.

Qui è districato:

define f(v)
{
    s= scale(x=v)
    for( i=r=1; i <= 10^s; i+=1 ){
        t= v * i +1/2
        scale=0
        m=t/=1 # this rounded multiple becomes nominator if
               # backward quotient is first closest to an integer
        scale=s+1
        t= t / i +10^-s/2 # divide multiple back by denominator, start rounding again...
        scale=s
        t= t/1 - v # ...rounding done. Signed residue of backward quotient
        if( (t*= -1^(t < 0)) < r ){
            r=t
            n=m
            d=i
        }
    }
}

Questa versione ha un semplice ciclo singolo e esegue solo $ \ Theta \ left (\ operatorname {fractional_decimals} (v) \ right) $ operazioni aritmetiche.

Originale - versione lenta

Questa funzione calcola il più piccolo nominatore n e denominatore d in modo tale che la frazione n / d arrotondata alle cifre frazionarie_decimali (v) sia uguale a un dato valore decimale v.

define f(v){s=scale(v);j=0;for(i=r=1;j<=v*10^s;){scale=s+1;t=j/i+10^-s/2;scale=s;t=t/1-v;if((t*=-1^(t<0))<r){r=t;n=j;d=i};if((i+=1)>10^s){i=1;j+=1}};v}

caso di prova:

define o(){ print "Input ",x,"\tOutput ",n,"/",d,"\n" }
f(1.7); o()
> 0
> Input 1.7       Output 5/3
> 0
f(0.); o()
> 0
> Input 0 Output 0/1
> 0
f(0.001); o()
> 0
> Input .001      Output 1/667
> 0
f(3.1416); o()
> 0
> Input 3.1416    Output 355/113
> 0

E qui è districato:

define f(v)
{
    s=scale(x=v) # save in global for later print
    j=0
    # do a full sequential hill-climb over the residues r of v and all possible
    # fractions n / d with fractional_decimals(v) == s precision.
    for( i=r=1; j <= v * 10^s; ){
        scale=s+1
        t= j / i +10^-s/2 # start rounding...
        scale=s
        t= t/1 - v # ...rounding done. New residue, but still signed
        if( (t*= -1^(t < 0)) < r ){ # absolute residue better?
            # climb hill
            r=t
            n=j
            d=i
        }
        if( (i+=1) > 10^s ){ # next inner step. End?
            # next outer step
            i=1
            j+=1
        }
    }
    v
}

Lo ammetto, ho tradito un po 'emulando un secondo loop interno all'interno di un singolo loop esterno, ma senza usare ulteriori istruzioni loop. Ed è per questo che in realtà esegue $ \ Theta \ left (v \ operatorname {fractional_decimals} (v) ^ 2 \ right) $ operazioni aritmetiche.

C, 233

Funziona chiamando una funzione di razionalizzazione r () con un denominatore iniziale di 1. La funzione inizia ad incrementare un numeratore e verificando ad ogni incremento se il numero risultante, quando arrotondato allo stesso numero di cifre dell'originale, ha la stessa stringa rappresentazione come originale. Una volta che il numeratore è stato aumentato così tanto che il risultato è maggiore dell'originale, la funzione incrementa il denominatore e chiama se stessa.

Questo ovviamente usa molto più codice, ma penso che lo spirito del problema esoneri questo approccio a ossa nude; per quanto ne sappiamo, le funzioni di razionalizzazione interna () delle lingue moderne hanno molti cicli interni.

Si noti che questo non funziona per un input di "0" perché questo non è un modo standard per scrivere un float, quindi quando riscrive il float su stringa, il risultato non sarà mai uno "0".

Le specifiche vogliono una funzione che restituisca valori invece di limitarsi a stampare sullo schermo, da cui il passaggio degli argomenti.

Codice (non salvato):

void r(char* x, int* a, int* b) {
    int i = -1;
    char z[32];
    double v =atof(x);
    while(1) {
        i++;
        double y = ((double)i)/((double)(*b));
        double w;
        sprintf(z, "%.*f", strlen(strchr(x,'.'))-1, y);
        if(strcmp(x, z)==0) {
            *a = i;
            return;
        }
        w = atof(z);
        if(w > v) {
            (*b)++;
            r(x, a, b);
            return;
        }
    }
}

Uso:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[]) {
    int num;
    int denom = 1; // start with a denominator of 1
    r(argv[1], &num, &denom);
    printf("%d/%d\n", num, denom);
    return 0;
}

Codice golfizzato:

typedef double D;
void r(char*x,int*a,int*b){int i=-1;char z[32];D v=atof(x);while(1){i++;D y=((D)i)/((D)(*b));D w;sprintf(z,"%.*f",strlen(strchr(x,'.'))-1,y);if(!strcmp(x,z)){*a=i;return;}w=atof(z);if(w>v){(*b)++;r(x,a,b);return;}}}

Pure Bash, 92 byte

Come spiegazione parziale per questa risposta , qui è portato a bash:

f=${1#*.}
q=${1//.}
for((n=0,d=1;x-q;x=2*10**${#f}*n/d+1>>1,n+=x<q,d+=x>q));{ :;}
echo $n/$d

In particolare:

• bash ha un'aritmetica di soli numeri interi. Quindi ridimensioniamo in modo appropriato tutto di 2 * 10 ^ (numero di cifre frazionarie).
• giri bash scorrimento al numero intero più vicino; il 2 nell'espressione sopra è quindi possiamo arrotondare al numero intero più vicino ( su o giù ).
• Solo un loop
• controlliamo se il razionale supera o abbassa il decimale e incrementa il denominatore o il numeratore di conseguenza.

Produzione:

$ for n in 1.7 0. 0.001 3.1416; do echo "    n = $n:"; ./unround.sh $n; done
    n = 1.7:
5/3
    n = 0.:
0/1
    n = 0.001:
1/667
    n = 3.1416:
355/113
$ 

JavaScript (E6) 85

F=r=>(l=>{for(n=r,d=1;l&&r!=((n=r*d+1/2|0)/d).toFixed(l);d++);})(r.length-2)||[n|0,d]

Ungolfed

F=r=>{
  l = r.length-2; // decimal digits
  if (l==0) return [r|0, 1] // if no decimal return the same (conv to number) with denominator 1

  // loop for increasing denominator 
  for(d = 2; 
      r != ( // loop until find an equal result
      // given R=N/D ==> N=R*D
      (n=r*d+1/2|0) // find possible numerator, rounding (+0.5 and trunc)
      /d).toFixed(l); // calc result to given decimals
      d++);
  return [n,d]
}

Test nella console FireFox / FireBug

;["1.7","0.","0.001","3.1416","9.9999"].forEach(v => console.log(v,F(v)))

Produzione

1.7 [5, 3]
0. [0, 1]
0.001 [1, 667]
3.1416 [355, 113]
9.9999 [66669, 6667]