C# - Bubble Sort Algorithm

Posted by ေတဇာလင္း Friday, 30 December 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ားအားလံုး မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ VS C# ကို အသံုးျပဳၿပီး Sorting Algorithms ေတြထဲက တစ္ခုျဖစ္တဲ့ Bubble Sort အေၾကာင္းေလးကို ေလ့လာၾကည့္ၾကပါ့မရ္ဗ်။ အေပၚကပံုကေတာ့ Bubble Sort Algorithm အလုပ္ လုပ္သြားတဲ့ ပံုစံပဲျဖစ္ပါတရ္။ အေပၚပံုမွာျမင္ရတဲ့အတိုင္း ကိန္းစဥ္တန္း ငါးလံုးရွိရင္ Loop Step ငါးခုရွိမွာျဖစ္ပါတရ္။ Step တစ္ခုစီတိုင္းမွာ ကပ္လွ်ပ္ ကိန္းစဥ္တန္းႏွစ္လံုးကို ႏႈိင္းယွဥ္ၿပီး ငယ္စဥ္ႀကီးလိုက္အတြက္ ေနာက္ကိန္းကငယ္ေနလွ်င္ေရွ႕ကိန္းနဲ႔ေနရာခ်ိန္းပါတရ္။ ေနာက္ကိန္းကႀကီးေနရင္ေတာ့ ဒီအတိုင္းပဲ ျပန္စီပါတရ္ဗ်။ ဒီနည္းအတုိင္းပဲ ကိန္းစဥ္တန္းဆံုးတဲ့အထိ ကပ္လွ်ပ္ႏွစ္လံုးစီ ႏႈိင္းယွဥ္ၿပီး ေနရာအခ်ိန္းအေျပာင္းလုပ္ပါတရ္။ Step တစ္ခုဆံုးတဲ့အခ်ိန္မွာ ကိန္းစဥ္တန္းရဲ႕ ေနာက္ဆံုးကို ေရာက္သြားတဲ့ ကိန္းဟာ အႀကီးဆံုးကိန္း ျဖစ္ေနမွာပါ။ ဒါေၾကာင့္ Step 1 ၿပီးတဲ့အခ်ိန္မွာ ေနာက္ဆံုး ကိန္းဟာ အႀကီးဆံုးကိန္း၊ Step 2 ဆံုးတဲ့အခါ ေနာက္ဆံုး ကိန္းႏွစ္လံုးဟာ Sort လုပ္ၿပီးသား အႀကီးဆံုးကိန္းျဖစ္ေနမွာပါ။ ဒီနည္းအတိုင္း ကိန္းစဥ္တန္းအားလံုး Sort လုပ္ၿပီးသည္အထိ Step သြားၿပီး Loop လုပ္ ႏႈိင္းယွဥ္ပါတရ္ဗ်ာ။ အေပၚက ပံုကို ၾကည့္လုိက္ရင္ေတာ့ က်ေနာ္ ဘာကို ဆိုလိုေနတရ္ဆုိတာကို နားလည္ႏိုင္ၾက လိမ့္မရ္လို႔ ထင္ပါတရ္။
ဒါကေတာ့ က်ေနာ္ရဲ႕ ေလ့လာၾကည့္မဲ့ Bubble Sort အတြက္ GUI ပါ။ DataGridView ထဲကို Array Set လုပ္တာကိုေတာ့ ေရွ႕က Insertion Sort သင္ခန္းစာမွာ ရွင္းျပခဲ့ၿပီးျဖစ္လို႔ မရွင္းေတာ့ပါဘူးဗ်ာ။ private void txtSetColumn_TextChanged(object sender, EventArgs e){ ...} မွာ Coding ေလး ၾကည့္လိုက္ပါ။
ေနာက္တစ္ခုကေတာ့ Bubble Sort ကို က်ေနာ္ Method ခြဲေရးထားတဲ့ ပံုစံပါ။ public int[] BubbleSorted(int[] arr, string Opt){...} မွာ Coding ေလး ေလ့လာၾကည့္ပါအံုးဗ်။
Method ကို Calling လုပ္တဲ့ ပံုစံကိုေတာ့ private void btnBubbleSort_Click(object sender, EventArgs e) {...} မွာေ လ့လာႏိုင္ပါတရ္။
Result ပံုေလးနဲ႔ Bubble Sort ရဲ႕ အလုပ္ လုပ္ပံုေလးကို သိၿပီဆိုရင္ေတာ့ က်ေနာ္တို႔ ပိုၿပီး နားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုေလးကို ေလ့လာၾကည့္ၾကမရ္ဗ်ာ။
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;
            }           
        }
    }
}

နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ေမ်ာ္လင့္ပါတရ္ဗ်။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Insertion Sort Algorithm

