Table of Contents for
Intermediate C Programming

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Intermediate C Programming by Yung-Hsiang Lu Published by CRC Press, 2015
  1. Front Cover
  2. Contents (1/2)
  3. Contents (2/2)
  4. List of Figures (1/2)
  5. List of Figures (2/2)
  6. List of Tables
  7. Foreword
  8. Preface
  9. Author, Reviewers, and Artist
  10. Rules in Software Development
  11. Source Code
  12. I. Computer Storage: Memory and File
  13. 1. Program Execution (1/2)
  14. 1. Program Execution (2/2)
  15. 2. Stack Memory (1/5)
  16. 2. Stack Memory (2/5)
  17. 2. Stack Memory (3/5)
  18. 2. Stack Memory (4/5)
  19. 2. Stack Memory (5/5)
  20. 3. Prevent, Detect, and Remove Bugs (1/2)
  21. 3. Prevent, Detect, and Remove Bugs (2/2)
  22. 4. Pointers (1/6)
  23. 4. Pointers (2/6)
  24. 4. Pointers (3/6)
  25. 4. Pointers (4/6)
  26. 4. Pointers (5/6)
  27. 4. Pointers (6/6)
  28. 5. Writing and Testing Programs (1/4)
  29. 5. Writing and Testing Programs (2/4)
  30. 5. Writing and Testing Programs (3/4)
  31. 5. Writing and Testing Programs (4/4)
  32. 6. Strings (1/3)
  33. 6. Strings (2/3)
  34. 6. Strings (3/3)
  35. 7. Programming Problems and Debugging (1/4)
  36. 7. Programming Problems and Debugging (2/4)
  37. 7. Programming Problems and Debugging (3/4)
  38. 7. Programming Problems and Debugging (4/4)
  39. 8. Heap Memory (1/3)
  40. 8. Heap Memory (2/3)
  41. 8. Heap Memory (3/3)
  42. 9. Programming Problems Using Heap Memory (1/4)
  43. 9. Programming Problems Using Heap Memory (2/4)
  44. 9. Programming Problems Using Heap Memory (3/4)
  45. 9. Programming Problems Using Heap Memory (4/4)
  46. 10. Reading and Writing Files (1/3)
  47. 10. Reading and Writing Files (2/3)
  48. 10. Reading and Writing Files (3/3)
  49. 11. Programming Problems Using File (1/2)
  50. 11. Programming Problems Using File (2/2)
  51. II. Recursion
  52. 12. Recursion (1/4)
  53. 12. Recursion (2/4)
  54. 12. Recursion (3/4)
  55. 12. Recursion (4/4)
  56. 13. Recursive C Functions (1/4)
  57. 13. Recursive C Functions (2/4)
  58. 13. Recursive C Functions (3/4)
  59. 13. Recursive C Functions (4/4)
  60. 14. Integer Partition (1/5)
  61. 14. Integer Partition (2/5)
  62. 14. Integer Partition (3/5)
  63. 14. Integer Partition (4/5)
  64. 14. Integer Partition (5/5)
  65. 15. Programming Problems Using Recursion (1/5)
  66. 15. Programming Problems Using Recursion (2/5)
  67. 15. Programming Problems Using Recursion (3/5)
  68. 15. Programming Problems Using Recursion (4/5)
  69. 15. Programming Problems Using Recursion (5/5)
  70. III. Structure
  71. 16. Programmer-Defined Data Types (1/6)
  72. 16. Programmer-Defined Data Types (2/6)
  73. 16. Programmer-Defined Data Types (3/6)
  74. 16. Programmer-Defined Data Types (4/6)
  75. 16. Programmer-Defined Data Types (5/6)
  76. 16. Programmer-Defined Data Types (6/6)
  77. 17. Programming Problems Using Structure (1/4)
  78. 17. Programming Problems Using Structure (2/4)
  79. 17. Programming Problems Using Structure (3/4)
  80. 17. Programming Problems Using Structure (4/4)
  81. 18. Linked Lists (1/3)
  82. 18. Linked Lists (2/3)
  83. 18. Linked Lists (3/3)
  84. 19. Programming Problems Using Linked List (1/2)
  85. 19. Programming Problems Using Linked List (2/2)
  86. 20. Binary Search Trees (1/4)
  87. 20. Binary Search Trees (2/4)
  88. 20. Binary Search Trees (3/4)
  89. 20. Binary Search Trees (4/4)
  90. 21. Parallel Programming Using Threads (1/5)
  91. 21. Parallel Programming Using Threads (2/5)
  92. 21. Parallel Programming Using Threads (3/5)
  93. 21. Parallel Programming Using Threads (4/5)
  94. 21. Parallel Programming Using Threads (5/5)
  95. IV. Applications
  96. 22. Finding the Exit of a Maze (1/5)
  97. 22. Finding the Exit of a Maze (2/5)
  98. 22. Finding the Exit of a Maze (3/5)
  99. 22. Finding the Exit of a Maze (4/5)
  100. 22. Finding the Exit of a Maze (5/5)
  101. 23. Image Processing (1/3)
  102. 23. Image Processing (2/3)
  103. 23. Image Processing (3/3)
  104. 24. Huffman Compression (1/10)
  105. 24. Huffman Compression (2/10)
  106. 24. Huffman Compression (3/10)
  107. 24. Huffman Compression (4/10)
  108. 24. Huffman Compression (5/10)
  109. 24. Huffman Compression (6/10)
  110. 24. Huffman Compression (7/10)
  111. 24. Huffman Compression (8/10)
  112. 24. Huffman Compression (9/10)
  113. 24. Huffman Compression (10/10)
  114. A. Linux
  115. B. Version Control
  116. C. Integrated Development Environments (IDE) (1/3)
  117. C. Integrated Development Environments (IDE) (2/3)
  118. C. Integrated Development Environments (IDE) (3/3)
