Create Task1.java

Task1.java

@@ -0,0 +1,14 @@
+public class Task1{
+	 public static void main(String []args)
+     {
+       int count  = 1000;
+       int sum  = 0;
+       for(int i=0;i<count; i++)
+       {
+           sum += ((i%5==0)||(i%3==0))? i:0;
+
+       }
+
+        System.out.println(sum);
+     }
+}

Task2.java

@@ -0,0 +1,23 @@
+public class Task2{
+
+     public static void main(String []args)
+     {
+
+       int count  = 4000000;
+       long sum  = 0;
+       int num = 0;
+       int old1 = 0;
+       int old2 =1;
+       while( (old1 + old2) < count)   
+       {
+
+           num = old1 + old2;
+           old2 = old1;
+           old1 = num;
+           sum  = (num%2==0)? sum + num:sum;
+       }
+
+
+        System.out.println(sum);
+     }
+}

Task3.java

@@ -0,0 +1,105 @@
+package com.company;
+
+import java.util.ArrayList;
+import static java.util.Collections.*;
+
+/**
+ * Created by miroshnichenko on 22.09.2015.
+ */
+public class Task3
+{
+    public ArrayList<Long> aaa = new ArrayList();
+
+    /** Определение простоты */
+    public boolean isPrime(long num)
+    {
+       double nn =  java.lang.Math.round(java.lang.Math.sqrt(num));
+        boolean isPrime = true;
+
+        for (int i = 2; i < nn; i++)
+        {
+           if((num%i)==0)
+            {
+                isPrime = false;
+                return isPrime;
+            }
+
+        }
+      return  isPrime;
+    }
+
+
+    public ArrayList<Long> getDels(long num)
+    {
+        // ищем корень из исходного числа. В дальнейшем будем перебирать делители от 2 и до округленного значения корня исходного числа
+        double numSqrt = java.lang.Math.round(java.lang.Math.sqrt(num));
+        System.out.println("Округленное значение корня из исходного числа:" + numSqrt);
+        ArrayList<Long> dels = new ArrayList();
+
+        // число всегда делится на себя и на 1
+        dels.add(num);
+        dels.add((long) 1);
+
+        long timestart=System.currentTimeMillis();
+       for (double i = 2; i<=numSqrt; i++)
+        {
+
+            if(num%i==0)
+            {
+                dels.add((long) i);
+                dels.add((long) (num/i));
+
+            }
+        }
+
+        long timeend=System.currentTimeMillis();
+        System.out.println("time:"+(timeend-timestart));
+        return dels;
+    }
+
+
+
+    public void  testArg(Long num)
+    {
+        System.out.println("число для анализа:"+num);
+
+        ArrayList<Long> dels =   this.getDels(num);
+        sort(dels);
+        for (int j =dels.size()-1; j > 0 ; j--)
+        {
+            if(isPrime((Long) dels.get(j)))
+            {
+                System.out.println("Максимальный делитель:"+dels.get(j));
+                System.out.println("____________________________________");
+                return;
+            }
+        }
+
+    }
+
+/*Пробовал запустить?
+main method should be static
+чтоб обратиться к методу класса изнутри нужно использовать this.testArg(num);
+ */
+        public void run(String[] args)
+
+        {
+
+                 long num = new Long("600851475143");
+                 testArg(num);
+
+            for (int i = 0; i < args.length; i++)
+            {
+                 num = Long.valueOf(args[i]);
+                testArg(num);
+
+
+            }
+
+
+
+
+
+        }
+
+}

Task4.java

