尝试在多条固定长度的线上打印单个字符串并最大限度地降低成本

Question

First some background I just started with Algorithms(which I now feel I lack the logic and reasoning power to excel at)I have been trying to print "This is a sample text "into various lines with max of 7 chars on each line so the first line will have :

this is  (no spaces left in the end so cost 0)
a  
[cost=6*6*6(The spaces left at the end of each line are cubed which will be the cost) ]
sample [cost=1*1*1]
text [cost= 3*3*3]

(Total cost = 0+216+1+27=244)

Now this can be optimized by

this [cost 3*3*3]
is a [cost 3*3*3]
sample [cost 1*1*1]
text [cost 3*3*3]

[Total cost = 27+27+1+27 = 82]

So clearly we cannot use a greedy approach here instead use dynamic programming but my problem is I cannot figure out the sub structure that will be reused. I am really stuck with figuring out how I link the cost condition to the printing in python, I can index each word and I can get the length of each word, sort of stuck with what I do next When print all that happens is the entire string gets printed on one line each (This is where I have got so far). I apologize if this is a really silly question, but I am stuck and really need some help on this. Thanks

---

This is how I have tried implementing the code although I tried running some tests on the code, the test were written by my friend and I dont think I am getting it right Any help or suggestion is appreciated print_test.py

 import os
 import sys
 from glob import glob

  #TODO -- replace this with your solution 
 from printing import print_neatly

 log = open('output.log', 'w')

 #This tests the code against my own text
 maxline = 80
 for source in glob('*.txt'):
 with open(source) as f:
    fulltext = f.read()

 words = fulltext.split()
 (cost, text) = print_neatly(words, maxline)

 #double check the cost
 #lines = text.split('\n')
 truecost = 0
 for line in text[0:-1]:
    truecost += (maxline - len(line))**3


   #print the output and cost
   print >>log, '----------------------'
   print >>log, source
   print >>log, '----------------------'
   print >>log, text
   print >>log, '----------------------'
   print >>log, 'cost = ', cost
   print >>log, 'true cost = ', truecost
   print >>log, '----------------------'


log.close()

#print the log
with open('output.log') as f: print f.read()

printing.py

def print_neatly(wordlist, max):
   #strings='This is a sample string'

   #splitting the string and taking out words from it 
   #wordlist=strings.split()
   (cost, dyn_print) = print_line(wordlist, len(wordlist), max)
   for dyn in dyn_print:
      print dyn
   return cost, dyn_print

 def cost(lines, max):

    return sum([(max-len(x)) ** 3 for x in lines])

 def print_line(wordlist, count, max, results = {}):
  results = [([],0)]
  for count in range(1, len(wordlist) + 1):
    best = wordlist[:count]               
    best_cost = cost(best, max)
    mycount = count - 1
    line = wordlist[mycount]       
    while len(line) <= max: 
        attempt, attempt_cost = results[mycount]
        attempt = attempt + [line]
        attempt_cost += cost([line],max)
        if attempt_cost < best_cost:
            best = attempt
            best_cost = attempt_cost
        if mycount > 0:
            mycount -= 1
            line = wordlist[mycount] + ' ' + line
        else:
            break
    results += [(best, best_cost)]

 #print best
 #print best_cost
 return (best_cost, best)


#print_neatly(0,7)

The text files that need to be tested give me this output, here the two cost need to be the same which I am not getting, can some one point out where I am going wrong

---

cost = 16036

true cost = 15911

Answer 1

Once approach is to list all possible alternatives and pick the one with the minimum cost:

from functools import wraps

def cache(origfunc):
    d = {}
    @wraps(origfunc)
    def wrapper(*args):
        if args in d:
            return d[args]
        result = origfunc(*args)
        d[args] = result
        return result
    return wrapper