Integer Partition 221
-: 30: {
628890: 31: i nt valid = 0;
628890: 32: i f ( ind == 0) // no res t riction for the
first number
-: 33: {
30: 34: valid = 1;
-: 35: }
-: 36: e l s e
-: 37: {
628860: 38: valid = ( arr [ ind - 1] % 2) != ( val
% 2);
-: 39: }
628890: 40: i f ( valid == 1)
-: 41: {
308288: 42: arr [ ind ] = val ;
308288: 43: p artition1 ( arr , ind + 1, left -
val ) ;
-: 44: }
-: 45: }
-: 46:}
-: 47:
-: 48: // 2. before printing , check whether the
partition is valid
-: 49: // check whether the numbers are a lternati ng
odd and even
-: 50: // return 1 if valid
-: 51: // return 0 if invalid
5368709 1 2: 52: in t isValid ( i n t * arr , i nt len )
-: 53:{
5368709 1 2: 54: i f ( len <= 1) // if only one number , it is
valid
-: 55: {
1: 56: return 1;
-: 57: }
-: 58: i nt ind ;
130496 3113: 59: for ( ind = 2; ind < len ; ind += 2)
-: 60: {
-: 61:
-: 62: // invalid if they are differen t
128397 3260: 63: i f (( arr [ ind ] % 2) != ( arr [0] % 2) )
-: 64: {
5158810 5 8: 65: return 0;
-: 66: }
-: 67: }
33079750: 68: f or ( ind = 1; ind < len ; ind += 2)
-: 69: {
-: 70:
-: 71: // invalid if they are the same
32978358: 72: i f (( arr [ ind ] % 2) == ( arr [0] % 2) )
-: 73: {
20888461: 74: return 0;
222 Intermediate C Programming
-: 75: }
-: 76: }
101392: 77: return 1;
-: 78:}
-: 79:
107374 1824: 80: void partitio n2 ( in t * arr , i n t ind , in t left )
-: 81:{
-: 82: i nt val ;
107374 1824: 83: i f ( left == 0)
-: 84: {
5368709 1 2: 85: i f ( isValid ( arr , ind ) == 1)
-: 86: {
101393: 87: prin t Partit ion ( arr , ind );
-: 88: }
161061 2736: 89: return ;
-: 90: }
161061 2735: 91: for ( val = 1; val <= left ; val ++)
-: 92: {
107374 1823: 93: arr [ ind ] = val ;
107374 1823: 94: partition2 ( arr , ind + 1 , left - val );
-: 95: }
-: 96:}
-: 97:
1: 98: in t main ( i n t argc , char * argv [])
-: 99:{
1: 100: i f ( argc != 2)
-: 101: {
#####: 102: return EXIT_FAI LURE ;
-: 103: }
1: 104: i nt n = ( in t ) strtol ( argv [1] , NULL , 10) ;
1: 105: i f ( n <= 0)
-: 106: {
#####: 107: return EXIT_FAI LURE ;
-: 108: }
-: 109: in t * arr ;
1: 110: arr = malloc ( s i z e o f ( i n t ) * n) ;
1: 111: printf ( " ---- - Partition 1- -- --\ n" );
1: 112: p a rtition1 ( arr , 0 , n ) ;
1: 113: printf ( " ---- - Partition 2- -- --\ n" );
1: 114: p a rtition2 ( arr , 0 , n ) ;
1: 115: free ( arr );
1: 116: return EX IT_SUCCE SS ;
-: 117:}
Please pay special attention to lines 85 and 87. Line 85 says isValid is called 536870912
times but it is true only 101393 times. In other words, most generated partitions are invalid.
This is another way to obtain the same information: partition2 generates many invalid
partitions.