Posted by ေတဇာလင္း Thursday, 29 December 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ားအားလံုး မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ ဒီေန႔ေတာ့ VS C# ကို အသံုးျပဳၿပီး Sorting Algorithms ေတြထဲက တစ္ခုျဖစ္တဲ့ Insertion Sort အေၾကာင္းေလးကို Coding ေလးေရးၿပီး ေလ့လာၾကည့္ၾကပါမရ္။
အေပၚက ပံုကေတာ့ Insertion Sort အလုပ္ လုပ္သြားတဲ့ ပံုစံပါ။ က်ေနာ့္ Website ေလးျဖစ္တဲ့ programmingknowledge.blogspot.com မွာ Insertion Sort အေၾကာင္းကို သီအုိရီနဲ႔ႏြယ္ၿပီး အနည္းငရ္ ရွင္းျပခဲ့ၿပီးပါၿပီ။ မိတ္ေဆြတို႔ ေလ့လာႏိုင္ပါတရ္ဗ်။ ဒါေၾကာင့္ ဒီေန႔ ေလ့က်င့္ခန္းမွာ က်ေနာ္ အေသးစိတ္မရွင္းေတာ့ပဲ Code Flow ေလးနဲ႔ Screen Shoot ေလးေတြပဲ ျပပါ့မရ္ဗ်။ Coding Flow ကိုေတာ့ ေလ့လာၾကည့္မရ္ဆိုရင္ေတာ့ အဆင့္(၄)ဆင့္နဲ႔ ေတြ႔ရမွာပါ။ အဆင့္(၁)။ မိမိႏွစ္သက္ရာ Columns အေရအတြက္ကို သက္မွတ္ၿပီး DataGridView မွာ Array[ ] အတြက္ Table တစ္ခု တည္ေဆာက္ယူမွာျဖစ္ပါတရ္။ အဆင့္(၂)။ ဖန္တီးထားေသာ UnSorted Table မွာ မိမိႏွစ္သက္ရာ Array[ ] အတြက္ ကိန္းစဥ္တန္းတစ္ခုကို ရိုက္ထည့္ပါ့မရ္။ အဆင့္(၃)။ ဒီအဆင့္မွာေတာ့ Sorting Option ကို ေရြးခ်ယ္ၿပီး Insertion Sort Btn ကိုႏွိပ္ကာ Sorting လုပ္ေဆာင္ယူမွာျဖစ္ပါတရ္။ အဆင့္(၄)။ ဒါဆိုရင္ေတာ့ က်ေနာ္တို႔ ေျပာင္းလဲယူလိုက္တဲ့ Sorting လုပ္ၿပီးသား Array[] တစ္ခုကို Sorted DataGridView မွာျမင္ရမွာျဖစ္ပါတရ္ဗ်ာ။ ဒီေလ့က်င့္ခန္းမွာ Sorting ကို သီးသန္႔ Method ခြဲၿပီး ေရးထားပါတရ္။ ဒီမွာ မိတ္ေဆြတို႔ တစ္ခု သတိထားရမွာေတာ့ က်ေနာ္တို႔ ဖန္တီးထားတဲ့ Sorting Method က Array[] ကို Parameter Passing လုပ္ထားၿပီး Array[] ကိုပဲ return ျပန္ထားတဲ့အတြက္ေၾကာင့္ Sorting Method ကို ေခၚမသံုးခင္ မိမိ Sort လုပ္ခ်င္ေသာ ကိန္းစဥ္တန္းကို Array[] တစ္ခုအျဖစ္ အရင္ ဖန္တီးယူရမွာျဖစ္ပါတရ္ဗ်။ public int[] InsertSort(int[] arr, string Opt){ ... } ဒါက Insertion Sort ရဲ႕ Method ပါ။ int[] SortedArr = InsertSort(Array, "ASC/DESC"); ဒါကေတာ့ Calling ပံုစံပါ။
Coding အျပည့္အစံုေလးကို ေအာက္မွာ ၾကည့္လိုက္ပါအံုးဗ်ာ။
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;
            }            
        }
     }
}

နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ေမ်ာ္လင့္ပါတရ္ဗ်။
မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - How to Change Number To Word in C# ?

Posted by ေတဇာလင္း Tuesday, 20 December 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ VS C# ကိုအသံုးျပဳၿပီး Number(ကိန္းဂဏန္း)ေတြကို Word(စကားလံုး)ေတြအျဖစ္ ဘရ္လို ေျပာင္းလဲယူႏိုင္မလဲ ဆိုတာေလးကို ေလ့လာၾကည့္ၾကပါ့မရ္။ က်ေနာ္ Method ခြဲေရးၿပီး ဆြဲသံုးတဲ့ နည္းလမ္းေလးနဲ႔ပဲ ေရးထားပါတရ္။ စိတ္၀င္စားတဲ့ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား က်ေနာ္နဲ႔အတူ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
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 ျဖစ္သြားမွာပဲျဖစ္ပါတရ္။
ဒီေလ့က်င့္ခန္းမွာေတာ့ က်ေနာ္ အႏုတ္ Key ရိုက္မရေအာင္ KeyPress Event မွာ ပိတ္ထားပါတရ္။ ဒါေပမဲ့ အေပၚမွာ အႏုတ္ Number ရိုက္ထည့္ရင္လည္း အလုပ္ လုပ္ေၾကာင္း ပံုနဲ႔ ျပထားပါတရ္ဗ်။ မိတ္ေဆြတို႔ အႏုတ္ကိန္းေတြပါ စာသားအျဖစ္ေျပာင္းခ်င္တရ္ဆိုရင္ေတာ့ TextBox_KeyPress Event ကို မသံုးပဲ Off ထားႏိုင္ပါတရ္။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။

How to Create & Use DLL File in C# ?

Posted by ေတဇာလင္း Saturday, 17 December 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ 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 ဖန္တီးၿပီး ျပန္လည္အသံုးခ် ႏိုင္တာေလးကို ေဆြးေႏြး ေပးသြားပါ့မရ္။ စိတ္၀င္စားတဲ့ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ားအားလံုး က်ေနာ္နဲ႔အတူ ေလ့လာၾကည့္ၾက အံုးစို႔ဗ်ာ။

အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။

မုန္တိုင္းလည္းစဲ... လမင္းလည္းသာ

