Code Review

public static void taskNumberTwo(int limitNumber) {
    for (int i = limitNumber; i > 0; i--) {
        System.out.printf("%s, ", i);
    }
    System.out.println(0);
}

public static void taskThree(int limitNumber) {
    int counter = 0;
    int startValue = 0;
    int currentValue = 1;
    System.out.println(startValue);
    System.out.println(currentValue);
    while (counter < limitNumber) {
        int lastValue = currentValue;
        System.out.println(currentValue += startValue);
        startValue = lastValue;
        counter++;
    }
}

public static void taskNumberFour(int limitNumber) {
    int firstCounter = 1;
    int secondCounter = 1;
    while (firstCounter <= limitNumber) {
        while (secondCounter <= limitNumber) {
            int firstResult = firstCounter * secondCounter;
            System.out.printf("%s * %s = %s   \t",secondCounter, firstCounter, firstResult);
            secondCounter++;
        }
        System.out.print("\n");
        secondCounter = 1;
        firstCounter++;
    }
}

# Build and Release Folders
/.idea
out/
bin-debug/
bin-release/
[Oo]bj/

public class Task01 {
    public static void main(String[] args){
        for (int i = 0; i <= 10; i++){
            System.out.println(i);
        }
    }
}

public class Task03 {
    public static void main(String[] args) {
        int n0 = 1;
        int n1 = 1;
        int n2;
        System.out.print(n0 + " " + n1 + " ");
        for (int i = 3; i < 11; i++){
            n2 = n0 + n1;
            System.out.print(n2 + " ");
            n0=n1;
            n1=n2;
        }
        System.out.println();
    }

}

public class Task04 {
    public static void main (String[] args){
        System.out.println("  1 2 3 4 5 6 7 8 9 10");
        int i = 1;
        while (i <=10) {
            System.out.print(i + " | ");
            int j = 2;
            while (j <= 10){
                int mult = i * j;
                if (mult <= 10)
                    System.out.print(mult + " ");
                else
                    System.out.print(mult + " ");
                j++;

            }
            System.out.println();
            i++;
        }

    }
}

public class Task01 {
    public static void main(String[] args) {
        int i = 0;
        while (i <= 10) {
            System.out.printf("%d ", i++);
        }
    }
}

public static void main(String... args) {
    int x = 1;
    int y = 2;
    while (x <= 11) {
        while (y <= 11) {
            System.out.println(x * y + "");
            y++;
        }
        System.out.println();
        x++;
        y = 1;
    }
}

public class Task01 {
    public static void main(String[] args) {
        System.out.println("output of numbers from 0 to 10:");
        int uupperLimit = 10;
        for (int number = 0; number <= uupperLimit; number++) {
            if (number < uupperLimit) {
                System.out.printf("%s, ", number);
            } else {
                System.out.printf("%s. ", number);
            }
        }
    }
}

public static void main(String[] args) {
    System.out.println("output of 10 fibonacci numbers");
    int numberN = 1;
    int numberNMinusOne = 0;
    int numberNPlusOne;
    int startN;
    int limitN = 8;
    System.out.printf("%s, %s, ", numberNMinusOne, numberN);
    for (startN = 1; startN <= limitN; startN++) {
        if (startN < limitN) {
            numberNPlusOne = numberN + numberNMinusOne;
            System.out.printf("%s, ", numberNPlusOne);
            numberNMinusOne = numberN;
            numberN = numberNPlusOne;
        } else {
            numberNPlusOne = numberN + numberNMinusOne;
            System.out.printf("%s. ", numberNPlusOne);
        }
    }
}

public static void main(String[] args) {
    int firstMultiplier = 1;
    int secondMultiplier = 1;
    int limitMultiplier = 10;
    while (secondMultiplier <= limitMultiplier) {
        while (firstMultiplier <= limitMultiplier) {
            System.out.printf("%2s x %2s = %3s\t", firstMultiplier, secondMultiplier, firstMultiplier * secondMultiplier);
            firstMultiplier++;
        }
        System.out.println();
        firstMultiplier = 1;
        secondMultiplier++;
    }
}

public class Lesson4Task3 {
    public static void main(String[] args) {
        int fibonachi = 1;
        int cikl = 0;
        while (cikl < 10) {
            System.out.println(fibonachi);
            fibonachi = fibonachi + fibonachi;
            cikl++;
        }
    }
}

public class Lesson4Task4 {
    public static void main(String[] args) {
        int mnozhitel1 = 1;
        int mnozhitel2 = 1;
        int proizvedenie = 0;
        while (mnozhitel1 <= 10) {
            while (mnozhitel2 <= 10) {
                proizvedenie = mnozhitel1 * mnozhitel2;
                System.out.println(mnozhitel1 + " * " + mnozhitel2 + " = " + proizvedenie);
                mnozhitel2++;
            }
            mnozhitel1++;
            mnozhitel2 = 1;
        }
    }
}

static String generateNumbersColumn(int numberRows) {
    String number = "";
    for (int i = 1; i <= numberRows; i++) {
        if (i < numberRows) {
            number += i + "\n";
        } else {
            number += i;
        }
    }
    return number;
}

static double getTotalDepositAmount(double depositAmount, double annualDepositPercent, int depositTerm) {
    final double PERCENT_FACTOR = 1 / 100.0;
    double money = depositAmount;
    for (int i = 1; i <= depositTerm; i++) {
        money += money * annualDepositPercent * PERCENT_FACTOR;
    }
    return NumberUtil.roundValueToTwoDigitsForMantissa(money);
}

