home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / Python 1.1 / Demo / lutz / roman.py < prev    next >
Encoding:
Text File  |  1994-10-08  |  14.0 KB  |  633 lines  |  [TEXT/R*ch]
  1. #
  2. #          R O M A N   N U M E R A L S   (python version)
  3. #
  4. #  This program takes Arabic numerals from standard input and writes
  5. #  the corresponding Roman numerals to standard outout.
  6.  
  7.  
  8.  
  9. ##########################################################################
  10. # the icon version:
  11. #
  12. # procedure main()
  13. #    local n
  14. #    while n := read() do
  15. #       write(roman(n) | "cannot convert")
  16. # end
  17. # 
  18. # procedure roman(n)
  19. #    local arabic, result
  20. #    static equiv
  21. #    initial equiv := ["","I","II","III","IV","V","VI","VII","VIII","IX"]
  22. #    integer(n) > 0 | fail
  23. #    result := ""
  24. #    every arabic := !n do
  25. #       result := map(result,"IVXLCDM","XLCDM**") || equiv[arabic+1]
  26. #    if find("*",result) then fail else return result
  27. # end
  28. #
  29. ##########################################################################
  30.  
  31.  
  32.  
  33. import sys
  34. from string import *            # atoi unqualified
  35.  
  36.  
  37.  
  38. # 
  39. # the main driver
  40. #
  41.  
  42.  
  43. def romans(converter):
  44.     while 1:
  45.         roman = converter(raw_input('enter number: '))
  46.         if roman != None: 
  47.             print roman
  48.         else: 
  49.             print 'cannot convert'
  50.  
  51.  
  52.  
  53.  
  54. #
  55. # simplest approach: implement map() inline;
  56. # note: 'equiv' could be global in the module for 'static'
  57. #
  58.  
  59.  
  60.  
  61. def roman1(n):
  62.    equiv = ['','I','II','III','IV','V','VI','VII','VIII','IX']        
  63.    if atoi(n) <= 0: return None
  64.    result = ''
  65.    for arabic in n:
  66.        new = ''
  67.        key, to = 'IVXLCDM*', 'XLCDM***'       # extra '*' or index fails
  68.        for x in result:
  69.            new = new + to[index(key, x)]
  70.        result = new + equiv[atoi(arabic)]     # atoi needed here
  71.    if '*' in result: return None
  72.    return result
  73.  
  74.  
  75.  
  76.  
  77. #
  78. # use a dictionary for mapping
  79. #
  80.  
  81.  
  82.  
  83. def roman2(n):
  84.     
  85.     dig = {'0':'',  '1':'I',  '2':'II',  '3':'III',  '4':'IV', \
  86.            '5':'V', '6':'VI', '7':'VII', '8':'VIII', '9':'IX'}  
  87.            
  88.     map = {'I':'X', 'V':'L', 'X':'C', \
  89.            'L':'D', 'C':'M', 'D':'*', 'M':'*', '*':'*'}                    
  90.     
  91.     if atoi(n) <= 0: return None
  92.     result = ''
  93.     for arabic in n:
  94.         new = ''; 
  95.         for x in result: new = new + map[x]
  96.         result = new + dig[arabic]
  97.     if '*' in result: return None
  98.     return result
  99.  
  100.  
  101.  
  102.  
  103. #
  104. # make our own map();  could add to string.py;
  105. # note: this is the best comparison to the icon version;
  106. # note: can't change strings directly in python;
  107. #
  108.  
  109.  
  110.  
  111. def map(string, key, to):
  112.     result = ''
  113.     for x in string:
  114.         result = result + to[index(key, x)]
  115.     return result
  116.  
  117.  
  118. def roman3(n):
  119.     dig = ['','I','II','III','IV','V','VI','VII','VIII','IX']        
  120.     if atoi(n) <= 0: return None
  121.     result = ''
  122.     for arabic in n:
  123.         result = map(result, 'IVXLCDM*', 'XLCDM***') + dig[atoi(arabic)]
  124.     if '*' in result: return None
  125.     return result
  126.  
  127.  
  128.  
  129.  
  130. #
  131. # alternative ways to map(): slices and (of course) recursion
  132. #
  133.  
  134.  
  135.  
  136. def map2(string, key, to):
  137.     result = string
  138.     for i in range(len(string)):
  139.         result = result[:i] + to[index(key,string[i])] + result[i+1:]
  140.     return result
  141.  
  142.  
  143.  
  144. def map3(string, key, to):
  145.     if string == '':
  146.         return ''
  147.     else:
  148.         return to[index(key, string[0])] + map3(string[1:], key, to)
  149.  
  150.  
  151.  
  152.  
  153. #
  154. # do the lisp thing: convert strings<->lists for mapping
  155. #
  156.  
  157.  
  158.  
  159. def explode(string):
  160.     list = []
  161.     for x in string: list.append(x)
  162.     return list
  163.  
  164. def implode(list):
  165.     string = ''
  166.     for x in list: string = string + x
  167.     return string
  168.  
  169.  
  170. def tuple_implode(list):
  171.     tuple = ()
  172.     for x in list: tuple = tuple + (x,)
  173.     return tuple
  174.  
  175. def tuple_explode(tuple): return explode(tuple)
  176.  
  177.  
  178.  
  179.  
  180.  
  181. #####################################################
  182. # generic sequence conversion, via function pointers;  
  183. # 3 cases suffice for all sequence conversion cases;
  184. #
  185. # ie, only target sequence type matters, since 'in'
  186. # can iterate through any of the 3 types generically
  187. # but need different start/singleton constructors;
  188. #
  189. # note: can't use 'in' or '+' with dictionaries;
  190. #####################################################
  191.  
  192.  
  193.  
  194. def seqcon1(source, start, single):
  195.     result = start
  196.     for x in source: result = result + single(x)
  197.     return result
  198.  
  199.  
  200. def explode2(string):      seqcon1(string, [], list)   # string->list 
  201. def tuple_explode2(tuple): explode2(tuple)             # tuple->list 
  202. def implode2(list):        seqcon1(list, '', string)   # list->string
  203. def tuple_implode2(tuple): implode2(tuple)             # tuple->string 
  204. def list_tuple(list):      seqcon1(list, (), tuple)    # list->tuple
  205. def string_tuple(string):  list_tuple(string)          # string->tuple
  206.  
  207.  
  208. def list(x):   return [x]
  209. def string(x): return x
  210. def tuple(x):  return (x,)
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218. #################################################
  219. # generic, using target switch logic or tables
  220. #################################################
  221.  
  222.  
  223.  
  224. def seqcon2(source, target):
  225.     starts = ['', [], ()]
  226.     single = [string, list, tuple]
  227.     result = target
  228.     for x in source: result = result + single[starts.index(target)](x)
  229.     return result
  230.  
  231.  
  232. def seqcon3(source, target):
  233.     config = {'string':('',string), 'list':([],list), 'tuple':((),tuple)}
  234.     result = config[target][0]
  235.     for x in source: result = result + config[target][1](x)
  236.     return result
  237.  
  238.  
  239. def seqcon4(source, target):
  240.     result = target
  241.     for x in source: 
  242.         if   target == '': result = result + x
  243.         elif target == []: result = result + [x]
  244.         elif target == (): result = result + (x,)
  245.     return result
  246.  
  247.  
  248. def seqcon5(source, target):
  249.     config = {'string':('','x'), 'list':([],'[x]'), 'tuple':((),'(x,)')}
  250.     result = config[target][0]
  251.     for x in source: result = result + eval(config[target][1])
  252.     return result
  253.  
  254.  
  255. def seqcon6(source, target):
  256.     start, single = \
  257.         {'string':('','x'), 'list':([],'[x]'), 'tuple':((),'(x,)')}[target]
  258.     result = start
  259.     for x in source: result = result + eval(single)
  260.     return result
  261.  
  262.  
  263.  
  264.  
  265.  
  266. ########################################################
  267. # or use a generic sequence class;
  268. #
  269. # manages a sequence data object internally, and
  270. # keeps track of its actual type manually;
  271. #
  272. # note: methods calls require '()', so data member refs
  273. # don't look same as function member calls (without 
  274. # the '()', function members are accessed directly;
  275. #
  276. # note: the .value() method is really superfluous,
  277. # since the value can be accessed directly using
  278. # the .data member;  get/set function members
  279. # are useful iff the data interface may have to
  280. # be made functional later, or you want to set
  281. # the value with a function call [x=Obj().set(val)]
  282. #   def set(self, val): self.data = val
  283. #
  284. # expected output:
  285. #   >>> test_sequence()
  286. #   abcde
  287. #   ['a', 'b', 'c', 'd', 'e']
  288. #   zbcde
  289. #   []
  290. #   ['a', 'b']
  291. #   ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
  292. #   ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i')
  293. #   ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k')
  294. #   abcdefghijk
  295. #   abcdefghijkl
  296. #   ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']
  297. #   a
  298. #   b
  299. #   ...
  300. #   k
  301. #   l
  302. ########################################################
  303.  
  304.  
  305.  
  306.  
  307.  
  308. class Sequence:
  309.     def to_string(self):
  310.         res = ''
  311.         for x in self.data: res = res + x
  312.         self.data = res
  313.     
  314.     def to_list(self):
  315.         res = []
  316.         for x in self.data: res.append(x)
  317.         self.data = res
  318.     
  319.     def to_tuple(self):
  320.         res = ()
  321.         for x in self.data: res = res + (x,)
  322.         self.data = res
  323.  
  324.     def add(self, item):
  325.         if   type(self.data) == type(''): single = item
  326.         elif type(self.data) == type([]): single = [item]
  327.         elif type(self.data) == type(()): single = (item,)
  328.         self.data = self.data + single
  329.  
  330.     def concat(self, items):
  331.         for x in items: self.add(x)         # 'in' is generic
  332.  
  333.     def value(self): return self.data
  334.  
  335.     def init(self, *value):  
  336.         if value == ():
  337.             self.data = []                  # starts as a list
  338.         else:    
  339.             self.data = value[0]            # opt value gives start type
  340.         return self
  341.  
  342.     def show(self):  
  343.         for x in self.data: print x         # indent needed here
  344.  
  345.  
  346.  
  347.  
  348. def test_sequence():
  349.     l = Sequence().init('')
  350.     l.concat('abcde')
  351.     print l.value()
  352.  
  353.     l.to_list()         # explode
  354.     print l.value()
  355.  
  356.     l.data[0] = 'z'
  357.     l.to_string()       # implode
  358.     print l.value()
  359.  
  360.     x = Sequence().init()
  361.     print x.value() 
  362.     
  363.     x.add('a'); x.add('b') 
  364.     print x.value()   
  365.     
  366.     x.concat('cd');
  367.     x.concat(['e', 'f'])                    # '+' needs same types
  368.     x.concat(('g', 'h', 'i'))
  369.     print x.value() 
  370.  
  371.     x.to_tuple();     print x.data  
  372.     x.concat('jk');   print x.data  
  373.  
  374.     x.to_string();    print x.data  
  375.     x.concat(['l']);  print x.data 
  376.  
  377.     x.to_list();      print x.data  
  378.     x.show();
  379.  
  380.  
  381.  
  382.  
  383.  
  384. ###############################################################
  385. # use specialization/inheritance;
  386. #
  387. # object type implies single/inits;
  388. # build a new object type to convert 
  389. # types (and reset virtual funcs);
  390. #
  391. # this could be used for a Sequence2:
  392. #    def init(self): return List().init()
  393. # to try and default to a List when 
  394. # a Sequence() is made; we cant' use it 
  395. # here because init() is more complex;
  396. # 
  397. # same expected output as test_sequence()
  398. ###############################################################
  399.  
  400.  
  401.  
  402.  
  403.  
  404. class Sequence2:
  405.     def convert(self, maker):
  406.         new = maker().init() 
  407.         new.concat(self.data)
  408.         return new
  409.  
  410.     def to_string(self): 
  411.         return self.convert(String)        # classes are 1st-class    
  412.  
  413.     def to_list(self):   
  414.         return self.convert(List)
  415.     
  416.     def to_tuple(self):  
  417.         return self.convert(Tuple)
  418.     
  419.     def concat(self, items):                # "in" is generic
  420.         for x in items: self.add(x)         # add is virtual
  421.     
  422.     def init(self, *value):                 # optional value arg
  423.         if not value:                       # '()' is false
  424.             self.data = self.empty()        # empty is virtual
  425.         else:
  426.             self.data = value[0]
  427.         return self
  428.     
  429.     def show(self): 
  430.         for x in self.data: print x
  431.  
  432.  
  433.  
  434.  
  435. class List(Sequence2):
  436.     def empty(self): 
  437.         return []  
  438.  
  439.     def add(self, item): 
  440.         self.data.append(item)                   # faster than '+ [item]'
  441.  
  442.  
  443. class String(Sequence2):
  444.     def empty(self):
  445.         return ''
  446.  
  447.     def add(self, item): 
  448.         self.data = self.data + item
  449.  
  450.  
  451. class Tuple(Sequence2):
  452.     def empty(self):
  453.         return ()
  454.  
  455.     def add(self, item): 
  456.         self.data = self.data + (item,)
  457.  
  458.  
  459.  
  460.  
  461. def test_sequence2():
  462.     l = String().init()
  463.     l.concat('abcde')
  464.     print l.data
  465.  
  466.     l = l.to_list()     # explode
  467.     print l.data
  468.  
  469.     l.data[0] = 'z'
  470.     l = l.to_string()   # implode
  471.     print l.data
  472.  
  473.  
  474.     x = List().init()                  # start as a list
  475.     print x.data                       # drop value() method 
  476.     
  477.     x.add('a'); x.add('b') 
  478.     print x.data   
  479.     
  480.     x.concat('cd');
  481.     x.concat(['e', 'f'])               # '+' needs same types
  482.     x.concat(('g', 'h', 'i'))
  483.     print x.data 
  484.  
  485.     x = x.to_tuple();  print x.data    # must assign new obj  
  486.     x.concat('jk');    print x.data  
  487.  
  488.     x = x.to_string(); print x.data  
  489.     x.concat(['l']);   print x.data 
  490.  
  491.     x = x.to_list();   print x.data  
  492.     x.show();
  493.  
  494.  
  495.  
  496.  
  497.  
  498.  
  499. #############################################
  500. # ok: finally, mapping via explode/implode
  501. #############################################
  502.  
  503.  
  504.  
  505. def map4(string, key, to):
  506.     list = []
  507.     for x in string:
  508.         list.append(to[index(key, x)])
  509.     return implode(list)
  510.  
  511.  
  512. def map5(string, key, to):
  513.     list = explode(string)
  514.     for i in range(len(list)):
  515.         list[i] = to[index(key, list[i])]
  516.     return implode(list)
  517.  
  518.  
  519. def map6(string, key, to):
  520.     list = explode(string); i = 0
  521.     for x in list:
  522.         list[i] = to[index(key, x)]; i = i+1
  523.     return implode(list)
  524.  
  525.  
  526. # does not work: x doesn't "share" with nodes in list
  527. #
  528. # def map7(string, key, to):
  529. #    list = explode(string)
  530. #    for x in list:
  531. #        x = to[index(key, x)]
  532. #    return implode(list)
  533.  
  534.  
  535.  
  536.  
  537.  
  538. ########################################
  539. # a few more coding variations..
  540. ########################################
  541.  
  542.  
  543.  
  544. def roman4(arab):
  545.    equiv = ['','I','II','III','IV','V','VI','VII','VIII','IX']        
  546.    if atoi(arab) <= 0: return None
  547.    res = ''
  548.    while arab != '':
  549.        new, key, to = '', 'IVXLCDM*', 'XLCDM***'
  550.        while res != '':
  551.            new, res = new + to[index(key, res[0])], res[1:]
  552.        res, arab = new + equiv[atoi(arab[0])], arab[1:]
  553.    if '*' in res: return None
  554.    return res
  555.  
  556.  
  557.  
  558.  
  559.  
  560. ##############################################################
  561. # note: illegal to ref undefined names: must 
  562. # explicitly initialize res and new to '' here;
  563. #
  564. # note: this is illegal syntax (cmp stmts require indent):
  565. #   res=''; while arab != '':
  566. #       new=''; while res != '':
  567. #           new, res = ...
  568. #
  569. # ok to subscript literals, but some methods useless:
  570. #   [1,2,3].index(3) ok (2)
  571. #   [1,2,3].append(5) means nothing (append returns no value)
  572. #   'abcd'[1] ok ('b')
  573. #   'abcd'.rjust(3) fails
  574. #   string.rjust('abcd',3) ok (strings not really a class)
  575. #   {'a':1, 'b':2}['a'] ok (1)
  576. ############################################################## 
  577.  
  578.  
  579.  
  580.  
  581. def roman5(arab):
  582.    equiv = ['','I','II','III','IV','V','VI','VII','VIII','IX']        
  583.    if atoi(arab) <= 0: return None
  584.    res = ''; 
  585.    while arab != '':
  586.        new = ''; 
  587.        while res != '':
  588.             new, res = new + 'XLCDM***'[index('IVXLCDM*',res[0])], res[1:]
  589.        res, arab = new + equiv[atoi(arab[0])], arab[1:]
  590.    if '*' in res: return None
  591.    return res
  592.  
  593.  
  594.  
  595.  
  596.  
  597.  
  598. #######################################################
  599. # test all varients: functions are 1st-class objects;
  600. # can test others by hand at interactive prompt:
  601. #   >>> from roman import *
  602. #   >>> seqcon(...
  603. #
  604. #   >>> import roman
  605. #   >>> roman.seqcon(...
  606. #
  607. #   >>> import pdb
  608. #   >>> pdb.run('from roman import *')
  609. #   >>> pdb.run('test_sequence2()')
  610. #
  611. # this code gets run when the module roman.py is 
  612. # imported (loaded);  it must be after the def's
  613. # above, since funcs aren't known till def runs;
  614. #######################################################
  615.  
  616.  
  617.  
  618.  
  619. def doit():
  620.     roman_funcs = [roman1, roman2, roman3, roman4, roman5]
  621.     for x in roman_funcs:
  622.         print '--running function:', roman_funcs.index(x) + 1
  623.         try: 
  624.             romans(x)
  625.         except:
  626.             print sys.exc_type + ':', sys.exc_value
  627.     
  628.  
  629.  
  630. doit()
  631.  
  632.  
  633.