Posted by ေတဇာလင္း Thursday, 15 December 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး မဂၤလာပါဗ်ာ။ စာေတြလည္း မတင္ျဖစ္တာ ၾကာၿပီဗ်ိဳ႕။ စိတ္မပါတာေရာ၊ မအားမလပ္တာေရာေပါ့ဗ်ာ။ ဒီေန႔ေတာ့ တင္ေနၾက ပံုစံမဟုတ္ပဲ အဆဲခံထိ(ျပည့္သူ႔ေမတၱာခံယူ)လိုက္အံုးမရ္။ က်ေနာ္ 2013-2014 ေလာက္က ၀တၱဳတိုေလးတစ္ပုဒ္ ေရးမိထားတာရွိတရ္ဗ်။ ဒါေလး တင္လိုက္မရ္ဗ်ာ။ မိတ္ေဆြတို႔ ဖတ္ရႈေပးၿပီး ေ၀ဖန္ေပးၾကပါအံုး။

အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။

Create Hexadecimal to Binary Converter in C#

Posted by ေတဇာလင္း Saturday, 12 November 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ရဲ႕ မၿပီးျပတ္ေသးတဲ့ Number System အေၾကာင္းေလးကို ေရွ႕ဆက္ၾကည့္ၾကရေအာင္ပါ။ ဒီေန႔ေတာ့ Hexadecimal Number တစ္ခုကို Binary Number အျဖစ္ ဘရ္လိုေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ မိတ္ေဆြတို႔ ပိုၿပီးနားလည္သြားေအာင္ က်ေနာ္ Hexadecimal ကေန Binary ေျပာင္းတာကို ေအာက္မွာ ဥပမာေလးနဲ႔ အရင္ျပပါ့မရ္။
 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 ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
  1. ပထမဦးဆံုး မိတ္ေဆြတို႔ရိုက္ထည့္လိုက္တဲ့ Hexadecimal Number ကို ToCharArray() Method အားအသံုးျပဳၿပီး HexArr ဆိုတဲ့ Char Array တစ္ခုအျဖင့္ ဖန္တီးယူလိုက္ပါတရ္။
  2. ဒုတိယအေနနဲ႔ while()loop ကိုအသံုးျပဳၿပီး count ကို 1 တိုးေပးၿပီး HexArr ဆံုးသည္အထိ loop ပတ္ပါတရ္။
  3. Loop အတြင္းမွာေတာ့ Switch( )statement ကိုအသံုးျပဳၿပီး HexArr[index] ကို key အျဖစ္သံုးကာ ၄င္းနဲ႔သက္ဆိုင္တဲ့ Binary တန္ဖိုးေတြကို ဆြဲထုတ္ပါတရ္။
  4. ေဒီနည္းအတိုင္းပဲ loop ဆံုးသည္အထိ သြားၿပီး loop တခါပတ္တိုင္းရရွိလာတဲ့ Binary တန္းဖိုးေတြကို ေပါင္းေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Binary တန္ဖိုးကိုရရွိမွာ ျဖစ္ပါတရ္ဗ်ာ
ဒီ Conversion ေလးရဲ႕ GUI ကိုေတာ့ ေအာက္ပါအတိုင္း ခ်ထားပါတရ္ဗ်။ မိတ္ေဆြတို႔အေနနဲ႔ ႀကိဳက္ႏွစ္သတ္ရာ ပံုစံ Tool ေတြနဲ႔ ဖန္တီးယူႏိုင္ပါတရ္။
ပိုၿပီး နားလည္သြားေအာင္ Coding အျပည့္အစံုေလးကို ေအာက္မွာ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
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

ရွင္းလင္းခ်က္နဲ႔ Screen Shoot ေလးေတြကို ၾကည့္လိုက္ရင္ေတာ့ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမတို႔အေနနဲ႔ Hexadecimal Number တစ္ခုကေနၿပီး Decimal Number တစ္ခုသို႔ ဘယ္လို ေျပာင္းလဲယူႏိုင္မလဲဆိုတာကို နားလည္သြားၾကမရ္လို႔ ထင္ပါတရ္ဗ်ာ။ စတင္ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္လို႔ တင္ျပပံု မွားယြင္းတာ၊ အဓိပၸါယ္ ကြဲလြဲေဖာ္ျပမိတာရွိခဲ့ရင္ နားလည္ေပးၾကဖို႔ ေတာင္းပန္ပါတရ္ဗ်။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

Create Hexadecimal to Decimal Converter in C#

