āĻĒ্āϰোāĻ্āϰাāĻŽিং āϏāĻŽāϏ্āϝা
āĻāĻ āĻ
āϧ্āϝাā§ে āĻāĻŽāϰা āĻā§েāĻāĻি āϏāĻšāĻ āϏāĻŽāϏ্āϝা āĻĻেāĻāĻŦ āĻ āϏāĻŽাāϧাāύেāϰ āĻেāώ্āĻা āĻāϰāĻŦ।
āĻāĻŽাāĻĻেāϰ āĻĒ্āϰāĻĨāĻŽ āϏāĻŽāϏ্āϝা āĻšāĻ্āĻে, āĻŦিāĻিāύ্āύ āϧāϰāύেāϰ āĻāĻৃāϤি āϤৈāϰি āĻāϰা। āύিāĻেāϰ āĻāĻŦিāĻুāϞো āĻĻেāĻো।
āϤোāĻŽাāĻĻেāϰ āĻাāϰāĻি āĻĒ্āϰোāĻ্āϰাāĻŽ āϞিāĻāϤে āĻšāĻŦে āĻāĻ āĻাāϰ āϧāϰāύেāϰ āĻāĻৃāϤি āϤৈāϰি āĻāϰাāϰ āĻāύ্āϝ। āĻেāĻŦāϞ printf āĻĢাংāĻļāύ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϞেāĻ āĻšāĻŦে āύা, āϞুāĻĒ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻšāĻŦে। āϤাāĻšāϞে āϞুāĻĒ āĻŦা āύেāϏ্āĻেāĻĄ āϞুāĻĒ, āĻāĻŦং 'c' āĻ ' ' (āϏ্āĻĒেāϏ āĻ্āϝাāϰেāĻ্āĻাāϰ) āĻĒ্āϰিāύ্āĻ āĻāϰে āϤোāĻŽāϰা āĻĒ্āϰোāĻ্āϰাāĻŽāĻুāϞো āϞিāĻে āĻĢেāϞāϤে āĻĒাāϰো। āĻāϰāĻ āĻেāϞাāϧুāϞা āĻāϰাāϰ āĻāĻ্āĻা āĻšāϞে āĻāϰāĻ āύাāύাāύ āϰāĻāĻŽ āĻāĻৃāϤি āϤৈāϰিāϰ āĻেāώ্āĻা āĻāϰāϤে āĻĒাāϰ।
āĻĒ্āϝাāϞিāύ্āĻĄ্āϰোāĻŽ (palindrome) āĻী āĻিāύিāϏ, āϤোāĻŽāϰা āĻাāύ? āĻোāύো āĻļāĻŦ্āĻĻāĻে āĻāϞ্āĻাāĻাāĻŦে (āĻŽাāύে āĻļেāώ āĻĨেāĻে āĻļুāϰু) āϞিāĻāϞে āϝāĻĻি āϏেāĻি āĻāϰ āύāϤুāύ āĻļāĻŦ্āĻĻāĻি āĻāĻāĻ āϰāĻāĻŽ āĻšā§ āϤāĻŦে āϏেāĻি āĻāĻāĻি āĻĒ্āϝাāϞিāύ্āĻĄ্āϰোāĻŽ। āϝেāĻŽāύ: madam। āĻāĻিāĻে āĻļেāώ āĻĨেāĻে āĻļুāϰু āĻĒāϰ্āϝāύ্āϤ āϞিāĻāϞেāĻ madam āĻšāĻŦে। āĻāĻāύ āĻāĻāĻি āĻĒ্āϰোāĻ্āϰাāĻŽ āϞিāĻāĻŦ āϝেāĻিāϤে āĻোāύো āĻļāĻŦ্āĻĻ āĻāύāĻĒুāĻ āĻĻিāϞে āϏেāĻি āĻĒ্āϝাāϞিāύ্āĻĄ্āϰোāĻŽ āĻি āύা āĻŦāϞে āĻĻেāĻŦে।
āĻāĻāύ্āϝ āĻāĻŽāϰা āĻী āĻāϰāϤে āĻĒাāϰি? āĻĒ্āϰāĻĨāĻŽে āĻļāĻŦ্āĻĻāĻি āϏ্āĻ্āϰিং āĻšিāϏেāĻŦে āĻāĻāĻি āĻ
্āϝাāϰেāϤে āĻāύāĻĒুāĻ āύেāĻŦ। āϤাāϰāĻĒāϰ āĻāϰেāĻāĻি āĻ
্āϝাāϰেāϤে āϏেāĻি āĻāϞ্āĻাāĻাāĻŦে āϰাāĻāĻŦ। āϤাāϰāĻĒāϰ āϝāĻĻি āĻĻুāĻি āĻāĻāĻ āϏ্āĻ্āϰিং āĻšā§, āϤāĻŦে āϏেāĻি āĻĒ্āϝাāϞিāύ্āĻĄ্āϰোāĻŽ। āϤাāĻšāϞে āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āϞিāĻে āĻĢেāϞি:
#include <stdio.h>
#include <string.h>
int main()
{
char word[80], reverse_word[80];
int i, j, len;
scanf("%s", word);
len = strlen(word);
for(i = 0, j = len - 1; i < len; i++, j--) {
reverse_word[i] = word[j];
}
reverse_word[i] = '\0';
printf("%s\n", reverse_word);
if (0 == strcmp(word, reverse_word)) {
printf("%s is a palindrome.\n", word);
}
else {
printf("%s is not a palindrome.\n", word);
}
return 0;
}
āĻĒ্āϰোāĻ্āϰাāĻŽ: ā§§ā§Š.ā§§
āĻী āĻŽāĻা! āĻāĻŽি āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āϞিāĻে āĻĻিāϞাāĻŽ। āϤāĻŦে āĻāĻŽি āĻāĻাāύে āĻŦেāĻļ āĻিāĻু āĻŦোāĻাāĻŽি āĻāϰেāĻি, āϝাāϰ āĻŽāϧ্āϝে āĻ
āύ্āϝāϤāĻŽ āĻšāĻ্āĻে āĻāĻāĻি āĻ
āϤিāϰিāĻ্āϤ āĻ
্āϝাāϰে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা। āϏুāϤāϰাং āϤোāĻŽাāĻĻেāϰ āĻāĻāύ āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻāĻŽāύāĻাāĻŦে āϞিāĻāϤে āĻšāĻŦে, āϝাāϤে āĻেāĻŦāϞ āĻāĻāĻি āĻ
্āϝাāϰে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰেāĻ āĻাāĻ āĻšā§। āĻāϰ āϤāĻāύ strcmp āĻĢাংāĻļāύāĻিāϰāĻ āĻĻāϰāĻাāϰ āĻšāĻŦে āύা। āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āϞিāĻāϤে āϏāĻŽā§ āĻŦেāĻļি āϞাāĻāϤে āĻĒাāϰে, āϞাāĻুāĻ, āĻ
āϏুāĻŦিāϧা āύেāĻ। āϤāĻŦে āϞিāĻāϤে āĻšāĻŦে āĻ িāĻāĻ াāĻ, āĻāĻিāĻ āĻšāϞো āĻāĻĨা।
āϤোāĻŽāϰা āϤো āĻĢ্āϝাāĻ্āĻāϰিā§াāϞ (factorial) āĻিāύিāϏāĻিāϰ āϏāĻ্āĻে āĻĒāϰিāĻিāϤ? āĻāĻি āĻāĻāĻি āĻাāĻŖিāϤিāĻ āĻ
āĻĒাāϰেāĻļāύ āϝা āĻোāύো āϧāύাāϤ্āĻŽāĻ āĻĒূāϰ্āĻŖāϏংāĻ্āϝাāϰ āĻ্āώেāϤ্āϰে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āϝাā§। n āĻāĻāĻি āϧāύাāϤ্āĻŽāĻ āĻĒূāϰ্āĻŖ āϏংāĻ্āϝা āĻšāϞে-āĻāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞāĻে āĻĒ্āϰāĻাāĻļ āĻāϰা āĻšā§ n! āĻĻিā§ে āĻāĻŦং n! = n * (n – 1) * (n – 2) * … * 3 * 2 * 1। āϝেāĻŽāύ 4! = 4 * 3 * 2 * 1 = 24। āĻāĻŦাāϰ 6! = 6 * 5 * 4 * 3 * 2 * 1 = 720। 1! = 1। 0! = 1 (0-āĻāϰ āĻ্āώেāϤ্āϰে āĻŦ্āϝāϤিāĻ্āϰāĻŽāĻি āϞāĻ্āώ āĻāϰো, āĻিāĻু āĻŦিāĻļেāώ āϏুāĻŦিāϧাāϰ āĻāύ্āϝ 0-āĻāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞেāϰ āĻŽাāύ 1 āϧāϰা āĻšā§)। āĻāĻāύ āϤোāĻŽāϰা āĻোāύো āϧāύাāϤ্āĻŽāĻ āĻĒূāϰ্āĻŖāϏংāĻ্āϝাāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞ āĻŦেāϰ āĻāϰাāϰ āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āϞিāĻে āĻĢেāϞো। āϏāĻšāĻ āĻĒ্āϰোāĻ্āϰাāĻŽ, āĻāĻāĻি āϞুāĻĒ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰেāĻ āĻāϰা āϝাā§। āĻāĻāύ āĻŦিāĻিāύ্āύ āϏংāĻ্āϝা āĻĻিā§ে āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻেāϏ্āĻ āĻāϰে āĻĻেāĻো āĻĢ্āϝাāĻ্āĻāϰিā§াāϞ āĻ িāĻāĻ াāĻ āĻŦেāϰ āĻāϰāϤে āĻĒাāϰে āĻি āύা। āĻĒ্āϰোāĻ্āϰাāĻŽে āϤুāĻŽি āϝāĻĻি āĻĄাāĻা āĻাāĻāĻĒ int āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āĻĨাāĻ āϤāĻŦে 12-āĻāϰ āĻেā§ে āĻŦā§ āĻোāύো āĻĒূāϰ্āĻŖ āϏংāĻ্āϝাāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞেāϰ āĻŽাāύ āĻ িāĻāĻŽāϤো āĻĻেāĻাāĻŦে āύা (āĻ্āϝাāϞāĻুāϞেāĻāϰে āĻāϰে āĻŽিāϞিā§ে āĻĻেāĻāϤে āĻĒাāϰো)। āĻাāϰāĻŖ āĻšāĻ্āĻে 12-āĻāϰ āĻেā§ে āĻŦā§ āĻোāύো āĻĒূāϰ্āĻŖ āϏংāĻ্āϝাāϰ āĻāύ্āϝ āϏেāĻ āϏংāĻ্āϝাāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞেāϰ āĻŽাāύ āϰেāĻ্āĻেāϰ āĻŦাāĻāϰে āĻāϞে āϝাā§।
āĻāĻāύ āϤোāĻŽাāĻĻেāϰ āĻāĻāĻি āĻŽāĻাāϰ āϏāĻŽāϏ্āϝা āϏāĻŽাāϧাāύ āĻāϰāϤে āĻšāĻŦে। āĻোāύো āĻĒূāϰ্āĻŖāϏংāĻ্āϝা n (āϝেāĻাāύে 1 < n < 100, āĻŽাāύে n-āĻāϰ āĻŽাāύ 2 āĻĨেāĻে 99 āĻĒāϰ্āϝāύ্āϤ āĻšāϤে āĻĒাāϰে)-āĻāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞāĻে āĻŽৌāϞিāĻ āϏংāĻ্āϝাāϰ āĻুāĻŖāĻĢāϞ āĻšিāϏেāĻŦে āĻĒ্āϰāĻাāĻļ āĻāϰāϞে āĻোāύ āĻŽৌāϞিāĻ āϏংāĻ্āϝা āĻāϤāĻŦাāϰ āĻāĻে āϏেāĻি āĻŦেāϰ āĻāϰāϤে āĻšāĻŦে। āϝেāĻŽāύ, āĻāĻŽāϰা āĻাāύি, 5! = 120 = 2 * 2 * 2 * 3 * 5। āĻāĻাāύে 2 āĻāĻে 3 āĻŦাāϰ, 3 āĻāĻে 1 āĻŦাāϰ āĻāϰ 5 āĻāĻে 1 āĻŦাāϰ। āϤাāĻ āĻāύāĻĒুāĻ 5 āĻšāϞে āĻāĻāĻāĻĒুāĻ āĻšāĻŦে: 5! = (2, 3), (3, 1), (5, 1)। āϤোāĻŽāϰা āĻি āĻāĻāĻি āĻŦ্āϝাāĻĒাāϰ āĻŦুāĻāϤে āĻĒাāϰāĻ āϝে āĻļুāϰুāϤে n-āĻāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞেāϰ āĻŽাāύ āĻŦেāϰ āĻāϰে āϤাāϰāĻĒāϰ āĻŽৌāϞিāĻ āĻā§āĻĒাāĻĻāĻে āĻাāĻāϤে āĻেāϞে āĻāĻāĻি āĻাāĻŽেāϞা āĻšā§ে āϝাāĻŦে? āĻাāϰāĻŖ n-āĻāϰ āĻŽাāύ āϏāϰ্āĻŦোāĻ্āĻ āĻšāϤে āĻĒাāϰে 99 āĻāϰ āĻāύ্āĻিāĻাāϰে āϤো 12-āĻāϰ āĻেā§ে āĻŦā§ āĻোāύো āϏংāĻ্āϝাāϰ āĻĢ্āϝাāĻ্āĻāϰিā§াāϞেāϰ āĻŽাāύ āϰাāĻা āϝাā§ āύা। āĻāϏāϞে āĻāĻ āĻĒ্āϰোāĻ্āϰাāĻŽেāϰ āĻāύ্āϝ n!-āĻāϰ āĻŽাāύ āĻŦেāϰ āĻāϰাāϰ āĻোāύো āĻĻāϰāĻাāϰ āύেāĻ। āĻļুāϧু āĻāĻāĻু āĻাāĻŖিāϤিāĻ āϝুāĻ্āϤি-āĻŦুāĻĻ্āϧি āĻাāĻাāĻ। āĻāϰ 2 āĻĨেāĻে 99 āĻĒāϰ্āϝāύ্āϤ āĻŽৌāϞিāĻ āϏংāĻ্āϝাāĻুāϞো āĻāĻāĻি āĻ
্āϝাāϰেāϤে āϰেāĻে āύাāĻ। āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻ িāĻāĻাāĻŦে āĻāϰāϤে āϤোāĻŽাāĻĻেāϰ āĻ
āύেāĻেāϰāĻ āĻĻু-āϤিāύ āĻĻিāύ āϏāĻŽā§ āϞেāĻে āϝেāϤে āĻĒাāϰে, āĻāϤে āĻšāϤাāĻļ āĻšāĻā§াāϰ āĻিāĻু āύেāĻ।
āĻāĻāύ āĻāĻŽāϰা āĻāĻāĻি āĻĒ্āϰোāĻ্āϰাāĻŽ āϞিāĻāĻŦ। āϝাāϰ āĻāĻĻ্āĻĻেāĻļ্āϝ āĻšāĻŦে āĻোāύো āĻ
্āϝাāϰেāϤে āĻিāĻু āϏংāĻ্āϝা āĻĨাāĻāϞে āϏেāĻুāϞোāĻে āĻোāĻ āĻĨেāĻে āĻŦā§ āĻ্āϰāĻŽে āϏাāĻাāύো। āϝেāĻŽāύ, āĻোāύো āĻ
্āϝাāϰে āϝāĻĻি āĻāĻŽāύ āĻšā§: int ara[] = {3, 1, 5, 2, 4}, āϤāĻŦে āĻāĻŽাāĻĻেāϰ āĻĒ্āϰোāĻ্āϰাāĻŽ āϏেāĻ āĻ
্āϝাāϰেāϰ āϏংāĻ্āϝাāĻুāϞো āĻāĻŽāύāĻাāĻŦে āϏাāĻাāĻŦে, āϝাāϤে ara[] = {1, 2, 3, 4, 5} āĻšā§।
āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻāĻāĻু āĻĒāϰে āϞিāĻāĻŦ, āϤাāϰ āĻāĻে āĻ িāĻ āĻāϰে āύেāĻ āϝে āϏেāĻি āĻীāĻাāĻŦে āĻাāĻ āĻāϰāĻŦে। āϤোāĻŽাāϰ āĻাāĻে āĻĒাঁāĻāĻি āϏংāĻ্āϝা āĻāĻে: 3, 1, 5, 2, 4। āĻোāĻ āĻĨেāĻে āĻŦā§ āĻ্āϰāĻŽে āϏাāĻাāϤে āĻšāĻŦে। āϤুāĻŽি āĻĒ্āϰāĻĨāĻŽে āĻী āĻāϰāĻŦে? āĻĒ্āϰāĻĨāĻŽে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝাāĻি āĻুঁāĻে āĻŦেāϰ āĻāϰে āϤাāĻে āĻļুāϰুāϤে āϞিāĻāĻŦে: 1। āϤāĻāύ āĻŦাāĻি āĻĨাāĻে āĻাāϰāĻি āϏংāĻ্āϝা: 3, 5, 2, 4। āĻāĻāύ āĻāĻ āĻাāϰāĻিāϰ āĻŽāϧ্āϝে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝাāĻি 1-āĻāϰ āĻĒāϰে āϞিāĻāĻŦে: 1, 2। āĻŦাāĻি āϰāĻāϞ 3, 5, 4। āĻāĻĻেāϰ āĻŽāϧ্āϝে āϏāĻŦāĻেā§ে āĻোāĻ 3। āϤাāĻ āϤুāĻŽি āϞিāĻāĻŦে : 1, 2, 3। āĻāĻāύ āĻŦাāĻি 5, 4। āĻāĻ āĻĻুāĻি āϏংāĻ্āϝাāϰ āĻŽāϧ্āϝে āϏāĻŦāĻেā§ে āĻোāĻ 4। āϏেāĻি āϤুāĻŽি 3-āĻāϰ āĻĒāϰে āϞিāĻāĻŦে: 1, 2, 3, 4। āĻāĻāύ āĻŦাāĻি āĻāĻāĻি āϏংāĻ্āϝা, 5। āϏেāĻি āϤুāĻŽি 4-āĻāϰ āĻĒāϰে āϞিāĻāĻŦে। 1, 2, 3, 4, 5। āϤোāĻŽাāϰ āϏাāĻাāύোāϰ āĻাāĻ āĻšā§ে āĻেāϞ। āĻāĻে āϏāϰ্āĻিং (sorting) āĻŦāϞে। āĻŦিāĻিāύ্āύ āĻāĻĒাā§ে āĻāĻি āĻāϰা āϝাā§। āϤāĻŦে āĻāĻŽāϰা āĻāĻāĻি āϏāĻšāĻ-āϏāϰāϞ āĻāĻĒাā§ে āĻāϰāϞাāĻŽ।
āĻāĻŽāϰা āϝেāĻাāĻŦে āĻাāĻāĻি āĻāϰেāĻি, āϏেāĻি āĻāĻāĻিāĻĒিāĻĄিā§াāϤে āĻāĻŽā§āĻাāϰ āĻāĻāĻা āĻ
্āϝাāύিāĻŽেāĻļāύেāϰ āϏাāĻšাāϝ্āϝে āĻĻেāĻাāύো āĻšā§েāĻে। āĻ
্āϝাāύিāĻŽেāĻļāύāĻি āĻāĻāĻŦাāϰ āĻĻেāĻāϞে āĻŦোāĻা āĻāĻ িāύ, āϤাāĻ āĻāĻŽাāϰ āĻĒāϰাāĻŽāϰ্āĻļ āĻšāĻ্āĻে āĻāĻŽāĻĒāĻ্āώে āĻাāϰ-āĻĒাঁāĻāĻŦাāϰ āĻāĻি āĻĻেāĻো।
āĻāĻāύ āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āϞিāĻāĻŦ āĻীāĻাāĻŦে?
āĻĒ্āϰāĻĨāĻŽে āĻāĻāĻি āĻ
্āϝাāϰেāϤে āϏংāĻ্āϝাāĻুāϞো āϰাāĻো: int ara1[] = {3, 1, 5, 2, 4};
āĻāĻāύ āĻāϰেāĻāĻি āĻ
্āϝাāϰে āύাāĻ:
int ara2[5];
āĻ
্āϝাāϰেāĻি āĻāĻāύো āĻাāϞি। āϤাāĻ āĻāĻāĻি āĻেāϰিā§েāĻŦāϞে āĻāύāĻĄেāĻ্āϏ 0 āϞিāĻে āϰাāĻো। int index_2 = 0;
āĻāĻāύ āĻāĻāĻি āĻāĻāĻি āĻāϰে ara2āϤে āϏংāĻ্āϝাāĻুāϞো āϰাāĻāϤে āĻšāĻŦে। āϤাāϰ āĻāύ্āϝ āĻāĻāĻি āϞুāĻĒ āĻĻāϰāĻাāϰ।
for(index_2 = 0; index_2 < 5; index_2++) // āĻŽাāύে 0 āĻĨেāĻে 4 āĻĒāϰ্āϝāύ্āϤ āĻĒ্āϰāϤিāĻি āĻāϰে āĻāĻŽāϰা āϏংāĻ্āϝা āĻŦāϏাāĻŦ। āĻāĻ āϞুāĻĒেāϰ āĻেāϤāϰে āĻāϰেāĻāĻি āϞুāĻĒ āĻĻāϰāĻাāϰ āϝেāĻি āĻĻিā§ে āĻāĻŽāϰা ara1-āĻāϰ āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝা āĻুঁāĻে āĻŦেāϰ āĻāϰāĻŦ।
minimum = 100000; // āĻāĻŽāύ āĻāĻāĻি āĻŦā§ āϏংāĻ্āϝা āĻ
্āϝাāϏাāĻāύ āĻāϰāϞাāĻŽ āϝেāĻি ara1-āĻāϰ āϝেāĻোāύো āϏংāĻ্āϝাāϰ āĻেā§ে āĻŦā§।
for (i = 0; i < 5; i++) {
if (ara1[i] < minimum) {
minimum = ara1[i];
}
}
āĻāĻāύ ara1-āĻāϰ āĻ্āώুāĻĻ্āϰāϤāĻŽ āϏংāĻ্āϝাāĻি minimum āĻ āĻāϞে āĻāϞ।
āϏেāĻি āĻāĻāύ ara2 āϤে āϰাāĻি: ara2[index_2] = minimum।
āϏāĻŦāĻļেāώে ara2-āĻāϰ āϏāĻŦ āϏংāĻ্āϝা āĻĒ্āϰিāύ্āĻ āĻāϰে āĻĻেāĻāĻŦ।
āĻāĻŦাāϰে āĻāϞো, āĻĒুāϰো āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āϞিāĻে āĻāĻŽ্āĻĒাāĻāϞ āĻ āϰাāύ āĻāϰে āĻĻেāĻি āĻāĻāĻāĻĒুāĻ āĻী āĻāϏে।
#include <stdio.h>
int main()
{
int ara1[] = {3, 1, 5, 2, 4};
int ara2[5];
int i, minimum, index_2;
for (index_2 = 0; index_2 < 5; index_2++) {
minimum = 10000;
for (i = 0; i < 5; i++) {
if (ara1[i] < minimum) {
minimum = ara1[i];
}
}
ara2[index_2] = minimum;
}
for (i = 0; i < 5; i++) {
printf("%d\n", ara2[i]);
}
return 0;
}
āĻĒ্āϰোāĻ্āϰাāĻŽ: ā§§ā§Š.⧍
āĻী āϏুāύ্āĻĻāϰ āĻĒ্āϰোāĻ্āϰাāĻŽ! āĻāĻāĻāĻĒুāĻ āĻী? āĻāĻāĻāĻĒুāĻāĻ āĻুāĻŦ āϏুāύ্āĻĻāϰ, āĻāĻে āĻāĻে āĻĒাঁāĻāĻি 1।
1
1
1
1
1
āĻিāύ্āϤু āĻāĻŽāϰা āϤো āĻāĻŽāύ āĻāĻāĻāĻĒুāĻ āĻাāĻāύি। āĻোāĻĨাāĻ āĻোāϞāĻŽাāϞ āĻšā§েāĻে। āĻāĻāύ āĻāĻŽাāϰ āĻোāĻĄে āĻĻেāĻো āϤো āĻোāύো āĻুāϞ āĻŦেāϰ āĻāϰা āϝাā§ āĻি āύা।
āĻāĻāĻি āĻাāĻŽেāϞা āĻšā§েāĻে। āĻেāϤāϰেāϰ āϞুāĻĒে (āϝেāĻাāύে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝা āĻŦেāϰ āĻāϰা āĻšā§) āĻিāύ্āϤু āϏāĻŦ āϏāĻŽā§āĻ minimum-āĻāϰ āĻŽাāύ 1 āĻāϏāĻŦে, āĻাāϰāĻŖ 1 āĻšāĻ্āĻে āĻāĻ āĻĒাঁāĻāĻিāϰ āĻŽāϧ্āϝে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝা। āĻāĻāύ্āϝ āĻĻ্āĻŦিāϤীā§ āĻ
্āϝাāϰেāϤে āĻĒাঁāĻāĻি āϏংāĻ্āϝাāĻ 1 āĻšā§ে āϝাāĻ্āĻে। āϤাāĻ āĻāĻŽāϰা āϝāĻāύ minimum āĻŦেāϰ āĻāϰāĻŦ, āϤāĻāύ āĻ
্āϝাāϰেāϰ āϝেāĻ āĻāϰে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝা āĻĒাāĻŦ āϏেāĻ āĻāϰেāϰ āĻŽাāύ āĻāĻāĻি āĻ
āύেāĻ āĻŦā§ āϏংāĻ্āϝা āĻĻিā§ে āĻĻেāĻŦ। āĻāĻāύ্āϝ āĻāĻāĻি āĻেāϰিā§েāĻŦāϞ āϰাāĻি minimum_index। āĻāϰ āϞুāĻĒāĻি āĻāĻāύ āĻāĻŽāύ āĻšāĻŦে:
minimum = 10000;
for (i = 0; i < 5; i++) {
if (ara1[i] < minimum) {
minimum = ara1[i];
minimum_index = i;
}
}
āĻāĻāύ minimum-āĻāϰ āĻŽাāύ āĻāĻŽāϰা āĻĒেā§ে āĻেāĻি āĻāĻŦং āϏেāĻ āϏāĻ্āĻে āĻāĻিāĻ āĻাāύি āϝে āĻāĻি āĻāϏāϞে āĻāĻে ara1[minimum_index] āĻāϰে।
ara1[minimum_index] = 10000;
āϤাāĻšāϞে āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻ িāĻ āĻāϰে āĻāĻŦাāϰ āĻাāϞাāĻ:
#include <stdio.h>
int main()
{
int ara1[] = {3, 1, 5, 2, 4};
int ara2[5];
int i, minimum, index_2, minimum_index;
for (index_2 = 0; index_2 < 5; index_2++) {
minimum = 10000;
for (i = 0; i < 5; i++) {
if (ara1[i] < minimum) {
minimum = ara1[i];
minimum_index = i;
}
}
ara1[minimum_index] = 10000;
ara2[index_2] = minimum;
}
for (i = 0; i < 5; i++) {
printf("%d\n", ara2[i]);
}
return 0;
}
āĻĒ্āϰোāĻ্āϰাāĻŽ: ā§§ā§Š.ā§Š
āĻāĻāύ āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻāĻāĻāĻĒুāĻ āĻ িāĻāĻ াāĻ āĻĻেāĻাāĻŦে। āĻāĻ্āĻা, āϏāĻŦ āĻাāĻāĻ āϤো āĻāĻŽি āĻāϰে āĻĻিāϞাāĻŽ। āϤোāĻŽাāĻĻেāϰ āĻাāĻāĻি āĻী? āϤোāĻŽাāĻĻেāϰ āĻাāĻ āĻšāĻŦে āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻāĻŽāύāĻাāĻŦে āϞেāĻা āϝাāϤে āĻĻ্āĻŦিāϤীā§ āĻ
্āϝাāϰেāϰ āĻĒ্āϰā§োāĻāύ āύা āĻšā§। āĻļুāϰুāϤে āϝে āĻ
্āϝাāϰেāĻি āĻāĻে āϤাāϰ āĻেāϤāϰেāĻ āϏāϰ্āĻিং āĻāϰāϤে āĻšāĻŦে। āĻāĻāύ্āϝ āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝাāĻি āĻ
্āϝাāϰেāϰ āĻĒ্āϰāĻĨāĻŽ āĻāϰে āύিā§ে āĻāϏো āĻāϰ āϝে āĻāϰ āĻĨেāĻে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝা āĻĒেā§েāĻ āϏেāĻাāύে āĻĒ্āϰāĻĨāĻŽ āĻāϰেāϰ āϏংāĻ্āϝাāĻি āϰাāĻো। āĻāĻāύ āϤোāĻŽাāϰ āĻ
্āϝাāϰেāϰ āĻĒ্āϰāĻĨāĻŽ āĻāϰে āĻāĻে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝা। āĻāĻŦাāϰে āĻŦাāĻি āĻাāϰāĻি āĻāϰেāϰ āĻŽāϧ্āϝে āϏāĻŦāĻেā§ে āĻোāĻ āϏংāĻ্āϝাāĻি āĻ
্āϝাāϰেāϰ āĻĻ্āĻŦিāϤীā§ āĻāϰে āϰাāĻো āĻāĻŦং āϝে āĻāϰ āĻĨেāĻে āĻāĻ āϏংāĻ্āϝাāĻি āĻĒেā§েāĻ āϏেāĻাāύে āĻĻ্āĻŦিāϤীā§ āĻāϰেāϰ āϏংāĻ্āϝাāĻি āϰাāĻো। āĻāϰ āĻিāĻু āĻŦāϞা āϝাāĻŦে āύা।
āϰোāĻŦāĻ āύিā§ে āĻāĻāύ āĻāĻŽāϰা āĻāĻāĻি āĻĒ্āϰোāĻ্āϰাāĻŽ āϞিāĻāĻŦ। āĻোāύো āĻāĻāĻি N x N āĻ্āϰিāĻĄে āĻāĻāĻি āϰোāĻŦāĻ āĻāĻে। āĻļুāϰুāϤে āϤাāϰ āĻāĻāĻি āĻ
āĻŦāϏ্āĻĨাāύ āĻāĻে। āĻāĻŽāϰা āϏেāĻিāĻে āĻিāĻু āĻāĻŽাāύ্āĻĄ āĻĻেāĻŦ, āĻāĻ āĻāϰ āĻĄাāύে, āĻŦাঁā§ে, āĻāĻĒāϰে āĻ āύিāĻে āϝাāĻā§াāϰ āĻāĻŽাāύ্āĻĄ
।
(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(0, 6)
(0, 7)
(0, 8)
(1, 0)
(1, 2)
(2, 0)
(2, 1)
R (2, 2)
(2, 3)
(3, 0)
(3, 2)
(4, 0)
(5, 0)
(6, 0)
(7, 0)
(8, 0)
(8, 8)
āĻ্āϰিāĻĄāĻি āĻĻেāĻো। āĻāĻĒāϰেāϰ āĻāĻেāĻŦাāϰে āĻŦাঁ āĻĻিāĻেāϰ āĻāϰ āĻšāĻ্āĻে (0, 0)। āĻāĻĒāϰেāϰ āĻāĻেāĻŦাāϰে āĻĄাāύāĻĻিāĻেāϰ āĻāϰ āĻšāĻ্āĻে (0, 8)। āύিāĻেāϰ āĻāĻেāĻŦাāϰে āĻŦাঁ āĻĻিāĻেāϰ āĻāϰ āĻšāĻ্āĻে (8, 0)। āύিāĻেāϰ āĻāĻেāĻŦাāϰে āĻĄাāύ āĻĻিāĻেāϰ āĻāϰ āĻšāĻ্āĻে (8, 8)। āϧāϰা āϝাāĻ, āĻāĻ āĻŽুāĻšূāϰ্āϤে āϰোāĻŦāĻāĻি āĻāĻে (2, 2) āĻāϰে। āĻāĻ āĻāϰ āĻāĻĒāϰে āϝেāϤে āĻŦāϞāϞে āϏে āϝাāĻŦে (1, 2) āĻāϰে। āύিāĻে āϝেāϤে āĻŦāϞāϞে āϝাāĻŦে (3, 2) āĻāϰে। āĻĄাāύে āĻāϰ āĻŦাঁā§ে āϝেāϤে āĻŦāϞāϞে āϝāĻĨাāĻ্āϰāĻŽে (2, 3) āĻ (2, 1) āĻāϰে āϝাāĻŦে। āĻāĻŽাāύ্āĻĄāĻুāϞো āĻšāĻ্āĻে U (up), D (down), L (left), R (right), S (stop)। āĻāĻāύ āϤোāĻŽাāĻে āϝāĻĻি āĻļুāϰুāϰ āĻ
āĻŦāϏ্āĻĨাāύ āĻāϰ āĻāĻŽাāύ্āĻĄāĻুāϞো āĻŦāϞে āĻĻিāĻ, āϤাāĻšāϞে āϰোāĻŦāĻেāϰ āĻļেāώ āĻ
āĻŦāϏ্āĻĨাāύ (stop āĻāϰাāϰ āĻĒāϰ āĻ
āĻŦāϏ্āĻĨাāύ) āĻŦেāϰ āĻāϰāϤে āĻšāĻŦে।
āϤোāĻŽāϰা āĻি āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āύিāĻে āϞিāĻাāϰ āĻāύ্āϝ āĻিāĻুāĻ্āώāĻŖ āĻেāώ্āĻা āĻāϰāĻŦে?
āϤোāĻŽāϰা āύিāĻļ্āĻā§āĻ āĻŦুāĻāϤে āĻĒাāϰāĻ āϝে āĻāĻāĻি 2-D āĻ
্āϝাāϰে āĻĻāϰāĻাāϰ āĻšāĻŦে āĻāĻ āĻĒ্āϰোāĻ্āϰাāĻŽে। āĻāϏāϞে āĻিāύ্āϤু āĻāĻাāύে āĻ
্āϝাāϰেāϰ āĻোāύোāĻ āĻĻāϰāĻাāϰ āύেāĻ। āĻāĻি āϏাāϧাāϰāĻŖ āϝোāĻ-āĻŦিā§োāĻেāϰ āĻĒ্āϰোāĻ্āϰাāĻŽ। āĻŽāύে āĻāϰি, āĻļুāϰুāϰ āĻ
āĻŦāϏ্āĻĨাāύ āĻšāĻ্āĻে (x, y)। āĻāĻāύ U āĻāĻŽাāύ্āĻĄ āĻĻিāϞে āĻāĻāĻāϰ āĻāĻĒāϰে āϝাāĻŦে, āϤāĻāύ x-āĻāϰ āĻŽাāύ āĻāĻ āĻāĻŽে āϝাāĻŦে, y-āĻāϰ āĻŽাāύেāϰ āĻোāύো āĻĒāϰিāĻŦāϰ্āϤāύ āĻšāĻŦে āύা। D āĻāĻŽাāύ্āĻĄ āĻĻিāϞে āĻāĻ āĻāϰ āύিāĻে āϝাāĻŦে, āϤāĻāύ x-āĻāϰ āĻŽাāύ āĻāĻ āĻŦেā§ে āϝাāĻŦে, y-āĻāϰ āĻŽাāύেāϰ āĻোāύো āĻĒāϰিāĻŦāϰ্āϤāύ āĻšāĻŦে āύা। R āĻāĻŽাāύ্āĻĄ āĻĻিāϞে y-āĻāϰ āĻŽাāύ āĻāĻ āĻŦাā§āĻŦে, x-āĻāϰ āĻŽাāύ āĻ
āĻĒāϰিāĻŦāϰ্āϤিāϤ āĻĨাāĻāĻŦে। L āĻāĻŽাāύ্āĻĄ āĻĻিāϞে y-āĻāϰ āĻŽাāύ āĻāĻ āĻāĻŽāĻŦে, x-āĻāϰ āĻŽাāύ āĻ
āĻĒāϰিāĻŦāϰ্āϤিāϤ āĻĨাāĻāĻŦে। āϤাāĻšāϞে āĻāĻŽাāĻĻেāϰ āĻĒুāϰো āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻĻাঁā§াāĻŦে āĻāĻ āϰāĻāĻŽ:
#include <stdio.h>
int main()
{
int x, y;
char c;
printf("Please enter the initial position: ");
scanf("%d %d", &x, &y);
while (1) {
scanf("%c", &c);
if (c == 'S') {
break;
}
else if (c == 'U') {
x--;
}
else if (c == 'D') {
x++;
}
else if (c == 'R') {
y++;
}
else if (c == 'L') {
y--;
}
}
printf("Final position of the robot is: %d, %d\n", x, y);
return 0;
}
āĻĒ্āϰোāĻ্āϰাāĻŽ: ā§§ā§Š.ā§Ē
āĻāĻāĻāĻĒুāĻ āĻী āĻšāĻŦে āϏেāĻি āύিāϰ্āĻāϰ āĻāϰāĻŦে āϤোāĻŽাāϰ āĻāύāĻĒুāĻেāϰ āĻāĻĒāϰ। āϝেāĻŽāύ:
Please enter the initial position: 2 2
D
R
D
R
S
Final position of the robot is: 4, 4
āĻŦেāĻļ āϏāĻšāĻ āϏāϰāϞ āĻĒ্āϰোāĻ্āϰাāĻŽ। āĻিāύ্āϤু āĻāĻāύ āϝāĻĻি āĻŦāϞি āϝে āĻ্āϰিāĻĄে āĻিāĻু āĻিāĻু āĻāϰে āϝাāĻā§া āύিāώেāϧ āĻāĻŦং āĻāĻ āĻāϰāĻুāϞোāϤে āϝেāϤে āĻŦāϞāϞে āϰোāĻŦāĻāĻি āĻিāĻুāĻ āĻāϰāĻŦে āύা (āĻ
āϰ্āĻĨাā§ āĻāĻ āĻāĻŽাāύ্āĻĄāĻে āĻāĻĒেāĻ্āώা āĻāϰāĻŦে), āϤāĻāύ āĻāĻŽāϰা āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻীāĻাāĻŦে āϞিāĻāĻŦ? āϝেāĻŽāύ āĻāĻāĻি āĻāĻĻাāĻšāϰāĻŖ āĻĻিāĻ। āϧāϰা āϝাāĻ, (0, 4) āĻāϰāĻি āύিāώিāĻĻ্āϧ (blocked)। āϝāĻĻি āϰোāĻŦāĻেāϰ āĻ
āĻŦāϏ্āĻĨাāύ āĻšā§ (0, 3) āĻāϰে āĻāĻŦং āϤাāĻে 'R' āĻāĻŽাāύ্āĻĄ āĻĻেāĻā§া āĻšā§, āϤāĻāύ āϤাāϰ āĻ
āĻŦāϏ্āĻĨাāύেāϰ āĻোāύো āĻĒāϰিāĻŦāϰ্āϤāύ āĻšāĻŦে āύা। āĻাāϰāĻŖ āĻāĻ āĻāϰ āĻĄাāύে (āĻŽাāύে (0, 4) āĻāϰে) āϝাāĻā§া āϏāĻŽ্āĻāĻŦ āύā§।
āĻāĻ āϏāĻŽāϏ্āϝাāϰ āϏāĻŽাāϧাāύ āĻāϰāϤে āϝে āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āϞিāĻāϤে āĻšāĻŦে, āϤাāϤে āĻিāύ্āϤু āĻāĻāĻি 2-D āĻ
্āϝাāϰে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻšāĻŦে। āĻāĻ āĻ
্āϝাāϰেāϰ āϏাāĻšাāϝ্āϝে āĻāĻŽāϰা āĻŦুāĻāĻŦ āϝে āĻোāύ āĻāϰে āϝাāĻā§া āϝাāĻŦে āĻāϰ āĻোāύ āĻāϰে āϝাāĻā§া āϝাāĻŦে āύা। āϏেāĻি āĻীāĻাāĻŦে? āĻুāĻŦāĻ āϏāĻšāĻ। āϝেāϏāĻŦ āĻāϰে āϝাāĻā§া āϝাāĻŦে āĻ
্āϝাāϰেāϰ āĻāĻ āĻāϰāĻুāϞোāϤে 1 āĻāϰ āϝেāϏāĻŦ āĻāϰে āϝাāĻā§া āϝাāĻŦে āύা āϏেāĻুāϞোāϤে 0 āϰাāĻāĻŦ।
āĻĒ্āϰāĻĨāĻŽে 10 x 10 āĻ্āϰিāĻĄেāϰ āĻāύ্āϝ āĻāĻāĻি 2-D āĻ
্āϝাāϰে āĻĄিāĻ্āϞেā§াāϰ āĻāϰি:
int grid[10][10];
āϤাāϰāĻĒāϰ āĻļুāϰুāϤে āϧāϰে āύিāĻ āϏāĻŦ āĻāϰে āϝাāĻā§া āϝাāĻŦে।
for (i = 0; i < 10; i++) {
for (j = 0; j < 10; j ++) {
grid[i][j] = 1;
}
}
āĻāĻāύ āĻোāύ āĻোāύ āĻāϰāĻুāϞোāϤে āϝাāĻā§া āϝাāĻŦে āύা āϤা āĻŦ্āϝāĻŦāĻšাāϰāĻাāϰীāϰ āĻাāĻ āĻĨেāĻে āĻāύāĻĒুāĻ āύিāĻ:
printf("Please enter the number of blocked cells: ");
scanf("%d", &n);
printf("Now enter the cells: ");
for (i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
grid[x][y] = 0;
}
āĻāĻāύ āĻোāύো āĻāϰে āϝাāĻā§া āϝাāĻŦে āĻি āύা, āϏেāĻি āĻŦোāĻাāϰ āĻāύ্āϝ āĻāĻāĻি āĻļāϰ্āϤ āĻĒāϰীāĻ্āώা āĻāϰāϞেāĻ āĻšāĻŦে।
if (grid[x][y] == 1) {
āϝāĻĻি āϏāϤ্āϝ āĻšā§, āϤāĻŦে (x, y) āĻāϰে āϝাāĻā§া āϝাāĻŦে।
}
āĻāĻāύ āϤোāĻŽāϰা āϏāĻŽ্āĻĒূāϰ্āĻŖ āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āύিāĻে āύিāĻে āϞিāĻে āĻĢেāϞো