如何基于页面边界在空格位置实现字符串无断词换行裁切？

我有一个给定字符串的空格位置数组，例如：[3, 7, 11, 18, 24, 29, 34, 45, 50, 55, 59, 67, 70, 75, 80, 84, 90, 93, 97, 108]，同时还有一组页面边界值数组，通过代码lower_and_higher_bounds = [i for i in range(37,444,37)]生成，具体为[37, 74, 111, 148, 185, 222, 259, 296, 333, 370, 407]。

需求是在字符串中找到符合以下条件的空格位置：该位置需在对应边界值的±5字符范围内，且尽可能接近边界值。比如第一个边界值37对应的最优空格位置是34，第二个边界值74对应的最优空格位置是67，以此类推。

尝试过多种实现方式，但均存在问题：要么文本内容丢失，要么文本超出边界范围。现寻求可行的实现思路，核心需求是编写一个函数计算换行位置，避免在单词中间断行。

现有代码如下：

lower_and_higher_bounds = [i for i in range(37,444,37)]


def search_cut_positions(space_positions, search_value):
    length = len(space_positions)
    lower_bound = 0
    upper_bound = length - 1

    while lower_bound <= upper_bound:
        midpoint = (upper_bound + lower_bound) // 2
        value_at_midpoint = space_positions[midpoint]

        if search_value >= value_at_midpoint - 5 and search_value <= value_at_midpoint:
            return value_at_midpoint
        elif search_value < value_at_midpoint:
            upper_bound = midpoint - 1
        elif search_value > value_at_midpoint:
            lower_bound = midpoint + 1

    return None


def cut_and_display_string(col_position, row_position ,input_string, rows=12):
    # Find space positions
    stringlen = len(input_string)
    space_positions = [i for i in range(stringlen) if input_string[i].isspace()]
    cut_array = [0,37]


    for i in range(len(lower_and_higher_bounds)):
        space_position = search_cut_positions(space_positions, lower_and_higher_bounds[i])
        if space_position == None:
            cut_array.append(lower_and_higher_bounds[i])
            break
        else:
            cut_array.append(space_position)

    # Calculate vertical positions
    x_positions = [card_height - i for i in range(20, card_height, 10)]

    for i in range(len(cut_array) - 1):
        start = cut_array[i]
        end = cut_array[i + 1]
        chunk = input_string[start:end].strip()
        display_position = row_position + x_positions[i]
        c.drawString(col_position + 10, display_position, chunk)

可行实现思路 #

1. 多优先级匹配逻辑：对每个边界值，先筛选[bound-5, bound+5]范围内的空格，选最接近边界的；若范围内无空格，优先选边界左侧最近的空格（避免内容超出边界）；左侧也无则选右侧最近的。
2. 避免回退截断：维护上一次的截断位置，确保所有换行位置按文本顺序递增，防止重复或混乱。
3. 处理边界情况：包括没有可用空格时的 fallback 方案，以及行数限制、剩余文本的收尾处理。

修改后的代码实现 #

lower_and_higher_bounds = [i for i in range(37, 444, 37)]

def find_optimal_space(space_positions, bound, last_cut):
    # 只保留上一次截断位置之后的空格，避免回退
    valid_spaces = [pos for pos in space_positions if pos > last_cut]
    if not valid_spaces:
        return None
    
    # 第一步：找bound±5范围内的空格，选最接近的
    candidates = [pos for pos in valid_spaces if abs(pos - bound) <= 5]
    if candidates:
        return min(candidates, key=lambda x: abs(x - bound))
    
    # 第二步：范围内无空格，找bound左侧最近的空格
    left_candidates = [pos for pos in valid_spaces if pos <= bound]
    if left_candidates:
        return max(left_candidates)
    
    # 第三步：左侧也无，只能选右侧最近的空格
    return min(valid_spaces, key=lambda x: x - bound)

def cut_and_display_string(col_position, row_position, input_string, rows=12):
    space_positions = [i for i, char in enumerate(input_string) if char.isspace()]
    cut_array = [0]
    last_cut = 0
    
    for bound in lower_and_higher_bounds:
        if len(cut_array) >= rows:
            break  # 达到指定行数后停止
        optimal_space = find_optimal_space(space_positions, bound, last_cut)
        if optimal_space is None:
            # 无可用空格时，按边界截断（尽可能不超文本长度）
            next_cut = min(last_cut + (bound - cut_array[-1]), len(input_string))
            cut_array.append(next_cut)
        else:
            cut_array.append(optimal_space)
        last_cut = cut_array[-1]
    
    # 确保最后一段包含所有剩余文本
    if cut_array[-1] < len(input_string):
        cut_array.append(len(input_string))
    
    # 计算垂直位置（假设card_height为已定义变量）
    x_positions = [card_height - i for i in range(20, card_height, 10)]
    
    for i in range(len(cut_array)-1):
        start = cut_array[i]
        end = cut_array[i+1]
        chunk = input_string[start:end].strip()
        if not chunk:
            continue  # 跳过空文本片段
        # 处理行数超出x_positions长度的情况
        display_pos = row_position + (x_positions[i] if i < len(x_positions) else x_positions[-1])
        c.drawString(col_position + 10, display_pos, chunk)

关键改进点 #

• 防止回退：通过last_cut参数确保截断位置始终递增，避免文本重复或顺序错误。
• 优先级匹配：优先保证在边界范围内换行，其次避免超出边界，最后才选择右侧空格，最大化符合排版需求。
• 边界处理：覆盖无可用空格、行数超限、剩余文本未处理等情况，减少内容丢失或溢出的概率。
• 空片段过滤：跳过可能出现的空文本块，避免无效绘制操作。

内容的提问来源于stack exchange，提问作者user16497397