Posted by ေတဇာလင္း Monday, 7 November 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ရဲ႕ မၿပီးျပတ္ေသးတဲ့ Number System အေၾကာင္းေလးကို ေရွ႕ဆက္ၾကည့္ၾကရေအာင္ပါ။ ဒီေန႔ေတာ့ Hexadecimal Number တစ္ခုကို Decimal Number အျဖစ္ ဘရ္လိုေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။ မိတ္ေဆြတို႔ ပိုၿပီးနားလည္သြားေအာင္ က်ေနာ္ Hexadecimal ကေန Decimal ေျပာင္းတာကို ေအာက္မွာ ဥပမာေလးနဲ႔ အရင္ျပပါ့မရ္။
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 ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
  1. ပထမဦးဆံုး မိတ္ေဆြတို႔ရိုက္ထည့္လိုက္တဲ့ Hexadecimal Number ကို ToCharArray() Method အားအသံုးျပဳၿပီး HexArr ဆိုတဲ့ Char Array တစ္ခုအျဖင့္ ဖန္တီးယူလိုက္ပါတရ္။
  2. ဒုတိယအေနနဲ႔ ၄င္းရရွိလာတဲ့ Hex Char Array ကို တိုက္ဆိုင္စစ္ေဆးဖို႔အတြက္ HexDigit 16 သာ ပါရွိတဲ့ HexDigits Array တစ္ခုကို ႀကိဳတင္ ဖန္တီးထားလိုက္ပါတရ္။
  3. ေနာက္တစ္ဆင့္မွာေတာ့ for( )loop ကိုအသံုးျပဳၿပီး HexArr ကိုေရာ HexDigits ကိုေရာ loop ဆံုးသည္အထိ ပတ္ပါတရ္။
  4. ေနာက္တစ္ဆင့္မွာေတာ့ loop အတြင္းမွာ HexArr ထဲက Item နဲ႔ HexDigits ထဲက Item ကို တူမတူ if( ) statement နဲ႔ တိုက္ဆိုင္ စစ္ေဆးပါတရ္။
  5. တူညီတဲ့ Item ေတြၿပီဆိုရင္ေတာ့ Dec += (int)(j * Math.Pow(16, power)); formula ကိုအသံုးျပဳၿပီး Decimal တန္ဖိုးတစ္ခုကို ဆြဲထုတ္ယူပါတရ္။
  6. ဒီနည္းအတိုင္းပဲ loop ဆံုးသည္အထိ သြားၿပီး loop တခါပတ္တိုင္းရရွိလာတဲ့ Decimal တန္းဖိုးေတြကို ေပါင္းေပးျခင္းျဖင့္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Decimal တန္ဖိုးကိုရရွိမွာျဖစ္ပါတရ္ဗ်ာ။
ဒီ Conversion ေလးရဲ႕ GUI ကိုေတာ့ ေအာက္ပါအတိုင္း ခ်ထားပါတရ္ဗ်။ မိတ္ေဆြတို႔အေနနဲ႔ ႀကိဳက္ႏွစ္သတ္ရာ ပံုစံ Tool ေတြနဲ႔ ဖန္တီးယူႏိုင္ပါတရ္။
ပိုၿပီး နားလည္သြားေအာင္ Coding အျပည့္အစံုေလးကို ေအာက္မွာ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
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


ရွင္းလင္းခ်က္နဲ႔ Screen Shoot ေလးေတြကို ၾကည့္လိုက္ရင္ေတာ့ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမတို႔အေနနဲ႔ Hexadecimal Number တစ္ခုကေနၿပီး Decimal Number တစ္ခုသို႔ ဘယ္လို ေျပာင္းလဲယူႏိုင္မလဲဆိုတာကို နားလည္သြားၾကမရ္လို႔ ထင္ပါတရ္ဗ်ာ။ စတင္ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္လို႔ တင္ျပပံု မွားယြင္းတာ၊ အဓိပၸါယ္ ကြဲလြဲေဖာ္ျပမိတာရွိခဲ့ရင္ နားလည္ေပးၾကဖို႔ ေတာင္းပန္ပါတရ္ဗ်။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

Create Octal To Hexadecimal Converter in C#

Posted by ေတဇာလင္း Thursday, 29 September 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Octal Number တစ္ခုကို Hexadecimal Number အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Coding ေရးသားတဲ့အခါမွာ Visual Studio က ေထာက္ပံ့ေပးထားတဲ့ Method ေတြကို အသံုးမျပဳပဲ Template Matching and Repeated Divison Method ႏွစ္ခုကို ေပါင္းစပ္ၿပီး အလြယ္ကူဆံုးနည္းလမ္းတစ္ခုနဲ႔ ကိုယ္ပိုင္ Method တစ္ခု တည္ေဆာက္ကာ ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။ Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကိုၾကည့္ၾကည့္မရ္ဗ်ာ။
  1. ေျပာင္းလဲတဲ့အခါမွာ Octal to Binary အျဖစ္ အရင္ေျပာင္းလဲမွာျဖစ္ၿပီး ၄င္း ရရွိလာတဲ့ Binary Number ကိုမွ Hexadecimal Number အျဖစ္ ေျပာင္းလဲယူမွာျဖစ္ပါတရ္။
  2. Octal ကို Binary ေျပာင္းတဲ့အခါမွာေတာ့ 10 နဲ႔စားကာ ကိန္းစဥ္တန္းရဲဲ႕ေနာက္ဆံုးတစ္လံုးကိုျဖတ္ယူပါတရ္။ ၄င္းရရွိလာတဲ့ Number ကိုမွ Template Matching Method ကိုအသံုးျပဳၿပီး က်ေနာ္တို႔ ႀကိဳတင္သတ္မွတ္ထားတဲ့ OctalArray နဲ႔ တိုက္ဆိုင္စစ္ေဆးပါတရ္။ ရရွိလာတဲ့ တန္ဖိုးေတြကိုမွ Loop -- False ျဖစ္တဲ့အထိ စုစည္းယူလိုက္ၿပီး Binary Number အျဖစ္ ဖန္တီးယူလိုက္တာပါ။
  3. 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 အျပည့္အစံုေလးကို ေအာက္မွာ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
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();
        }   
    }
} 
ရွင္းလင္းခ်က္နဲ႔ Screen Shoot ေလးေတြကို ၾကည့္လိုက္ရင္ေတာ့ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ Trace လိုက္ၿပီး Coding Flow ေလးကို ေလ့လာၾကည့္ေစခ်င္ပါတရ္။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။

Create Octal To Binary Converter in C#

