مقسوم علیه های اول یک عدد

سلام 

اول از همه یه راهنمایی: وقتی کد مینویسید باید خیلی ریلکس باشید :) نمیخواد اینقدر مسئله رو بپیچونی، اول از همه ساده ترین راهی که به ذهنتون میخوره رو بنویسید، بعدا میشه شاخ و برگ بهش داد، مثلا:

int num = 11;
for (int i = 2; i <= num / 2; i++)
{
      if (num % i == 0) {
          Log.i("LOG", "adad aval nist");
          return;
      }
}
Log.i("LOG", "OK"); 

خوب حالا اینجا چکار کردیم:

1: توی حلقه اومدم num / 2  کردم - این کار به این خاطره که هیچ عددی بر اعداد بزرگتر از نصف خودش بخشپذیر نیست :) (امیدوارم منظورمو رسونده باشم :)) ) پس دیگه نیازی نیست اعداد بزرگتر از num / 2 چک بشه که این باعث میشه سرعت برنامه بیشتر بشه.

2: توی ()if گفتیم که آقا اگه توی این مسیر ( از 2 تا  num / 2) به عددی رسیدی که num  بر اون عدد بخشپذیر بود یه پیغام چاپ کن و return کن( از برنامه کلا بیا بیرون و الکی تقسیم نکن، که این هم توی سرعت بازم تاثیر داره و برنامه دیگه الکی سرچ نمیکنه. ) 

3: حالا چرا گفتیم از 2 شروع به سرچ کردن کن - به خاطر این که همه اعداد بر 1 بخشپذیر هستن، چرا الکی اینو چک کنه ؟ :))

4: آخر کار هم بعد از این که حلقه for کارشو انجام داد اومدیم یه پیغام چاپ کردیم که آره، عدد اوله :)) به همین سادگی، به همین خوشمزگی

چاپ مقسوم علیه هایی که عدد اول هستند (خیلی سخته ها ، از ویکیپدیا هم کمک گرفتم):

int number = 284565;
for (int i = 1; i <= number/2; i++) {
 if (number % i == 0) {
     System.out.println(i);
     number /= i;
        }
}

سلام

الگوریتمی که براتون گذاشتم دقیقا همون کاری که میخوای رو انجام میده

الگوریتم شما تقریبا درست بود اما سه جاش ایراد جزیی داشت اما من الگوریتم شما رو تصحیح کردم و بهتون میگم اشتباه شما کجا بود

