窮舉法應用

SoaB

發現新的玩具【V language】，用來還算順手，拿來練習。
注意這東東只能拿來玩…

1. /*
   
2.    中國古代數學家張丘建在他的《算經》
   
3.    提出了一個著名的「百錢買百雞問題」，
   
4.    雞翁一，值錢五，雞母一，值錢三，雞雛三，值錢一，
   
5.    百錢買百雞，問翁、母、雛各幾何？
   
6. 
   
7.    x = 翁
   
8.    y = 母
   
9.    z = 雛
   
10. 
    
11.    5x+3y+z/3 =100(百錢)
    
12.    x+y+z = 100(百雞)
    
13.    0 <= x <= 100/5 ==> range = 20
    
14.    0 <= y <= 100/3 ==> range = 33
    
15.    0 <= z <= 100   ==> range = 100
    
16. */
    
17. module main
    
18. 
    
19. fn main() {
    
20.         mut x := 0
    
21.         mut y := 0
    
22.         mut z := 0
    
23.         mut sum := 0
    
24.         println("百錢買百雞問題")
    
25.         for x = 0; x <= 20; x++ {
    
26.                 for y = 0; y <= 33; y++ {
    
27.                         for z = 0; z <= 100; z++ {
    
28.                                 sum = 5 * x + 3 * y + z / 3
    
29.                                 if sum == 100 && z % 3 == 0 && x + y + z == 100 {
    
30.                                         println('翁:$x 母:$y 雛:$z')
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.         }
    
35. }

複製代碼

SoaB

再來一個 pi …
一樣玩玩而已裏面算法請Google。

1. /*
   
2. ================================================================
   
3. calculate pi with n digits
   
4. ================================================================
   
5. */
   
6. module main
   
7. 
   
8. const (
   
9.         scale   = 10000
   
10.         arr_int = 20000
    
11. )
    
12. 
    
13. fn pi_digits(digits int) {
    
14.         mut tm := 0
    
15.         mut carry := 0
    
16.         mut arr := [arr_int].repeat(arr_int + 1)
    
17.         for i := digits; i > 0; i -= 4 {
    
18.                 mut sum := 0
    
19.                 for j := i; j > 0; j-- {
    
20.                         sum = sum * j + scale * arr[j]
    
21.                         arr[j] = sum % (j * 2 - 1)
    
22.                         sum /= j * 2 - 1
    
23.                 }
    
24.                 tm = carry + sum / scale
    
25.                 print('${tm:04d}')
    
26.                 carry = sum % scale
    
27.         }
    
28. }
    
29. 
    
30. fn main() {
    
31.         pi_digits(20000)
    
32. }

複製代碼

akii

SoaB 發表於 2020-7-31 15:46  
再來一個 pi …
一樣玩玩而已裏面算法請Google。

請問甚麼是 V language ? 有編譯器嗎?

SoaB

akii 發表於 2020-8-3 05:25  
請問甚麼是 V language ? 有編譯器嗎?

V

SoaB

小小的文字遊戲，有沒有人把它弄成H-GAME文字遊戲啊？

1. module main
   
2. 
   
3. import os
   
4. 
   
5. struct Pagenode {
   
6.         text    string
   
7. mut:
   
8.         choices &Choices
   
9. }
   
10. 
    
11. // /////////////////////////////////////////////////////////////////
    
12. struct Choices {
    
13.         cmd         string
    
14.         description string
    
15. mut:
    
16.         next_node   &Pagenode
    
17.         next_choice &Choices
    
18. }
    
19. 
    
20. fn new_page(text string) &Pagenode {
    
21.         page := &Pagenode{text, 0}
    
22.         return page
    
23. }
    
24. 
    
25. fn (mut node Pagenode) add_choice(cmd, description string, next_node &Pagenode) {
    
26.         choice := &Choices{cmd, description, next_node, 0}
    
27.         if node.choices == 0 {
    
28.                 node.choices = choice
    
29.         } else {
    
30.                 mut current_choice := node.choices
    
31.                 for current_choice.next_choice != 0 {
    
32.                         current_choice = current_choice.next_choice
    
33.                 }
    
34.                 current_choice.next_choice = choice
    
35.         }
    
36. }
    
37. 
    
38. fn (node Pagenode) render() {
    
39.         println(node.text)
    
40.         mut current_choice := node.choices
    
41.         for current_choice != 0 {
    
42.                 println(current_choice.cmd + ' : ' + current_choice.description)
    
43.                 current_choice = current_choice.next_choice
    
44.         }
    
45. }
    
46. 
    
47. fn (node Pagenode) execute_cmd(cmd string) &Pagenode {
    
48.         mut current_choice := node.choices
    
49.         for current_choice != 0 {
    
50.                 if current_choice.cmd.to_lower() == cmd.to_lower() {
    
51.                         return current_choice.next_node
    
52.                 }
    
53.                 current_choice = current_choice.next_choice
    
54.         }
    
55.         println('選個我看的懂的啦！')
    
56.         return 0
    
57. }
    
58. 
    
59. fn (node Pagenode) play() {
    
60.         node.render()
    
61.         mut cmd := ''
    
62.         if node.choices != 0 {
    
63.                 for cmd.len < 1 {
    
64.                         cmd = os.get_line().trim_space()
    
65.                 }
    
66.                 node.execute_cmd(cmd).play()
    
67.         }
    
68. }
    
69. 
    
70. fn main() {
    
71.         println('小白的冒險')
    
72.         println('This is a nonesence damn story!!')
    
73.         mut star := new_page('
    
74.         嗯…一張開眼，你發現你在一個小小小的房間裏，昏暗的燈光下你看到有3個門…
    
75.         驚不驚喜！！！
    
76.         要不要開開看？
    
77.         PS：不開就等著餓死吧！')
    
78.         mut dark_room := new_page('伸手不見5指的房間')
    
79.         mut dark_room_lit := new_page('有點小小亮光的房間')
    
80.         grue := new_page('就是一個房間')
    
81.         trap := new_page('哈一個該的陷阱！你死了。')
    
82.         treasure := new_page('出○')
    
83.         star.add_choice('N', '北門', dark_room)
    
84.         star.add_choice('S', '南門', dark_room)
    
85.         star.add_choice('E', '東門', trap)
    
86.         dark_room.add_choice('S', '退回南門', grue)
    
87.         dark_room.add_choice('O', '點亮臘燭！', dark_room_lit)
    
88.         dark_room_lit.add_choice('N', '走北門', treasure)
    
89.         dark_room_lit.add_choice('S', '走南門', star)
    
90.         star.play()
    
91.         println('結束了？？？')
    
92. }

複製代碼

ikj78i

計算質數表的 Eratosthenes 篩選法應該也算是窮舉法吧？

假設想要列出小於 N 的質數，可以先由 2 開始把小於 N 的正整數一一列出，然後把 2 的倍數刪去。
之後再由 2 開始找到第一個沒被刪去的數，3，即為質數，再把 3 的倍數刪去。刪去之後再由 3 開始
，找到第一個沒被刪去的數，5，這就是下一個質數，再刪去 5 的倍數。然後由 5 開始，找到下一個
沒被刪去的數，7，7 就是下個質數……如此循環不已，直到 N 為止。

SoaB

也算是窮舉法的應用了…
程式如下…只取2-25中的質數…

1. module main
   
2. 
   
3. fn main() {
   
4.         mut prime_num := []int{}
   
5.         mut nums := [2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]
   
6.         println(nums)
   
7.         for nums.len > 1 {
   
8.                 prime_num << nums[0]
   
9.                 nums = nums.filter(it % nums[0] != 0)
   
10.         }
    
11.         prime_num << nums[0]
    
12.         println(prime_num)
    
13. }

複製代碼