golang版约瑟夫环

package main

import (
   "fmt"
)

func main() {

   elements := []string{"a", "b", "c", "d", "e", "f"}
   //字符串数组

   interval := 2
   //间隔

   survive_count := 1
   //幸存数量

   c := josef_circle(elements, survive_count, interval)
   fmt.Println(c)

}

func get_cycle(elements []string) chan string {
   //此函数用于循环获得字符串数组中的单个元素
   //功能类似python的generator
   c := make(chan string)
   go func() {
      for current_index := 0; current_index < len(elements); {
         current_val := elements[current_index]
         c <- current_val
         if current_index < len(elements)-1 {
            current_index += 1
         } else {
            current_index = 0
         }
      }
   }()
   return c
}

func josef_circle(total_elements []string, survive_count, interval int) []string {

   elements_generator := get_cycle(total_elements)
   //声明生成器
   defer close(elements_generator)
   //完成后，将chan关闭

   status_map := make(map[string]bool)
   //此map用于保存输入数组中的各元素状态。为true则代表已被从数组中取出，false代表未取出

   for _, value := range total_elements {
      status_map[value] = false
   }
   var current_ele string
   //预定义一个string变量，用于保存当前的被遍历到的string

   remain_count_init := len(total_elements)
   current_remain_count := remain_count_init

   for current_remain_count > survive_count {
   //当未取出的元素数量小于等于幸存数量时，外循环终止

       for steps := 0; steps <= interval; {
      //每次从chan中取出一个元素
          current_ele = <-elements_generator

          if status_map[current_ele] == false {
         //若未被取出，则有效间隔+1
             steps += 1
          }
       }
       //fmt.Println(current_ele)
       status_map[current_ele] = true
       //将被取出的元素标记

       current_remain_count -= 1
       //未取出的元素数量-1
    }
   survive_string_array := []string{}
   for key, val := range status_map {
      if val == false {
         survive_string_array = append(survive_string_array, key)
      }
   }
   return survive_string_array
}