Jadval funksiyani Fure qatoriga yoyish. Fure koeffitsientlarini hisoblash. Qator hadlari sonini tanlash Ishdan maqsad

Topshiriqlar.

1. 
   Hoffman algoritmidan foydalanib, optimal kodni yarating, kodning natijasini toping.
   

https://www.matburo.ru/Examples/Files/Haf1.pdf

2. 
   6 ta kod belgisi mavjud. Huffman algoritm bilan STUDENT matn xabari uchun kodni qurish
   

https://www.matburo.ru/Examples/Files/Cod1.pdf

3. 
   7-bit kodi bilan qancha ikkilik raqamni ko'rsatish mumkin. Misol sifatida ko’rsating.
   
4. 
   Hoffman algoritmi haqida ma’lumot (misollar bilan)
   
5. 
   Hoffman kodi algoritmi asosida tasvirlarni siqish
   
6. 
   Hoffman kodi algoritmi asosida ma’lumotlarni siqish
   
7. 
   Hoffman kodi algoritmi orqali TATUFF so’z birikmalrini siqish
   
8. 
   Hoffman kodi algoritmi orqali O’ZBEKISTON so’zini siqish
   
9. 
   Hoffman kodi algoritmi orqali HOFFMAN so’zini siqish
   
10. 
    Hoffman kodi algoritmi orqali ALGORITM so’zini siqish
    
11. 
    // Huffman Coding in C++
    
12. 
    
13. 
    #include
    
14. 
    using namespace std;
    
15. 
    
16. 
    #define MAX_TREE_HT 50
    
17. 
    
18. 
    struct MinHNode {
    
19. 
    unsigned freq;
    
20. 
    char item;
    
21. 
    struct MinHNode *left, *right;
    
22. 
    };
    
23. 
    
24. 
    struct MinH {
    
25. 
    unsigned size;
    
26. 
    unsigned capacity;
    
27. 
    struct MinHNode **array;
    
28. 
    };
    
29. 
    
30. 
    // Creating Huffman tree node
    
31. 
    struct MinHNode *newNode(char item, unsigned freq) {
    
32. 
    struct MinHNode *temp = (struct MinHNode *)malloc(sizeof(struct MinHNode));
    
33. 
    
34. 
    temp->left = temp->right = NULL;
    
35. 
    temp->item = item;
    
36. 
    temp->freq = freq;
    
37. 
    
38. 
    return temp;
    
39. 
    }
    
40. 
    
41. 
    // Create min heap using given capacity
    
42. 
    struct MinH *createMinH(unsigned capacity) {
    
43. 
    struct MinH *minHeap = (struct MinH *)malloc(sizeof(struct MinH));
    
44. 
    minHeap->size = 0;
    
45. 
    minHeap->capacity = capacity;
    
46. 
    minHeap->array = (struct MinHNode **)malloc(minHeap->capacity * sizeof(struct MinHNode *));
    
47. 
    return minHeap;
    
48. 
    }
    
49. 
    
50. 
    // Print the array
    
51. 
    void printArray(int arr[], int n) {
    
52. 
    int i;
    
53. 
    for (i = 0; i < n; ++i)
    
54. 
    cout << arr[i];
    
55. 
    
56. 
    cout << "\n";
    
57. 
    }
    
58. 
    
59. 
    // Swap function
    
60. 
    void swapMinHNode(struct MinHNode **a, struct MinHNode **b) {
    
61. 
    struct MinHNode *t = *a;
    
62. 
    *a = *b;
    
63. 
    *b = t;
    
64. 
    }
    
65. 
    
66. 
    // Heapify
    