Posted by ေတဇာလင္း 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Octal Number တစ္ခုကို Binary Number အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Coding ေရးသားတဲ့အခါမွာ Visual Studio က ေထာက္ပံ့ေပးထားတဲ့ Method ေတြကို အသံုးမျပဳပဲ အလြယ္ကူဆံုးနည္းလမ္းတစ္ခုနဲ႔ ကိုယ္ပိုင္ Method တစ္ခု တည္ေဆာက္ၿပီး ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
  1. မိတ္ေဆြရိုက္ထည့္လိုက္ေသာ Octal Number ကို 10 နဲ႔ စားၿပီး ေနာက္ဆံုးတစ္လံုးကို ျဖတ္ယူပါ့မရ္။
  2. ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မညီမခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 10 နဲ႔ စားေနမရ္။
  3. ရလာတဲ့ စားၾကြင္းဟာ loop ပါတ္တိုင္း Octal Number ရဲ႕ ေနာက္ဆံုးတစ္လံုးရရွိေနမွာပါ။ ၄င္း Octal Number ကိုမွ Index အျဖစ္သံုးၿပီး က်ေနာ္တို႔ ႀကိဳတင္ ဖန္တီးထားတဲ့ string[] OctalConstant Array ကိုျဖတ္ၿပီး ရရွိလာတဲ့ Value ကို Binary အျဖစ္ Container တစ္ခုထဲ ေခတၱသိမ္းထားလိုက္မွာျဖစ္ပါတရ္။
  4. ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီသြားတဲ့အခ်ိန္မွာ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စုစည္းထားတဲ့ Binary 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 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();
        }
    }
}   
ခက္ခဲတဲ့ Coding ေတြ မရွိလို႔ က်ေနာ္ အေသးစိတ္ မရွင္းျပေတာ့ပါဘူးဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ Coding Flow ေလးကို Trace လိုက္ၿပီး စမ္းၾကည့္ေစခ်င္ပါတရ္။ ဒီေလ့က်င့္ခန္းမွာဆိုရင္ေတာ့ က်ေနာ္ အေျပာင္းအလဲေလးျဖစ္သြားေအာင္ if()statement ေလးနဲ႔ မိတ္ေဆြတို႔ ရိုက္ထည့္လိုက္တဲ့ Number ဟာ Octal Number ျဖစ္လား/မျဖစ္လားဆိုတာကို စစ္ေဆးထားပါတရ္(Octal Number က 0 to 7 ပဲရွိတာကိုဗ်)။ မိတ္ေဆြတို႔အေနနဲ႔ 7 ထက္ႀကီးတဲ့ Number တစ္ခု ရိုက္ထည့္မိၿပီဆိုတာနဲ႔ Error Message တတ္လာၿပီး မွန္ကန္တဲ့ Octal Number ရိုက္ထည့္ႏိုင္ဖို႔ ေျပာပါလိမ့္မရ္။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ယံုၾကည္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

Create Octal To Decimal Converter in C#

Posted by ေတဇာလင္း Tuesday, 27 September 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Octal Number တစ္ခုကို Decimal Number အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Coding ေရးသားတဲ့အခါမွာ Visual Studio က ေထာက္ပံ့ေပးထားတဲ့ Method ေတြကို အသံုးမျပဳပဲ Repeated Division Method ကိုအေျခခံၿပီး အလြယ္ကူဆံုးနည္းလမ္းတစ္ခုနဲ႔ ကိုယ္ပိုင္ Method တစ္ခု တည္ေဆာက္ၿပီး ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
  1. Decimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Octal ကို 10 နဲ႔စားမရ္။
  2. ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မညီမခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 10 နဲ႔ စားေနမရ္။
  3. Loop ပတ္တိုင္း Dec += (int)(remainder * Math.Pow(8, power)); ဆိုတဲ့ formula ကိုျဖတ္ၿပီး ရလာတဲ့ Number တစ္ခုကိုေတာ့ container တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
  4. ေနာက္ဆံုး စားလဒ္(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();
        }        
    }
}   
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ ေအာက္ပါအေတြးကို ပံုေဖာ္ထားတာပါ။
ပိုၿပီးနားလည္သြားေအာင္ က်ေနာ္ Trace လိုက္ျပပါ့မရ္။
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 = 120
Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။

Create Binary To Hexadecimal converter - Easy way by Getting ‘char’ Method

Posted by ေတဇာလင္း Monday, 12 September 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ 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 ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
  1. ပထမဦးဆံုး Binary Number ကို 10000 နဲ႔ စားပါ့မရ္( Binary Number ရဲ႕ ေနာက္ဆံုး(4)လံုးကို ျဖတ္ယူခ်င္လို႔ပါ)။
  2. ရလာတဲ့ စားၾကြင္းကို loop ပတ္ၿပီး က်ေနာ္တို႔ ႀကိဳတင္သတ္မွတ္ထားတဲ့ Binary array နဲ႔ တိုက္ဆိုင္စစ္ေဆးၿပီး ရရွိလာတဲ့ Index Number ကိုဆြဲထုတ္ပါတရ္။
  3. ၄င္း ဆြဲထုတ္ယူလာတဲ့ if( ) statement နဲ႔ စစ္ထုတ္ၿပီး formula ကိုျဖတ္ခိုင္းပါတရ္။ ရလာတဲ့ တန္ဖိုးကို char type ေျပာင္းလဲယူပါ့မရ္။ ရလာတဲ့ Char တန္ဖိုးဟာ က်ေနာ္တို႔ first loop ရဲ႕ Hexadecimal Number ျဖစ္ပါတရ္။
  4. ေနာက္ဆံုးမွာေတာ့ Binary Number ကို 10000 နဲ႔စားၿပီး စားလဒ္ကို သုညနဲ႔ မညီမခ်င္း loop ပတ္ စစ္ထုတ္ေနမွာျဖစ္ပါတရ္။
  5. ေနာက္ဆံုးမွာေတာ့ 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 လုိက္ျပပါ့မရ္။
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
ဒီေလာက္ဆိုရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ Getting 'char' method ေလးကို အသံုးျပဳၿပီး Binary Number ကေနၿပီး Hexadecimal Number အျဖစ္ ေျပာင္းလဲႏိုင္ၿပီလို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

