├── .gitignore
├── Module 1
    ├── .gitignore
    ├── limitations.c
    ├── output.c
    ├── print.c
    └── variable.c
├── Module 10
    ├── .gitignore
    ├── A_Create_A_New_String.c
    ├── B_Let_s_use_Getline.c
    ├── E_Count.c
    ├── array_of_char.c
    ├── initialize.c
    ├── input.c
    ├── input_with_space.c
    └── lenght.c
├── Module 11.5
    ├── .gitignore
    └── J_Count_Letters.c
├── Module 11
    ├── .gitignore
    ├── counting_character.c
    ├── couting_array.c
    ├── strcat.c
    ├── strcmp.c
    ├── string_compare.c
    ├── string_concat.c
    └── string_copy.c
├── Module 13
    ├── .gitignore
    ├── pattern_1.c
    ├── pattern_2.c
    ├── pattern_3.c
    ├── pattern_4.c
    ├── sorting.c
    └── sum_of_two.c
├── Module 14
    ├── .gitignore
    ├── function_1.c
    ├── function_2.c
    ├── function_3.c
    ├── function_4.c
    ├── math_functions.c
    ├── pointer.c
    └── scope.c
├── Module 15
    ├── .gitignore
    ├── array_and_pointer.c
    ├── call_by_reference.c
    ├── call_by_value.c
    ├── function_and_array.c
    ├── function_and_array_as_reference.c
    ├── function_and_string.c
    ├── pointers.c
    └── pointers2.c
├── Module 17
    ├── .gitignore
    ├── call_stack.c
    ├── length_of_string.c
    ├── print_1_to_5.c
    ├── print_5_to_1.c
    ├── print_5_to_1_2.c
    ├── print_array.c
    └── recursion.c
├── Module 18
    ├── .gitignore
    ├── exact_row_column_print.c
    ├── input_output.c
    ├── primary_diagona.c
    ├── scalar_matrix.c
    ├── secondary_diagonal.c
    ├── unit_matrix.c
    ├── unit_matrix_secondary.c
    └── zero_matrix.c
├── Module 19
    ├── .gitignore
    ├── D_Print_Digits_using_Recursion.c
    ├── I_Count_Vowels.c
    ├── J_Factorial.c
    ├── K_Max_Number.c
    ├── N_Sum_of_a_Matrix.c
    ├── W_Mirror_Array.c
    ├── palindrome.c
    └── palindrome_two_pointer.c
├── Module 2
    ├── .gitignore
    ├── arithmetic.c
    ├── conditiona_1.c
    ├── conditional_2.c
    └── conditional_3.c
├── Module 3
    ├── .gitignore
    ├── break.c
    ├── continue.c
    ├── do_while.c
    ├── loop_1.c
    ├── loop_2.c
    ├── loop_condition.c
    ├── loop_sum.c
    └── while.c
├── Module 5
    ├── .gitignore
    ├── i.c
    ├── j.c
    ├── k.c
    ├── m.c
    ├── n.c
    └── p.c
├── Module 6
    ├── .gitignore
    ├── B_Even_Numbers.c
    ├── C_Even_Odd_Positive_and_Negative.c
    ├── D_Fixed_Password.c
    ├── E_Max.c
    ├── F_Multiplication_table.c
    ├── Q_Digits.c
    ├── inc_dec.c
    └── nested_loop.c
├── Module 7.5
    ├── .gitignore
    ├── B_Searching.c
    └── E_Lowest_Number.c
├── Module 7
    ├── .gitignore
    ├── array_declare.c
    ├── array_initialize.c
    ├── array_input_output_1.c
    ├── array_input_output_2.c
    ├── array_reverse_print.c
    └── sum_of_array.c
├── Module 9
    ├── .gitignore
    ├── copy.c
    ├── delete.c
    ├── insert.c
    └── reverse.c
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | Setup/
2 | .vscode/


--------------------------------------------------------------------------------
/Module 1/.gitignore:
--------------------------------------------------------------------------------
1 | *.txt
2 | *.exe
3 | *.bin


--------------------------------------------------------------------------------
/Module 1/limitations.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     double a=22.123456789123456;
5 |     printf("%0.15lf",a);
6 |     return 0;
7 | }


--------------------------------------------------------------------------------
/Module 1/output.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     int a,b;
5 |     scanf("%d %db",&a,&b);
6 |     printf("%da %db",a,b);
7 |     return 0;
8 | }


--------------------------------------------------------------------------------
/Module 1/print.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     printf("Hello World\t\t\tNew Tab e Jao");
 5 |     printf("Hello World");
 6 |     return 0;
 7 | }
 8 | 
 9 | // \n - new line 
10 | // \t - tab            
11 | // Hello World
12 | // Now I am a programmer


--------------------------------------------------------------------------------
/Module 1/variable.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     int rahim=10;
5 |     float karim=10000.52;
6 |     char habib='Z';
7 |     printf("%0.1f",karim);
8 |     return 0;
9 | }


--------------------------------------------------------------------------------
/Module 10/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 10/A_Create_A_New_String.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char s[1001],t[1001];
 6 |     scanf("%s %s",&s,&t);
 7 |     int lenS=strlen(s);
 8 |     int lenT = strlen(t);
 9 |     printf("%d %d\n",lenS,lenT);
10 |     printf("%s %s\n",s,t);
11 |     return 0;
12 | }


--------------------------------------------------------------------------------
/Module 10/B_Let_s_use_Getline.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     char a[1000001];
 5 |     fgets(a,100001,stdin);
 6 |     for(int i=0;a[i] != '\\';i++)
 7 |     {
 8 |         printf("%c",a[i]);
 9 |     }
10 |     return 0;
11 | }


--------------------------------------------------------------------------------
/Module 10/E_Count.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[1000001];
 6 |     scanf("%s",a);
 7 |     int sum=0;
 8 |     for(int i=0;i<strlen(a);i++)
 9 |     {
10 |         sum=sum+(a[i]-'0');
11 |     }
12 |     printf("%d",sum);
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 10/array_of_char.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     char a[5];
5 |     int sz=sizeof(a)/sizeof(char);
6 |     printf("%d",sizeof(a));
7 |     return 0;
8 | }