static int calculateRaidTime(int healthPoints, double regenerationPercentPerHour, int averageDamagePerHour) {
    final double PERCENT_FACTOR = 1 / 100.0;
    int monsterHealth = healthPoints;
    int time = 0;
    for (int i = 1; i <= 24; i++) {
        monsterHealth += monsterHealth * regenerationPercentPerHour * PERCENT_FACTOR - averageDamagePerHour;
        if (monsterHealth > 0 && i == 24) {
            time = -1;
            break;
        }
        if (monsterHealth <= 0) {
            time = i;
            break;
        }
    }
    return time;
}

static double calculateTotalDistance(int startDistance, int finishDistance, double dailyProgressAsPercentage) {
    final double PERCENT_FACTOR = 1 / 100.0;
    double theDistance = startDistance;
    double theWholeDistance = 0;
    if (theDistance != 0) {
        while (theDistance < finishDistance) {
            theDistance += theDistance * dailyProgressAsPercentage * PERCENT_FACTOR;
            theWholeDistance += theDistance;
        }
    } else {
        theWholeDistance = 0;
    }
    return NumberUtil.roundValueToTwoDigitsForMantissa(theWholeDistance);
}

static String generateTotalPriceList(int startNumberItems, double startPriceAllItems, int differentialNumberItems, double differentialSell, int sizeTotalPrice) {
    final double PERCENT_COEFFICIENT = 1 / 100.0;
    String bill = "";
    double percentSellInLine;
    int amountAllItemsInLine;
    double priceAllItemsInLine;
    double sellAllItemsInLine;
    double priseOneItem = startPriceAllItems / startNumberItems;
    for (int i = 0; i < sizeTotalPrice; i++) {
        amountAllItemsInLine = startNumberItems + differentialNumberItems * i;
        percentSellInLine = differentialSell * i;
        sellAllItemsInLine = amountAllItemsInLine * priseOneItem * percentSellInLine * PERCENT_COEFFICIENT;
        priceAllItemsInLine = NumberUtil.roundValueToTwoDigitsForMantissa(amountAllItemsInLine * priseOneItem - sellAllItemsInLine);
        if (i == sizeTotalPrice - 1) {
            bill += amountAllItemsInLine + " - " + priceAllItemsInLine + " with sell " + percentSellInLine + "%";
            break;
        }
        bill += amountAllItemsInLine + " - " + priceAllItemsInLine + " with sell " + percentSellInLine + "%\n";
    }
    return bill;
}

static int countPrimeNumber(int startNumber, int finishNumber) {
    int amountPrimeNumbers = 0;
    for (int i = finishNumber; i >= startNumber; i--) {
        int integerDivisionCounter = 0;
        for (int j = 1; j <= i; j++) {
            if (i % j == 0) {
                integerDivisionCounter++;
            }
        }
        if (integerDivisionCounter == 2) {
            amountPrimeNumbers++;
        }
    }
    return amountPrimeNumbers;
}

static double calculateTotalDistance(int startDistance, int finishDistance, double dailyProgressAsPercentage) {
    //TODO
    // Код, решающий задачу пишем ниже, при этом используя параметры метода
    double everyDayDistancePercent = dailyProgressAsPercentage / 100.0;
    double currentDistance = startDistance;
    double totalDistance = currentDistance;
    if (startDistance > finishDistance || startDistance == 0) {
        return 0.0;
    }
    while (currentDistance < finishDistance) {
        currentDistance = currentDistance * (1.0 + everyDayDistancePercent);
        totalDistance += currentDistance;
    }
    return NumberUtil.roundValueToTwoDigitsForMantissa(totalDistance - startDistance);
}

static int calculateHealthPointsByTime(int healthPoints, double regenerationPercentFromCurrentHealth, int hoursAfterRespawn) {
    double currentHP = healthPoints;
    for (int i = 0; i < hoursAfterRespawn; i++) {
        currentHP += currentHP * regenerationPercentFromCurrentHealth / 100;
    }
    return (int) currentHP;
}

static int calculateRaidTime(int healthPoints, double regenerationPercentPerHour, int averageDamagePerHour) {
    int hourInDay = 24;
    int currentHp = healthPoints;
    int time = 0;
    int finalTime;
        do {
            currentHp += currentHp * regenerationPercentPerHour / 100;
            currentHp = currentHp - averageDamagePerHour;
            time++;
        } while (currentHp > 0 && time < hourInDay);
        if (currentHp > 0) {
            finalTime = -1;
        } else {
            finalTime = time;
        }
        return finalTime;
}

static double getTotalDepositAmount(double depositAmount, double annualDepositPercent, int depositTerm) {
    Double result = depositAmount;
    for (int i= 1; i <= depositTerm; i++) {
        result = result + ((float)(result * annualDepositPercent) / 100);
    }
    return (double) Math.round(result * 100) / 100;
}

static int calculateRaidTime(int healthPoints, double regenerationPercentPerHour, int averageDamagePerHour) {
    int time = 0;
    int amountHP = healthPoints;

    while (amountHP > 0) {
        amountHP = (int) (amountHP + (amountHP * regenerationPercentPerHour / 100));
        amountHP = amountHP - averageDamagePerHour;
        time++;
        if (time > 24) {
            return -1;
        }
    }
    return time;
}

static int countPrimeNumber(int startNumber, int finishNumber) {
    int countNumber = 0;

    if (startNumber < 2) {
        startNumber = 2;
    }
    for (int i = startNumber; i <= finishNumber; i++) {
        if (checkSimple(i)) {
            countNumber++;
        }
    }
    return countNumber;
}

static boolean checkSimple(int number) {
    for (int i = 2; i * i <= number; i++) {
        if (number % i == 0) {
            return false;
        }
    }
    return true;
}