Create Binary To Octal converter - Easy way by Getting ‘char’ Method

Posted by ေတဇာလင္း Friday, 9 September 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Binary Number တစ္ခုကို Octal Number အျဖစ္ ဘရ္လိုေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။ ေရွ႕သင္ခန္းစာမွာေတာ့ က်ေနာ္တို႔ function ႏွစ္ခုကို ျဖတ္ၿပီးမွ Octal Number အျဖစ္ ဆြဲထုတ္ပံုေလးကို ေဆြးေႏြးေပးခဲ့ၿပီးျဖစ္ပါတရ္။ ဒီေန႔ေတာ့ Getting 'char' Method ေလးကို အသံုးျပဳၿပီး Binary Number မွ Octal Number အျဖစ္သို႔ တိုက္ရိုက္ ေျပာင္းလဲႏိုင္တာေလးကို ေဆြးေႏြးေပးသြားပါ့မရ္ဗ်ာ။ ေရွ႕မွာ ေလ့လာခဲ့ၿပီးသား သင္ခန္းစာေတြကိုပဲ ေက်ာရိုးျပဳၿပီး သာမာန္အေတြးေလးကို ရုပ္လံုးေဖာ္ၾကည့္ထားတာပါ။
သတိျပဳရမရ္႕ 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 ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္။
  1. ပထမဦးဆံုး Binary Number ကို 1000 နဲ႔ စားပါ့မရ္( Binary Number ရဲ႕ ေနာက္ဆံုး(3)လံုးကို ျဖတ္ယူခ်င္လို႔ပါ)။
  2. ရလာတဲ့ စားၾကြင္းကို loop ပတ္ၿပီး က်ေနာ္တို႔ ႀကိဳတင္သတ္မွတ္ထားတဲ့ Binary array နဲ႔ တိုက္ဆိုင္စစ္ေဆးၿပီး ရရွိလာတဲ့ Index Number ကိုဆြဲထုတ္ပါတရ္။
  3. ၄င္း ဆြဲထုတ္ယူလာတဲ့ Index Number + ‘0’ ဆိုတဲ့ formual ကိုျဖတ္ၿပီး ရလာတဲ့ တန္ဖိုးကို char type ေျပာင္းလဲယူပါ့မရ္။ ရလာတဲ့ Char တန္ဖိုးဟာ က်ေနာ္တို႔ first loop ရဲ႕ Octal Number ျဖစ္ပါတရ္။
  4. ေနာက္ဆံုးမွာေတာ့ Binary Number ကို 1000 နဲ႔စားၿပီး စားလဒ္ကို သုညနဲ႔ မညီမခ်င္း loop ပတ္ စစ္ထုတ္ေနမွာျဖစ္ပါတရ္။
  5. ေနာက္ဆံုးမွာေတာ့ 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 လုိက္ျပပါ့မရ္။

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
ဒီေလာက္ဆိုရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ Getting 'char' method ေလးကို အသံုးျပဳၿပီး Binary Number ကေနၿပီး Octal Number အျဖစ္ ေျပာင္းလဲႏိုင္ၿပီလို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

Create Binary To Octal Converter in C#

Posted by ေတဇာလင္း Wednesday, 7 September 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Binary Number တစ္ခုကို Octal Number အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Logic ပိုင္း ေထြေထြထူးထူး မရွိပါဘူး။ Binary Number ကို Octal Number အျဖစ္သို႔ တိုက္ရိုက္ မေျပာင္းလဲဘဲ မိတ္ေဆြတို႔ နားလည္လြရ္သြားေအာင္ က်ေနာ္တို႔ ေရွ႕သင္ခန္းစာေတြမွာ ေလ့လာခဲ့ၿပီးျဖစ္တဲ့ function ႏွစ္ခုကို ေပါင္းစီးၿပီး Octal Number အျဖစ္ ဆြဲထုတ္ပံုေလးကို ေဆြးေႏြးေပးသြားမွာျဖစ္ပါတရ္။ Coding Flow ေလးကို အနည္းငရ္ ေျပာရမရ္ဆိုရင္ေတာ့....
  1. ပထမဦးဆံုး Binary Number ကို BinaryToDecimal( ) ဆိုတဲ့ function ကိုျဖတ္ၿပီး Decimal Number တစ္ခုကို အရင္ဆြဲထုတ္မရ္။
  2. ေနာက္ဆံုးမွာေတာ့ ၄င္း ရရွိလာေသာ Decimal Number ကို DecToOctal( ) function ကို ထပ္ျဖတ္ေစၿပီး Octal Number တစ္ခုကို ရယူလိုက္မွာပဲျဖစ္ပါတရ္ဗ်ာ။
