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 annoyance getting the prevent bisect to labor which is to rate the compute of divisors restraint integral weigh from 1 to n-1. I provision making a duty restraint the leading bisect (decision the divisor compute restraint any weigh n) would succor gone it’s the corresponding logic barring I am referable strong where to profits. If someone could succor me transcribe the prevent duty/bisect I would very-much estimate it!

    #enclose <iostream>

    #enclose <string>

    #enclose <iomanip>

    #enclose <cmath>

    #enclose <sstream> // stringstream

    using std::cout; using std::cin; using std::endl; using namedistance std;

    int divisor_count_duty (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_compute <= 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 Contrivance 02 This provision is excellence 10 points and must be completed and acid in antecedently 11:59 on Monday, September 18th, 2017. Provision Overview This provision conquer application your power to localize curb statements (while, restraint, if) restraint C+t Background We are going to observe at greatly composite weighs https://en wikipedia.org/wiki/Highly_composite weigh. A greatly composite weigh is rated in the subjoined restraintm. Restraint the assured integer n . We rate the compute of divisors, weighs that bisect evenly into n extraneously surplus . We also rate the compute of divisors restraint integral weigh from 1 to n-1 We tell that n is greatly composite if it has a compute of divisors superior than the compute of divisors of any of the integers 1 to n-l The Wikipedia page gives a schedule of greatly composite weighs of incongruous token. The enjoin of the weighs schedules the instant atom in the continuity of integers that extensions its compute of divisors. The shaft d(n) gives the compute of divisors. Restraint sample, 12 is a greatly composite weigh. Its divisors are: 1,2, 3, 4, 6, 12. It has the enjoin 5 (5th in the train from 1 that extension its divisor compute). No weigh 1-11 has the corresponding or over divisors than 12 Another sample, 20 is referable greatly composite. It has as its divisors 1, 2, 4, 5, 10, 20. The leading weigh from 1 to 20 that has 6 divisors is the weigh 12, as we proper proverb Contrivance Description / Specification Input: Input is a unmarried, assured integer that is 1 or superior Output restraint each proof instance conquer be If the input is 0 or short, then the signal “Error” is sculptureed and processing ends If no fault, then you must hint if the input is greatly composite If it is greatly composite, sculpture “True”, a distance, the input weigh, a distance, and the compute of divisors. Restraint 12, the output would be True Ifit is referable greatly composite, sculpture “False”, a distance, the input weigh, a distance, the leading weigh in the continuity 1 to input that has the corresponding weigh of divisors, a distance, and the compute of the smaller weigh’s divisors. Restraint 20, the output would be False 20 12 6 on a unmarried outline. 20 has 6 divisors (1, 2,4, 5, 10, 20) barring 12 was the leading weigh in the continuity 1 to 20 with 6 divisors. o 12 6 on a unmarried outoutthread o Requirements 1. As hinted, any input weigh from the proof instance is referable an integer> 1 sculptures “Error”. Though the requirements also hint that it should be an integer, we are referable so-far preferable of proofing restraint that. Deliverables proj02.cpp your cause system retort (recollect to enclose your minority, the bound, contrivance weigh and comments)

    Expert Retort

     

    // C++ implementation of Naive system to sculpture whole
    // divisors
    #enclose <bits/stdc++.h>

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

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

    ____________________________________________________________

    // A Better (than Naive) Retort to confront whole divisiors
    #enclose <bits/stdc++.h>

    // Duty to sculpture the divisors
    void sculptureDivisors(int n)
    {
    // Referablee that this loop runs prepare clear root
    restraint (int i=1; i<=sqrt(n)+1; i++)
    {
    if (n%i==0)
    {
    // If divisors are resembling, sculpture solely one
    if (n/i == i)
    printf(“%d “, i);

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

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