@cache
def alternatives(t, m=7):
    ''' Given a tuple of word lengths and a maximum line length,
        return a list of all possible line groupings
        showing the total length of each line.

        >>> alternatives((4, 2, 1, 3), 7)
        [[4, 2, 1, 3], [4, 2, 5], [4, 4, 3], [7, 1, 3], [7, 5]]

    '''
    if not t:
        return []
    alts = []
    s = 0
    for i, x in enumerate(t):
        s += x
        if s > m:
            break
        tail = t[i+1:]
        if not tail:
            alts.append([s])
            break
        for subalt in alternatives(tail, m):
            alts.append([s] + subalt)
        s += 1
    return alts

def cost(t, m=7):
    ''' Evaluate the cost of lines given to line lengths

            >>> cost((7, 1, 6, 4), m=7)  # 'this is', 'a', 'sample', 'text'
            244
            >>> cost((4, 4, 6, 4))       # 'this', 'is a', 'sample', 'text'
            82

    '''
    return sum((m - x) ** 3 for x in t)

def textwrap(s, m=7):
    ''' Given a string, result a list of strings with optimal line wrapping

        >>> print textwrap('This is a sample text', 7)
        ['This', 'is a', 'sample', 'text']

    '''
    words = s.split()
    t = tuple(map(len, words))
    lengths = min(alternatives(t, m), key=cost)
    result = []
    worditer = iter(words)
    for length in lengths:
        line = []
        s = 0
        while s < length:
            word = next(worditer)
            line.append(word)
            s += len(word) + 1
        result.append(' '.join(line))
    return result


if __name__ == '__main__':
    import doctest
    print doctest.testmod()

The code can be sped-up by limiting the number of alternatives searches (perhaps limited to the three longest alternatives on each line).

Answer 2

If there's a "best" way to arrange one word, two words, etc into lines, that's not going to change based on what lines come later. It can change based on what words come later, if the words are small enough to join others on a line. But if we take those words in isolation and try to arrange them into lines, the same set of solutions will always be optimal. (There may be equivalent answers; for example, given the criteria, "cats in hats" on 7-char lines has two solutions. Both are "best", and always will be -- and we can decide on either one and stick with it without sacrificing correctness.)

