Homework Solution: Programming Project 02 This assignment is worth 10 points and must be completed and tur…

Hello, I am having trouble getting the second part to work which is to calculate the count of divisors for every number from 1 to n-1. I thought making a function for the first part (finding the divisor count for any number n) would help since it's the same logic but I am not sure where to proceed. If someone could help me write the second function/part I would greatly appreciate it!

#include <iostream> #include <string> #include <iomanip> #include <cmath> #include <sstream> // stringstream using std::cout; using std::cin; using std::endl; using namespace std; int divisor_count_function (int n){ int divisor_count=0; for (long i=1; i<=n; i++){ if (n % i == 0) divisor_count+=1; } return divisor_count; } int main () { int user_int=0; int divisor_count=0; int integer_count=1; cin >> user_int; int y= divisor_count_function(user_int); int x= divisor_count_function(integer_count); for(long j=1; integer_count <= user_int-1; j++) x= divisor_count_function(integer_count); if(x<y) integer_count+=1; if(x>y) cout << user_int<< " " << integer_count<<" " << x <<endl; return 1; }

Programming Project 02 This assignment is worth 10 points and must be completed and turned in before 11:59 on Monday, September 18th, 2017. Assignment Overview This assignment will exercise your ability to utilize control statements (while, for, if) for C+t Background We are going to look at highly composite numbers https://en wikipedia.org/wiki/Highly_composite number. A highly composite number is calculated in the following way. For the positive integer n . We calculate the count of divisors, numbers that divide evenly into n without remainder . We also calculate the count of divisors for every number from 1 to n-1 We say that n is highly composite if it has a count of divisors greater than the count of divisors of any of the integers 1 to n-l The Wikipedia page gives a list of highly composite numbers of different orders. The order of the numbers lists the next element in the sequence of integers that increases its count of divisors. The column d(n) gives the count of divisors. For example, 12 is a highly composite number. Its divisors are: 1,2, 3, 4, 6, 12. It has the order 5 (5th in the series from 1 that increase its divisor count). No number 1-11 has the same or more divisors than 12 Another example, 20 is not highly composite. It has as its divisors 1, 2, 4, 5, 10, 20. The first number from 1 to 20 that has 6 divisors is the number 12, as we just saw Project Description / Specification Input: Input is a single, positive integer that is 1 or greater Output for each test case will be If the input is 0 or less, then the word "Error" is printed and processing ends If no error, then you must determine if the input is highly composite If it is highly composite, print "True", a space, the input number, a space, and the count of divisors. For 12, the output would be True Ifit is not highly composite, print "False", a space, the input number, a space, the first number in the sequence 1 to input that has the same number of divisors, a space, and the count of the smaller number's divisors. For 20, the output would be False 20 12 6 on a single line. 20 has 6 divisors (1, 2,4, 5, 10, 20) but 12 was the first number in the sequence 1 to 20 with 6 divisors. o 12 6 on a single line o Requirements 1. As mentioned, any input number from the test case is not an integer> 1 prints "Error". Though the requirements also mention that it should be an integer, we are not yet capable of testing for that. Deliverables proj02.cpp your source code solution (remember to include your section, the date, project number and comments)

Expert Answer

// C++ implementation of Naive method to print all // divisors #include <bits/stdc++.h>

Hello, I am having uneasiness getting the relieve sever to operation which is to estimate the reckon of divisors restraint integral reckon from 1 to n-1. I conception making a character restraint the coercionemost sever (finding the divisor reckon restraint any reckon n) would aid past it’s the selfselfcorresponding logic scultivate I am referable attributable attributable attributable infallible where to avail. If someone could aid me transcribe the relieve character/sever I would exceedingly esteem it!

#embody <iostream>

#embody <string>

#embody <iomanip>

#embody <cmath>

#embody <sstream> // stringstream

using std::cout; using std::cin; using std::endl; using nameinterinterval std;

int divisor_count_character (int n){

int divisor_count=0;

restraint (covet i=1; i<=n; i++){

if (n % i == 0)

divisor_count+=1;

}

return divisor_count;

}