67. 
    void minHeapify(struct MinH *minHeap, int idx) {
    
68. 
    int smallest = idx;
    
69. 
    int left = 2 * idx + 1;
    
70. 
    int right = 2 * idx + 2;
    
71. 
    
72. 
    if (left < minHeap->size && minHeap->array[left]->freq < minHeap->array[smallest]->freq)
    
73. 
    smallest = left;
    
74. 
    
75. 
    if (right < minHeap->size && minHeap->array[right]->freq < minHeap->array[smallest]->freq)
    
76. 
    smallest = right;
    
77. 
    
78. 
    if (smallest != idx) {
    
79. 
    swapMinHNode(&minHeap->array[smallest],
    
80. 
    &minHeap->array[idx]);
    
81. 
    minHeapify(minHeap, smallest);
    
82. 
    }
    
83. 
    }
    
84. 
    
85. 
    // Check if size if 1
    
86. 
    int checkSizeOne(struct MinH *minHeap) {
    
87. 
    return (minHeap->size == 1);
    
88. 
    }
    
89. 
    
90. 
    // Extract the min
    
91. 
    struct MinHNode *extractMin(struct MinH *minHeap) {
    
92. 
    struct MinHNode *temp = minHeap->array[0];
    
93. 
    minHeap->array[0] = minHeap->array[minHeap->size - 1];
    
94. 
    
95. 
    --minHeap->size;
    
96. 
    minHeapify(minHeap, 0);
    
97. 
    
98. 
    return temp;
    
99. 
    }
    
100. 
     
101. 
     // Insertion
     
102. 
     void insertMinHeap(struct MinH *minHeap, struct MinHNode *minHeapNode) {
     
103. 
     ++minHeap->size;
     
104. 
     int i = minHeap->size - 1;
     
105. 
     
106. 
     while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) {
     
107. 
     minHeap->array[i] = minHeap->array[(i - 1) / 2];
     
108. 
     i = (i - 1) / 2;
     
109. 
     }
     
110. 
     
111. 
     minHeap->array[i] = minHeapNode;
     
112. 
     }
     
113. 
     
114. 
     // BUild min heap
     
115. 
     void buildMinHeap(struct MinH *minHeap) {
     
116. 
     int n = minHeap->size - 1;
     
117. 
     int i;
     
118. 
     
119. 
     for (i = (n - 1) / 2; i >= 0; --i)
     
120. 
     minHeapify(minHeap, i);
     
121. 
     }
     
122. 
     
123. 
     int isLeaf(struct MinHNode *root) {
     
124. 
     return !(root->left) && !(root->right);
     
125. 
     }
     
126. 
     
127. 
     struct MinH *createAndBuildMinHeap(char item[], int freq[], int size) {
     
128. 
     struct MinH *minHeap = createMinH(size);
     
129. 
     
130. 
     for (int i = 0; i < size; ++i)
     
131. 
     minHeap->array[i] = newNode(item[i], freq[i]);
     
132. 
     
133. 
     minHeap->size = size;
     
134. 
     buildMinHeap(minHeap);
     
135. 
     
136. 
     return minHeap;
     
137. 
     }
     
138. 
     
139. 
     struct MinHNode *buildHfTree(char item[], int freq[], int size) {
     
140. 
     struct MinHNode *left, *right, *top;
     
141. 
     struct MinH *minHeap = createAndBuildMinHeap(item, freq, size);
     
142. 
     
143. 
     while (!checkSizeOne(minHeap)) {
     
144. 
     left = extractMin(minHeap);
     
145. 
     right = extractMin(minHeap);
     
146. 
     
147. 
     top = newNode('$', left->freq + right->freq);
     
148. 
     
149. 
     top->left = left;
     
150. 
     top->right = right;
     
151. 
     
152. 
     insertMinHeap(minHeap, top);
     
153. 
     }
     
154. 
     return extractMin(minHeap);
     
155. 
     }
     