خب اول الگوریتم درست رو مینویسم

  int number = 26;
    for (int i = 1; i <= number; i++)
      {   
          if (number % i == 0)
          {
            int k = 0;
             for (int j = 1; j <= i; j++)
              {
                if (i % j == 0)
                  {
                    k++;
                  }
              }
             if (k == 2)
             {
               Log.i("LOG", ""+i); 
             {
          }
      }

اولین اشتباه:متغیر kرا باید بیرون for تعریف میکردید

دومین:دستور مقایسه ای k==2 را باید بیرون for تعریف میکردید

سومین:باید به جای log کردن j باید i را log میکردید

من این سوال رو قبلا از استاد کرده بودم خواستی یه نگا بنداز

نمایش مقسوم علیه های اول در الگوریتم های جاوا

چون ما میدونیم عدد یک اول نیست پس بهتره که از دو شروع بشه مثل زیر

for(int i =2; i < = number; i+ ){

نا امید نشو دوست عزیز.

فرق کسانی که نا امید میشن با کسانی که نمی شن در این هست که دسته اول پشت چاله های کوچکتر می مونن و دسته دوم پشت چاله های بزرگ تر می مونن.

در هر حال همه پشت چاله ها معطلیم.

سلام دوستان من هم خیلی به این الگوریتم فکر کردم و دوست داشتم که حتما اون رو انجام بدم

باید بگم من هم دقیقا فکری رو داشتم که شما داشتید یعنی خروجی های مربوط به مقسوم علیه باید 2 تا باشه پس اون عدد یک عدد اول میشه

دیروز راجب or . and سوال کردم میخواستم برای این الگوریتم استفاده کنم که نشد و در اخر من همین الان الگوریتمش رو تموم کردم <

که به این صورت هست :D خیلی پیچیده شده : D

//یک عدد برای تست انتخاب میکنیم
 int tnum = 21;
// پیدا کردن تمام مقسوم علیه ها برای عددی که انتخاب کردیم
      for (int tm = 1; tm <= tnum; tm++) {
            if (tnum % tm == 0) {
// متغییری که چک میکنه تعداد مقسوم علیه ها 2 تا باشه باید بیرون از حلقه تعریف بشه                
int chek = 0;
// نک نک مقسوم علیه های بدست اومده از عددی که انتخاب کریدم دوباره مقسوم گیری میکنیم
                for (int tm2 = 1; tm2 <= tm; tm2++) {
                    if (tm % tm2 == 0) {
// به تعداد مقسوم علیه ها متغیر افزایش پیدا میکنه
                        chek++;
                    }
                }
// اگر از 2 بیشتر بشه اون عدد اول نیست
                if (chek > 2) {}
                else {
// پس اعداد اول رو در مقسوم علیه ها به ترتیب زیر تشخیص داده میشه
                    Log.i("ONE LOG", "all ONE maghsoom for " + tnum + " is : " + tm);
                }
            }
        }

//----------------سورس رو جدا میکنم که به چشم بیاد

 int tnum = 21;
      for (int tm = 1; tm <= tnum; tm++) {
            if (tnum % tm == 0) {
int chek = 0;
                for (int tm2 = 1; tm2 <= tm; tm2++) {
                    if (tm % tm2 == 0) {
                        chek++;
                    }
                }
                if (chek > 2) {}
                else {
                    Log.i("ONE LOG", "all ONE maghsoom for " + tnum + " is : " + tm);
                }
            }
        }

کاشک مدیران انجمن یک بخش جداگانه برای تمرینات رو میگذاشتند که اگر روش های متفاوتی وجود داشته باشه دوستان اونجا کد هارو بزارند

توی قسمت 02-05 و اموزش متد هابرای متدی که الگوریتم فاکتوریل تعریف میشه

من سعی کردم قضیه رو به روش برعکسش حل کنم که اولش به مشکل برخوردم

یعنی 8! رو از 1 تا 8 ضرب کنیم و نه از 8 تا 1

که کدش به اینصورت میشه - خودم فکر میکنم جالب نشده ( بقول استاد اصلا قشنگ نیست از این روش استفاده بشه :D ) دوستان اگر روش جالبتری رو میشناسید معرفی کنید

int factor = mfactor(5);
        Log.i("Mfactor LOG", "" + factor);
}
// بلاک مربوط به public viote on create رو رعایت کنید
public int mfactor(int aa) {
        int fac = 1;
        for (int i = 1; i < (aa + 1); i++) {
            fac = fac * i;
        }
        return fac;

در جواب  Criss : 

مگه بازگشتی چشه ؟

 public int fact(int x){
     return ((x==1) || (x==0)) ? 1 : x*fact(x-1);
}

 من این سورس رو برای مقسوم علیه عدد اول نوشتم 
ولی کل  مقسوم علیه هارو تو خروجی میده و مشخص میکنه کدوم اوله و کدوم نیست.میشه راهنمایی کنید کاملش کنم؟
 
        int num = 100;
        for (int j = 2; j <= num; j++) {
            if (num % j == 0) {
 
                if (j == 2) {
                    Log.i("LOG", " " + j + " is avval");
                }
                else if (j == 3) {
                    Log.i("LOG", " " + j + " is avval");
                }
 
                else if (j % 2 == 0) {
                    Log.i("LOG", j + "is not avval");
                    // break;
                }
                else if (j % 3 == 0) {
                    Log.i("LOG", j + "is not avval");
                    // break;
                }
                else if (j % 5 == 0) {
                    Log.i("LOG", j + "is not avval");
                    // break;
                }
 
            }
 
        }
    }
}

کسی نمیتونه الگوریتم منو تکمیل کنه؟
دوستان لطفا راهنمایی کنید

این سورس کد کارتونو راه میندازه؟

  int number = 255;
        for (int i = 2; i <= number; i++) {

            // آیا متغیر نامبر به آی بخش پذیر است
            if (number % i == 0) {
                // بله پس آی یک مقسوم علیه نامبر است

                // فرض کنیم آی اول است
                boolean z = true;

                // ببینیم آیا مثال نقضی پیدا می شود
                for (int j = 2; j < i; j++) {
                    if (i % j == 0) {
                        // عددی کوچکتر از آی پیدا شد که آی به آن بخش پذیر باشد پس آی اول نیست
                        z = false;

                        // دیگر ادامه دادن فایده ندارد
                        break;
                    }
                }

                // آیا به این نتیجه رسیدیم که آی اول است
                if (z) {
                    // بله، بود پس چاپش می کنیم
                    Log.i("LOG", "aval= " + i);
                }
            }
        }

پس continue کجاست ؟!

به نظر من این الگوریتم خیلی سادست,امیدوارم به دردتون بخوره

        int num = 100;
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                boolean g = false;
                for (int z = 2; z < i; z++)
                    if (i % z == 0) {
                        g = true;
                    }
                if (g == false) {
                    Log.i("LOG", "number is: " + i);
                }
            }
        }

