אני אמור לרשום את 30 המספרים הראשוניים הראשונים, ידוע שמספר ראשוני אם הוא לא מתחלק במסברים הראשוניים הקטנים ממנו, עכשיו נתון לי ש-2 הוא ראשוני לכן אני אמור לבדוק אם 3 מתחלק ב-2 או לא ואז אם 4 מתחלק בארשוניים שמתחתיו (3 ו-2)

ניסיתי ליצור מערך אבל לא הלך לי עם הלולאה בפנים, בהתחלה הדפסתי את 2 (כי נתון שהוא ראשוני) והכנסתי אותו למערך שיצרתי (עם 30 מקומות), אח"כ בדקתי אם 3 מתחלק בו וגם אותו הדפסתי והכנסתי למערך אבל כשהגעתי למספר 4 לא הצלחתי ליצור אלוגריתם שמחלק ובודק אם המספר שלי מתחלק או לא במספרים הראשוניים שכבר במערך (בדוגמא שלי עכשיו המספרים 2 ו-3), ניסיתי וניסיתי ולא הלך, מחקתי הכל ואין לי אפילו רעיון חוץ מלהתחיל את מה שרשמתי פה

אשמח להכוונה.

יש דרך פשוטה מאוד לבדוק אם מספר כלשהו הוא ראשוני - פשוט לבדוק אם הוא מתחלק באחד מהמספרים שקטנים ממנו (חוץ מ-1). דהיינו, n ראשוני אם הוא לא מתחלק ב-2,3,4... עד n-1.

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

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

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

מעבר לזה נתקעתי:

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


namespace T206
{
  class Program
  {
    static void Main(string[] args)
    {
      int[] PrimeNum = new int[28];


      PrimeNum[0] = 2;
      PrimeNum[1] = 3;
      int num = 4;
      int count = 2;


      for (int i = 0; i <= 28; i++)
      {
        if (num % PrimeNum[count-1] != 0)
        {
          count--;
        }


        PrimeNum[i] = num; 
        num++;
      }


      Console.ReadLine();
    }
  }
}

בוא נאמר שכרגע אני בודק את המספר 4 אז אני מחפש דרך לכתוב אם 4 מתחלק ללא שארית ב-i0 שלי במערך ואם כן אז ב-i1 (כי כרגע יש לי במערך 2 איברים) ואז אחד מהם לא (או הראשון כמובן) אז לקחת את המספר 5 ולבדוק אותו.

אגב אני לא רוצה למצוא את המספרים הראשוניים עד למספר מסויים אלא את 30 הראשונים ולהדפיס אותם.

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

ב. התאים במערך בגודל 28 ממוספרים מ-0 עד 27, לא עד 28. כמו שכבר אמרתי בת'רד קודם, עדיף לעשות ככה:

for (int i = 0; i < PrimeNum.Length; i++)

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

אוקיי תודה רבה לך אני אנסה ואם לא ילך אני ירשום כאן

ה-PrimeNum.Length זה המערך שלי ?

כשאני יוצר מערך int[] PrimeNum.Length = new int[29]; הוא אומר לי The name 'Length' does not exist in the current context

אני לא למדתי עדיין פקודה של Length אם לזה התכוונת.

קראת את מה שרשמתי?

אתה יודע מה אומרת המילה Length באנגלית?

בכל מקרה, כמו שאמרתי - במערך בגודל 28 האיברים ממוספרים מ-0 עד 27. כלומר אם תנסה לגשת למקום ה-28 במערך תקבל שגיאה. הלולאה צריכה לרוץ עד 27, לא עד 28. הצורה הנהוגה לעשות את זה היא ע"י שימוש ב > במקום ב =>.

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


namespace T206
{
  class Program
  {
    static void Main(string[] args)
    {
      //define array 
      int[] PrimeNum = new int[29];


      PrimeNum[0] = 2;
      Console.WriteLine(2);


      int PrimeNumLength = 1;
      int num = 3;


      for (int i = 1; i < 29; i++)
      {
        if (num % PrimeNum[i] == 0)
        {
          num++;
        }
        else
        {
          PrimeNum[i] = num;
          Console.WriteLine(num);
          PrimeNumLength++;
          num++;
        }
      }





      Console.ReadLine();
    }
  }
}

התחלתי קודם כל ושמתי את 2 במערך לכן המערך שלי יהיה בעל 29 מקומות, אח"כ התחלתי לבדוק את 3 ואם הוא לא מתחלק אני מעלה את המספר באחד, כשאני מגיע ל-5 איך אני יכול לרשום בקוד שהוא יבדוק את האיברים שיש לי כבר במערך (2 ו-3) ?

זו הבעיה שלי

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

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

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


namespace T206
{
  class Program
  {
    static void Main(string[] args)
    {   
      int[] PrimeNum = new int[5];
      PrimeNum[0] = 2;
      PrimeNum[1] = 3;
      PrimeNum[2] = 5;
      PrimeNum[3] = 7;
      int num = 8;


      for (int i = 0; i < 5; i++)
      {
        if (num % PrimeNum[i] == 0)
        {
          Console.WriteLine("The Number Is Not Prime Number");
          break;
        }
        else
        {
          for (int count = 0; count < 5; count++)
          {
            while (num % PrimeNum[count+1] != 0)
            {


            }
          }
        }
      }


      Console.ReadLine();
    }
  }
}

זה מה שעשיתי ונתקעתי פה

יש לי איזה בעיה קטנה (גדולה) בהבנה של זה

קודם כל, כמו שכבר אמרתי לך קודם - אתה בודק אם num מתחלק באיברים במערך שלא אתחלת עדיין. אם במערך יש רק 4 מספרים ראשוניים, אז צריך לבדוק אם num מתחלק ב-4 המספרים האלו, לא יותר.

חוץ מזה, אני אומר שוב - תפריד בין הקוד שבודק אם המספר הוא ראשוני, והקוד שמוסיף אותו למערך. קודם כל רק תבדוק קוד שבודק אם הוא ראשוני.

מספיק לבדוק עד שורש של X... לא צריך לבדוק עד X-1

נכון, אבל עדיף להתחיל ממשהו פשוט יותר.

טוב את התרגיל הפשוט יותר עשיתי:

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


namespace T206
{
  class Program
  {
    static void Main(string[] args)
    {
      int[] PrimeNum = new int[5];
      PrimeNum[0] = 2;
      PrimeNum[1] = 3;
      PrimeNum[2] = 5;
      PrimeNum[3] = 7;
      int count = 0;


      Console.WriteLine("Enter Number: ");
      int num = int.Parse(Console.ReadLine());


      while (count < 4)
      {
        if (num % PrimeNum[count] != 0)
        {
          count++;
        }
        else
        {
          Console.WriteLine("The Number Is Not Prime Number");
          Console.ReadLine();
          return;
        }
      }


      Console.WriteLine("The Number Is Prime Number");
      Console.ReadLine();
    }
  }
}

      // Create the array
      int[] PrimeNum = new int[30];
      PrimeNum[0] = 2;
      PrimeNum[1] = 3;
      PrimeNum[2] = 5;
      PrimeNum[3] = 7;
      int nPrimes = 4; // number of primes currently in the array


      int num = 8;
      bool isPrime = true;

      for (int i = 0; i < nPrimes; i++)
      {
        if (num % PrimeNum[i] == 0)
        {
          isPrime = false;
          break;
        }
      }

      if (isPrime)
      {
        Console.WriteLine("The Number Is a Prime Number");
      }
        Console.WriteLine("The Number Is Not Prime Number");
      }

יש מבין?

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