# coding: utf-8

import logging
import sys

logger = logging.getLogger('zapisywacz')
ch = logging.StreamHandler(sys.stderr)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter('[%(message)s]')
ch.setFormatter(formatter)
logger.addHandler(ch)
# odkomentuj żeby włączyć logowanie:
#logger.setLevel(logging.DEBUG)

class Ulamek:
    def __init__(self, licznik, mianownik):
        self.licznik = licznik
        self.mianownik = mianownik
    def __cmp__(self, other):
        return (self.licznik * other.mianownik).__cmp__(other.licznik * self.mianownik)
    def __str__(self):
        return str(self.licznik) + '/' + str(self.mianownik)

def str2ulamek(napis):
    licznik, _, mianownik = napis.partition('/')
    return Ulamek(int(licznik), int(mianownik))

def zapisz_wymierna(naturalna, ulamek):
    zapis = zapisz_naturalna(naturalna) + zapisz_ulamek(ulamek)
    logger.info('Na koniec liczby dopisuję E.')
    return zapis + 'E'

def zapisz_naturalna(naturalna):
    logger.info('Liczbę %d zapisuję jako ciąg %d liter D.' % (naturalna, naturalna))
    return 'D' * naturalna

def zapisz_ulamek(ulamek):
    assert ulamek.licznik < ulamek.mianownik
    return zapisz_ulamek_z_zakresem(ulamek, Ulamek(0, 1))

def zapisz_ulamek_z_zakresem(ulamek, poczatek_zakresu):
    nastepny = Ulamek(poczatek_zakresu.licznik + 1, poczatek_zakresu.mianownik + 1)
    logger.info('Wiem, że badany ułamek %s leży między %s a %s. Ale gdzie w tym zakresie? Przed %s czy za nim?' % (str(ulamek), str(poczatek_zakresu), str(Ulamek(poczatek_zakresu.licznik + 1, poczatek_zakresu.mianownik)), str(nastepny)))
    if ulamek == nastepny:
        logger.info('A, on leży równo na %s. Więc do reprezentacji dopisuję B.' % (str(nastepny)))
        return 'B'
    if ulamek < nastepny:
        logger.info('A, on leży przed %s. Więc do reprezentacji dopisuję A.' % (str(nastepny)))
        return 'A' + zapisz_ulamek_z_zakresem(ulamek, Ulamek(nastepny.licznik - 1, nastepny.mianownik))
    if ulamek > nastepny:
        logger.info('A, on leży po %s. Więc do reprezentacji dopisuję C.' % (str(nastepny)))
        return 'C' + zapisz_ulamek_z_zakresem(ulamek, nastepny)

print 'Podaj liczbę wymierną w formacie "3 2/7". W ułamku licznik musi być mniejszy od mianownika.'
napis = raw_input()
naturalna, _, ulamek = napis.partition(' ')
naturalna = int(naturalna)
licznik, _, mianownik = ulamek.partition('/')
ulamek = Ulamek(int(licznik), int(mianownik))
print 'Twoja liczba to %s %s.' % (str(naturalna), (ulamek))
print 'W zapisie dziesiętnym to %6.3f.' % (naturalna + float(licznik) / float(mianownik))
print 'W moim zapisie to %s' % zapisz_wymierna(naturalna, ulamek)

data Ulamek = Ulamek Integer Integer

instance Show Ulamek where
   show (Ulamek a b) = (show a) ++ "/" ++ (show b)

instance Eq Ulamek where
   (Ulamek a x) == (Ulamek b y) = (a * y) == (b * x)

instance Ord Ulamek where
   (Ulamek a x) `compare` (Ulamek b y) = (a * y) `compare` (b * x)

data Wymierna = Wymierna Integer Ulamek

instance Show Wymierna where
   show (Wymierna a b) = (show a) ++ " " ++ (show b)

nastepny (Ulamek a b) = Ulamek (a + 1) b

zapiszUlamekZZakresem ulamek poczatekZakresu
   | ulamek == nastepny = "B"
   | ulamek < nastepny  = "A" ++ zapiszUlamekZZakresem ulamek (Ulamek x (y + 1))
   | ulamek > nastepny  = "C" ++ zapiszUlamekZZakresem ulamek nastepny
   where (Ulamek a b) = ulamek
         (Ulamek x y) = poczatekZakresu
         nastepny = Ulamek (x + 1) (y + 1)

zapiszUlamek ulamek = zapiszUlamekZZakresem ulamek (Ulamek 0 1)

zapiszNaturalna 0 = ""
zapiszNaturalna x = "D" ++ (zapiszNaturalna (x - 1))

zapiszWymierna (Wymierna naturalna ulamek) = (zapiszNaturalna naturalna) ++ (zapiszUlamek ulamek) ++ "E"

-- oto przykład użycia tej funkcji dla liczby 5 3/4
main = do putStrLn (zapiszWymierna (Wymierna 5 (Ulamek 3 4)))

RSS