@@ -0,0 +1,68 @@
+package com.company;
+
+
+import java.util.ArrayList;
+
+import static java.util.Collections.sort;
+
+/**
+ * Created by miroshnichenko on 22.09.2015.
+ */
+public class Task4 {
+
+
+// проверка  - является ли число полиндромом. Разделяем число на разряды и переворачиваем
+public boolean isPol(int a)
+{
+
+    int razr = (int) java.lang.Math.floor( java.lang.Math.log10(a)  )+1; // количество разрядов
+    int m = a;
+    int l = 0;
+
+    for (int i = 0; i < razr; i++) {
+
+        l = l*10 + m%10;
+        m = (int) java.lang.Math.floor(m/10);
+
+    }
+
+
+    return a==l;  // равно ли исходное число перевернутому
+}
+
+   public void getListPol()
+   {
+       //proizv-транслит всегда плохо, multiply-хорошо
+       ArrayList<Integer> proizv = new ArrayList();  // тут хранятся произведения множителей
+
+       long timestart=System.currentTimeMillis();
+
+       // так как в условии только 3-х значные числа
+       for (int i = 1000; i > 99 ; i--) {
+
+           for (int j = i; j > 99 ; j--) {
+
+               if(isPol(i * j))
+               {
+                   proizv.add(i*j);
+               }
+
+           }
+       }
+       sort(proizv);  // сортируем значения по возрастанию
+       long timeend=System.currentTimeMillis();
+       System.out.println("time:" + (timeend - timestart));
+
+       System.out.println("Самый большой: "+ proizv.get(proizv.size()-1));  
+   }
+
+
+//Тут тоже не запустится
+    public void run()
+
+    {
+        this.getListPol();
+    }
+
+
+    }

Task5.java

@@ -0,0 +1,117 @@
+package com.company;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+/**
+ * Created by miroshnichenko on 23.09.2015.
+ */
+public class Task5
+implements   Runnable
+{
+
+
+    Task5(String[] args)
+    {
+       this.mnoz = args.clone();
+
+    }
+
+    public ArrayList<Integer> globalDels = new ArrayList();
+    private String[] mnoz;
+
+
+
+    // Проверяем является ли полученное число простым
+    public boolean isPrime(long num)
+    {
+        double nn =  java.lang.Math.round(java.lang.Math.sqrt(num));
+        boolean isPrime = true;
+
+        for (int i = 2; i < nn; i++)
+        {
+            if((num%i)==0)
+            {
+                isPrime = false;
+                return isPrime;
+            }
+
+        }
+        return  isPrime;
+    }
+
+
+
+    // получение делителей исходного числа
+    public void getDelis( int num)
+    {
+
+
+        ArrayList<Integer> localDels = new ArrayList();
+
+        // составляем список делителей числа
+        int tmp = 0;  // временная переменная.
+        while (tmp<num)
+        {
+            tmp = tmp+1;
+            if((num%tmp==0)&&(isPrime(tmp)))
+            {
+                localDels.add(tmp);
+                num = num/tmp;
+                tmp = 1;
+            }
+
+
+        }
+
+
+        /*
+            Последовательно перебираем все значения массива простых  делителей
+            Сравниваем с глобальным массивом.
+            Если локальный массив не входит в глобальный массив - добавляем в глобальный массив недостающие значения
+         */
+
+        for (int j = 0; j < localDels.size(); j++) {
+
+            if(Collections.frequency(globalDels,localDels.get(j))<Collections.frequency(localDels,localDels.get(j)))
+            {
+                globalDels.add(localDels.get(j));
+            }
+
+        }
+        localDels.clear();
+    }
+
+
+
+    public  void run()
+    {
+
+
+
+        // при написании алгоритма использовалось http://math-prosto.ru/?page=pages/find_nod_and_nok/find_nok.php .
+        long timestart=System.currentTimeMillis();
+        // список делителей для которых ищем значение
+
+        for (int i = 0; i < mnoz.length; i++) {
+            this.getDelis(Integer.valueOf(mnoz[i]));
+        }
+
+
+        int s = 1;
+        // последовательно перемножаем все делители
+        for (int i = 0; i < this.globalDels.size(); i++) {
+
+            s = s * this.globalDels.get(i);
+        }
+
+        long timeend=System.currentTimeMillis();
+        System.out.println("time:" + (timeend - timestart));
+
+        System.out.println("Наибольшее общее кратное:" + s);
+
+
+    }
+
+
+}