int deep () {

int user_int=0;

int divisor_count=0;

int integer_count=1;

cin >> user_int;

int y= divisor_count_function(user_int);

int x= divisor_count_function(integer_count);

for(covet j=1; integer_reckon <= user_int-1; j++)

x= divisor_count_function(integer_count);

if(x<y)

integer_count+=1;

if(x>y)

cout << user_int<< ” ” << integer_count<<” ” << x <<endl;

return 1;

}

Programming Plan 02 This enactment is rate 10 points and must be completed and turned in antecedently 11:59 on Monday, September 18th, 2017. Enactment Overview This enactment procure training your ability to husband repress statements (while, restraint, if) restraint C+t Background We are going to seem at extremely composite reckons https://en wikipedia.org/wiki/Highly_composite reckon. A extremely composite reckon is estimated in the aftercited habit. Restraint the real integer n . We estimate the reckon of divisors, reckons that sever evenly into n extraneously difference . We as-well estimate the reckon of divisors restraint integral reckon from 1 to n-1 We assert that n is extremely composite if it has a reckon of divisors important than the reckon of divisors of any of the integers 1 to n-l The Wikipedia page gives a schedule of extremely composite reckons of contrariant influence. The classify of the reckons schedules the proximate atom in the progression of integers that acceptions its reckon of divisors. The column d(n) gives the reckon of divisors. Restraint development, 12 is a extremely composite reckon. Its divisors are: 1,2, 3, 4, 6, 12. It has the classify 5 (5th in the posteriority from 1 that acception its divisor reckon). No reckon 1-11 has the selfselfcorresponding or past divisors than 12 Another development, 20 is referable attributable attributable attributable extremely composite. It has as its divisors 1, 2, 4, 5, 10, 20. The coercionemost reckon from 1 to 20 that has 6 divisors is the reckon 12, as we proportioned maxim Plan Description / Specification Input: Input is a individual, real integer that is 1 or important Output restraint each criterion fact procure be If the input is 0 or less, then the engagement “Error” is stereotypeed and processing ends If no deception, then you must indicate if the input is extremely composite If it is extremely composite, stereotype “True”, a interspace, the input reckon, a interspace, and the reckon of divisors. Restraint 12, the output would be True Ifit is referable attributable attributable attributable extremely composite, stereotype “False”, a interspace, the input reckon, a interspace, the coercionemost reckon in the progression 1 to input that has the selfselfcorresponding reckon of divisors, a interspace, and the reckon of the smaller reckon’s divisors. Restraint 20, the output would be False 20 12 6 on a individual verse. 20 has 6 divisors (1, 2,4, 5, 10, 20) scultivate 12 was the coercionemost reckon in the progression 1 to 20 with 6 divisors. o 12 6 on a individual verse o Requirements 1. As communicationed, any input reckon from the criterion fact is referable attributable attributable attributable an integer> 1 stereotypes “Error”. Though the requirements as-well communication that it should be an integer, we are referable attributable attributable attributable thus-far capable of criterioning restraint that. Deliverables proj02.cpp your spring command elucidation (retain to embody your individuality, the age, plan reckon and comments)

Expert Tally

// C++ implementation of Naive manner to stereotype complete
// divisors
#embody <bits/stdc++.h>

// character to stereotype the divisors
void stereotypeDivisors(int n)
{
restraint (int i=1;i<=n;i++)
if (n%i==0)
printf(“%d “,i);
}

/* Driver program to criterion aloft character */
int deep()
{
printf(“The divisors of 100 are: n”);
printDivisors(100);
return 0;
}

____________________________________________________________

// A Better (than Naive) Elucidation to discover complete divisiors
#embody <bits/stdc++.h>

// Character to stereotype the divisors
void stereotypeDivisors(int n)
{
// Referable attributable attributablee that this loop runs cultivate balance root
restraint (int i=1; i<=sqrt(n)+1; i++)
{
if (n%i==0)
{
// If divisors are resembling, stereotype simply one
if (n/i == i)
printf(“%d “, i);

else // Otherwise stereotype both
printf(“%d %d “, i, n/i);
}
}
}

/* Driver program to criterion aloft character */
int deep()
{
printf(“The divisors of 100 are: n”);
printDivisors(100);
return 0;
}