逆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;
     }
 }