C语言系统化精讲重塑你的编程思想打造坚实的开发基础

download:C语言系统化精讲重塑你的编程思想打造坚实的开发基础

修炼内功最强语言，训练编程思想最有效语言，圣经般存在的语言，2020 TIOBE排行冠军语言——这些说的，都是C语言。每个优秀开发者都应该精通C语言，这门课程就是为所有没学过、没学好C语言的你专属打造，多种编程语言技术专家bennyhuo独家分享，带你系统、高效、轻松啃透C语言这个硬骨头！

适合人群
希望获得更深层次进阶语言的开发者
希望夯实语言基础的开发者
希望精雕细琢掌握多门语言的开发者
有面试/跳槽/晋升需求的开发者和在校生
技术储备要求
零门槛，有计算机基础、操作系统、编程基础和经验更佳

挑选法找素数是个不错的办法，2、3、4、5、6、7、8、9、10 ... 这些数中，第一个数 2 是素数，取出来，然后将 2 的倍数全部去掉；剩下的第一个数 3 还是素数，再去掉一切 3 的倍数，不断停止下去，就能找到很多素数。本例子也就是用的这个办法。

详细逻辑是：第一个管道记载从2开端的自然数，取第一自然数/质数 2；然后第二个管道记载从第一个管道中过滤后的一切自然数，再取一个质数 3；第三个管道取第二个管道中过滤后的数，又得一个质数；一切的管道都是无限长的，只需程序嚒有终止，这些挑选/过滤便不断在停止着。

1. c add1 (x *Number ) *Number {
2. e := new (Number )
3. *e = x
4. return e
5. }
7. func sub1 (x *Number ) *Number {
8. return *x
9. }
11. func add (x , y *Number ) *Number {
12. if isZero (y ) {
13. return x
14. }
15. return add (add1 (x ), sub1 (y ))
16. }
18. func mul (x , y *Number ) *Number {
19. if isZero (x ) || isZero (y ) {
20. return zero ()
21. }
22. return add (mul (x , sub1 (y )), x )
23. }
25. func fact (n *Number ) *Number {
26. if isZero (n ) {
27. return add1 (zero ())
28. }
29. return mul (fact (sub1 (n )), n )
30. }
32. // -------------------------------------
33. // Helpers to generate/count Peano integers
35. func gen (n int ) *Number {
36. if n > 0 {
37. return add1 (gen (n - 1 ))
38. }
39. return zero ()
40. }
42. func count (x *Number ) int {
43. if isZero (x ) {
44. return 0
45. }
46. return count (sub1 (x )) + 1
47. }
49. // -------------------------------------
50. // Print i! for i in [0,9]
52. func main () {
53. for i := 0 ; i < = 9 ; i ++ {
54. f := count (fact (gen ( i )))
55. fmt .Println ( i , "! =" , f )
56. }
57. }
这是一个 n！的例子，但又不是单单的一个求 n！的例子；这个例子让 e 们赶脚到了 —— 自然数能够结构出来或是逐个数出来！“皮亚诺自然数公理”：0 是一个自然数；每个自然数后面都跟有一个自然数；除 0 之外，每个自然数前面都有一个自然数；—— 0 很特殊，是第一个自然数，由于它前面没有自然数！同时例子中也反映了：阶乘依赖于自然数乘法；自然数乘法依赖于自然数加法，而自然数加法其实是个递归定义。

