אני אמור לקלוט מספר ולהציג את הערך שלו בבינארי, יש לי איזה בעיהואני משתגע, תמיד משום מה המספר השני יוצא לי 0

בתוך לולאת ה-FOR יש לי WHILE ועשיתי בדיקות כמה N שווה בכניסה וביציאה אם אני למשל קולט את המספר 3 (בתחילת התוכנית)

אז בפעם הראשונה הוא 3 ואחרי פעולת המודולו אני עושה

n = n/2;

ואז גם בדקתי והוא מקבל את הערך 1 אבל אז הוא אמור שוב להיכנס ל-WHILE כי עשיתי בלולאה הזאת כל עוד ה-N גדול מאפס ועכשיו הוא כאמור 1

בקיצור יש לי פה איזה באג מעצבן שאני לא מוצא

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace T190
{
  class Program
  {
    static void Main(string[] args)
    {


      //define array
      int[] bin_array = new int [4];


      Console.WriteLine("Eter Number: ");


      //read input
      int n = int.Parse(Console.ReadLine());


      //convert the number from numeric number to binary number and read the numbers into array
      for (int i = 0; i < 2 ; i++)
      {
        while (n>0)
        {
          bin_array[i] = n%2;
          n = n/2;
        }
      }


      Console.Write(bin_array[0]);
      Console.Write(bin_array[1]);


      Console.ReadLine();


      //for (int i = 3; i >= 0; i--)
      //{
      //  Console.Write("The Bibary Presentation Of The Number Is: " + bin_array[3]);
      //}

    }
  }
}

למה יש לך while בתוך for?

זה אסור ?

טוב הורדתי את ה-WHILE ושמתי FOR וזה עובד

אני מחפש דרך להעלים את האפסים בהתחלה (אם יש כמובן)

דוגמא:

המספר 99 הוא 1100011 אבל אני מראש לא יודע איזה מספר אני קולט אז המערך שבניתי מורכב מ-10 תאים אז מה שמוצג לי אם אני קולט את המספר 99 זה 0001100011 ואני מחפש דרך שהתוכנית תתעלם מכל האפסים עד שיגיע פעם ראשונה המספר 1.

זה לא אסור, פשוט אין בזה היגיון בתכנית שלך.

לכתוב קטע קוד שידלג על אפסים עד ה-1 הראשון הוא ממש ממש פשוט.

אם אפשר אז אשמח לעזרה קטנה כי לא ממש הולך לי

בסןף התוכנית יש לי FOR שבתוכו יש לי את הפקודת הדפסה של המערך מהסןף להתחלה (בכדי שהמספר הבינארי לא יצא הפוך) ואחרי זה התוכנית נגמרת.

ניסיתי לשים בתוך ה-FOR פקודת IF אבל זה לא מצליח לי

הנה הקוד ברקורסיה:

  static void Main(string[] args)
  {
     int num = 32;
     string bin = "";
     Dec2Bin(num, ref bin);
     Console.WriteLine(bin);
  }




  static void Dec2Bin(int num, ref string bin)
  {
    if (num == 0) return;
    Dec2Bin(num >> 1, ref bin);
    bin += ((num & 1) == 0) ? "0" : "1";
  }

היתרון ברקורסיה הוא שסדר ההדפסה יוצא תקין "במתנה".

לא ממש הבנתי את הקוד שלך, אני השתמשתי במערך:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace T190
{
  class Program
  {
    static void Main(string[] args)
    {
      Console.Write("Enter Number: ");


      //read input
      int n = int.Parse(Console.ReadLine());


      //define array
      int[] bin_array = new int[10];


      //convert the number from numeric to binary presentation and read the numbers into array
      for (int i = 0; i < 10 ; i++)
      {
        if (n!=0)
        {
          bin_array[i] = n%2;
          n = n/2;
        }
      }


      //print all numbers in reverse11
      for (int i = 9; i >= 0; i--)
      {
       Console.Write(bin_array[i]);
      }

     Console.ReadLine();


    }
  }
}

אוקיי, אז אני אסביר את הקוד. אני מקווה שתבין ואם תלמד מזה משהו חדש אז רק הרווחת

הפונקציה Dec2Bin מקבלת את המספר שאותו אתה רוצה להציג בבינארי ומחרוזת שאותה אנחנו משנים וכל הזמן מוסיפים לה 0 או 1

כך שבסוף היא תכיל ייצוג בינארי של המספר ששלחנו לפונקציה. המילה ref לפי סוג המשנה היא כדי לומר לפונקציה שתשנה את המשנה

שמחוץ לפונקציה ולא תיצור העתק מקומי (אם שמעת על פויינטר אז זה דומה).

שורה ראשונה בפונקציה:

if (num == 0) return;

אם המספר הוא 0 זאת אומרת שסיימנו ואפשר לצאת.

שורה שניה:

Dec2Bin(num >> 1, ref bin);

