Given an integer n, return a string array answer (1-indexed) where:

• answer[i] == "FizzBuzz" if i is divisible by 3 and 5.

• answer[i] == "Fizz" if i is divisible by 3.

• answer[i] == "Buzz" if i is divisible by 5.

• answer[i] == i (as a string) if none of the above conditions are true. - это условие мы не будем проверять.

Example 1:

Input: n = 3
Output: ["1","2","Fizz"]

Example 2:

Input: n = 5
Output: ["1","2","Fizz","4","Buzz"]

Example 3:

Input: n = 15
Output: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]

В Java компилятор и оптимизатор JVM (Just-In-Time Compiler) могут вносить изменения в порядок выполнения инструкций в целях оптимизации производительности. Когда вы используете System.out.println для вывода данных, компилятор может решить переставить или оптимизировать строки кода, что может привести к неожиданным результатам при замерах времени выполнения.

Например, компилятор может решить отложить вывод в консоль до более позднего момента, когда это будет наименее влиятельным на производительность. Такие оптимизации могут сделать ваши замеры времени менее точными.

Для точных замеров производительности в Java лучше использовать специализированные инструменты, такие как Java Microbenchmarking Harness (JMH) или профайлеры производительности. Эти инструменты предоставляют надежные и консистентные результаты, учитывая различные аспекты работы с виртуальной машиной Java и оптимизациями кода.

<!-- Start for benchmarks
<dependency>    
  <groupId>org.openjdk.jmh</groupId>    
  <artifactId>jmh-core</artifactId>    
  <version>1.37</version>
</dependency><dependency>    
  <groupId>org.openjdk.jmh</groupId>    
  <artifactId>jmh-generator-annprocess</artifactId>    
  <version>1.37</version>
</dependency>
<!-- End for benchmarks-->

@Benchmark
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(value = 1, warmups = 2)
@BenchmarkMode(Mode.AverageTime)

    private static final int LIMIT = 1_000_000;

    @Benchmark
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Fork(value = 1, warmups = 2)
    @BenchmarkMode(Mode.AverageTime)
    public void init0() {
        List<String> rez = new ArrayList<>();
        for (int i = 0; i < LIMIT; i++){
            if (i % 3 == 0 && i % 5 == 0){
                rez.add("FizzBuzz");
            } else if (i % 3 == 0){
                rez.add("Fizz");
            } else if (i % 5 == 0){
                rez.add("Buzz");
            }
        }
        System.out.println(rez.size());
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Fork(value = 1, warmups = 2)
    @BenchmarkMode(Mode.AverageTime)
    public void init1() {
        List<String> rez = new ArrayList<>();
        for (int i = 0; i < LIMIT; i++){
            StringBuilder sb = new StringBuilder();
            if (i % 3 == 0){
                sb.append("Fizz");
            } 
            if(i % 5 == 0){
                sb.append("Buzz");
            }
            if (!sb.isEmpty()){
                rez.add(sb.toString());
            }
        }
        System.out.println(rez.size());
    }

@Benchmark
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Fork(value = 1, warmups = 2)
    @BenchmarkMode(Mode.AverageTime)
    public void init2() {
        List<String> rez = new ArrayList<>();
        int i = 1, fizz = 0, buzz = 0;
        while (i <= LIMIT){
            fizz++; buzz++;
            if (fizz == 3 && buzz == 5) {
                rez.add("FizzBuzz");
                fizz = buzz = 0;
            } else if (fizz == 3) {
                rez.add("Fizz");
                fizz = 0;
            } else if (buzz == 5) {
                rez.add("Buzz");
                buzz = 0;
            }
            i++;
        }

        System.out.println(rez.size());
    }

    private static final int LIMIT = 1_000_000;
    private static final int NUM_THREADS = 4;


    @Benchmark
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Fork(value = 1, warmups = 2)
    @BenchmarkMode(Mode.AverageTime)
    public void init3() {
        ExecutorService executorService = Executors.newFixedThreadPool(NUM_THREADS);
        CountDownLatch latch = new CountDownLatch(NUM_THREADS);

        int chunkSize = LIMIT / NUM_THREADS;

        List<String> results = Collections.synchronizedList(new ArrayList<>());

        for (int i = 0; i < NUM_THREADS; i++) {
            final int start = i * chunkSize + 1;
            final int end = (i + 1) * chunkSize;
            executorService.submit(() -> {
                List<String> threadResults = printFizzBuzzInRange(start, end);
                results.addAll(threadResults);
                latch.countDown();
            });
        }

        try {
            latch.await(); // Wait for all threads to finish
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        executorService.shutdown();

        // Print the results
        System.out.println(results.size());
    }

    private static List<String> printFizzBuzzInRange(int start, int end) {
        List<String> threadResults = new ArrayList<>();
        for (int i = start; i <= end && i <= LIMIT; i++) {
            boolean divisibleBy3 = i % 3 == 0;
            boolean divisibleBy5 = i % 5 == 0;

            if (divisibleBy3 && divisibleBy5) {
                threadResults.add("FizzBuzz");
            } else if (divisibleBy3) {
                threadResults.add("Fizz");
            } else if (divisibleBy5) {
                threadResults.add("Buzz");
            }
        }
        return threadResults;
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Fork(value = 1, warmups = 2)
    @BenchmarkMode(Mode.AverageTime)
    public static void init4() {
        int chunkSize = LIMIT / NUM_THREADS;

        List<CompletableFuture<List<String>>> futures = new ArrayList<>();

        for (int i = 0; i < NUM_THREADS; i++) {
            final int start = i * chunkSize + 1;
            final int end = (i + 1) * chunkSize;
            CompletableFuture<List<String>> future = CompletableFuture.supplyAsync(() -> {
                return printFizzBuzzInRange(start, end);
            });
            futures.add(future);
        }

        List<String> results = futures.stream()
                .map(CompletableFuture::join) // Wait for each CompletableFuture to complete
                .collect(ArrayList::new, List::addAll, List::addAll);

        // Print the results
        System.out.println(results.size());
    }

    private static List<String> printFizzBuzzInRange(int start, int end) {
        List<String> threadResults = new ArrayList<>();
        for (int i = start; i <= end && i <= LIMIT; i++) {
            boolean divisibleBy3 = i % 3 == 0;
            boolean divisibleBy5 = i % 5 == 0;

            if (divisibleBy3 && divisibleBy5) {
                threadResults.add("FizzBuzz");
            } else if (divisibleBy3) {
                threadResults.add("Fizz");
            } else if (divisibleBy5) {
                threadResults.add("Buzz");
            }
        }
        return threadResults;
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Fork(value = 1, warmups = 2)
    @BenchmarkMode(Mode.AverageTime)
    public static void init5() {
        List<String> results = IntStream.rangeClosed(1, LIMIT)
                .parallel()
                .mapToObj(ParallelFizzBuzz3::printFizzBuzz)
                .filter(s -> !s.isEmpty())
                .toList();

        // Print the results
        System.out.println(results.size());
    }

    private static String printFizzBuzz(int num) {
        boolean divisibleBy3 = num % 3 == 0;
        boolean divisibleBy5 = num % 5 == 0;

        if (divisibleBy3 && divisibleBy5) {
            return "FizzBuzz";
        } else if (divisibleBy3) {
            return "Fizz";
        } else if (divisibleBy5) {
            return "Buzz";
        } else {
            return "";
        }
    }