逆FizzBuzz问题求最短序列

问题描述

FizzBuzz问题：一个大于0的自然数能整除3，将输出“Fizz”；能整除5，将输出“Buzz”；能整除3和5，将输出“FizzBuzz”；否则输出自己。

逆FizzBuzz问题最短序列：已知一个FizzBuzz问题的非数字输出序列，求能获得该序列的最短连续数字序列。如“Fizz”的最短序列是“3”，“Fizz Buzz”的最短序列是“9 10”，而不是“3 4 5”。

编程实现

<?php

/**
 * @author cenze
 *
 * 反FizzBuzz问题求最短序列
 * 
 * $inverseFizzBuzz = new InverseFizzBuzz([
 *   'fizz',
 *   'fizz',
 *   'buzz',
 * ]);
 * $inverseFizzBuzz->sequence():
 * Array ( [0] => 6 [1] => 7 [2] => 8 [3] => 9 [4] => 10 )
 */
class InverseFizzBuzz
{
    // FizzBuzz问题赋值
    const FizzBuzz = [
        'fizz' => 3,
        'buzz' => 5,
        'fizzbuzz' => 15
    ];
    
    // 预定义问题区间
    private $range = [
        1,
        100
    ];
    
    // 待求序列
    private $list = [];
    
    // 待求序列包含项数统计
    private $listItemsCount = 0;

    public function __construct($list = [], $range = [])
    {
        $this->init($list, $range);
    }

    /**
     * 待求序列、区间初始化
     *
     * @param array $list
     *            待求序列
     * @param array $range
     *            问题区间
     * @param bool $check
     *            是否检查属性已完成初始化
     *            
     * @return void
     */
    private function init($list = [], $range = [], $check = false)
    {
        if ($list) {
            $this->list = $this->inverseList($list);
            $this->listItemsCount = count($this->list);
            if (! $this->listItemsCount) {
                exit('Invalid list.');
            }
        }
        
        if ($range) {
            $this->range = $range;
        }
        
        if ($check) {
            if (! $this->list) {
                exit('Property list uninitialized.');
            }
        }
    }

    /**
     * 将待求解序列反转
     *
     * @param array $list
     *            待求解序列
     *            
     * @return mixed
     */
    private function inverseList($list)
    {
        $inverseList = [];
        foreach ($list as $item) {
            if (! array_key_exists($item, self::FizzBuzz)) {
                return null;
            }
            $inverseList[] = self::FizzBuzz[
                $item
            ];
        }
        
        return $inverseList;
    }

    /**
     * 搜索最短序列是否存在
     *
     * @param array $list
     *            待求序列
     * @param array $range
     *            问题区间
     *            
     *            
     * @return mixed
     */
    public function sequence($list = [], $range = [])
    {
        $this->init($list, $range, true);
        
        $sequences = $this->findSequences();
        if (! $sequences) {
            return 'Found no sequences.';
        }
        
        $sequence = $this->findShortestSequence($sequences);
        // 将最短序列序列化后返回
        return range($sequence[0], $sequence[$this->listItemsCount - 1]);
    }

    /**
     * 搜索最短序列(未序列化)
     *
     * @param array $sequences
     *            序列集合，包含最短序列
     *            
     * @return array
     */
    private function findShortestSequence($sequences)
    {
        // 默认第一条为最短
        $shortestSequence = $sequences[0];
        // 把每一个序列看做一条路径，都有对应的长度。记录最短的序列长度
        $shortestSequenceLength = $sequences[0][$this->listItemsCount - 1] - $sequences[0][0];
        // 为array_reduce()定义一个callback，用来搜索最短序列
        $findShortestSequence = function ($shortestSequence, $currentSequence) use(&$shortestSequenceLength) {
            $currentSequenceLength = $currentSequence[$this->listItemsCount - 1] - $currentSequence[0];
            if ($currentSequenceLength < $shortestSequenceLength) {
                $shortestSequenceLength = $currentSequenceLength;
                return $currentSequence;
            } else {
                return $shortestSequence;
            }
        };
        
        return array_reduce($sequences, $findShortestSequence, $shortestSequence);
    }

    /**
     * 从指定位置开始搜索指定项目的序列
     *
     * @param int $item
     *            指定项目
     * @param int $start
     *            起始搜索位置
     *            
     * @return int
     */
    private function findItemSequenceFromPosition($item, $start)
    {
        if ($start % $item == 0) {
            return $start;
        }
        
        return $start + ($item - $start % $item);
    }

    /**
     * 从指定位置开始搜索首个序列
     *
     * @param int $start
     *            起始搜索位置
     *            
     * @return mixed
     */
    private function findSequenceFromPosition($start)
    {
        $listSequence = [];
        for ($i = 0; $i < $this->listItemsCount; $i ++) {
            $itemSequence = $this->findItemSequenceFromPosition($this->list[$i], $start);
            if ($itemSequence > $this->range[1]) {
                return null;
            } else {
                $listSequence[] = $itemSequence;
                $start = $itemSequence + 1;
            }
        }
        
        return $listSequence;
    }

    /**
     * 找到多个序列，其中包括最短序列
     *
     * @return void
     */
    private function findSequences()
    {
        $sequences = [];
        // 以第一个项为初始搜索位置在预定区间中搜索，且以第一个项为递增步长向后逐步搜索
        for ($start = $this->list[0]; $start <= $this->range[1]; $start += $this->list[0]) {
            // 只需找到指定位置开始的第一个序列即可
            if ($sequence = $this->findSequenceFromPosition($start)) {
                $sequences[] = $sequence;
            }
        }
        
        return $sequences;
    }
}