נקרא לפונקציה Dec2Bin עם המספר אבל במימד קטן יותר, כלומר:

נחשוב על המספר כמחרוזת של 0 ו 1. אם ניקח את המספר שלך, 99, המחרוזת המתאימה היא 1100011.

מימד קטן יותר של המחרוזת הוא אורך המחרוזת פחות אחד שהוא: 110001 וכן הלאה.

הפעולה << משמעותה Shift Right (הזזה ימינה) והיא מזיזה את כל המספר הבינארי אחד ימינה.

שורה שלישית:

bin += ((num & 1) == 0) ? "0" : "1";

משמעותה בכתיב לא מקוצר הוא:

if ( (num & 1) == 0) {
	bin = bin + "0";
}else{
	bin = bin + "1";
}

הפעולה & היא פעולה שנקראת AND שמופעלת על הביטים של המספר. התוצאה שלה דומה לכפל של 1 ו 0. לדוגמא:

0 & 0 = 0

0 & 1 = 0

1 & 0 = 0

1 & 1 = 1

כאשר אנחנו עושים למספר & עם 1 כמו בתוכנית אנחנו עושים את הדבר הבא:

1100011 & 0000001

ואם נרשום את זה בצורה מאונכת:

1100011

0000001

נסתכל בטבלה הקטנה למעלה של הפעולות ונפעיל & על כל זוג (עליון & תחתון) ונקבל:

1100011

0000001

-------

0000001

ועכשיו אנחנו בודקים האם קיבלנו 0 או 1 ורושמים את מה שקיבלנו.

הבדיקה הזו בודקת את הביט האחרון במספר כל הזמן עד שהמספר עצמו הופך ל 0 כתוצאה מההזזה שלו ימינה כל הזמן.

כפי שההסבר על שורה שניה אומר, אנחנו קוראים לפונקציה כל הזמן עם מספר קטן יותר וקטן יותר עד שמגיעים ל 0 (כל האחדים נפלו מהצד הימני).

כאשר הפונקציה הגיעה ל 0 היא חוזרת חזרה וממשיכה מהנקודה שהיא הפסיקה, כלומר ממשיכה לשורה שלישית.

ניתן לקרוא לכל כניסה לפונקציה "רמה" וכל כניסה מגדילה את הרמה שבה היא נמצאת כך שבצורה שהפונקציה הזו רשומה, אחרי שהיא הגיע לרמה

הכי עמוקה (שהמספר כבר נהיה 0) היא מתחילה להוסיף למשתנה bin אחדים ואפסים מהסוף להתחלה שזה בדיוק הסדר שאנחנו צריכים.

אם לא הבנת את החלק הזה תוכל להעמיק ולקרוא על רקורסיה.

מקווה שהבנת.

קודם כל תודה רבה על ההסבר, עדיין לא למדנו את הפונקציה הזו אז השאלה שלי היא האם בכילים שעומדים לרשותי כרגע אני יכול לעשות את זה בעזרת איזה IF פשוט כי סיימתי כבר הכל וזה רק מה שנשאר לי

פיתרון לא רקורסי

{
static void Main(string[] args)
{
do{
Console.WriteLine("Eter Number: ");

//read input
int n = int.Parse(Console.ReadLine());

//convert the number from a decimal number to a reversed binary number

string str = "";

while (n > 0)
{
str += n % 2;
n /= 2;
}

// Revrse the order of the binary number

int len = str.Length;

for (int i = 0; i < len; i++)
Console.Write(str[len - 1 - i]);
Console.WriteLine();

} while (true);

}
}

class Program

אפשר הסבר על מה שעשית ?

שני חלקים:

{
str += n % 2;
n /= 2;
}

 while (n > 0)

י

יוצר מחרוזת שמשרשים לה את המספר הבינארי בצורה הפוכה.

for (int i = 0; i < len; i++)
Console.Write(str[len - 1 - i]);

מדפיס את המחרוזת מהסוף להתחלה, כדי להציג את המספר הבינאר בסדר הנכון.

ואם למשל הייתי רוצה להשתמש בקוד שלי שיצא לי טוב רק עם האפסים בהתחלה אני יכול להוסיף משהו שלא יציג אותם ?

כי ניסיתי ולא הלך לי

using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace T190
{
class Program
{
static void Main(string[] args)
{
Console.Write("Enter Number: ");


//read input
int n = int.Parse(Console.ReadLine());


//define array
int[] bin_array = new int[10];

int ctr = 0;

//convert the number from numeric to binary presentation and read the numbers into array
for (int i = 0; i < 10; i++)
{
if (n != 0)
{
bin_array[i] = n % 2;
n = n / 2;
ctr++;
}
}


//print all numbers in reverse11
for (int i =0; i < ctr; i++)
{
Console.Write(bin_array[ctr-1-i]);
}

Console.ReadLine();


}
}
}

using System;

תודה רבה, תוכל להסביר לי מה הטריק הזה עם ה-ctr עושה ?