• "This" will always be best as ["This"] . (Note, i'm not saying it will always be best on a line by itself! What i am saying is that if you have the one word, the single best way to arrange it is on one line.)

• "This is" can be arranged as ["This", "is"] or as ["This is"] . The latter, however, is best. So from here on, whenever we only have these two words to consider, we can ignore ["This", "is"] entirely -- it will never be superior.

• "This is a" can be arranged as ["This", "is", "a"] , ["This is", "a"] , or ["This", "is a"] . (We already know that ["This is"] is superior to ["This", "is"] -- see the previous bullet point!) Turns out ["This", "is a"] is best. So we can ignore ["This is", "a"] from here on.

• "This is a sample" can be arranged as:

  • ["This", "is", "a", "sample"] (See bullet #2 -- we don't even have to look at this)
  • ["This is", "a", "sample"] (See bullet #3)
  • ["This", "is a", "sample"]

I don't know Python; i just hacked this together. So forgive me if it's "un-Pythonic" or whatever. :P

def cost(lines, limit):
    # figures the cost of the current arrangement of words in lines.
    return sum([(limit-len(x)) ** 3 for x in lines])


def lineify(words, limit):
    # splits up words into lines of at most (limit) chars.
    # should find an optimal solution, assuming all words are < limit chars long

    results = [([], 0)]

    for count in range(1, len(words) + 1):
        best = words[:count]         # (start off assuming one word per line)
        best_cost = cost(best, limit)
        mycount = count - 1
        line = words[mycount]        # start with one word

        while len(line) <= limit:
            # figure the optimal cost, assuming the other words are on another line
            attempt, attempt_cost = results[mycount]
            attempt = attempt + [line]
            attempt_cost += cost([line],limit)
            # print attempt
            if attempt_cost < best_cost:
                best = attempt
                best_cost = attempt_cost

            # steal another word.  if there isn't one, we're done
            if mycount > 0:
                mycount -= 1
                line = words[mycount] + ' ' + line
            else:
                break

        # once we have an optimal result for (count) words, save it for posterity
        results += [(best, best_cost)]

    return results[len(words)][0]


def wrap(phrase, limit):
    # helper function...so the caller doesn't have to pass an array of words.
    # they shouldn't need to know to do that
    words = phrase.split()
    return lineify(words, limit)

I originally had a recursive solution, but it turns out that Python places some limits on recursion that make it unsuitable when a decent size text and real-world length limit come into play. (You have to backtrack all the way to the beginning anyway before anything gets memoized, and if i had over like 1000 words, i ended up hitting recursion limits. This could be extended by starting with enough words to fill the last line, but it'd still limit the max to some multiple of the original limit.) I found myself using a hack to build up the results til the recursion limit was no longer an issue. If you have to do that, though, that's perhaps an indication that the recursion itself is an issue.

Answer 3

This algorithm relies on assumption that if we know optimal solution for the N-1,N-2,..,2,1 last words in the text then it is easy to construct optimal solution for N words. Memorization allows to avoid recomputing results of best_partition() calls for the same input:

import functools

def wrap(text, width):
    """
    >>> wrap('This is a sample text', 7)
    ['This', 'is a', 'sample', 'text']
    """
    return [' '.join(line) for line in best_partition(
        tuple(text.split()), functools.partial(cost, width=width))]

def best_partition(words, cost):
    """The best partition of words into lines according to the cost function."""
    best = [words] # start with all words on a single line
    for i in reversed(range(1, len(words))): # reverse to avoid recursion limit
        lines = [words[:i]] + best_partition(words[i:], cost)
        if cost(lines) < cost(best):
            best = lines
    return best

def memoize(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args):
        try: return cache[args]
        except KeyError:
            ret = cache[args] = func(*args)
            return ret
    return wrapper

best_partition = memoize(best_partition)

Where cost() is:

def linelen(words):
    """Number of characters in a line created from words."""
    if not words: return 0
    # words + spaces between them
    return sum(map(len, words)) + len(words) - 1

def cost(lines, width):
    """
    - each line except last costs `(width - w)**3`, where `w` is the
      line width

    - cost is infinite if `w > width` and the line has more than one word

    >>> cost([['a'], ['b']], 1)
    0
    >>> cost([['a','b']], 1)
    inf
    >>> cost([['a'], ['b']], 3)
    8
    >>> cost([['a', 'b']], 2)
    inf
    """
    if not lines: return 0
    s = 0
    for i, words in enumerate(lines, 1):
        w = linelen(words)
        if width >= w:
            if i != len(lines): # last line has zero cost
                s += (width - w)**3
        elif len(words) != 1: # more than one word in the line
            return float("inf") # penalty for w > width
    return s

Example:

print('\n'.join(wrap("""
    In olden times when wishing still helped one, there lived a king whose
    daughters were all beautiful, but the youngest was so beautiful that
    the sun itself, which has seen so much, was astonished whenever it
    shone in her face. Close by the king's castle lay a great dark forest,
    and under an old lime-tree in the forest was a well, and when the day
    was very warm, the king's child went out into the forest and sat down
    by the side of the cool fountain, and when she was bored she took a
    golden ball, and threw it up on high and caught it, and this ball was
    her favorite plaything.
    """, int(sys.argv[1]) if len(sys.argv) > 1 else 70)))

Output

In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that
the sun itself, which has seen so much, was astonished whenever it
shone in her face. Close by the king's castle lay a great dark forest,
and under an old lime-tree in the forest was a well, and when the day
was very warm, the king's child went out into the forest and sat down
by the side of the cool fountain, and when she was bored she took a
golden ball, and threw it up on high and caught it, and this ball was
her favorite plaything.