Homework

Student.cpp

@@ -0,0 +1,83 @@
+#include<iostream>
+#include<string>
+#include<cmath>
+#include<vector>
+#define N 5
+
+
+    std::string Mike[]={"Mike Barnes","Male","1","4.0",};
+    std::string Jim[]={"Jim Nickerson","Male","2","3.0",};
+    std::string Jack[]={"Jack Indabox","Male","3","2.5",};
+    std::string Jane[]={"Jane Miller","Female","4","3.6",};
+    std::string Mary[]={"Mary Scott","Female","4","2.7",};
+/*struct STUDENT
+{
+    std::string name;
+    std::string sex;
+    int grade;
+    float gpa;
+}stu1;
+STUDENT students[N]
+{
+    NAME[0],SEX[0],1,4.0,
+    NAME[1],SEX[0],2,3.0,
+    NAME[2],SEX[0],3,2.5,
+    NAME[3],SEX[1],4,3.6,
+    NAME[4],SEX[1],4,2.7,
+};*/
+
+class Student
+{
+    private:
+    std::string name;
+    std::string sex;
+    int grade;
+    double gpa;
+
+    public:
+    Student(std::string str[])
+    {
+        name=str[0];
+        sex=str[1];
+        grade=std::stoi(str[2]);
+        gpa=std::stod(str[3]);
+    }
+    ~Student()
+    {
+
+    }
+    void show_myself()
+    {
+        std::cout<<name<<" "<<grade<<" "
+        <<sex<<" "<<gpa<<std::endl;
+    }
+    float study_time(double study_time)
+    {
+        gpa+=log10(study_time);
+        return gpa=gpa>4.0? 4.0: gpa;
+    }
+};
+
+int main()
+{
+    Student student1(Mike);
+    Student student2(Jim);
+    Student student3(Jack);
+    Student student4(Jane);
+    Student student5(Mary);
+    Student students[N]={student1,student2,student3,student4,student5};
+    for(int i=0;i<N;i++)
+    {
+        students[i].show_myself();
+    }
+    double studytime[N]={60.0,100.0,40.0,300.0,1000.0};
+    for(int i=0;i<N;i++)
+    {
+        students[i].study_time(studytime[i]);
+    }
+        for(int i=0;i<N;i++)
+    {
+        students[i].show_myself();
+    }
+    return 0;
+}

SuperPrime_HW.cpp

@@ -1,5 +1,97 @@
-#include <iostream>
+#include<iostream>
+class SuperPrime
+{
+    private:
+    int LowLimit,HighLimit;
+    public:
+    SuperPrime(int a,int b)
+    {
+        LowLimit=a;
+        HighLimit=b;
+    }
+    ~SuperPrime()
+    {
 
-int main() {
-  return 0;
-}
+    }
+    void FindSP(int*p)
+    {
+        IsSPrime(p);
+    }
+    void IsSPrime(int *r)
+    {
+        for(int i=LowLimit;i<=HighLimit;i++)
+        {
+            int j;
+            for(j=2;j<i;j++)
+            {
+                if(i%j==0)
+                {
+                    break;
+                }
+            }
+            if(j==i)
+            {
+                if(operation(i))
+                {
+                    *r=i;
+                    r++;
+                }
+            }
+        }
+    }
+    int operation(int k)
+    {
+        int number[3];
+        for(int ni=0;ni<3;ni++)
+        {
+            number[ni]=k%10;
+            k=k/10;
+        }
+        int NumberSum=number[0]+number[1]+number[2];
+        for(int ni=2;ni<NumberSum;ni++)
+        {
+            if(NumberSum%ni==0)
+            {
+                return 0;
+            }
+        }
+        int NumberMult=number[0]*number[1]*number[2];
+        for(int ni=2;ni<NumberMult;ni++)
+        {
+            if(NumberMult%ni==0)
+            {
+                return 0;
+            }
+        }    
+        int NumberSqrt=number[0]*number[0]+number[1]*number[1]+number[2]*number[2];
+        for(int ni=2;ni<NumberSqrt;ni++)
+        {
+            if(NumberSqrt%ni==0)
+            {
+                return 0;
+            }
+        }
+        return 1;
+    }
+};
+
+int main()
+{
+    SuperPrime sp(100,999);
+    int sum=0,SPsum=0,max;
+    int SP[80]={0},*q=&SP[0];
+    sp.FindSP(q);
+    for(int l=0;l<80;l++)
+    {
+        if(SP[l]!=0)
+        {
+            sum++;
+            SPsum+=SP[l];
+            max=SP[l];
+        }
+    }
+    std::cout <<"The Total Of Super Prime:"<<sum<<std::endl;
+    std::cout<<"The Sum Of Super Prime:"<<SPsum<<std::endl;
+    std::cout<<"The Max Of Super Prime:"<<max<<std::endl;
+    return 0;
+}

SuperPrime_HW2.cpp

@@ -1,20 +1,23 @@
 #include <iostream>
 #include <vector>