156. 
     void printHCodes(struct MinHNode *root, int arr[], int top) {
     
157. 
     if (root->left) {
     
158. 
     arr[top] = 0;
     
159. 
     printHCodes(root->left, arr, top + 1);
     
160. 
     }
     
161. 
     
162. 
     if (root->right) {
     
163. 
     arr[top] = 1;
     
164. 
     printHCodes(root->right, arr, top + 1);
     
165. 
     }
     
166. 
     if (isLeaf(root)) {
     
167. 
     cout << root->item << " | ";
     
168. 
     printArray(arr, top);
     
169. 
     }
     
170. 
     }
     
171. 
     
172. 
     // Wrapper function
     
173. 
     void HuffmanCodes(char item[], int freq[], int size) {
     
174. 
     struct MinHNode *root = buildHfTree(item, freq, size);
     
175. 
     
176. 
     int arr[MAX_TREE_HT], top = 0;
     
177. 
     
178. 
     printHCodes(root, arr, top);
     
179. 
     }
     
180. 
     
181. 
     int main() {
     
182. 
     char arr[] = {'A', 'B', 'C', 'D'};
     
183. 
     int freq[] = {5, 1, 6, 3};
     
184. 
     
185. 
     int size = sizeof(arr) / sizeof(arr[0]);
     
186. 
     
187. 
     cout << "Char | Huffman code ";
     
188. 
     cout << "\n----------------------\n";
     
189. 
     HuffmanCodes(arr, freq, size);
     
190. 
     }
     

Nazorat savollari

1. 
   Axborotlar oqimini segmentlarga ajratish qanday amalga oshiriladi.
   
2. 
   Chiziqli modelni tushuntirib bering.
   

LABORATORIYA ISHI - 17
Mavzu: Jarayon matematik modelini tuzishda eng kichik kvadratlar usulidan foydalanish.
Ishdan maqsad. Jarayon matematik modelini tuzishda eng kichik kvadratlar usulidan foydalanishni o’rganish.
Qo’yilgan masala. Jarayon matematik modelini tuzishda eng kichik kvadratlar usulidan foydalanish.
Ish tartibi:

• 
  Tajriba ishi nazariy ma’lumotlarini o‘rganish;
  
• 
  Berilgan topshiriqning algoritmini ishlab chiqish;
  
• 
  Natijalarni tekshirish;
  
• 
  Hisobotni tayyorlash va topshirish.
  

Nazariy qism
Birlashmali saralash (Merge Sort) algoritmi asosiy beshta saralash algoritmlari (pufakchali saralash, tezkor saralash va boshqalar) dan biri bo`lib, chiziqli saralash algoritmlaridan farqli ravishda "bo`lib tashla va hukmronlik qil" tipidagi algoritm hisoblanadi.
Bu tipdagi algoritmlar katta hajmdagi masalalarni nisbatan kichik bo`lgan va oson yechiladigan qismlarga ajratgan holda bajaradi. Bunday algoritmlar masalalarni hal qilishda vaqtdan katta yutuq qilish imkonini beradi.
Birlashmali saralashda biz berilgan massivni uzunligi faqat 1 elementga teng bo`lgan qismlar qolmaguncha o`rtasidan ajratamiz. Keyin bu qismlar to`g`ri tartibda birlashtiriladi.
Keling ushbu massivni qaraylik:
Uni teng ikkiga ajratamiz:
Va yana har bir qismni ikkiga ajratamiz, toki 1 elementli qismlar qolmagunicha:
Massivni maksimal qisqa qismlarga ajratgandan so`ng, ularni to`g`ri tartibda birlashtiramiz, ya'ni:
Dastlab, 2 elementli saralangan guruhlarni olamiz va ularni 4 elementli guruhlarga birlashtiramiz va yakunida hammasini birlashtirgan holda saralangan massivni hosil qilamiz.
Algoritm ishlashi uchun quyidagi amallarni amalga oshirish kerak:

1. 
   Massivni guruhlarga rekursiv ajratish amali ( sort).
   
2. 
   To`g`ri tartibda birlashtirish amali (merge).
   

Java dasturlash tilidagi algoritm kodi:
import java.util.Arrays;