自然数就是一个链表，链表的第一个元素代表 0 ，第二个元素代表 1，第三个代表 2，不断下去。10 就是一个长度为 10 的链表！求 10！的思绪不再是循环一下，乘一下！而是，结构出一个长度是 10！的链表，然后 count 一下长度，就是 10！多此一举？！这里一切的操作只树立在“加一”、“减一”和“递归”的根底之上。
并发求圆周率 π
1. // Concurrent computation of pi.
2. // See http://goo.gl/ZuTZM.
3. //
4. // This demonstrates Go's ability to handle
5. // large numbers of concurrent processes.
6. // It is an unreasonable way to calculate pi.
7. package main
9. import (
10. "fmt"
11. "math"
12. )
14. func main () {
15. fmt .Println (pi ( 5000 ))
16. }
18. // pi launches n goroutines to compute an
19. // approximation of pi.
20. func pi (n int ) float64 {
21. ch := make ( chan float64 )
22. for k := 0 ; k < = n ; k ++ {
23. go term (ch , float64 (k ))
24. }
25. f := 0 . 0
26. for k := 0 ; k < = n ; k ++ {
27. f += < -ch
28. }
29. return f
30. }
32. func term (ch chan float64 , k float64 ) {
33. ch < - 4 * math .Pow ( - 1 , k ) / ( 2 *k + 1 )
34. }
割圆术求圆周长或是圆周率，听的比拟多，but，太不实在可行！不论公式怎样来的，总之有下面一个公式，本例子就是用这个公式求 π ：

例子中运用了并发求每单项的值，然后将每单项的值加起来，赶脚是，加的项数越多，便越接近与真值。

go 中的管道（channel）提供了一种很便当的并发同步机制。管道是衔接多个并发函数的通道，就像是水管，一端能够流进去，另一端能够流进来。这里多个函数/进程将每个单项的求值放到管道之后，谁先谁后是不肯定的，然后另外一个函数/进程从管道中取值然后加起来，最后的结果便是就得的 π 的近似值。管道的同步操作曾经内置，也就是不需求偶们本人去管来的。 go 是偶目前看到的写并发程序最容易的言语，么有之一！
并发经过挑选法求素数
1. // A concurrent prime sieve
3. package main
5. // Send the sequence 2, 3, 4, ... to channel 'ch'.
6. func Generate (ch chan< - int ) {
7. for i := 2 ; ; i ++ {
8. ch < - i // Send 'i' to channel 'ch'.
9. }
10. }
12. // Copy the values from channel 'in' to channel 'out',
13. // removing those divisible by 'prime'.
14. func Filter (in < - chan int , out chan< - int , prime int ) {
15. for {
16. i := < -in // Receive value from 'in'.
17. if i %prime != 0 {
18. out < - i // Send 'i' to 'out'.
19. }
20. }
21. }
23. // The prime sieve: Daisy-chain Filter processes.
24. func main () {
25. ch := make ( chan int ) // Create a new channel.
26. go Generate (ch ) // Launch Generate goroutine.
27. for i := 0 ; i < 10 ; i ++ {
28. prime := < -ch
29. print (prime , "\n" )
30. ch1 := make ( chan int )
31. go Filter (ch , ch1 , prime )
32. ch = ch1
33. }
34. }
孔明棋
1. // This program solves the (English) peg
2. // solitaire board game.
3. // http://en.wikipedia.org/wiki/Peg_solitaire
5. package main
7. import "fmt"
9. const N = 11 + 1 // length of a row (+1 for \n)
11. // The board must be surrounded by 2 illegal
12. // fields in each direction so that move()
13. // doesn't need to check the board boundaries.
14. // Periods represent illegal fields,
15. // ● are pegs, and ○ are holes.
17. var board = []rune (
18. `...........
19. ...........
20. ....●●●....
21. ....●●●....
22. ..●●●●●●●..
23. ..●●●○●●●..
24. ..●●●●●●●..
25. ....●●●....
26. ....●●●....
27. ...........
28. ...........
29. ` )
31. // center is the position of the center hole if
32. // there is a single one; otherwise it is -1.
33. var center int
35. func init () {
36. n := 0
37. for pos , field := range board {
38. if field == '○' {
39. center = pos
40. n ++
41. }

来源：oschina

链接：https://my.oschina.net/u/4978051/blog/4952524

标签

MUL

sieve

C语言系统化精讲 重塑你的编程思想 打造坚实的开发基础

download:C语言系统化精讲 重塑你的编程思想 打造坚实的开发基础

C语言系统化精讲重塑你的编程思想打造坚实的开发基础

download:C语言系统化精讲重塑你的编程思想打造坚实的开发基础