4.TDD实现幸运抽奖

1.题目

有 n 位幸运观众参加抽奖，生成对应的随机数(1 ~ n)，按倍数删除数据(若是1，只删除1;若是2，则删除#2，#4，#6…;若是3,则删除#3，#6，#9…)。若剩余99位数字，再生成随机数(1~99)，再按倍数删除数据… 直到只剩下最后一位,即为中奖观众

2.TDD测试

package cs.luck.draw;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Assert;
import org.junit.Test;

import cs.luck.factory.LuckDogFactory;
import cs.lucky.draw.LuckDraw;

public class LuckDrawTest {
    @Test
    public void 抽奖前() {
        //given
        int givenNumber = 100;
        int[] givenArray = LuckDogFactory.initial(givenNumber);
        Map<Integer,Integer> givenMap = LuckDogFactory.initialMap(givenNumber);
        LuckDraw luckDraw = new LuckDraw();

        //when
        int[] returnArray = luckDraw.initial(100);
        Map<Integer,Integer> returnMap = luckDraw.initialMap(givenNumber);

        //then
        Set<Integer> setGiven = givenMap.keySet();
        Set<Integer> setReturn = returnMap.keySet();
        Assert.assertArrayEquals(givenArray, returnArray);
        Assert.assertTrue(setGiven.containsAll(setReturn));
        Assert.assertTrue(setReturn.containsAll(setGiven));
        for(Iterator<Integer> iter = setGiven.iterator(); iter.hasNext(); ) {
            Integer inte = iter.next();
            Assert.assertEquals(givenMap.get(inte), returnMap.get(inte));
        }
    }

    @Test
    public void 中奖号码() {
      //given
        int givenNumber = 100;
        LuckDraw luckDraw = new LuckDraw();

        //when
        int returnInt = luckDraw.luckyDog(givenNumber);
        System.out.println();

        //then
        Assert.assertEquals(1, returnInt);
    }
}

3.工厂类

package cs.luck.factory;

import java.util.Map;
import java.util.TreeMap;

public class LuckDogFactory {
    public static int[] initial(int num) {
        int[] array = new int[num]; 
        for(int i = 0; i < num; i++) {
            array[i] = i + 1;
        }
        return array;
    }

    public static Map<Integer,Integer> initialMap(int num) {
        Map<Integer,Integer> set = new TreeMap<>();
        for(int i = 0; i < num; i++) {
            set.put(i + 1, i + 1);
        }
        return set;
    }
}

4.问题实现代码

/***
 * 
 * 
 * @author shuai.chen
 * @date 2018年9月10日
 * @Description
 *  有 n 位幸运观众参加抽奖，生成对应的随机数(1 ~ n)，按倍数删除数据(若是1，只删除1;若是2，则删除#2，#4，#6...;若是3,则删除#3，#6，#9...)
 *  若剩余99位数字，再生成随机数(1~99)，再按倍数删除数据...
 *  直到只剩下最后一位,即为中奖观众
 *  
 *  这只是自己玩的一个小东西，不算真正的抽奖。因为拿的数比较打的容易被淘汰
 *  例如，假若号码为100,只要抽中2,4,5,10,20，100等会把100淘汰，而号码1只能被号码1淘汰。
 */
public class LuckDraw {
    public int luckyDog(int num) {
        int[] array = initial(num);
        Map<Integer,Integer> map = initialMap(num);
        Map<Integer,Integer> lockyMap = sweepStake(array, map);

        while(lockyMap.keySet().size() != 1) {
            lockyMap = arrayLockyMap(lockyMap);
            int arraySize = lockyMap.size();
            array = initial(arraySize);
            lockyMap = sweepStake(array, lockyMap);
        }
        printLuckPeople(lockyMap);
        return lockyMap.keySet().size();
    }

    private void printLuckPeople(Map<Integer, Integer> lockyMap) {
        Set<Integer> sets = lockyMap.keySet();

        for(Iterator<Integer> iter = sets.iterator(); iter.hasNext(); ) {
            int keyNumber = iter.next();
            int valueNumber = lockyMap.get(keyNumber);
            System.out.println("Luck people is No." + valueNumber);
        }
    }

    /**  对数组进行重新组合排序      */
    public Map<Integer,Integer> arrayLockyMap(Map<Integer,Integer> lockyMap){
        Map<Integer,Integer> returnLockyMap = new TreeMap<>();
        int i = 1;
        Set<Integer> set = lockyMap.keySet();
        for(Iterator<Integer> iter = set.iterator(); iter.hasNext();) {
            returnLockyMap.put(i++, lockyMap.get(iter.next()));
        }
        return returnLockyMap;
    }

    /**   初始化数组      */
    public int[] initial(int num) {
        int[] array = new int[num]; 
        for(int i = 0; i < num; i++) {
            array[i] = i + 1;
        }
        return array;
    }

    /**   初始化Map   */
    public Map<Integer,Integer> initialMap(int num) {
        Map<Integer,Integer> set = new TreeMap<>();
        for(int i = 0; i < num; i++) {
            set.put(i + 1, i + 1);
        }
        return set;
    }

    /**   删除倍数数据       */
    public Map<Integer,Integer> sweepStake(int[] array, Map<Integer,Integer> map) {
        int random = getRandomNumber(array.length);
        if(random == 1) {
            map.remove(random);
        }
        if(random != 1) {
            int skip = random;
            for(; random <= array.length; ) {
                map.remove(random);
                random += skip; 
            }
        }
        return map;
    }

    /**   生成随机数      */
    private int getRandomNumber(int num) {
        return new Random().nextInt(num) + 1;
    }

}