--------------------------------------------------------------------------------
/Module 10/initialize.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     // char a[6]={'R','a','h','a','t'}; // no gurantee
 5 |     char a[6]="Rahat"; // gurantee
 6 |     // int sz=sizeof(a)/sizeof(char);
 7 |     // printf("%d\n",sz);
 8 |     printf("%s",a);
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 10/input.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     char a[18];
5 |     scanf("%s",&a);
6 |     printf("%s\n",a);
7 |     return 0;
8 | }


--------------------------------------------------------------------------------
/Module 10/input_with_space.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[100];
 6 |     fgets(a,19,stdin);
 7 |     a[17]='\0';
 8 |     printf("%s",a);
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 10/lenght.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[100];
 6 |     scanf("%s",a);
 7 |     int st = strlen(a);
 8 |     printf("%d\n",st);
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 11.5/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 11.5/J_Count_Letters.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     char c;
 5 |     int cnt[26]={0};
 6 |     while(scanf("%c",&c) != EOF)
 7 |     {
 8 |         cnt[c-'a']++;
 9 |     }
10 |     for(char i='a';i<='z';i++)
11 |     {
12 |         if(cnt[i-'a']>0)
13 |         {
14 |             printf("%c : %d\n",i,cnt[i-'a']);
15 |         }
16 |     }
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Module 11/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 11/counting_character.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char s[100];
 6 |     scanf("%s",s);
 7 |     int cnt[26]={0};
 8 |     for(int i=0;i<strlen(s);i++)
 9 |     {
10 |         int value = s[i]-'a';
11 |         cnt[value]++;
12 |     }
13 |     for(int i=0;i<strlen(s);i++)
14 |     {
15 |         int value=s[i]-97;
16 |         if(cnt[value]!=0)
17 |         {
18 |             printf("%c - %d\n",value+'a',cnt[value]);
19 |         }
20 |         cnt[value]=0;
21 |     }
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 11/couting_array.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int a[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&a[i]);
10 |     }
11 |     int cnt[7]={0};
12 |     for(int i=0;i<n;i++)
13 |     {
14 |         int val=a[i];
15 |         cnt[val]++;
16 |     }
17 |     
18 |     for(int i=0;i<=6;i++)
19 |     {
20 |         printf("%d - %d\n",i,cnt[i]);
21 |     }
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 11/strcat.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[200],b[100];
 6 |     scanf("%s %s",a,b);
 7 |     strcat(a,b);
 8 |     printf("%s %s",a,b);
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 11/strcmp.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[100],b[100];
 6 |     scanf("%s %s",a,b);
 7 |     int v=strcmp(a,b);
 8 |     if(v<0)
 9 |     {
10 |         printf("A is smaller\n");
11 |     }
12 |     else if(v>0)
13 |     {
14 |         printf("B is smaller\n");
15 |     }
16 |     else 
17 |     {
18 |         printf("Same\n");
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Module 11/string_compare.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     char a[100],b[100];
 5 |     scanf("%s %s",a,b);
 6 |     int i=0;
 7 |     while(1)
 8 |     {
 9 |         if(a[i]=='\0' && b[i]=='\0')
10 |         {
11 |             printf("Same\n");
12 |             break;
13 |         }
14 |         else if(a[i]=='\0')
15 |         {
16 |             printf("A choto\n");
17 |             break;
18 |         }
19 |         else if(b[i]=='\0')
20 |         {
21 |             printf("B choto\n");
22 |             break;
23 |         }
24 | 
25 |         if(a[i]==b[i])
26 |         {
27 |             i++;
28 |         }        
29 |         else if(a[i]<b[i])
30 |         {
31 |             printf("A choto\n");
32 |             break;
33 |         }
34 |         else
35 |         {
36 |             printf("B choto\n");
37 |             break;
38 |         }
39 |     }
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Module 11/string_concat.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[200],b[100];
 6 |     scanf("%s %s",a,b);
 7 |     int k=strlen(a);
 8 |     for(int i=0;i<=strlen(b);i++)
 9 |     {
10 |         a[k]=b[i];
11 |         k++;
12 |     }
13 |     printf("%s %s",a,b);
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 11/string_copy.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[100],b[100];
 6 |     scanf("%s %s",a,b);
 7 |     strcpy(a,b);
 8 |     printf("%s %s",a,b);
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 13/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 13/pattern_1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n,k=1;
 5 |     scanf("%d",&n);
 6 |     for(int i=1;i<=n;i++)
 7 |     {
 8 |         for(int j=1;j<=k;j++)
 9 |         {
10 |             printf("*");
11 |         }
12 |         // line sesh
13 |         k++;
14 |         printf("\n");
15 |     }
16 |     return 0;
17 | }


