using System;
using System.Windows.Forms;
namespace BubbleSort
{
public partial class frmBubbleSort : Form
{
public frmBubbleSort()
{
InitializeComponent();
}
private void txtSetColumn_TextChanged(object sender, EventArgs e)
{
if (txtSetColumn.Text != "") {
//For Row of UnSorted-DataGridView
dgvUnSort.RowTemplate.Height = 35;
dgvUnSort.RowCount = 1;
dgvUnSort.RowHeadersVisible = false;
//For Column of UnSorted-DataGridView
dgvUnSort.ColumnCount = int.Parse(txtSetColumn.Text);
dgvUnSort.AllowUserToResizeColumns = true;
dgvUnSort.ColumnHeadersVisible = false;
for (int i = 0; i < dgvUnSort.ColumnCount; i++) {
dgvUnSort.Columns[i].Width = 35;
}
//For Row of Sorted-DataGridView
dgvSort.RowTemplate.Height = 35;
dgvSort.RowCount = 1;
dgvSort.RowHeadersVisible = false;
//For Column of Sorted-DataGridView
dgvSort.ColumnCount = int.Parse(txtSetColumn.Text);
dgvSort.AllowUserToResizeColumns = true;
dgvSort.ColumnHeadersVisible = false;
for (int i = 0; i < dgvSort.ColumnCount; i++) {
dgvSort.Columns[i].Width = 35;
}
} else {
dgvUnSort.Rows.Clear();
dgvSort.Rows.Clear();
}
}
private void btnBubbleSort_Click(object sender, EventArgs e)
{
//Set Default Sorting Option
if (cbSortOption.SelectedIndex == -1) {
cbSortOption.Text = "ASC";
}
//Load Data to Array[] from DataDridView
int length = dgvUnSort.ColumnCount;
int[] UnSortedArr = new int[length];
for (int i = 0; i < length; i++) {
UnSortedArr[i] = int.Parse(dgvUnSort.Rows[0].Cells[i].Value.ToString());
}
//Call BubbleSort Method
int[] SortedResult = BubbleSorted(UnSortedArr, cbSortOption.Text);
//Add Sorted Data to DataGridView
for (int i = 0; i < SortedResult.Length; i++) {
dgvSort.Rows[0].Cells[i].Value = SortedResult[i];
}
}
public int[] BubbleSorted(int[] arr, string Opt)
{
int length = arr.Length;
switch (Opt)
{
case "ASC" :
for (int i = 0; i < length; i++) {
for (int j = 0; j < length-1 - i ; j++) {
if (arr[j] > arr[j+1]) {
int key = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = key;
}
}
}
return arr;
case "DESC":
for (int i = 0; i < length; i++) {
for (int j = 0; j < length - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
int key = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = key;
}
}
}
return arr;
default:
return null;
}
}
}
}
using System;
using System.Windows.Forms;
namespace InsertionSort
{
public partial class frmInsertionSort : Form
{
public frmInsertionSort()
{
InitializeComponent();
}
private void txtSetColumn_TextChanged(object sender, EventArgs e)
{
if (txtSetColumn.Text != "") {
//For Row of UnSorted-DataGridView
dgvUnSort.RowTemplate.Height = 35;
dgvUnSort.RowCount = 1;
dgvUnSort.RowHeadersVisible = false;
//For Column of UnSorted-DataGridView
dgvUnSort.ColumnCount = int.Parse(txtSetColumn.Text);
dgvUnSort.AllowUserToResizeColumns = true;
dgvUnSort.ColumnHeadersVisible = false;
for (int i = 0; i < dgvUnSort.ColumnCount; i++) {
dgvUnSort.Columns[i].Width = 35;
}
//For Row of Sorted-DataGridView
dgvSort.RowTemplate.Height = 35;
dgvSort.RowCount = 1;
dgvSort.RowHeadersVisible = false;
//For Column of Sorted-DataGridView
dgvSort.ColumnCount = int.Parse(txtSetColumn.Text);
dgvSort.AllowUserToResizeColumns = true;
dgvSort.ColumnHeadersVisible = false;
for (int i = 0; i < dgvSort.ColumnCount; i++) {
dgvSort.Columns[i].Width = 35;
}
}else {
dgvUnSort.Rows.Clear();
dgvSort.Rows.Clear();
}
}
private void btnInsertionSort_Click(object sender, EventArgs e)
{
//Set Default Sorting Option
if (cbSortOption.SelectedIndex == -1)
{
cbSortOption.Text = "ASC";
}
//Load Data to Array[] from DataDridView
int length = dgvUnSort.ColumnCount;
int[] UnSortedArr = new int[length];
for (int i = 0; i < length; i++){
UnSortedArr[i] = int.Parse(dgvUnSort.Rows[0].Cells[i].Value.ToString());
}
//Call InsertionSort Method
int[] SortedResult = InsertSort(UnSortedArr, cbSortOption.Text);
//Add Sorted Data to DataGridView
for (int i = 0; i < SortedResult.Length; i++)
{
dgvSort.Rows[0].Cells[i].Value = SortedResult[i];
}
}
public int[] InsertSort(int[] arr, string Opt) {
int key, j;
switch (Opt)
{
case "ASC" :
for (int i = 1; i < arr.Length; i++){
key = arr[i];
j = i - 1;
while (key < arr[j] && j >= 0){
arr[j+1] = arr[j];
j = j-1;
if (j < 0)
break;
}
arr[j+1] = key;
}
return arr;
case "DESC" :
for (int i = 1; i < arr.Length; i++){
key = arr[i];
j = i - 1;
while (key > arr[j] && j <= arr.Length)
{
arr[j+1] = arr[j];
j = j-1;
if (j < 0)
break;
}
arr[j+1] = key;
}
return arr;
default :
return null;
}
}
}
}
using System;
using System.Windows.Forms;
namespace NumberToChar
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
public string NumberToWords(long number)
{
string words = "";
if (number == 0){ return "သုည"; }
if (number < 0){ return "အႏုတ္ " + NumberToWords(Math.Abs(number)); }
if ((number / 100000) > 0){
words += NumberToWords(number / 100000) + "သိန္း၊ ";
number %= 100000;
}
if ((number / 10000) > 0){
words += NumberToWords(number / 10000) + "ေသာင္း ";
number %= 10000;
}
if ((number / 1000) > 0){
words += NumberToWords(number / 1000) + "ေထာင္ ";
number %= 1000;
}
if ((number / 100) > 0){
words += NumberToWords(number / 100) + "ရာ ";
number %= 100;
}
if (number > 0){
var unitsMap = new[] { "သုည", "တစ္", "ႏွစ္", "သံုး", "ေလး", "ငါး", "ေျခာက္", "ခုႏွစ္",
"ရွစ္", "ကိုး", "တစ္ဆယ္", "တစ္ဆယ့္တစ္", "တစ္ဆယ့္ႏွစ္", "တစ္ဆယ့္သံုး", "တစ္ဆယ့္ေလး", "တစ္ဆယ့္ငါး",
"တစ္ဆယ့္ေျခာက္", "တစ္ဆယ့္ခုႏွစ္", "တစ္ဆယ့္ရွစ္", "တစ္ဆယ့္ကိုး" };
var tensMap = new[] { "သုည", "တစ္ဆယ့္", "ႏွစ္ဆယ့္", "သံုးဆယ့္", "ေလးဆယ့္",
"ငါးဆယ့္", "ေျခာက္ဆယ့္", "ခုႏွစ္ဆယ့္", "ရွစ္ဆယ့္", "ကိုးဆယ့္" };
if (number < 20){
words += unitsMap[number];
}else{
words += tensMap[number / 10];
if ((number % 10) > 0){
words += "-" + unitsMap[number % 10];
}
}
}
return words;
}
private void btnNoToWord_Click(object sender, EventArgs e)
{
txtWord.Text = NumberToWords(long.Parse(txtNumber.Text)) +"က်ပ္";
}
private void txtNumber_KeyPress(object sender, KeyPressEventArgs e)
{
char ch = e.KeyChar;
if (!Char.IsDigit(ch) && ch != 8 && ch != 46)
{
e.Handled = true;
}
}
}
}
Resutl ကေတာ့ ပံုမွာ ျမင္ေတြ႔ရတဲ့အတုိင္းပါပဲဗ်ာ။ က်ေနာ္တို႔ ေရးထည့္ေပးလိုက္တဲ့ ကိန္းဂဏန္းေတြကို စကားလံုးေတြနဲ႔ ျပန္လည္ေဖာ္ျပေပးမွာျဖစ္ပါတရ္။ Coding မွာ ခက္ခဲတာေတြ မပါ ပါဘူးဗ်ာ။ က်ေနာ္တို႔ Number Conversion ေလ့က်င့္ခန္းေတြတုန္းက ေလ့လာခဲ့တဲ့ ကိန္းစဥ္တန္းတစ္ခုကို မိမိလိုခ်င္သေလာက္ အျပည့္ကိန္းနဲ႔ စား၊ ျဖတ္ထုတ္ၿပီး စာသားခ်ိန္းယူတဲ့ နည္းကို သံုးထားပါတရ္။ တြက္ခ်က္တဲ့အခ်ိန္မွာေတာ့ မိမိ Function ကို Funciton Body အတြင္းမွပဲ ထပ္ခါတလဲလဲ ျပန္ေခၚသံုးတဲ့ Function Recursion နည္းလမ္းကို အသံုးျပဳထားပါတရ္။ TextBox မွာ KeyPress Event ကိုအသံုးျပဳထားတာကေတာ့ က်ေနာ္တို႔ TextBox အတြင္းကို 0-9 digit ေတြနဲ႔ BackSpace Key, Delete Key တို႔ကို သီးသန္႔ အသံုးျပဳႏိုင္ေအာင္လို႔ ျဖည့္စြပ္ထားတာပါ။ မိတ္ေဆြတို႔အေနနဲ႔ မႀကိဳက္ရင္ မသံုးပဲ ေနႏိုင္ပါတရ္။ ဒါဆိုရင္ေတာ့ TextBox အတြင္းကို Number ေတြရိုက္ထည့္တဲ့အခါ သတိထားရမွာျဖစ္ၿပီး အျခားမဆိုင္တဲ့ Character ေတြ ပါလာခဲ့ရင္ေတာ့ Function ကိုျဖတ္တဲ့အခါ အလုပ္ မလုပ္ႏိုင္ပဲ Error ျဖစ္သြားမွာပဲျဖစ္ပါတရ္။
မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Microsoft Visual Studion C# ကိုအသံုးျပဳၿပီးေတာ့ DLL File တစ္ခုကို ဘရ္လို ဖန္တီးယူႏိုင္မလဲ၊ ဘရ္လိုျပန္လည္ၿပီး ေခၚယူ အသံုးျပဳႏိုင္မလဲ ဆိုတာနဲ႔ ပတ္သတ္ၿပီး ေဆြးေႏြးေပးသြားပါ့မရ္။ Dll ဆိုတာကေတာ့ Dynamic Link Library ရဲ႔ အတိုေကာက္ စကားလံုးျဖစ္ပါတရ္။ Library File ဆိုတာနဲ႔တင္ ကုဒ္တင္းကို တီးမိေခါက္မိ သူေတြအေနနဲ႔ေတာ့ အသံုးခ်ႏိုင္မႈနဲ႔ စြမ္းေဆာင္ရည္ကို သိေနေလာက္ၿပီလို႔ ထင္ပါတရ္။
က်ေနာ္ အနည္းငရ္ေျပာရရင္ Dll ဆိုတာ Programming Language အသီးသီးအတြက္ IDE နဲ႔ Writer အၾကား Coding Flow ကုိ Convert လုပ္ေပးႏိုင္တဲ့ File တစ္ခုပါ။ အက်ိဳးသက္ေရာက္မႈကေတာ့ ေျပာမျပႏိုင္ေလာက္ေအာင္ပါပဲ။ က်ေနာ္တို႔ VS မွာ C# ကို အသံုးျပဳၿပီး Project တစ္ခုေရးမရ္ဆိုပါစို႔။ အေျခခံ အက်ဆံုး Text ေတြ၊ Label ေတြ၊ Button ေတြ အစရွိတဲ့ Tools ေတြကို က်ေနာ္တို႔ မျဖစ္မေနကို အသံုးျပဳ ရမွာပါ။ က်ေနာ္တို႔ ဒီလို အသံုးျပဳႏိုင္ဖုိ႔ IDE Creater ေတြက အမ်ိဳးမ်ိဳးေသာ Functions ေတြအတြက္ Library File ေတြကို ထည့္သြင္း ေပးထားရပါတရ္။ ဒါမွသာ Writer ေတြအတြက္ မဆင္ေျပမရ္မဟုတ္လားဗ်။ ဥပမာ ေျပာရရင္ က်ေနာ္တို႔ Form အစရွိတဲ့ Text, Label, Button ေတြ အသံုးျပဳႏိုင္ဖို႔အတြက္ using System.Windows.Forms; ဆိုတဲ့ Library dll file အသံုးျပဳေပးရပါတရ္။ Graphic သမားေတြအတြက္ Line, Circle, Shape,... အစရွိတဲ့ ဖန္တီးမႈေတြ လုပ္ေဆာင္ႏိုင္ဖို႔အတြက္ using System.Drawing.Drawing2D; ဆိုတဲ့ Library File ကိုအသံုးျပဳရပါတရ္။ ဒီလိုပါပဲ။ မိတ္ေဆြတို႔အေနနဲ႔ File and Directory ေတြကို Read, Write, Create,... စတာေတြ လုပ္ခ်င္ပါသလား။ using System.IO; ဆိုတဲ့ Library File ကိုအသံုးျပဳရပါတရ္။ အျခားလည္း အမ်ားႀကီးပါပဲဗ်ာ။ က်ေနာ္ ဒီေလာက္ပဲ ေျပာပါရေစ။
ဒီမွာ က်ေနာ္အေနနဲ႔ သိေစခ်င္တာက Library File ကိုအသံုးျပဳျခင္းျဖင့္ Writer သို႔မဟုတ္ Programmer တစ္ေယာက္အေနနဲ႔ Coding ကို အေသးစိတ္ စဥ္းစားစရာမလို၊ ကိုယ္တိုင္ဖန္တီး စရာမလို၊ ထပ္ခါတလဲလဲ ေရးေနစရာမလိုပဲ မိမိစိတ္ကူးကို အခ်ိန္တိုအတြင္းမွာ ဖန္တီးယူႏိုင္တရ္ဆိုတာပါပဲဗ်ာ။ ဒါဆို ဒီေလာက္ အက်ိဳးသက္ေရာက္မႈ အားေကာင္းတဲ့ library file ကို ကိုယ္တိုင္ေရာ ဖန္တီးယူလို႔ မရႏိုင္ဘူးလားလို႔ ေမးစရာရွိလာပါတရ္။ က်ေနာ္အေနနဲ႔ ေျပာရရင္ Programming Language တိုင္းအတြက္ ရပါတရ္ဗ်ာ။ ဒီေလ့က်င့္ခန္းမွာေတာ့ က်ေနာ္ VS C# ကိုအသံုးျပဳၿပီး 0 to 9 Number ေတြကို ျမန္မာကေနအဂၤလိပ္၊ အဂၤလိပ္ကေနျမန္မာ သို႔ ေျပာင္းလဲႏိုင္ဖို႔အတြက္ Dll file ဖန္တီးၿပီး ျပန္လည္အသံုးခ် ႏိုင္တာေလးကို ေဆြးေႏြး ေပးသြားပါ့မရ္။ စိတ္၀င္စားတဲ့ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ားအားလံုး က်ေနာ္နဲ႔အတူ ေလ့လာၾကည့္ၾက အံုးစို႔ဗ်ာ။
အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။
အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။
မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး မဂၤလာပါဗ်ာ။ စာေတြလည္း မတင္ျဖစ္တာ ၾကာၿပီဗ်ိဳ႕။ စိတ္မပါတာေရာ၊ မအားမလပ္တာေရာေပါ့ဗ်ာ။ ဒီေန႔ေတာ့ တင္ေနၾက ပံုစံမဟုတ္ပဲ အဆဲခံထိ(ျပည့္သူ႔ေမတၱာခံယူ)လိုက္အံုးမရ္။ က်ေနာ္ 2013-2014 ေလာက္က ၀တၱဳတိုေလးတစ္ပုဒ္ ေရးမိထားတာရွိတရ္ဗ်။ ဒါေလး တင္လိုက္မရ္ဗ်ာ။ မိတ္ေဆြတို႔ ဖတ္ရႈေပးၿပီး ေ၀ဖန္ေပးၾကပါအံုး။
အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။
eg. Hex = 1AD, Binary =?
so, Hex = 1 A D
= 0001 1010 1101
= 000110101101<2>
Hex(1AD) = Binary(000110101101)
အနည္းငယ္ရွင္းရမရ္ဆိုရင္ေတာ... Hexadecimal ကေန Binary ေျပာင္းလဲယူမရ္ဆိုရင္ျဖင့္ ပထမဆံုး Hex Number ေတြကို တစ္လံုးခ်င္းဆီ အရင္ခြဲယူပါတရ္။ ရလာတဲ့ Hex Number တစ္လံုးခ်င္းစီကိုမွ Binary Conversion Table နဲ႔ တိုက္ဆိုင္စစ္ေဆးပါတရ္။ ေနာက္ဆံုး ရလာတဲ့ တန္ဖိုးအသီးသီးကို ျပန္ေပါင္းေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုအပ္ေနတဲ့ Binary Number တစ္ခုကို ဆြဲထုတ္ယူလိုက္တာပဲျဖစ္ပါတရ္ဗ်။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။
ကဲ... အခုဆိုရင္ က်ေနာ္တို႔ Logic အေတြးကိုလည္း နားလည္သြားၿပီဆိုေတာ့ Coding Flow ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
- ပထမဦးဆံုး မိတ္ေဆြတို႔ရိုက္ထည့္လိုက္တဲ့ Hexadecimal Number ကို ToCharArray() Method အားအသံုးျပဳၿပီး HexArr ဆိုတဲ့ Char Array တစ္ခုအျဖင့္ ဖန္တီးယူလိုက္ပါတရ္။
- ဒုတိယအေနနဲ႔ while()loop ကိုအသံုးျပဳၿပီး count ကို 1 တိုးေပးၿပီး HexArr ဆံုးသည္အထိ loop ပတ္ပါတရ္။
- Loop အတြင္းမွာေတာ့ Switch( )statement ကိုအသံုးျပဳၿပီး HexArr[index] ကို key အျဖစ္သံုးကာ ၄င္းနဲ႔သက္ဆိုင္တဲ့ Binary တန္ဖိုးေတြကို ဆြဲထုတ္ပါတရ္။
- ေဒီနည္းအတိုင္းပဲ loop ဆံုးသည္အထိ သြားၿပီး loop တခါပတ္တိုင္းရရွိလာတဲ့ Binary တန္းဖိုးေတြကို ေပါင္းေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Binary တန္ဖိုးကိုရရွိမွာ ျဖစ္ပါတရ္ဗ်ာ
ဒီ Conversion ေလးရဲ႕ GUI ကိုေတာ့ ေအာက္ပါအတိုင္း ခ်ထားပါတရ္ဗ်။ မိတ္ေဆြတို႔အေနနဲ႔ ႀကိဳက္ႏွစ္သတ္ရာ ပံုစံ Tool ေတြနဲ႔ ဖန္တီးယူႏိုင္ပါတရ္။
ပိုၿပီး နားလည္သြားေအာင္ Coding အျပည့္အစံုေလးကို ေအာက္မွာ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ရွင္းလင္းခ်က္နဲ႔ Screen Shoot ေလးေတြကို ၾကည့္လိုက္ရင္ေတာ့ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမတို႔အေနနဲ႔ Hexadecimal Number တစ္ခုကေနၿပီး Decimal Number တစ္ခုသို႔ ဘယ္လို ေျပာင္းလဲယူႏိုင္မလဲဆိုတာကို နားလည္သြားၾကမရ္လို႔ ထင္ပါတရ္ဗ်ာ။ စတင္ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္လို႔ တင္ျပပံု မွားယြင္းတာ၊ အဓိပၸါယ္ ကြဲလြဲေဖာ္ျပမိတာရွိခဲ့ရင္ နားလည္ေပးၾကဖို႔ ေတာင္းပန္ပါတရ္ဗ်။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။
using System;
using System.Windows.Forms;
namespace Converter
{
public partial class HexToBinary : Form
{
public HexToBinary()
{
InitializeComponent();
}
public string HexadecimalToBinary(string hex)
{
string Bi = "";
string Binary = "";
int i = 0;
char[] HexArr = hex.ToCharArray();
while (HexArr.Length > i)
{
switch (HexArr[i])
{
case '0': Bi = "0000"; break;
case '1': Bi = "0001"; break;
case '2': Bi = "0010"; break;
case '3': Bi = "0011"; break;
case '4': Bi = "0100"; break;
case '5': Bi = "0101"; break;
case '6': Bi = "0110"; break;
case '7': Bi = "0111"; break;
case '8': Bi = "1000"; break;
case '9': Bi = "1001"; break;
case 'A': Bi = "1010"; break;
case 'B': Bi = "1011"; break;
case 'C': Bi = "1100"; break;
case 'D': Bi = "1101"; break;
case 'E': Bi = "1110"; break;
case 'F': Bi = "1111"; break;
default: Bi = ""; break;
}
Binary += Bi +" ";
i++;
}
return Binary;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtBinary.Text = HexadecimalToBinary(txtHexadecimal.Text.ToUpper()).ToString();
}
private void btnReset_Click(object sender, EventArgs e)
{
txtHexadecimal.Clear();
txtBinary.Clear();
txtHexadecimal.Focus();
}
}
}
အေသးစိတ္နားလည္ႏိုင္ဖို႔အတြက္ က်ေနာ္ Trace လုိက္ျပပါ့မရ္။
Hex = 1AD, Binary=?
char[] HexArr = { '1', 'A', 'D'};
i = 0;
Loop1 => while(HexArr.Length >0) =>
while(3 > 0) => true
switch(HexArr[i]) =>
switch(HexArr[0]) => case '1': Bi = "0001"; break;
so, Bi = 0001
i++;
i = 1;
Loop2 => while(3 > 1) => true
switch(HexArr[1]) => case 'A': Bi = "1010"; break;
so, Bi = 1010
i++;
i = 2;
Loop3 => while(3 > 2) => true
switch(HexArr[2]) => case 'D': Bi = "1101"; break;
so, Bi = 1101
i++;
i = 3;
Loop4 => while(3 > 3) => false
so, Binary = Loop1 Loop2 Loop3 = 0001 1010 1101
eg. Hex = 1AD, Dec =?
so, Hex = (1 x 16(2)) + (10 x 16(1)) + (13 x 16(0))
= 256 + 160 + 13
= 429<10>
Hex(1AD) = Dec(429)
အနည္းငယ္ရွင္းရမရ္ဆိုရင္ေတာ... Hexadecimal ကေန Decimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ ကိန္းစဥ္တန္းရဲ႕ ေနရာလိုက္တန္ဖိုးအတိုင္း Power တင္ၿပီး 16 နဲ႔ ေျမွာက္ယူပါတရ္။ ရလာတဲ့ တန္ဖိုးအသီးသီးကို ျပန္ေပါင္းေပးျခင္း ျဖင့္ က်ေနာ္တို႔ လိုအပ္ေနတဲ့ Decimal Number တစ္ခုကို ဆြဲထုတ္ယူလိုက္တာပဲျဖစ္ပါတရ္ဗ်။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။
ကဲ... အခုဆိုရင္ က်ေနာ္တို႔ Logic အေတြးကိုလည္း နားလည္သြားၿပီဆိုေတာ့ Coding Flow ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
- ပထမဦးဆံုး မိတ္ေဆြတို႔ရိုက္ထည့္လိုက္တဲ့ Hexadecimal Number ကို ToCharArray() Method အားအသံုးျပဳၿပီး HexArr ဆိုတဲ့ Char Array တစ္ခုအျဖင့္ ဖန္တီးယူလိုက္ပါတရ္။
- ဒုတိယအေနနဲ႔ ၄င္းရရွိလာတဲ့ Hex Char Array ကို တိုက္ဆိုင္စစ္ေဆးဖို႔အတြက္ HexDigit 16 သာ ပါရွိတဲ့ HexDigits Array တစ္ခုကို ႀကိဳတင္ ဖန္တီးထားလိုက္ပါတရ္။
- ေနာက္တစ္ဆင့္မွာေတာ့ for( )loop ကိုအသံုးျပဳၿပီး HexArr ကိုေရာ HexDigits ကိုေရာ loop ဆံုးသည္အထိ ပတ္ပါတရ္။
- ေနာက္တစ္ဆင့္မွာေတာ့ loop အတြင္းမွာ HexArr ထဲက Item နဲ႔ HexDigits ထဲက Item ကို တူမတူ if( ) statement နဲ႔ တိုက္ဆိုင္ စစ္ေဆးပါတရ္။
- တူညီတဲ့ Item ေတြၿပီဆိုရင္ေတာ့ Dec += (int)(j * Math.Pow(16, power)); formula ကိုအသံုးျပဳၿပီး Decimal တန္ဖိုးတစ္ခုကို ဆြဲထုတ္ယူပါတရ္။
- ဒီနည္းအတိုင္းပဲ loop ဆံုးသည္အထိ သြားၿပီး loop တခါပတ္တိုင္းရရွိလာတဲ့ Decimal တန္းဖိုးေတြကို ေပါင္းေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Decimal တန္ဖိုးကိုရရွိမွာျဖစ္ပါတရ္ဗ်ာ။
ဒီ Conversion ေလးရဲ႕ GUI ကိုေတာ့ ေအာက္ပါအတိုင္း ခ်ထားပါတရ္ဗ်။ မိတ္ေဆြတို႔အေနနဲ႔ ႀကိဳက္ႏွစ္သတ္ရာ ပံုစံ Tool ေတြနဲ႔ ဖန္တီးယူႏိုင္ပါတရ္။
ပိုၿပီး နားလည္သြားေအာင္ Coding အျပည့္အစံုေလးကို ေအာက္မွာ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ရွင္းလင္းခ်က္နဲ႔ Screen Shoot ေလးေတြကို ၾကည့္လိုက္ရင္ေတာ့ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမတို႔အေနနဲ႔ Hexadecimal Number တစ္ခုကေနၿပီး Decimal Number တစ္ခုသို႔ ဘယ္လို ေျပာင္းလဲယူႏိုင္မလဲဆိုတာကို နားလည္သြားၾကမရ္လို႔ ထင္ပါတရ္ဗ်ာ။ စတင္ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္လို႔ တင္ျပပံု မွားယြင္းတာ၊ အဓိပၸါယ္ ကြဲလြဲေဖာ္ျပမိတာရွိခဲ့ရင္ နားလည္ေပးၾကဖို႔ ေတာင္းပန္ပါတရ္ဗ်။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class HexadecimalConversion : Form
{
public HexadecimalConversion()
{
InitializeComponent();
}
public long HexToDecimal(string hex)
{
long Dec = 0;
int power = 0;
char[] HexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F'};
char[] HexArr = hex.ToCharArray();
for (int i = HexArr.Length-1; i >=0; i--)
{
for (int j = 0; j < HexDigits.Length-1; j++)
{
if (HexArr[i] == HexDigits[j])
{
Dec += (int)(j * Math.Pow(16, power));
}
}
power++;
}
return Dec;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtDecimal.Text = HexToDecimal(txtHexadecimal.Text.ToUpper()).ToString();
}
private void btnReset_Click(object sender, EventArgs e)
{
txtDecimal.Clear();
txtHexadecimal.Clear();
txtHexadecimal.Focus();
}
}
}
အေသးစိတ္နားလည္ႏိုင္ဖို႔အတြက္ က်ေနာ္ Trace လုိက္ျပပါ့မရ္။
Hex = 1AD, Dec=?
char[] HexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F'};
char[] HexArr = { '1', 'A', 'D'};
Loop1 => for (int i = HexArr.Length-1; i >=0; i--) =>
for (int i = 2; i >=0; i--) => true
for (int j = 0; j < HexDigits.Length-1; j++) =>
for (int j = 0; j < 15; j++) => true
if (HexArr[i] == HexDigits[j]) =>
if (HexArr[2] == HexDigits[13]) => true
Dec = (int)(13 * Math.Pow(16, 0)); => 13
Loop2 => for (int i = 1; i >=0; i--) => true
for (int j = 0; j < 15; j++) => true
if (HexArr[1] == HexDigits[10]) => true
Dec = (int)(10 * Math.Pow(16, 1)); => 160
Loop3 => for (int i = 0; i >=0; i--) => true
for (int j = 0; j < 15; j++) => true
if (HexArr[0] == HexDigits[1]) => true
Dec += (int)(1 * Math.Pow(16, 2)); => 256
Loop4 => for (int i = -1; i >=0; i--) => false
so, Dec = Loop1 + Loop2 + Loop3 = 13 + 160 + 156 = 429
- ေျပာင္းလဲတဲ့အခါမွာ Octal to Binary အျဖစ္ အရင္ေျပာင္းလဲမွာျဖစ္ၿပီး ၄င္း ရရွိလာတဲ့ Binary Number ကိုမွ Hexadecimal Number အျဖစ္ ေျပာင္းလဲယူမွာျဖစ္ပါတရ္။
- Octal ကို Binary ေျပာင္းတဲ့အခါမွာေတာ့ 10 နဲ႔စားကာ ကိန္းစဥ္တန္းရဲဲ႕ေနာက္ဆံုးတစ္လံုးကိုျဖတ္ယူပါတရ္။ ၄င္းရရွိလာတဲ့ Number ကိုမွ Template Matching Method ကိုအသံုးျပဳၿပီး က်ေနာ္တို႔ ႀကိဳတင္သတ္မွတ္ထားတဲ့ OctalArray နဲ႔ တိုက္ဆိုင္စစ္ေဆးပါတရ္။ ရရွိလာတဲ့ တန္ဖိုးေတြကိုမွ Loop -- False ျဖစ္တဲ့အထိ စုစည္းယူလိုက္ၿပီး Binary Number အျဖစ္ ဖန္တီးယူလိုက္တာပါ။
- Binary ကို Hexadecimal ေျပာင္းတဲ့အခါမွာေတာ့ (၄)လံုးအတြဲခြဲထုတ္မွာျဖစ္လို႔ 10000 နဲ႔ စားပါတရ္။ ရလာတဲ့ Binary (၄)လံုးတြဲေတြကိုမွ if() statement ကိုျဖတ္ၿပီး Template Matching Method သေဘာနဲ႔ပဲ တိုက္ဆိုင္စစ္ေဆးပါတရ္။ ေနာက္ဆံုးမွာေတာ့ loop -- False ျဖစ္တဲ့အထိ ပါတ္ၿပီး loop အႀကိမ္တိုင္းမွာ ရလာတဲ့ Hex value ေတြကို စုစည္းေဖာ္ျပေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Hexadecimal Number တစ္ခုကို ဖန္တီးယူလိုက္တာပဲျဖစ္ပါတရ္ဗ်ာ။
နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/7-number-system-conversions-from-octal.html Page မွာ ပံုနဲ႔တကြ ရွင္းထားတာေလးရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
ပိုၿပီး နားလည္သြားေအာင္ Coding အျပည့္အစံုေလးကို ေအာက္မွာ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ရွင္းလင္းခ်က္နဲ႔ Screen Shoot ေလးေတြကို ၾကည့္လိုက္ရင္ေတာ့ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ Trace လိုက္ၿပီး Coding Flow ေလးကို ေလ့လာၾကည့္ေစခ်င္ပါတရ္။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class Octal_Conversion : Form
{
public Octal_Conversion()
{
InitializeComponent();
}
public string OctalToHexadecimal(int Oct)
{
//Octal to Binary
string[] OctalConstant = { "000", "001", "010", "011", "100", "101", "110", "111" };
int OctIndex, quotient = Oct;
string binary = null, Hex = null, result=null;
while (quotient != 0)
{
OctIndex = quotient % 10;
if (OctIndex >= 8)
{
MessageBox.Show("It's not Octal Number");
goto End;
}
else
{
binary = OctalConstant[OctIndex] + "" + binary;
quotient /= 10;
}
}
//Binary To Hex
long fourDigit, bi = long.Parse(binary);
while (bi != 0)
{
fourDigit = bi % 10000;
if (fourDigit == 0) Hex = "0";
if (fourDigit == 1) Hex = "1";
if (fourDigit == 10) Hex = "2";
if (fourDigit == 11) Hex = "3";
if (fourDigit == 100) Hex = "4";
if (fourDigit == 101) Hex = "5";
if (fourDigit == 110) Hex = "6";
if (fourDigit == 111) Hex = "7";
if (fourDigit == 1000) Hex = "8";
if (fourDigit == 1001) Hex = "9";
if (fourDigit == 1010) Hex = "A";
if (fourDigit == 1011) Hex = "B";
if (fourDigit == 1100) Hex = "C";
if (fourDigit == 1101) Hex = "D";
if (fourDigit == 1110) Hex = "E";
if (fourDigit == 1111) Hex = "F";
result = Hex+""+result;
bi /= 10000;
}
End:
return result;
}
private void btnConvert_Click(object sender, EventArgs e)
{
if (txtOctal.Text !="")
{
txtHexadecimal.Text = OctalToHexadecimal(int.Parse(txtOctal.Text));
}
txtOctal.Focus();
}
private void btnReset_Click(object sender, EventArgs e)
{
txtOctal.Clear();
txtHexadecimal.Clear();
txtOctal.Focus();
}
}
}
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
- မိတ္ေဆြရိုက္ထည့္လိုက္ေသာ Octal Number ကို 10 နဲ႔ စားၿပီး ေနာက္ဆံုးတစ္လံုးကို ျဖတ္ယူပါ့မရ္။
- ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မညီမခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 10 နဲ႔ စားေနမရ္။
- ရလာတဲ့ စားၾကြင္းဟာ loop ပါတ္တိုင္း Octal Number ရဲ႕ ေနာက္ဆံုးတစ္လံုးရရွိေနမွာပါ။ ၄င္း Octal Number ကိုမွ Index အျဖစ္သံုးၿပီး က်ေနာ္တို႔ ႀကိဳတင္ ဖန္တီးထားတဲ့ string[] OctalConstant Array ကိုျဖတ္ၿပီး ရရွိလာတဲ့ Value ကို Binary အျဖစ္ Container တစ္ခုထဲ ေခတၱသိမ္းထားလိုက္မွာျဖစ္ပါတရ္။
- ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီသြားတဲ့အခ်ိန္မွာ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စုစည္းထားတဲ့ Binary Number တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။
နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/7-number-system-conversions-from-octal.html Page မွာ ပံုနဲ႔တကြ ရွင္းထားတာေလးရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
ပိုၿပီး နားလည္သြားေအာင္ Coding အျပည့္အစံုေလးကို ေအာက္မွာ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ခက္ခဲတဲ့ Coding ေတြ မရွိလို႔ က်ေနာ္ အေသးစိတ္ မရွင္းျပေတာ့ပါဘူးဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ Coding Flow ေလးကို Trace လိုက္ၿပီး စမ္းၾကည့္ေစခ်င္ပါတရ္။ ဒီေလ့က်င့္ခန္းမွာဆိုရင္ေတာ့ က်ေနာ္ အေျပာင္းအလဲေလးျဖစ္သြားေအာင္ if()statement ေလးနဲ႔ မိတ္ေဆြတို႔ ရိုက္ထည့္လိုက္တဲ့ Number ဟာ Octal Number ျဖစ္လား/မျဖစ္လားဆိုတာကို စစ္ေဆးထားပါတရ္(Octal Number က 0 to 7 ပဲရွိတာကိုဗ်)။ မိတ္ေဆြတို႔အေနနဲ႔ 7 ထက္ႀကီးတဲ့ Number တစ္ခု ရိုက္ထည့္မိၿပီဆိုတာနဲ႔ Error Message တတ္လာၿပီး မွန္ကန္တဲ့ Octal Number ရိုက္ထည့္ႏိုင္ဖို႔ ေျပာပါလိမ့္မရ္။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ယံုၾကည္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class Octal_Conversion : Form
{
public Octal_Conversion()
{
InitializeComponent();
}
public string OctalToBinary(int Oct)
{
string[] OctalConstant = { "000", "001", "010", "011", "100", "101", "110", "111" };
int OctIndex, quotient = Oct;
string binary = "";
while (quotient != 0)
{
OctIndex = quotient % 10;
if (OctIndex >= 8)
{
MessageBox.Show("It's not Octal Number");
break;
}
else
{
binary = OctalConstant[OctIndex] + " " + binary;
quotient /= 10;
}
}
return binary;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtBinary.Text = OctalToBinary(int.Parse(txtOctal.Text));
}
private void btnReset_Click(object sender, EventArgs e)
{
txtOctal.Clear();
txtBinary.Clear();
txtOctal.Focus();
}
}
}
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
- Decimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Octal ကို 10 နဲ႔စားမရ္။
- ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မညီမခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 10 နဲ႔ စားေနမရ္။
- Loop ပတ္တိုင္း Dec += (int)(remainder * Math.Pow(8, power)); ဆိုတဲ့ formula ကိုျဖတ္ၿပီး ရလာတဲ့ Number တစ္ခုကိုေတာ့ container တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
- ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီသြားတဲ့အခ်ိန္မွာ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ Decimal Number တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။
နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/7-number-system-conversions-from-octal.html Pageမွာ ပံုနဲ႔တကြ ရွင္းထားတာေလးရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ ေအာက္ပါအေတြးကို ပံုေဖာ္ထားတာပါ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class Octal_Conversion : Form
{
public Octal_Conversion()
{
InitializeComponent();
}
public int OctalToDecimal(int Oct)
{
int Dec = 0, power = 0, remainder, Quotient = Oct;
while (Quotient != 0)
{
remainder = Quotient % 10;
Dec += (int)(remainder * Math.Pow(8, power));
++power;
Quotient /= 10;
}
return Dec;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtDecimal.Text = OctalToDecimal(int.Parse(txtOctal.Text)).ToString();
}
private void btnReset_Click(object sender, EventArgs e)
{
txtOctal.Clear();
txtDecimal.Clear();
txtOctal.Focus();
}
}
}
OctalToDecimal(int Oct) Oct=170 loop1 => while(170 != 0) => true remainder = 170%10 = 0 Quotient = 170/10 = 17 Dec = (int)(0 * pow(8,0) = 0 loop2 => while(17 != 0) => true remainder = 17%10 = 7 Quotient = 17/10 = 1 Dec = (int)(0 + 7 * pow(8,1) = 56 loop3 => while(1 != 0) => true remainder = 1%10 = 1 Quotient = 1/10 = 0 Dec = (int)(56 + 1 * pow(8,2) = 120 loop4 => while(0 != 0) => false so, Dec = 120Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။
မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Binary Number တစ္ခုကို Hexadecimal Number အျဖစ္ ဘရ္လိုေျပာင္းလဲ ယူႏိုင္မလဲ ဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။ ေရွ႕သင္ခန္းစာေတြမွာ က်ေနာ္တို႔ Binary To Decimal ေျပာင္းလဲတာ၊ Decimal To Hexadecimal ေျပာင္းလဲတာ အစရွိတဲ့ function ေတြကို ေလ့လာခဲ့ၿပီးျဖစ္ပါတရ္။ ဒါေၾကာင့္ မိတ္ေဆြတို႔အေနနဲ႔ ၄င္း function ႏွစ္ခုကိုျဖတ္ၿပီး Binary To Hexadecimal ေျပာင္းလဲတာေလးကို ျပဳလုပ္ႏိုင္ပါတရ္။ဒီေန႔ေတာ့ Getting 'char' Method ေလးကို အသံုးျပဳၿပီး Binary Number မွ Hexadecimal Number အျဖစ္သို႔ တိုက္ရိုက္ ေျပာင္းလဲႏိုင္တာေလးကို ေဆြးေႏြးေပးသြားပါ့မရ္ဗ်ာ။ ေရွ႕မွာ ေလ့လာခဲ့ၿပီးသား သင္ခန္းစာေတြကိုပဲ ေက်ာရိုးျပဳၿပီး သာမာန္အေတြးေလးကို ရုပ္လံုးေဖာ္ၾကည့္ထားတာပါ။
သတိျပဳရမရ္႕ Logic အေနနဲ႔ကေတာ့ ကိန္းစဥ္တန္းတစ္ခုကို ဆယ္ျပည့္ကိန္း၊ ရာျပည့္ကိန္း၊ ေထာင္ျပည့္ကိန္း... စသည္တို႔ျဖင့္ စားတဲ့အခါ စားၾကြင္းအျဖင့္ ကိန္းစဥ္တန္းမွာရွိေသာ မိမိလိုခ်င္တဲ့ ကိန္းအေရအတြက္ကို ျဖတ္ယူႏိုင္တရ္ဆိုတာပါပဲဗ်ာ။ ဥပမာ အေနနဲ႔ ကိန္းစဥ္တန္းတစ္ခုကို 10 နဲ႔ စားရင္ ၄င္းကိန္းစဥ္တန္းရဲ႕ ေနာက္ဆံုး 1 လံုးကို စားၾကြင္းအျဖင့္ ျပန္ရမရ္။ 100 နဲ႔ စားရင္ 2 လံုးျပန္ရမရ္၊ 1000 နဲ႔စားရင္ 3 လံုးျပန္ရမရ္ေပါ့... စသည္ျဖင့္ မိမိလိုခ်င္သေလာက္ ျပည့္ကိန္းကို တိုးၿပီး စားႏိုင္တာပဲျဖစ္ပါတရ္ဗ်။
မိတ္ေဆြတို႔ ပိုၿပီးနားလည္သြားေအာင္ က်ေနာ္ Binary ကေန Hexadecimal ေျပာင္းတာကို ေအာက္မွာ ဥပမာေလးနဲ႔ အရင္ျပပါ့မရ္။
eg. Binary = 110110110, Hex =?
so, Binary = 0001 1011 0110
= 1 B 6
= 1B6
Binary(000110110110) = Hex(1B6)
အနည္းငယ္ရွင္းရမရ္ဆိုရင္ေတာ... Binary ကေန Hexadecimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ Binary Number ကို Right to Left ေလးလံုးစီ အရင္ျဖတ္ယူပါ့မရ္။ ရလာတဲ့ ေလးလံုးတြဲ Binary Number ကိုမွ Decimal အျဖစ္ ေျပာင္းလဲမရ္။ ရလာတဲ့ Decimal ကို Hexadecimal ေျပာင္းလဲတဲ့အခါမွာ 10 to 15 ကို A to F အျဖစ္ ေျပာင္းလဲယူပါ့မရ္။ ၿပီးရင္ေတာ့ ၄င္း ေလးလံုး Group အလိုက္ ရရွိလာတဲ့ Hexadecimal ေတြကိုစုစည္း ေဖာ္ျပျခင္းလိုက္ျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Hexadecimal Number တစ္ခုကို ရရွိမွာျဖစ္ပါတရ္။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ အခက္အခဲရွိတရ္ ဆိုရင္ေတာ့ က်ေနာ္ http://programmingknowledge.blogspot.com/2014/07/5-number-system-conversions-from-binary.html Page မွာ ပံုနဲ႔တကြ ရွင္းျပထားတာရွိပါတရ္ဗ်။
ကဲ... အခုဆိုရင္ က်ေနာ္တို႔ Logic အေတြးကိုလည္း နားလည္သြားၿပီဆိုေတာ့ Coding Flow ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
- ပထမဦးဆံုး Binary Number ကို 10000 နဲ႔ စားပါ့မရ္( Binary Number ရဲ႕ ေနာက္ဆံုး(4)လံုးကို ျဖတ္ယူခ်င္လို႔ပါ)။
- ရလာတဲ့ စားၾကြင္းကို loop ပတ္ၿပီး က်ေနာ္တို႔ ႀကိဳတင္သတ္မွတ္ထားတဲ့ Binary array နဲ႔ တိုက္ဆိုင္စစ္ေဆးၿပီး ရရွိလာတဲ့ Index Number ကိုဆြဲထုတ္ပါတရ္။
- ၄င္း ဆြဲထုတ္ယူလာတဲ့ if( ) statement နဲ႔ စစ္ထုတ္ၿပီး formula ကိုျဖတ္ခိုင္းပါတရ္။ ရလာတဲ့ တန္ဖိုးကို char type ေျပာင္းလဲယူပါ့မရ္။ ရလာတဲ့ Char တန္ဖိုးဟာ က်ေနာ္တို႔ first loop ရဲ႕ Hexadecimal Number ျဖစ္ပါတရ္။
- ေနာက္ဆံုးမွာေတာ့ Binary Number ကို 10000 နဲ႔စားၿပီး စားလဒ္ကို သုညနဲ႔ မညီမခ်င္း loop ပတ္ စစ္ထုတ္ေနမွာျဖစ္ပါတရ္။
- ေနာက္ဆံုးမွာေတာ့ loop တခါပတ္တိုင္းရရွိလာတဲ့ char တန္းဖိုးေတြကို စုစည္းေရးသားေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Hexadecimal တန္ဖိုးကိုရရွိမွာျဖစ္ပါတရ္ဗ်ာ။
ဒီ Conversion ေလးရဲ႕ GUI ကိုေတာ့ ေအာက္ပါအတိုင္း ခ်ထားပါတရ္ဗ်။ မိတ္ေဆြတို႔အေနနဲ႔ ႀကိဳက္ႏွစ္သတ္ရာ ပံုစံ Tool ေတြနဲ႔ ဖန္တီးယူႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class BinaryConversion : Form
{
public BinaryConversion()
{
InitializeComponent();
}
public string BinaryToHexadecimal(int Bi)
{
int[] HexConstant = { 0, 1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111 };
int remainder, count = 0;
char[] arr = new char[32];
while (Bi != 0)
{
remainder = Bi % 10000;
for (int i = 0; i <= HexConstant.Length - 1; i++)
{
if (HexConstant[i] == remainder)
{
if (i > 9 && i < 16)
{
/* A-F character constant */
arr[count++] = (char)((i - 10) + 'A');
}
else
{
/* 0-9 integer constant */
arr[count++] = (char)(i + '0');
}
}
}
Bi /= 10000;
}
//Revert array
string output = "";
for (int i = count - 1; i >= 0; i--)
{
output += arr[i];
}
return output;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtHexadecimal.Text = BinaryToHexadecimal(int.Parse(txtBinary.Text));
}
private void btnReset_Click(object sender, EventArgs e)
{
txtBinary.Clear();
txtHexadecimal.Clear();
txtBinary.Focus();
}
}
}
အေသးစိတ္နားလည္ႏိုင္ဖို႔အတြက္ က်ေနာ္ Trace လုိက္ျပပါ့မရ္။
ဒီေလာက္ဆိုရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ Getting 'char' method ေလးကို အသံုးျပဳၿပီး Binary Number ကေနၿပီး Hexadecimal Number အျဖစ္ ေျပာင္းလဲႏိုင္ၿပီလို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။
Binary = 00011011, Hex=?
Loop1 => (00011011 != 0) => true
Remainder = 00011011 % 10000 = 1011
For(loop(11)== 1011) => true
arr[0] = (char)((11 - 10) + 'A') = 1 + 65 = 66(B)
Binary = 00011011 / 10000 = 1
Loop2 => (1 != 0) => true
Remainder = 1 % 10000 = 1
For(loop(1)==1) => true
arr[1] = (char)(1+ '0') = 1+48 =49(1)
Binary = 1 / 10000 = 0
Loop3 => (0 != 0) => false
arr[] = B1
so, output = 1B
သတိျပဳရမရ္႕ Logic အေနနဲ႔ကေတာ့ ကိန္းစဥ္တန္းတစ္ခုကို ဆယ္ျပည့္ကိန္း၊ ရာျပည့္ကိန္း၊ ေထာင္ျပည့္ကိန္း... စသည္တို႔ျဖင့္ စားတဲ့အခါ စားၾကြင္းအျဖင့္ ကိန္းစဥ္တန္းမွာရွိေသာ မိမိလိုခ်င္တဲ့ ကိန္းအေရအတြက္ကို ျဖတ္ယူႏိုင္တရ္ဆိုတာပါပဲဗ်ာ။ ဥပမာ အေနနဲ႔ ကိန္းစဥ္တန္းတစ္ခုကို 10 နဲ႔ စားရင္ ၄င္းကိန္းစဥ္တန္းရဲ႕ ေနာက္ဆံုး 1 လံုးကို စားၾကြင္းအျဖင့္ ျပန္ရမရ္။ 100 နဲ႔ စားရင္ 2 လံုးျပန္ရမရ္၊ 1000 နဲ႔စားရင္ 3 လံုးျပန္ရမရ္ေပါ့... စသည္ျဖင့္ မိမိလိုခ်င္သေလာက္ ျပည့္ကိန္းကို တိုးၿပီး စားႏိုင္တာပဲျဖစ္ပါတရ္ဗ်။
မိတ္ေဆြတို႔ ပိုၿပီးနားလည္သြားေအာင္ က်ေနာ္ Binary ကေန Octal ေျပာင္းတာကို ေအာက္မွာ ဥပမာေလးနဲ႔ အရင္ျပပါ့မရ္။
eg. Binary = 110110110, Octal =?
so, Binary = 110 110 110
= 6 6 6
= 666
Binary(110110110) = Octal(666)
အနည္းငယ္ရွင္းရမရ္ဆိုရင္ေတာ... Binary ကေန Octal ေျပာင္းမွာျဖစ္တဲ့အတြက္ Binary Number ကို Right to Left သံုးလံုးစီ အရင္ျဖတ္ယူပါ့မရ္။ ရလာတဲ့ သံုးလံုးတြဲ Binary Number ကိုမွ Decimal အျဖစ္ ေျပာင္းလဲမရ္။ Binary Group အလိုက္ ရလာတဲ့ Decimal ကိန္းေတြကို စုစည္း ေဖာ္ျပျခင္းလိုက္ျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Octal Number တစ္ခုကို ရရွိမွာျဖစ္ပါတရ္။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ အခက္အခဲရွိတရ္ဆိုရင္ေတာ့ က်ေနာ္ ... Page မွာ ပံုနဲ႔တကြ ရွင္းျပထားတာရွိပါတရ္ဗ်။
ကဲ... အခုဆိုရင္ က်ေနာ္တို႔ Logic အေတြးကိုလည္း နားလည္သြားၿပီဆိုေတာ့ Coding Flow ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
- ပထမဦးဆံုး Binary Number ကို 1000 နဲ႔ စားပါ့မရ္( Binary Number ရဲ႕ ေနာက္ဆံုး(3)လံုးကို ျဖတ္ယူခ်င္လို႔ပါ)။
- ရလာတဲ့ စားၾကြင္းကို loop ပတ္ၿပီး က်ေနာ္တို႔ ႀကိဳတင္သတ္မွတ္ထားတဲ့ Binary array နဲ႔ တိုက္ဆိုင္စစ္ေဆးၿပီး ရရွိလာတဲ့ Index Number ကိုဆြဲထုတ္ပါတရ္။
- ၄င္း ဆြဲထုတ္ယူလာတဲ့ Index Number + ‘0’ ဆိုတဲ့ formual ကိုျဖတ္ၿပီး ရလာတဲ့ တန္ဖိုးကို char type ေျပာင္းလဲယူပါ့မရ္။ ရလာတဲ့ Char တန္ဖိုးဟာ က်ေနာ္တို႔ first loop ရဲ႕ Octal Number ျဖစ္ပါတရ္။
- ေနာက္ဆံုးမွာေတာ့ Binary Number ကို 1000 နဲ႔စားၿပီး စားလဒ္ကို သုညနဲ႔ မညီမခ်င္း loop ပတ္ စစ္ထုတ္ေနမွာျဖစ္ပါတရ္။
- ေနာက္ဆံုးမွာေတာ့ loop တခါပတ္တိုင္းရရွိလာတဲ့ char တန္းဖိုးေတြကို စုစည္းေရးသားေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Octal တန္ဖိုးကိုရရွိမွာျဖစ္ပါတရ္ဗ်ာ။
ဒီ Conversion ေလးရဲ႕ GUI ကိုေတာ့ ေအာက္ပါအတိုင္းခ်ထားပါတရ္ဗ်။ မိတ္ေဆြတို႔အေနနဲ႔ ႀကိဳက္ႏွစ္သတ္ရာ ပံုစံ Tool ေတြနဲ႔ ဖန္တီးယူႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class BinaryConversion : Form
{
public BinaryConversion()
{
InitializeComponent();
}
public string BinaryToOctal(int Bi)
{
int[] OctalConstant = {0, 1, 10, 11, 100, 101, 110, 111};
int remainder, count = 0;
char[] arr = new char[32];
while (Bi != 0)
{
remainder = Bi % 1000;
for (int i = 0; i <= OctalConstant.Length-1; i++)
{
if (OctalConstant[i] == remainder)
{
arr[count++] = (char)(i + '0');
}
}
Bi /= 1000;
}
//Revert array
string output = "";
for (int i = count-1; i >= 0; i--)
{
output += arr[i];
}
return output;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtOctal.Text = BinaryToOctal(int.Parse(txtBinary.Text));
}
private void btnReset_Click(object sender, EventArgs e)
{
txtBinary.Clear();
txtOctal.Clear();
txtBinary.Focus();
}
}
}
အေသးစိတ္နားလည္ႏိုင္ဖို႔အတြက္ က်ေနာ္ Trace လုိက္ျပပါ့မရ္။
ဒီေလာက္ဆိုရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ Getting 'char' method ေလးကို အသံုးျပဳၿပီး Binary Number ကေနၿပီး Octal Number အျဖစ္ ေျပာင္းလဲႏိုင္ၿပီလို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။
Binary = 110110, Octal=? Loop1 => (110110 != 0) => true Remainder = 110110 % 1000 = 110 For(loop(6)==110) => true arr[0] = (char) 6 + ‘0’ = 6+48 = 54(6) Binary = 110110 / 1000 = 110 Loop2 => (110 != 0) => true Remainder = 110% 1000 = 110 For(loop(6)==110) => true arr[1] = (char) 6 + ‘0’ = 6+48 = 54(6) Binary = 110 / 1000 = 0 Loop3 => (0 != 0) => false So, arr[] = 66
- ပထမဦးဆံုး Binary Number ကို BinaryToDecimal( ) ဆိုတဲ့ function ကိုျဖတ္ၿပီး Decimal Number တစ္ခုကို အရင္ဆြဲထုတ္မရ္။
- ေနာက္ဆံုးမွာေတာ့ ၄င္း ရရွိလာေသာ Decimal Number ကို DecToOctal( ) function ကို ထပ္ျဖတ္ေစၿပီး Octal Number တစ္ခုကို ရယူလိုက္မွာပဲျဖစ္ပါတရ္ဗ်ာ။
Function ႏွစ္ခုစလံုးဟာ ေရွ႕သင္ခန္းစာေတြမွာ ေလ့လာခဲ့ၿပီးသားျဖစ္လို႔ မိတ္ေဆြတို႔အေနနဲ႔ အခက္အခဲမရွိ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်ာ။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္းခ်ထားပါတရ္။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ မိမိႀကိဳက္ႏွစ္သက္ရာ ပံုစံနဲ႔ ျပဳလုပ္ႏိုင္ပါတရ္ဗ်ာ။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
အနည္းငယ္ရွင္းရမရ္ဆိုရင္ျဖင့္... က်ေနာ္တို႔ Binary Number အျဖစ္ 110110 ဆိုတာကို ရိုက္ထည့္လိုက္ပါမရ္။ ပထမ BinaryToDecimal( ) function ကိုျဖတ္ၿပီးတဲ့အခ်ိန္မွာေတာ့ 54 ဆိုတဲ့ Decimal Number တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။ ၄င္းကိုမွ DecToOctal( ) function ကိုထက္ျဖတ္လိုက္တဲ့အခါမွာေတာ့ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Octal Number ျဖစ္တဲ့ 66 ဆိုတဲ့ Result တစ္ခုကို ရရွိခဲ့တာပဲျဖစ္ပါတရ္ဗ်ာ။ Function ႏွစ္ခုစလံုးက ေလ့လာခဲ့သားေတြျဖစ္လို႔ က်ေနာ္အေသးစိတ္မရွင္းျပေတာ့ပါဘူး။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class BinaryConversion : Form
{
public BinaryConversion()
{
InitializeComponent();
}
public int BinaryToDecimal(int Bi)
{
int Dec=0, power=0, remainder=0, Quotient= Bi;
while (Quotient != 0)
{
remainder = Quotient % 10;
Dec += (int)(remainder * Math.Pow(2, power));
Quotient /= 10;
++power;
}
return Dec;
}
public string DecToOctal(int Dec)
{
string remainder = null, result = null;
int Quotient = Dec;
while (Quotient > 0)
{
remainder += (Quotient % 8).ToString();
Quotient /= 8;
}
for (int i = remainder.Length - 1; i >= 0; i--)
{
result += remainder[i];
}
return result;
}
private void btnConvert_Click(object sender, EventArgs e)
{
int Dec = BinaryToDecimal(int.Parse(txtBinary.Text));
txtOctal.Text = DecToOctal(Dec).ToString();
}
private void btnReset_Click(object sender, EventArgs e)
{
txtBinary.Clear();
txtOctal.Clear();
txtBinary.Focus();
}
}
}
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
- Decimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Binary ကို 10 နဲ႔စားမရ္။
- ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မညီမခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 10 နဲ႔ စားေနမရ္။
- Loop ပတ္တိုင္း Dec += (int)(remainder * Math.Pow(2, power)); ဆိုတဲ့ formula ကိုျဖတ္ၿပီး ရလာတဲ့ Number တစ္ခုကိုေတာ့ container တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
- ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီသြားတဲ့အခ်ိန္မွာ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ Decimal Number တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။
Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/5-number-system-conversions-from-binary.html
Pageမွာ ပံုနဲ႔တကြ ရွင္းထားတာေလး ရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ ေအာက္ပါအေတြးကို ပံုေဖာ္ထားတာပါ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class BinaryConversion : Form
{
public BinaryConversion()
{
InitializeComponent();
}
public int BinaryToDecimal(int Bi)
{
int Dec=0, power=0, remainder, Quotient= Bi;
while (Quotient != 0)
{
remainder = Quotient % 10;
Quotient /= 10;
Dec += (int)(remainder * Math.Pow(2, power));
++power;
}
return Dec;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtDecimal.Text = BinaryToDecimal(int.Parse(txtBinary.Text)).ToString();
}
private void btnReset_Click(object sender, EventArgs e)
{
txtBinary.Clear();
txtDecimal.Clear();
txtBinary.Focus();
}
}
}
BinaryToDecimal(int Bi) Bi=1101 loop1 => while(1101 != 0) => true remainder = 1101%10 = 1 Quotient = 1101/10 = 110 Dec = (int)(1 * pow(2,0) = 1 loop2 => while(110 != 0) => true remainder = 110%10 = 0 Quotient = 110/10 = 11 Dec = (int)(1 + 0 * pow(2,1) = 1 loop3 => while(11 != 0) => true remainder = 11%10 = 1 Quotient = 11/10 = 1 Dec = (int)(1 + 1 * pow(2,2) = 5 loop4 => while(1 != 0) => true remainder = 1%10 = 1 Quotient = 1/10 = 0 Dec = (int)(5 + 1 * pow(2,3) = 13 loop5 => while(0 != 0) => false so, Dec = 13Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။
ဒီေန႔ သင္ခန္းစာမွာေတာ့ တမူထူးျခားမႈေလးျဖစ္သြားေအာင္ Getting ‘Char’ Mthod ကို အေျခခံၿပီး ေလ့လာၾကည့္ၾကပါမရ္။ Function ေရးသားရာမွာလည္း Conversion တိုင္းကို သီးျခား function ေတြ ခြဲေရးမေနေတာ့ပဲ Function တစ္ခုတည္းျဖင့္ Type Conversion အားလံုး ေျပာင္းလဲႏိုင္တဲ့ ပံုစံေလးနဲ႔ ေလ့လာၾကည့္သြားၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
- Decimal Number ကို မိမိတို႔ ေျပာင္းလဲခ်င္ေသာ Type ရဲ႕Base နဲ႔စားမရ္။
- ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ Base နဲ႔ စားေနမရ္။
- စားၾကြင္း(remainder)ကိုေတာ့ remainder -10+ 'A' OR remainder +'0' ဆိုတဲ့ Formula ကိုျဖတ္ၿပီး Char Value တစ္ခု ရယူမရ္။ ရလာတဲ့ result တစ္ခုကို char array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
- ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ char array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။
- ေနာက္ဆံုးမွာေတာ့ ၄င္း Array ကို Invert လုပ္ ေျပာင္းျပန္လွန္ေပးျခင္းျဖင့္ က်ေနာ္တို႔လိုခ်င္တဲ့ အျခားေသာ Type string တစ္ခုကို ဆြဲထုတ္ယူလိုက္တာပဲျဖစ္ပါတရ္။
GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class frmDecToOther : Form
{
public frmDecToOther()
{
InitializeComponent();
}
public string DecToOther(int Dec, int Base)
{
int count = 0, remainder;
char[] arr = new char[32];
while (Dec > 0)
{
remainder = Dec % Base;
Dec /= Base;
if (remainder > 9 && remainder < 16)
{
arr[count++] = (char)(remainder -10+ 'A');
}
else
{
arr[count++] = (char)(remainder + '0');
}
}
//Revert String
string output = "";
for (int i = count-1; i >= 0; i--)
{
output += arr[i];
}
return output;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtBinary.Text =DecToOther(int.Parse(txtDecimal.Text), 2);
txtOctal.Text = DecToOther(int.Parse(txtDecimal.Text), 8);
txtHexadecimal.Text = DecToOther(int.Parse(txtDecimal.Text), 16);
}
private void btnReset_Click(object sender, EventArgs e)
{
txtDecimal.Clear();
txtBinary.Clear();
txtOctal.Clear();
txtHexadecimal.Clear();
txtDecimal.Focus();
}
}
}
အားလံုးကို အေသးစိတ္နားလည္သြားေအာင္ Decimal Nume (10) ကို Octal Number အျဖစ္ ေျပာင္းလဲတာေလးကို trace လိုက္ျပပါ့မရ္။
DecToOther(int Dec, int Base)
Dec = 10, Base=8
loop1 => while(10> 0) => true
remainder = 10%8 = 2
Dec = 10/8 = 1
if() =false
arr[1] = (char)(2+50) = (52)2
loop2 => while(1> 0) => true
remainder = 1%8 =1
Dec = 1/8 =0
if() => false
arr[2] = (char)(1+50) = (51)1
loop3 => while(0 > 0) => false
so, arr[] ={2,1}
အနည္းငယ္ရွင္းရမယ္ဆိုရင္ေတာ့... ပထမ loop မွာ array[1] ထဲကို 52 ထည့္ရပါ့မရ္။ 52 ကို Char ေျပာင္းတဲ့အခါ 2 ကိုရပါလိမ့္မရ္။ ဒါေၾကာင့္ arr[1] =2 ရတာပါ။ ဒုတိယ loop မွာ array[2] ထဲကို 51 ထည့္ရပါ့မရ္။ 51 ကို Char ေျပာင္းတဲ့အခါ 1 ကိုရပါလိမ့္မရ္။ ဒါေၾကာင့္ arr[2] =1 ရတာပါ။ တတိယ loop မွာေတာ့ while connection false ျဖစ္ပါတရ္။ ဒီေတာ့ loop ကထြက္ပါၿပီ။ ဒီအေျခအေနမွာ က်ေနာ္တို႔ array အခန္းထဲမွာ arr[] ={2,1} ဆိုၿပီး ရရွိေနပါၿပီဗ်ာ။ ေနာက္ဆံုးမွာေတာ့ ၄င္း array ကို invert လုပ္ ေျပာင္းျပန္လွန္ေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္တဲ့ octal တန္ဖိုး 12 ဆိုတာကို ရရွိခဲ့တာျဖစ္ပါတရ္။ နားလည္းၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်ာ။ အျခား Type Conversion ေတြလည္း ဒီနည္းအတိုင္းပဲ ေျပာင္းလဲသြားတာျဖစ္ပါတရ္။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
- Octal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Decimal ကို 8 နဲ႔စားမရ္။
- ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 8 နဲ႔ စားေနမရ္။
- Loop ပတ္တိုင္း ရလာတဲ့ စားၾကြင္း(remainder)ကိုေတာ့ container array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
- ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။
- ေနာက္ဆံုးမွာေတာ့ ၄င္း Array ကို Invert လုပ္ ေျပာင္းျပန္လွန္ေပးျခင္းျဖင့္ Octal string တစ္ခုကို ဖန္တီးယူလိုက္တာပဲျဖစ္ပါတရ္။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။
Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/6-number-system-conversions-from.html
Pageမွာ ပံုနဲ႔တကြ ရွင္းထားတာေလး ရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။
using System;
using System.Windows.Forms;
namespace NumberTypeConverter
{
public partial class frmDecToOctal : Form
{
public frmDecToOctal()
{
InitializeComponent();
}
public string DecToOctal(int Dec)
{
string remainder=null, result=null;
int Quotient = Dec;
while (Quotient > 0)
{
remainder += (Quotient % 8).ToString();
Quotient /= 8;
}
for (int i = remainder.Length-1; i >=0; i--)
{
result += remainder[i];
}
return result;
}
private void btnConvert_Click(object sender, EventArgs e)
{
txtOctal.Text = DecToOctal(int.Parse(txtDecimal.Text));
}
private void btnReset_Click(object sender, EventArgs e)
{
txtDecimal.Clear();
txtOctal.Clear();
txtDecimal.Focus();
}
}
}
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
- Binary ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Decimal ကို 2 နဲ႔စားမရ္။
- ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 2 နဲ႔ စားေနမရ္။
- Loop ပတ္တိုင္း ရလာတဲ့ စားၾကြင္း(remainder)ကိုေတာ့ container array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
- ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။
- ေနာက္ဆံုးမွာေတာ့ ၄င္း Array ကို Invert လုပ္ ေျပာင္းျပန္လွန္ေပးျခင္းျဖင့္ Binary string တစ္ခုကို ဖန္တီးယူလိုက္တာပဲျဖစ္ပါတရ္။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။
Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/6-number-system-conversions-from.html
Pageမွာ ပံုနဲ႔တကြ ရွင္းထားတာေလး ရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။
using System;
using System;
using System.Windows.Forms;
namespace Converter
{
public partial class frmDecToBinary : Form
{
public frmDecToBinary()
{
InitializeComponent();
}
public string DecToBinary(int Dec)
{
string remainder = null, result = null;
int Quotient = Dec;
while (Quotient > 0) {
remainder += (Quotient % 2).ToString();
Quotient /= 2;
}
//Invert String
for (int i = remainder.Length - 1; i >= 0; i--) {
result += remainder[i];
}
return result;
}
private void btnConvertDecToBi_Click(object sender, EventArgs e)
{
txtBinary.Text = DecToBinary(int.Parse(txtDecimal.Text));
}
private void btnReset_Click(object sender, EventArgs e)
{
txtDecimal.Text = "";
txtBinary.Clear();
txtDecimal.Focus();
}
}
}
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
- Hexadecimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Decimal ကို 16 နဲ႔စားမရ္။
- ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 16 နဲ႔ စားေနမရ္။
- စားၾကြင္း(remainder)ကိုေတာ့ template filtering စနစ္နဲ႔ တိုက္ဆိုင္စစ္ေဆးမရ္။ ရလာတဲ့ result တစ္ခုကို container array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
- ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။
- ေနာက္ဆံုးမွာေတာ့ Array ကို Invert လုပ္ ေျပာင္းျပန္လွန္ေပးျခင္းျဖင့္ Hexadecimal string တစ္ခုကို ဆြဲထုတ္လိုက္တာပဲျဖစ္ပါတရ္။ နားလည္ႏိုင္ၾကပါလိမ့္မရ္ဗ်ာ။
Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/6-number-system-conversions-from.html
Pageမွာ ပံုနဲ႔တကြ ရွင္းထားတာေလး ရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
using System;
using System.Linq;
using System.Windows.Forms;
namespace DecToHex
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
public string DecToHex(int Dec)
{
string remainder= null, result = null;
int Quotient = Dec;
while (Quotient > 0)
{
remainder = (Quotient % 16).ToString();
if (remainder == "0") remainder = "0";
if (remainder == "1") remainder = "1";
if (remainder == "2") remainder = "2";
if (remainder == "3") remainder = "3";
if (remainder == "4") remainder = "4";
if (remainder == "5") remainder = "5";
if (remainder == "6") remainder = "6";
if (remainder == "7") remainder = "7";
if (remainder == "8") remainder = "8";
if (remainder == "9") remainder = "9";
if (remainder == "10") remainder = "A";
if (remainder == "11") remainder = "B";
if (remainder == "12") remainder = "C";
if (remainder == "13") remainder = "D";
if (remainder == "14") remainder = "E";
if (remainder == "15") remainder = "F";
result += remainder;
Quotient = Quotient / 16;
}
////Revert String
return new string(result.ToCharArray().Reverse().ToArray());
}
private void btnDecToHex_Click(object sender, EventArgs e)
{
txtHex.Text = DecToHex(int.Parse(txtDec.Text));
}
}
}
ေနာက္ဆံုး String ကို Reverse လုပ္ထားတဲ့စနစ္ကိုေတာ့ Linq ရဲ႕ Method နဲ႔ ျပထားပါတရ္။ မိတ္ေဆြတို႔အေနနဲ႔ သာမာန္အေတြးအတိုင္း for loop ကို အသံုးျပဳၿပီး Reverse လုပ္ခ်င္တရ္ဆိုရင္ေတာ့ ေအာက္က ကုဒ္တင္းေလးနဲ႔ ေျပာင္းေရးႏိုင္ပါတရ္ဗ်ာ။
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။
string output = "";
for (int i = result.Length - 1; i >= 0; i--)
{
output += result[i];
}
return output;