Function ႏွစ္ခုစလံုးဟာ ေရွ႕သင္ခန္းစာေတြမွာ ေလ့လာခဲ့ၿပီးသားျဖစ္လို႔ မိတ္ေဆြတို႔အေနနဲ႔ အခက္အခဲမရွိ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်ာ။ 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=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();
        }
    }
}
အနည္းငယ္ရွင္းရမရ္ဆိုရင္ျဖင့္... က်ေနာ္တို႔ Binary Number အျဖစ္ 110110 ဆိုတာကို ရိုက္ထည့္လိုက္ပါမရ္။ ပထမ BinaryToDecimal( ) function ကိုျဖတ္ၿပီးတဲ့အခ်ိန္မွာေတာ့ 54 ဆိုတဲ့ Decimal Number တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။ ၄င္းကိုမွ DecToOctal( ) function ကိုထက္ျဖတ္လိုက္တဲ့အခါမွာေတာ့ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Octal Number ျဖစ္တဲ့ 66 ဆိုတဲ့ Result တစ္ခုကို ရရွိခဲ့တာပဲျဖစ္ပါတရ္ဗ်ာ။ Function ႏွစ္ခုစလံုးက ေလ့လာခဲ့သားေတြျဖစ္လို႔ က်ေနာ္အေသးစိတ္မရွင္းျပေတာ့ပါဘူး။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

Create Binary To Decimal Converter in C#

Posted by ေတဇာလင္း Monday, 5 September 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Binary Number တစ္ခုကို Decimal Number အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Coding ေရးသားတဲ့အခါမွာ Visual Studio က ေထာက္ပံ့ေပးထားတဲ့ Method ေတြကို အသံုးမျပဳပဲ အလြယ္ကူဆံုးနည္းလမ္းတစ္ခုနဲ႔ ကိုယ္ပိုင္ Method တစ္ခု တည္ေဆာက္ၿပီး ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။
  1. Decimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Binary ကို 10 နဲ႔စားမရ္။
  2. ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မညီမခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 10 နဲ႔ စားေနမရ္။
  3. Loop ပတ္တိုင္း Dec += (int)(remainder * Math.Pow(2, power)); ဆိုတဲ့ formula ကိုျဖတ္ၿပီး ရလာတဲ့ Number တစ္ခုကိုေတာ့ container တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
  4. ေနာက္ဆံုး စားလဒ္(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();
        }
    }
}   
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ ေအာက္ပါအေတြးကို ပံုေဖာ္ထားတာပါ။
ပိုၿပီးနားလည္သြားေအာင္ က်ေနာ္ Trace လိုက္ျပပါ့မရ္။
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 = 13
Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ ေရွ႕သင္ခန္းစာေတြမွာ Decimal Number ကို Hex, Octal and Binary Number ေတြအျဖစ္ ေျပာင္းလဲႏိုင္တာေလးကို Repeated Division Mehtod ကို အေျခခံၿပီး Function တစ္ခုခ်င္းစီျဖင့္ သီးျခားေလ့လာခဲ့ၿပီးျဖစ္ပါတရ္။ သာမာန္အေတြးကိုပဲ ပံုေဖာ္ထားတာျဖစ္လို႔ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ယံုၾကည္ပါတရ္။
ဒီေန႔ သင္ခန္းစာမွာေတာ့ တမူထူးျခားမႈေလးျဖစ္သြားေအာင္ Getting ‘Char’ Mthod ကို အေျခခံၿပီး ေလ့လာၾကည့္ၾကပါမရ္။ Function ေရးသားရာမွာလည္း Conversion တိုင္းကို သီးျခား function ေတြ ခြဲေရးမေနေတာ့ပဲ Function တစ္ခုတည္းျဖင့္ Type Conversion အားလံုး ေျပာင္းလဲႏိုင္တဲ့ ပံုစံေလးနဲ႔ ေလ့လာၾကည့္သြားၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။ 
  1. Decimal Number ကို မိမိတို႔ ေျပာင္းလဲခ်င္ေသာ Type ရဲ႕Base နဲ႔စားမရ္။
  2. ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ Base နဲ႔ စားေနမရ္။
  3. စားၾကြင္း(remainder)ကိုေတာ့ remainder -10+ 'A' OR remainder +'0' ဆိုတဲ့ Formula ကိုျဖတ္ၿပီး Char Value တစ္ခု ရယူမရ္။ ရလာတဲ့ result တစ္ခုကို char array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
  4. ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ char array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။
  5. ေနာက္ဆံုးမွာေတာ့ ၄င္း 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 ေတြလည္း ဒီနည္းအတိုင္းပဲ ေျပာင္းလဲသြားတာျဖစ္ပါတရ္။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။

Create Decimal To Octal Converter - Easy Way by Repeated Division Method in C#

Posted by ေတဇာလင္း Thursday, 1 September 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Decimal Number တစ္ခုကို Octal String အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Coding ေရးသားတဲ့အခါမွာ Visual Studio က ေထာက္ပံ့ေပးထားတဲ့ Method ေတြကို အသံုးမျပဳပဲ အလြယ္ကူဆံုးနည္းလမ္းတစ္ခုနဲ႔ ကိုယ္ပိုင္ Method တစ္ခု တည္ေဆာက္ၿပီး ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။ 
  1. Octal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Decimal ကို 8 နဲ႔စားမရ္။
  2. ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 8 နဲ႔ စားေနမရ္။
  3. Loop ပတ္တိုင္း ရလာတဲ့ စားၾကြင္း(remainder)ကိုေတာ့ container array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။
  4. ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။
  5. ေနာက္ဆံုးမွာေတာ့ ၄င္း Array ကို Invert လုပ္ ေျပာင္းျပန္လွန္ေပးျခင္းျဖင့္ Octal string တစ္ခုကို ဖန္တီးယူလိုက္တာပဲျဖစ္ပါတရ္။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။
Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/6-number-system-conversions-from.html Pageမွာ ပံုနဲ႔တကြ ရွင္းထားတာေလး ရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
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();
        }
    }
}

ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။