--------------------------------------------------------------------------------
/Module 13/pattern_2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n,s,k;
 5 |     scanf("%d",&n);
 6 |     s=n-1;
 7 |     k=1;
 8 |     for(int i=1;i<=n;i++)
 9 |     {
10 |         for(int j=1;j<=s;j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for(int j=1;j<=k;j++)
15 |         {
16 |             printf("*");
17 |         }
18 |         // line sesh
19 |         s--;
20 |         k=k+2;
21 |         printf("\n");
22 |     }
23 | 
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/Module 13/pattern_3.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n,k=1;
 5 |     scanf("%d",&n);
 6 |     for(int i=1;i<=n;i++)
 7 |     {
 8 |         // line print
 9 |         for(int j=1;j<=k;j++)
10 |         {
11 |             printf("%d ",j);
12 |         }
13 |         // line sesh
14 |         k++;
15 |         printf("\n");
16 |     }
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Module 13/pattern_4.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n,s,k;
 5 |     scanf("%d",&n);
 6 |     s=n-1;
 7 |     k=1;
 8 |     for(int i=1;i<=(2*n)-1;i++)
 9 |     {
10 |         // ekta line
11 |         for(int j=1;j<=s;j++)
12 |         {
13 |             printf(" ");
14 |         }
15 |         for(int j=1;j<=k;j++)
16 |         {
17 |             printf("*");
18 |         }
19 |         // line seshe
20 |         if(i<=n-1)
21 |         {
22 |             s--;
23 |             k=k+2;
24 |         }
25 |         else
26 |         {
27 |             s++;
28 |             k=k-2;
29 |         }
30 |         printf("\n");
31 |     }
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Module 13/sorting.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |      int n;
 5 |     scanf("%d",&n);
 6 |     int a[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&a[i]);
10 |     }
11 |     // ascending
12 |     // for(int i=0;i<n-1;i++)
13 |     // {
14 |     //     for(int j=i+1;j<n;j++)
15 |     //     {
16 |     //         if(a[i]>a[j])
17 |     //         {
18 |     //             int tmp=a[i];
19 |     //             a[i]=a[j];
20 |     //             a[j]=tmp;
21 |     //         }
22 |     //     }
23 |     // }
24 |      // descending
25 |     for(int i=0;i<n-1;i++)
26 |     {
27 |         for(int j=i+1;j<n;j++)
28 |         {
29 |             if(a[i]<a[j])
30 |             {
31 |                 int tmp=a[i];
32 |                 a[i]=a[j];
33 |                 a[j]=tmp;
34 |             }
35 |         }
36 |     }
37 |     for(int i=0;i<n;i++)
38 |     {
39 |         printf("%d ",a[i]);
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Module 13/sum_of_two.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int a[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&a[i]);
10 |     }
11 |     int x;
12 |     scanf("%d",&x);
13 |     int flag=0;
14 |     for(int i=0;i<n-1;i++)
15 |     {
16 |         for(int j=i+1;j<n;j++)
17 |         {
18 |             if(a[i]+a[j]==x)
19 |             {
20 |                 flag=1;
21 |             }
22 |         }
23 |     }
24 |     if(flag==0)
25 |     {
26 |         printf("NO\n");
27 |     }
28 |     else 
29 |     {
30 |         printf("YES\n");
31 |     }
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Module 14/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 14/function_1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | // return_type name(parameter)
 4 | // {
 5 | //     code 
 6 | //     return what? 
 7 | // }
 8 | int sum(int x,int y) // x=20 y=25
 9 | {
10 |     // code 
11 |     int sum=x+y;
12 |     return sum;
13 | }
14 | int main()
15 | {
16 |     int x,y;
17 |     scanf("%d %d",&x,&y);
18 |     printf("%d",sum(x,y));
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Module 14/function_2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int sum()
 3 | {
 4 |     int a,b;
 5 |     scanf("%d %d",&a,&b);
 6 |     int s=a+b;
 7 |     return s;
 8 | }
 9 | // int sum()
10 | // {
11 | //     printf("Bisshash koro input nicchi\n");
12 | //     return 0;
13 | // }
14 | int main()
15 | {
16 |     // printf("Ami kintu call kortesi\n");
17 |     int s=sum(100);
18 |     // printf("Dekhi ki korla tumi!\n");
19 |     printf("%d",s);
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Module 14/function_3.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | void sum(int x,int y)
 4 | {
 5 |     int s=x+y;
 6 |     printf("%d\n",s);
 7 | }
 8 | int main()
 9 | {
10 |     int a,b;
11 |     scanf("%d %d",&a,&b);
12 |     sum(a,b);
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 14/function_4.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | void sum(void)
 4 | {
 5 |     int a,b;
 6 |     scanf("%d %d",&a,&b);
 7 |     int s=a+b;
 8 |     printf("%d\n",s);
 9 | }
10 | int main()
11 | {
12 |     sum();
13 |     sum();
14 |     sum();
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 14/math_functions.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | #include<stdlib.h>
 4 | int main()
 5 | {
 6 |     // double x;
 7 |     // scanf("%lf",&x);
 8 |     // int ans=ceil(x);
 9 |     // int ans=floor(x);
10 |     // int ans=round(x);
11 | 
12 |     // double x;
13 |     // scanf("%lf",&x);
14 |     // double ans=sqrt(x);
15 |     // printf("%0.2lf",ans);
16 | 
17 |     // int a,b;
18 |     // scanf("%d %d",&a,&b);
19 |     // int ans=pow(a*1.0,b*1.0);
20 |     // printf("%d\n",ans);
21 | 
22 |     int x;
23 |     scanf("%d",&x);
24 |     int ans=abs(x);
25 |     printf("%d",ans);
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/Module 14/pointer.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int x=10;
 5 |     // printf("%p\n",&x);
 6 |     int* p=&x;
 7 |     // printf("%p\n",p);
 8 |     // dereference
 9 |     // printf("%d\n",*p);
10 |     *p=500;
11 | 
12 | 
13 |     printf("%d\n",x);
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 14/scope.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | // global
 3 | int x=500;
 4 | void fun(void)
 5 | {
 6 |     // printf("fun er x er address - %p\n",&x);
 7 | }
 8 | int main()
 9 | {
10 |     // printf("Main er x er address - %p\n",&x);
11 | 
12 |     // fun();
13 | 
14 |     int y=100;
15 |     for(int i=0;i<5;i++)
16 |     {
17 |         int z=100;
18 |     }
19 |     // printf("%d",z);
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Module 15/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 15/array_and_pointer.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int ar[5]={10,20,30,40,50};
 5 |     // printf("0th index er address - %p\n",&ar[0]);
 6 |     // printf("0th index er address - %p\n",ar);
 7 | 
 8 |     // printf("0th index er value - %d\n",ar[0]);
 9 |     // printf("0th index er value - %d\n",*ar);
10 | 
11 |     // printf("1st index er value - %d\n",ar[1]);
12 |     // printf("1st index er value - %d\n",*(ar+1));
13 | 
14 |     // printf("%d\n",*(1+ar));
15 | 
16 |     printf("%d\n",*(ar+1));
17 |     printf("%d\n",*(1+ar));
18 |     printf("%d\n",ar[1]);
19 |     printf("%d\n",1[ar]);
20 | 
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Module 15/call_by_reference.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(int* p)
 3 | {
 4 |     // printf("main er x er value - %d\n",*p);
 5 |     *p=500;
 6 | }
 7 | int main()
 8 | {
 9 |     int x=100;
10 |     // printf("x er address - %p\n",&x);
11 |     fun(&x);
12 |     printf("%d",x);
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 15/call_by_value.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(int x)
 3 | {
 4 |     x=200;
 5 | }
 6 | int main()
 7 | {
 8 |     int x=10;
 9 |     // printf("main x er address - %p\n",&x);
10 |     fun(x);
11 |     printf("main er x er value - %d\n",x);
12 |     return 0;
13 | }


--------------------------------------------------------------------------------
/Module 15/function_and_array.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(double ar[],int n)
 3 | {
 4 |     for(int i=0;i<n;i++)
 5 |     {
 6 |         printf("%0.2lf ",ar[i]);
 7 |     }
 8 | }
 9 | int main()
10 | {
11 |     double ar[5]={10.5,20.2,30.1,40.6,50.0};
12 |     fun(ar,5);
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 15/function_and_array_as_reference.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(char * ar)
 3 | {
 4 |     ar[0]='G';
 5 | }
 6 | int main()
 7 | {
 8 |     char ar[]="Hello";
 9 |     fun(ar);
10 |     printf("%s",ar);
11 |     return 0;
12 | }


--------------------------------------------------------------------------------
/Module 15/function_and_string.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | void fun(char ar[])
 4 | {
 5 |     printf("%d",strlen(ar));
 6 |     char n[]="World";
 7 |     return n;
 8 | }
 9 | int main()
10 | {
11 |     char ar[20]="Hello";
12 |     fun(ar);
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 15/pointers.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int x=100;
 5 |     int * ptr = &x;
 6 |     // x=200;
 7 |     *ptr=200;
 8 |     // x -> *ptr same 
 9 | 
10 |     printf("x er value - %d\n",x);
11 |     printf("x er value - %d\n",*ptr);
12 |     return 0;
13 | }


--------------------------------------------------------------------------------
/Module 15/pointers2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     double x=5.26;
 5 |     double * ptr = &x;
 6 |     double * ptr2 = ptr;
 7 |     // *ptr=10.20;
 8 |     *ptr2=100.50;
 9 | 
10 |     printf("x er value - %0.2lf\n",x);
11 |     printf("x er value - %0.2lf\n",*ptr);
12 |     printf("x er value - %0.2lf\n",*ptr2);
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 17/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 17/call_stack.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void world()
 3 | {
 4 |     printf("World Start\n");
 5 |     printf("World End\n");
 6 | }
 7 | void hello()
 8 | {
 9 |     printf("Hello Start\n");
10 |     world();
11 |     printf("Hello End\n");
12 | }
13 | int main()
14 | {
15 |     printf("Main Start\n");
16 |     hello();
17 |     printf("Main End\n");
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Module 17/length_of_string.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int fun(char a[],int i)
 3 | {
 4 |     if(a[i]=='\0') return 0;
 5 |     int l=fun(a,i+1);
 6 |     return l+1;
 7 | }
 8 | int main()
 9 | {
10 |     char a[6]="hello";
11 |     int length=fun(a,0);
12 |     printf("%d\n",length);
13 |     return 0;
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/Module 17/print_1_to_5.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(int i)
 3 | {
 4 |     if(i==6) return; // Base case
 5 |     printf("%d\n",i);
 6 |     fun(i+1);
 7 | }
 8 | int main()
 9 | {
10 |     fun(1);
11 |     return 0;
12 | }


--------------------------------------------------------------------------------
/Module 17/print_5_to_1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(int i)
 3 | {
 4 |     // base case
 5 |     if(i==0) return;
 6 |     printf("%d\n",i);
 7 |     fun(i-1);
 8 | }
 9 | int main()
10 | {
11 |     fun(5);
12 |     return 0;
13 | }


--------------------------------------------------------------------------------
/Module 17/print_5_to_1_2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(int i)
 3 | {
 4 |     if(i==6) return;
 5 |     fun(i+1);
 6 |     printf("%d\n",i);
 7 | }
 8 | int main()
 9 | {
10 |     fun(1);
11 |     return 0;
12 | }


--------------------------------------------------------------------------------
/Module 17/print_array.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(int a[],int n,int i)
 3 | {
 4 |     // base case
 5 |     if(i==n) return;
 6 |     printf("%d\n",a[i]);
 7 |     fun(a,n,i+1);
 8 | }
 9 | int main()
10 | {
11 |     int n;
12 |     scanf("%d",&n);
13 |     int a[n];
14 |     for(int i=0;i<n;i++)
15 |     {
16 |         scanf("%d",&a[i]);
17 |     }
18 |     fun(a,n,0);
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Module 17/recursion.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun()
 3 | {
 4 |     printf("Fun\n");
 5 |     fun();
 6 | }
 7 | int main()
 8 | {
 9 |     fun();
10 |     return 0;
11 | }


--------------------------------------------------------------------------------
/Module 18/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 18/exact_row_column_print.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     } 
14 |     // exact row
15 |     // int e;
16 |     // scanf("%d",&e);
17 |     // for(int i=0;i<col;i++)
18 |     // {
19 |     //     printf("%d ",a[e][i]);
20 |     // }
21 |     // exact column
22 |     int c;
23 |     scanf("%d",&c);
24 |     for(int i=0;i<row;i++)
25 |     {
26 |         printf("%d ",a[i][c]);
27 |     }
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/Module 18/input_output.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     // declare 2d array
 5 |     int a[5][3];
 6 |     for(int i=0;i<5;i++)
 7 |     {
 8 |         for(int j=0;j<3;j++)
 9 |         {
10 |             scanf("%d",&a[i][j]);
11 |         }
12 |     } 
13 |     for(int i=0;i<5;i++)
14 |     {
15 |         for(int j=0;j<3;j++)
16 |         {
17 |             printf("%d ",a[i][j]);
18 |         }
19 |         printf("\n");
20 |     } 
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Module 18/primary_diagona.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     }
14 |     int flag=1;
15 |     if(row != col) 
16 |     {
17 |         flag=0;
18 |     }
19 |     for(int i=0;i<row;i++)
20 |     {
21 |         for(int j=0;j<col;j++)
22 |         {
23 |             if(i==j)
24 |             {
25 |                 continue;;
26 |             }
27 |             if(a[i][j]!=0)
28 |             {
29 |                 flag=0;
30 |             }
31 |         }
32 |     }
33 |     if(flag==1)
34 |     {
35 |         printf("Primary Diagonal\n");
36 |     }
37 |     else 
38 |     {
39 |         printf("Not Diagonal\n");
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Module 18/scalar_matrix.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     }
14 |     int flag=1;
15 |     if(row != col) 
16 |     {
17 |         flag=0;
18 |     }
19 |     for(int i=0;i<row;i++)
20 |     {
21 |         for(int j=0;j<col;j++)
22 |         {
23 |             if(i==j)
24 |             {
25 |                 if(a[i][j] != a[0][0])
26 |                 {
27 |                     flag=0;
28 |                 }
29 |             }
30 |             else if(a[i][j]!=0)
31 |             {
32 |                 flag=0;
33 |             }
34 |         }
35 |     }
36 |     if(flag==1)
37 |     {
38 |         printf("Scalar Matrix\n");
39 |     }
40 |     else 
41 |     {
42 |         printf("Not Scalar matrix\n");
43 |     }
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Module 18/secondary_diagonal.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     }
14 |     int flag=1;
15 |     if(row != col) 
16 |     {
17 |         flag=0;
18 |     }
19 |     for(int i=0;i<row;i++)
20 |     {
21 |         for(int j=0;j<col;j++)
22 |         {
23 |             if(i+j==row-1)
24 |             {
25 |                 continue;
26 |             }
27 |             if(a[i][j]!=0)
28 |             {
29 |                 flag=0;
30 |             }
31 |         }
32 |     }
33 |     if(flag==1)
34 |     {
35 |         printf("Secondary Diagonal\n");
36 |     }
37 |     else 
38 |     {
39 |         printf("Not Diagonal\n");
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Module 18/unit_matrix.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     }
14 |     int flag=1;
15 |     if(row != col) 
16 |     {
17 |         flag=0;
18 |     }
19 |     for(int i=0;i<row;i++)
20 |     {
21 |         for(int j=0;j<col;j++)
22 |         {
23 |             if(i==j)
24 |             {
25 |                 if(a[i][j] != 1)
26 |                 {
27 |                     flag=0;
28 |                 }
29 |             }
30 |             else if(a[i][j]!=0)
31 |             {
32 |                 flag=0;
33 |             }
34 |         }
35 |     }
36 |     if(flag==1)
37 |     {
38 |         printf("Unit Matrix\n");
39 |     }
40 |     else 
41 |     {
42 |         printf("Not Unit matrix\n");
43 |     }
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Module 18/unit_matrix_secondary.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     }
14 |     int flag=1;
15 |     if(row != col) 
16 |     {
17 |         flag=0;
18 |     }
19 |     for(int i=0;i<row;i++)
20 |     {
21 |         for(int j=0;j<col;j++)
22 |         {
23 |             if(i+j==row-1)
24 |             {
25 |                 if(a[i][j] != 1)
26 |                 {
27 |                     flag=0;
28 |                 }
29 |             }
30 |             else if(a[i][j]!=0)
31 |             {
32 |                 flag=0;
33 |             }
34 |         }
35 |     }
36 |     if(flag==1)
37 |     {
38 |         printf("Secondary Unit Matrix\n");
39 |     }
40 |     else 
41 |     {
42 |         printf("Not Unit matrix\n");
43 |     }
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Module 18/zero_matrix.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     int element=row*col;
 8 |     for(int i=0;i<row;i++)
 9 |     {
10 |         for(int j=0;j<col;j++)
11 |         {
12 |             scanf("%d",&a[i][j]);
13 |         }
14 |     }
15 |     int cnt=0;
16 |     for(int i=0;i<row;i++)
17 |     {
18 |         for(int j=0;j<col;j++)
19 |         {
20 |             if(a[i][j] == 0)
21 |             {
22 |                 cnt++;
23 |             }
24 |         }
25 |     }
26 |     if(element == cnt)
27 |     {
28 |         printf("Zero matrix\n");
29 |     }
30 |     else 
31 |     {
32 |         printf("Not zero matrix\n");
33 |     }
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/Module 19/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 19/D_Print_Digits_using_Recursion.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void fun(int n)
 3 | {
 4 |     // base case
 5 |     if(n==0) return;
 6 |     int x=n%10; // 4
 7 |     fun(n/10);
 8 |     printf("%d ",x);
 9 | }
10 | int main()
11 | {
12 |     int test;
13 |     scanf("%d",&test);
14 |     for(int t=0;t<test;t++)
15 |     {
16 |         int n;
17 |         scanf("%d",&n);
18 |         fun(n);
19 |         if(n==0) 
20 |         {
21 |             printf("0");
22 |         }
23 |         printf("\n");
24 |     }
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/Module 19/I_Count_Vowels.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | int fun(char s[],int i)
 4 | {
 5 |     // base case
 6 |     if(s[i]=='\0') 
 7 |     {
 8 |         return 0;
 9 |     }
10 |     int ans=fun(s,i+1);
11 |     if(s[i]>='A' && s[i]<='Z')
12 |     {
13 |         s[i]=s[i]+32;
14 |     }
15 |     if(s[i]=='a' || s[i]=='e' || s[i]=='o' || s[i]=='u' || s[i]=='i')
16 |     {
17 |         return ans+1;
18 |     }
19 |     else 
20 |     {
21 |         return ans;
22 |     }
23 | }
24 | int main()
25 | {
26 |     char s[205];
27 |     fgets(s,205,stdin);
28 |     int cnt=fun(s,0);
29 |     printf("%d\n",cnt);
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Module 19/J_Factorial.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | long long int fact(long long int n)
 3 | {
 4 |     // base case
 5 |     if(n==0)
 6 |     {
 7 |         return 1;
 8 |     }
 9 |     long long int ans=fact(n-1);
10 |     return ans*n;
11 | }
12 | int main()
13 | {
14 |     long long int n;
15 |     scanf("%lld",&n);
16 |     long long int ans=fact(n);
17 |     printf("%lld",ans);
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Module 19/K_Max_Number.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<limits.h>
 3 | int fun(int a[],int n,int i)
 4 | {
 5 |     if(i==n)
 6 |     {
 7 |         return INT_MIN;
 8 |     }
 9 |     int mx=fun(a,n,i+1);
10 |     if(a[i] > mx)
11 |     {
12 |         return a[i];
13 |     }
14 |     else 
15 |     {
16 |         return mx;
17 |     }
18 | }
19 | int main()
20 | {
21 |     int n;
22 |     scanf("%d",&n);
23 |     int a[n];
24 |     for(int i=0;i<n;i++)
25 |     {
26 |         scanf("%d",&a[i]);
27 |     }
28 |     int mx=fun(a,n,0);
29 |     printf("%d\n",mx);
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Module 19/N_Sum_of_a_Matrix.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col],b[row][col],c[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     }
14 |     for(int i=0;i<row;i++)
15 |     {
16 |         for(int j=0;j<col;j++)
17 |         {
18 |             scanf("%d",&b[i][j]);
19 |         }
20 |     }
21 |     for(int i=0;i<row;i++)
22 |     {
23 |         for(int j=0;j<col;j++)
24 |         {
25 |             c[i][j]=a[i][j]+b[i][j];
26 |         }
27 |     }
28 |     for(int i=0;i<row;i++)
29 |     {
30 |         for(int j=0;j<col;j++)
31 |         {
32 |             printf("%d ",c[i][j]);
33 |         }
34 |         printf("\n");
35 |     }
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/Module 19/W_Mirror_Array.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int row,col;
 5 |     scanf("%d %d",&row,&col);
 6 |     int a[row][col];
 7 |     for(int i=0;i<row;i++)
 8 |     {
 9 |         for(int j=0;j<col;j++)
10 |         {
11 |             scanf("%d",&a[i][j]);
12 |         }
13 |     }
14 |     for(int i=0;i<row;i++)
15 |     {
16 |         for(int j=col-1;j>=0;j--)
17 |         {
18 |             printf("%d ",a[i][j]);
19 |         }
20 |         printf("\n");
21 |     }
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 19/palindrome.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[1001],b[1001];
 6 |     scanf("%s",&a);
 7 |     strcpy(b,a);
 8 |     int i=0,j=strlen(b)-1;
 9 |     while(i<j)
10 |     {
11 |         char tmp=b[i];
12 |         b[i]=b[j];
13 |         b[j]=tmp;
14 |         i++;
15 |         j--;
16 |     }
17 |     if(strcmp(a,b)==0)
18 |     {
19 |         printf("YES");
20 |     }
21 |     else 
22 |     {
23 |         printf("NO");
24 |     }
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/Module 19/palindrome_two_pointer.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 |     char a[1001];
 6 |     scanf("%s",a);
 7 |     int i=0,j=strlen(a)-1;
 8 |     int flag=1;
 9 |     while(i<j)
10 |     {
11 |         if(a[i]!=a[j])
12 |         {
13 |             flag=0;
14 |         }
15 |         i++;
16 |         j--;
17 |     }
18 |     if(flag==0)
19 |     {
20 |         printf("NO");
21 |     }
22 |     else 
23 |     {
24 |         printf("YES");
25 |     }
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/Module 2/.gitignore:
--------------------------------------------------------------------------------
1 | *.txt
2 | *.exe
3 | *.bin


--------------------------------------------------------------------------------
/Module 2/arithmetic.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     int a=3,b=20;
5 |     int mod=a%b;
6 |     printf("%d",mod);
7 |     return 0;
8 | }


--------------------------------------------------------------------------------
/Module 2/conditiona_1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int tk;
 5 |     scanf("%d",&tk);
 6 |     if(tk >= 100)
 7 |     {
 8 |         printf("Burger Khabo");
 9 |     }
10 |     else
11 |     {
12 |         printf("Sharadin kichu khabo na");
13 |     }
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 2/conditional_2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int tk;
 5 |     scanf("%d",&tk);
 6 |     if(tk >= 100)
 7 |     {
 8 |         printf("Burger khabo");
 9 |     }
10 |     else if(tk >= 50)
11 |     {
12 |         printf("Fuchka khabo");
13 |     }
14 |     else if(tk >= 20)
15 |     {
16 |         printf("Ice cream khabo");
17 |     }
18 |     else
19 |     {
20 |         printf("Khabo na");
21 |     }
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 2/conditional_3.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int tk;
 5 |     scanf("%d",&tk);
 6 |     if(tk >= 5000)
 7 |     {
 8 |         printf("Cox's Bazar jabo\n");
 9 |         if(tk >= 10000)
10 |         {
11 |             printf("Saint Martin jabo\n");
12 |         }
13 |         else
14 |         {
15 |             printf("Ferot chole jabo\n");
16 |         }
17 |     }
18 |     else
19 |     {
20 |         printf("Kothao jabo na\n");
21 |     }
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 3/.gitignore:
--------------------------------------------------------------------------------
1 | *.txt
2 | *.exe
3 | *.bin


--------------------------------------------------------------------------------
/Module 3/break.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int i,n;
 5 |     for(i=1;i<=10;i=i+1)
 6 |     {
 7 |         
 8 |         printf("%d\n",i);
 9 |         if(i==5)
10 |         {
11 |             break;
12 |         }
13 |     }
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 3/continue.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int i,n;
 5 |     for(i=1;i<=10;i=i+1)
 6 |     {
 7 |         
 8 |         printf("%d\n",i);
 9 |         if(i==5)
10 |         {
11 |             continue;
12 |         }
13 |     }
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 3/do_while.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int i;
 5 | 
 6 |     // do while
 7 |     i=1;
 8 |     do 
 9 |     {
10 |         printf("%d\n",i);
11 |         i=i+1;
12 |     }
13 |     while(i<=5);
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 3/loop_1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int i;
 5 |     for(i=1;i<=3;i=i+1)
 6 |     {
 7 |         printf("Hello\n");
 8 |     }
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 3/loop_2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int i;
 5 |     for(i=10;i>=1;i=i-1)
 6 |     {
 7 |         printf("%d\n",i);
 8 |     }
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 3/loop_condition.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int i,n;
 5 |     scanf("%d",&n);
 6 |     for(i=1;i<=n;i=i+1)
 7 |     {
 8 |         if(i%2==0)
 9 |         {
10 |             printf("%d-even\n",i);
11 |         }
12 |         else
13 |         {
14 |             printf("%d-odd\n",i);
15 |         }
16 |     }
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Module 3/loop_sum.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     long long int sum=0;
 5 |     int i;
 6 |     int n;
 7 |     scanf("%d",&n);
 8 |     for(i=1;i<=n;i=i+1)
 9 |     {
10 |         sum+=i;
11 |     }
12 |     printf("%lld",sum);
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 3/while.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int i;
 5 |     
 6 | 
 7 |     // while 
 8 |     i=100;
 9 |     while(i<=5)
10 |     {
11 |         printf("%d\n",i);
12 |         i=i+1;
13 |     }
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 5/.gitignore:
--------------------------------------------------------------------------------
1 | *.txt
2 | *.exe
3 | *.bin


--------------------------------------------------------------------------------
/Module 5/i.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int a,b;
 5 |     scanf("%d %d",&a,&b);
 6 |     if(a>=b)
 7 |     {
 8 |         printf("Yes\n");
 9 |     }
10 |     else
11 |     {
12 |         printf("No\n");
13 |     }
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 5/j.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int a,b;
 5 |     scanf("%d %d",&a,&b);
 6 |     if(a%b==0)
 7 |     {
 8 |         printf("Multiples\n");
 9 |     }
10 |     else if(b%a==0)
11 |     {
12 |         printf("Multiples\n");
13 |     }
14 |     else 
15 |     {
16 |         printf("No Multiples\n");
17 |     }
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Module 5/k.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int a,b,c;
 5 |     scanf("%d %d %d",&a,&b,&c);
 6 |     // minimum
 7 |     if(a<=b && a<=c)
 8 |     {
 9 |         printf("%d ",a);
10 |     }
11 |     else if(b<=a && b<=c)
12 |     {
13 |         printf("%d ",b);
14 |     }
15 |     else 
16 |     {
17 |         printf("%d ",c);
18 |     }
19 | 
20 |     // maximum
21 |     if(a>=b && a>=c)
22 |     {
23 |         printf("%d\n",a);
24 |     }
25 |     else if(b>=a && b>=c)
26 |     {
27 |         printf("%d\n",b);
28 |     }
29 |     else 
30 |     {
31 |         printf("%d\n",c);
32 |     }
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Module 5/m.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     char x;
 5 |     scanf("%c",&x);
 6 |     if(x>='0' && x<='9')
 7 |     {
 8 |         printf("IS DIGIT\n");
 9 |     }
10 |     else
11 |     {
12 |         printf("ALPHA\n");
13 |         if(x>='a' && x<='z')
14 |         {
15 |             printf("IS SMALL\n");
16 |         }
17 |         else 
18 |         {
19 |             printf("IS CAPITAL\n");
20 |         }
21 |     }
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 5/n.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     char a;
 5 |     scanf("%c",&a);
 6 |     if(a>='a' && a<='z')
 7 |     {
 8 |         // choto hater
 9 |         int ans=a-32;
10 |         printf("%c",ans);
11 |     }
12 |     else 
13 |     {
14 |         int ans=a+32;
15 |         printf("%c",ans);
16 |     }
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Module 5/p.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int x;
 5 |     scanf("%d",&x);
 6 |     int digit=x/1000;
 7 |     if(digit%2==0)
 8 |     {
 9 |         printf("EVEN\n");
10 |     }
11 |     else 
12 |     {
13 |         printf("ODD\n");
14 |     }
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 6/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 6/B_Even_Numbers.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     if(n==1)
 7 |     {
 8 |         printf("-1\n");
 9 |     }
10 |     else 
11 |     {
12 |         for(int i=1;i<=n;i=i+1)
13 |         {
14 |             if(i%2==0)
15 |             {
16 |                 printf("%d\n",i);
17 |             }
18 |         }
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Module 6/C_Even_Odd_Positive_and_Negative.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int a;
 7 |     int even=0,odd=0,pos=0,neg=0;
 8 |     for(int i=1;i<=n;i=i+1)
 9 |     {
10 |         scanf("%d",&a);
11 |         // kaj
12 |         if(a%2==0)
13 |         {
14 |             //even
15 |             even++;
16 |         }
17 |         else
18 |         {
19 |             //odd
20 |             odd++;
21 |         }
22 | 
23 | 
24 |         if(a>0)
25 |         {
26 |             //positive
27 |             pos++;
28 |             
29 |         }
30 |         else if(a<0)
31 |         {
32 |             // negative 
33 |             neg++;
34 |         }
35 | 
36 |     }
37 |     printf("Even: %d\nOdd: %d\nPositive: %d\nNegative: %d\n",even,odd,pos,neg);
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/Module 6/D_Fixed_Password.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     while(scanf("%d",&n) != EOF)
 6 |     {
 7 |         //kaj
 8 |         if(n==1999)
 9 |         {
10 |             printf("Correct\n");
11 |             break;
12 |         }
13 |         else 
14 |         {
15 |             printf("Wrong\n");
16 |         }
17 |     }
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Module 6/E_Max.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<limits.h>
 3 | int main()
 4 | {
 5 |     int n;
 6 |     scanf("%d",&n);
 7 |     int a,max=INT_MIN,min=INT_MAX;
 8 |     for(int i=1;i<=n;i++)
 9 |     {
10 |         scanf("%d",&a);
11 |         if(a>max)
12 |         {
13 |             max=a;
14 |         }
15 |         if(a<min)
16 |         {
17 |             min=a;
18 |         }
19 |     }
20 |     printf("%d %d\n",min,max);
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Module 6/F_Multiplication_table.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     for(int i=1;i<=12;i++)
 7 |     {
 8 |         printf("%d * %d = %d\n",n,i,n*i);
 9 |     }
10 |     return 0;
11 | }


--------------------------------------------------------------------------------
/Module 6/Q_Digits.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int test;
 5 |     scanf("%d",&test);
 6 |     for(int t=1;t<=test;t++)
 7 |     {
 8 |         int n;
 9 |         scanf("%d",&n);
10 |         do
11 |         {
12 |             printf("%d ",n%10);
13 |             n=n/10;
14 |         }
15 |         while(n!=0);
16 |         printf("\n");
17 |     }
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/Module 6/inc_dec.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     int i=10;
5 |     int x=--i;
6 |     printf("x-%d i-%d",x,i);
7 |     return 0;
8 | }


--------------------------------------------------------------------------------
/Module 6/nested_loop.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     for(int i=1;i<=10;i++)
 5 |     {
 6 |         // kaj
 7 |         for(int j=1;j<=5;j++)
 8 |         {
 9 |             printf("%d ",j);
10 |         }
11 |         printf("\n");
12 |     }
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 7.5/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 7.5/B_Searching.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int ar[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&ar[i]);
10 |     }
11 |     int x;
12 |     scanf("%d",&x);
13 |     int ans=-1;
14 |     for(int i=0;i<n;i++)
15 |     {
16 |         if(ar[i] == x)
17 |         {
18 |             ans=i;
19 |             break;
20 |         }
21 |     }
22 |     printf("%d\n",ans);
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/Module 7.5/E_Lowest_Number.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<limits.h>
 3 | int main()
 4 | {
 5 |     int n;
 6 |     scanf("%d",&n);
 7 |     int ar[n];
 8 |     for(int i=0;i<n;i++)
 9 |     {
10 |         scanf("%d",&ar[i]);
11 |     }
12 |     int mn=INT_MAX,pos;
13 |     for(int i=0;i<n;i++)
14 |     {
15 |         if(ar[i] < mn)
16 |         {
17 |             mn=ar[i];
18 |             pos=i+1;
19 |         }
20 |     }
21 |     printf("%d %d\n",mn,pos);
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 7/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 7/array_declare.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     int ar[10];
5 |     return 0;
6 | }


--------------------------------------------------------------------------------
/Module 7/array_initialize.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int ar[5]={100};
 5 |     for(int i=0;i<5;i++)
 6 |     {
 7 |         printf("%d\n",ar[i]);
 8 |     }
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 7/array_input_output_1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int ar[5000];
 5 |     // ar[0], ar[1], ar[2]
 6 |     ar[0]=100;
 7 |     ar[1]=200;
 8 |     ar[2]=500;
 9 | 
10 |     printf("%d %d %d",ar[0],ar[1],ar[2]);
11 |     return 0;
12 | }


--------------------------------------------------------------------------------
/Module 7/array_input_output_2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int ar[5];
 5 |     for(int i=0;i<5;i++)
 6 |     {
 7 |         scanf("%d",&ar[i]);
 8 |     }
 9 |     for(int i=0;i<5;i++)
10 |     {
11 |         printf("%d\n",ar[i]);
12 |     }
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 7/array_reverse_print.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int ar[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&ar[i]);
10 |     }
11 |     for(int i=n-1;i>=0;i--)
12 |     {
13 |         printf("%d ",ar[i]);
14 |     }
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 7/sum_of_array.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int ar[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&ar[i]);
10 |     }
11 |     int sum=0;
12 |     for(int i=0;i<n;i++)
13 |     {
14 |         sum=sum+ar[i];
15 |     }
16 |     printf("%d",sum);
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Module 9/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 9/copy.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int a[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&a[i]);
10 |     }
11 |     int m;
12 |     scanf("%d",&m);
13 |     int b[m];
14 |     for(int i=0;i<m;i++)
15 |     {
16 |         scanf("%d",&b[i]);
17 |     }
18 |     int ans[n+m];
19 |     for(int i=0;i<n;i++)
20 |     {
21 |         ans[i]=a[i];
22 |     }
23 |     int i=n;
24 |     for(int j=0;j<m;j++)
25 |     {
26 |         ans[i]=b[j];
27 |         i++;
28 |     }
29 | 
30 | 
31 |     for(int i=0;i<n+m;i++)
32 |     {
33 |         printf("%d ",ans[i]);
34 |     }
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Module 9/delete.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n); // 5
 6 |     int ar[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&ar[i]);
10 |     }
11 |     int pos;
12 |     scanf("%d",&pos);
13 |     for(int i=pos;i<n-1;i++)
14 |     {
15 |         ar[i]=ar[i+1];
16 |     }
17 |     for(int i=0;i<n-1;i++)
18 |     {
19 |         printf("%d ",ar[i]);
20 |     }
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Module 9/insert.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n); // 5
 6 |     int ar[n+1];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&ar[i]);
10 |     }
11 |     int pos,val;
12 |     scanf("%d %d",&pos,&val);
13 |     for(int i=n;i>=pos+1;i--)
14 |     {
15 |         ar[i]=ar[i-1];
16 |     }
17 |     
18 |     ar[pos]=val;
19 |     for(int i=0;i<=n;i++)
20 |     {
21 |         printf("%d ",ar[i]);
22 |     }
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/Module 9/reverse.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     scanf("%d",&n);
 6 |     int ar[n];
 7 |     for(int i=0;i<n;i++)
 8 |     {
 9 |         scanf("%d",&ar[i]);
10 |     }
11 |     int i=0,j=n-1;
12 |     while(i<j)
13 |     {
14 |         int tmp=ar[i];
15 |         ar[i]=ar[j];
16 |         ar[j]=tmp;
17 |         i++;
18 |         j--;
19 |     }
20 |     for(int i=0;i<n;i++)
21 |     {
22 |         printf("%d ",ar[i]);
23 |     }
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Batch-3-Introduction-to-C-Programming
2 | 


--------------------------------------------------------------------------------