+#include <math.h>
+using namespace std;
+
 class Nature {
 private:
   int num;
 public:
   Nature():num(0){
-    std::cout << "Default Create Nature as " << num << std::endl;
+    //std::cout << "Default Create Nature as " << num << std::endl;
   }
   Nature(int n):num(n) {
-    std::cout << "Create Nature as " << num << std::endl;
+    //std::cout << "Create Nature as " << num << std::endl;
   }
   Nature(const Nature &nat):num(nat.num){
-    std::cout << "Copy Create Nature as " << num << std::endl;
+    //std::cout << "Copy Create Nature as " << num << std::endl;
   }
   ~Nature() {
-    std::cout << "Destroy Nature as " << num << std::endl;
+    //std::cout << "Destroy Nature as " << num << std::endl;
   }
   bool isPrime() {
     if(num == 1 || num == 0)
@@ -34,61 +37,111 @@ class Nature {
 
   	return -1;
   }
-private:
+  int sum(const Nature &nat){
+    return num+=nat.num;
+  }
 };
-class SuperPrime : public Nature {
+
+class SuperPrime : public Nature { //继承
 private:
   int num;
 public:
   SuperPrime(int n):num(n) {
   } 
-  bool isPrime() {
-  	Nature nat(num);
-  	return nat.isPrime();
-  } 
-  int compare(const SuperPrime &nat) {
+  bool isSuperPrime() {
+  	Nature nat(num),nat1(0),nat2(0),nat3(0);
+    operation(nat1,nat2,nat3);
+    if(nat.isPrime()&&nat1.isPrime()&&nat2.isPrime()&&nat3.isPrime())
+    {
+      return true;
+    }
+  	else
+    {
+      return false;
+    }
+  }
+  /*int compare(const SuperPrime &nat) {
   	if (num > nat.num)
   	  return 1;
   	else if(num == nat.num)
   	  return 0;
 
   	return -1;
+  }*/
+  void operation(Nature nat1,Nature nat2,Nature nat3)
+    {
+      int number[3];
+      for(int ni=0;ni<3;ni++)
+      {
+        number[ni]=num%10;
+        num=num/10;
+      }
+      int NumberSum=number[0]+number[1]+number[2];
+      nat1=NumberSum;
+      int NumberMult=number[0]*number[1]*number[2];
+      nat2=NumberMult;
+      int NumberSqrt=number[0]*number[0]+number[1]*number[1]+number[2]*number[2];
+      nat3=NumberSqrt;
+    }
+  void out()
+  {
+    cout<<num<<endl;
   }
 };
+
 class Container {
 private:
   std::vector<SuperPrime> natures;
 public:
   Container(int a, int b) {
-    std::cout << "Create SuperPrime from " << a << " to " << b << std::endl;
+    //std::cout << "Create SuperPrime from " << a << " to " << b << std::endl;
     for(int i = a; i < b; i++) {
       SuperPrime nat(i);
-      std::cout << "HAHA" << std::endl;
+      //std::cout << "HAHA" << std::endl;
       if(nat.isSuperPrime())
         natures.push_back(nat);
-      std::cout << "DDDDD" << std::endl;
-	}
+      //std::cout << "DDDDD" << std::endl;
+	  }
   }
   ~Container() {
     std::cout << "Destroy SuperPrime " << std::endl;
   }
 
   SuperPrime max() {
-  	std::vector<SuperPrime>::iterate it = natures.begin();
-  	Nature max(0);
+  	std::vector<SuperPrime>::iterator it = natures.begin();
+  	SuperPrime max(0);
   	for(; it != natures.end(); it ++) {
       if (max.compare(*it)) {
   	  	  max = *it;
       }
-	}
+	  }
   	return max;
   }
+  SuperPrime sum()
+  {
+    std::vector<SuperPrime>::iterator it = natures.begin();
+  	SuperPrime sum(0);
+    for(; it != natures.end(); it ++) {
+      sum.sum(*it);
+	  }
+    return sum;
+  }
+  SuperPrime total()
+  {
+    return natures.size();
+  }
 };
 int main() {
-  SuperPrime sp(10, 13);
-  Nature n = sp.max(); 
-  std::cout << "��󳬼�������" ;
-  n.show();
-
+  Container sp(100,999);
+  SuperPrime max=sp.max(),sum=sp.sum(),total=sp.total();
+  std::cout <<"The Total Of Super Prime:";
+  total.out();
+  cout<<endl;
+  std::cout <<"The Sum Of Super Prime:";
+  sum.out();
+  cout<<endl;
+  std::cout <<"The Max Of Super Prime:";
+  max.out();
+  cout<<endl;
   return 0;
-} 
+}

SuperPrime_HW3.cpp

@@ -24,11 +24,11 @@ class SuperPrime:public Nature {
   SuperPrime(int n):Nature(n) {
   }
   bool isPrime() {
-  	int tmp = num + 1;
+  	int tmp = num;
   	int sum = 0, mul = 1, sqr = 0;
   	while(tmp != 0) {
-  	  tmp = tmp / 10;
   	  int x = tmp % 10;
+  	  tmp = tmp / 10;
   	  sum += x;
   	  mul *= x;
   	  sqr += x*x;
@@ -52,7 +52,5 @@ int main() {
   for(it=sps.begin(); it!=sps.end();it++) {
   	delete *it;
   }
-
-  //���ij������� 
   return 0;
 }