Create Decimal To Binary Converter - Easy Way by Custom Method in C#

Posted by ေတဇာလင္း Wednesday, 31 August 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Decimal Number တစ္ခုကို Binary String အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Coding ေရးသားတဲ့အခါမွာ Visual Studio က ေထာက္ပံ့ေပးထားတဲ့ Method ေတြကို အသံုးမျပဳပဲ အလြယ္ကူဆံုးနည္းလမ္းတစ္ခုနဲ႔ ကိုယ္ပိုင္ Method တစ္ခု တည္ေဆာက္ၿပီး ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။ 
  1. Binary ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Decimal ကို 2 နဲ႔စားမရ္။ 
  2. ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 2 နဲ႔ စားေနမရ္။ 
  3. Loop ပတ္တိုင္း ရလာတဲ့ စားၾကြင္း(remainder)ကိုေတာ့ container array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။ 
  4. ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။ 
  5. ေနာက္ဆံုးမွာေတာ့ ၄င္း Array ကို Invert လုပ္ ေျပာင္းျပန္လွန္ေပးျခင္းျဖင့္ Binary string တစ္ခုကို ဖန္တီးယူလိုက္တာပဲျဖစ္ပါတရ္။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။
Logic အနည္းငယ္စိမ္းေနမရ္ဆိုရင္ေတာ့..... http://programmingknowledge.blogspot.com/2014/07/6-number-system-conversions-from.html Pageမွာ ပံုနဲ႔တကြ ရွင္းထားတာေလး ရွိပါတရ္။ ေလ့လာၾကည့္ႏိုင္ပါတရ္ဗ်ာ။ အခုေတာ့ Coding အပိုင္းေလး ဆက္ၾကမရ္။ GUI ကိုေတာ့ က်ေနာ္ ေအာက္က ပံုစံအတိုင္း ပံုေဖာ္ထားပါတရ္။ မိတ္ေဆြတို႔ေတာ့ စိတ္ႀကိဳက္ ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္။
Coding ေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
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();  
   }  
  } 
}   
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။

Create Decimal To Hexadecimal Converter - Easy Way by Custom Method in C#

Posted by ေတဇာလင္း Monday, 29 August 2016 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Decimal Number တစ္ခုကို Hexadecimal String အျဖစ္ ဘရ္လို ေျပာင္းလဲ ယူႏိုင္မလဲဆိုတာေလးကို ေလ့လာၾကည့္ၾကမွာ ျဖစ္ပါတရ္။ Coding ေရးသားတဲ့အခါမွာ Visual Studio က ေထာက္ပံ့ေပးထားတဲ့ Method ေတြကို အသံုးမျပဳပဲ အလြယ္ကူဆံုးနည္းလမ္းတစ္ခုနဲ႔ ကိုယ္ပိုင္ Method တစ္ခု တည္ေဆာက္ၿပီး ေလ့လာၾကည့္ၾကမွာျဖစ္ပါတရ္။
Logic ပိုင္း ေထြေထြထူးထူးမရွိပါဘူး။ သာမာန္အေတြးကိုပဲ ရုပ္လံုးေဖာ္လုိက္တာပါ။ Coding Flow ေလးကို ၾကည့္ၾကည့္မရ္ဗ်ာ။ 
  1. Hexadecimal ေျပာင္းမွာျဖစ္တဲ့အတြက္ က်ေနာ္တို႔ ေျပာင္းလဲခ်င္တဲ့ Decimal ကို 16 နဲ႔စားမရ္။ 
  2. ရလာတဲ့ စားလဒ္(Quotient)ကို သုညနဲ႔မငယ္မခ်င္း Loop ပတ္ၿပီး ထပ္ခါတလဲလဲ 16 နဲ႔ စားေနမရ္။ 
  3. စားၾကြင္း(remainder)ကိုေတာ့ template filtering စနစ္နဲ႔ တိုက္ဆိုင္စစ္ေဆးမရ္။ ရလာတဲ့ result တစ္ခုကို container array တစ္ခုထဲ ေခတၱထည့္သိမ္းထားမရ္ေပါ့။ 
  4.  ေနာက္ဆံုး စားလဒ္(Quotient)ဟာ သုညနဲ႔ညီလွ်င္ပဲျဖစ္ျဖစ္၊ ငယ္သြားရင္ပဲျဖစ္ျဖစ္ Loop ကို ရပ္မရ္။ ဒီအခ်ိန္မွာေတာ့ စားၾကြင္း(remainder)ေတြႀကီး စုစည္းထားတဲ့ array တစ္ခုကို က်ေနာ္တို႔ ရရွိေနပါၿပီ။ 
  5.  ေနာက္ဆံုးမွာေတာ့ 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 လုပ္ခ်င္တရ္ဆိုရင္ေတာ့ ေအာက္က ကုဒ္တင္းေလးနဲ႔ ေျပာင္းေရးႏိုင္ပါတရ္ဗ်ာ။

string output = "";
for (int i = result.Length - 1; i >= 0; i--)
{
     output += result[i];
}
return output;
ခက္ခက္ခဲခဲ ဘာမွ မရွိပါဘူးဗ်ာ။ Coding ေလးနဲ႔ ScreenShoot ေလးကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ ရွင္းျပစရာမလိုေလာက္ေအာင္ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်ာ။ မိတ္ေဆြအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစဗ်ာ။