اگه میخواید بخونید کدو کپی کنید تو اکلیپس:)

سلام

فکر کنم بهترین جواب رو پیدا کردم. البته با کمک از کد جناب نصرتی لطفا نظر بدید. 

long number = 744;
bool isRepetitive;

for (int i = 2; i <= number; i++) {
     isRepetitive = false;
     while (number % i == 0) {
           if(!isRepetitive){
              Log.i("LOG", i + "");
              isRepetitive = true;
          }
          number /= i;
     }
}

این برنامه فک کنم چیزی که میخواینو انجام میده :

int adad = 10;
        int shomar;
        for (int i = 2; i < adad; i++) {
            shomar = 0;
            for (int j = 1; j < adad; j++) {
                if (i % j == 0) {
                    shomar++;
                    if (shomar < 3 && j == i) {
                        if (adad % j == 0) {
                            Log.i("LOG", "Adad Aval= " + j);
                        }
                    }
                }
            }
        }

کمی ریاضی : اگر اعداد اول را با p نشان دهیم آنگاه p = 6k+1 یا p = 6k-1 که  K اعداد ظبیعی هستند(به غیر از 2 و 3) 

مثال : 5 = 1-6 یا 17 = 1-6(3) 

با این الگو می تونید به راحتی اعداد اول مثلا بین 1000000 تا 10000000000000000000 رو با فقط یک تقسیم ساده به دست بیارید اما با الگوریتم هایی که در پایین نوشتن (یعنی تقسیم دونه دونه اعداد به دونه به دونه اعداد قبل خودش) اگه اعداد بزرگ یا زیاد باشن ممکنه طول بکشه یا حتی برنامه بسته بشه 

امیدوارم کمک کرده باشم.

این کد نمیدونم درست یا نه اما خیلی راحت قابل فهم و کار میکنه دوستان نظر بدن

فقط نمیدونم چرا else if رو به else خالی تبدیل کنیم به هم میریزه فرقشون چیه

  int z = 6;
 for (int indexz = 1; indexz <= z; indexz++) {
 if (z % indexz == 0) {
 if (indexz == 2) {
 Log.i("LOG", " number is : " + 2);
 }
 else if (indexz % 2 == 0) {
 continue;
 }

 else {
 Log.i("LOG", "number is : " + indexz);
 }
 }
 }