Правильное решение от разработчиков некорректного составлено?

Прошу прощения - может быть не очень точно сформулировал вопрос. Вопрос касается не моего кода, а кода приведённого в правильном решении от разработчиков. Вот сам код, выложенный как правильное решение от разработчиков:

package com.javarush.task.pro.task08.task0813;
/*
Степень двойки
*/
public class Solution {

    public static void main(String[] args) {
        System.out.println(getPowerOfTwo(6));
    }

    public static int getPowerOfTwo(int power) {
        if (power >= 0) {
            return 1 << power;
        } else {
            return 1 >> -power;
        }
    }
}

Теперь повторю вопрос: Так вот я не нашёл Где в правильном решении от разработчиков строка: int result = 2; которая заложена в условии? Ее там просто нет. Почему там return 1, а не 2 << power; и где вообще в правильном решении фигурирует цифра 2, которая нам дана по условию задачи? ну и логика, для чего нам в лекции рассказывали про то, что четвёртая степень-это сдвинуть четыре бита, если к условию задачи это нельзя применить, так как два в третьей степени сдвинутая на 3 бита бита будет никак не 8, а 16? Логичнее было бы объяснение такое же как, из твоего примера из школьной программы: мы знаем, что любое число в первой степени будет само число, следовательно дальше каждое увеличение степени на 1 - просто сдвиг на одно значение влево. Т.е. 2^3 = 0010 (это два в первой степени) и сдвиг на два значения (т.е. вторая степень - это справа добавляем 0 и в третьей степени справа добавляется ещё 1 ноль, т.е. прибавилось два нуля и стало 01000). Значит возведение result в степень power будет result < (power - 1), а не сдвиг на power

Ну ты тогда уже и условие приложи ) Я то его не вижу. Почему там return 1 я описал в предыдущем сообщении, прочитай его внимательно. Равно как и почему в правильном решении не нужна цифра 2. Любое число в первой степени конечно же само это число, но почему ты забываешь что степень бывает и нулевая?) ведь если код возводит в какую-то степень он же в любую степень возводит, а не в "избранные" :) Да, в рамках этой задачи не рассматриваются отрицательные степени, это вызвано ограничением типа данных и тонкостями работы с дробями в вычислительной технике. Но возвести именно двойку в достаточно большую степень больше или равную нулю совершенно не сложно посредством битового сдвига. Это не логика, это банальная и скучная математика.

Пардон, вот условие задачи: Реализуй метод getPowerOfTwo(int power), который возвращает число 2 в степени power. Тебе нужно изменить реализацию метода getPowerOfTwo(int), используя соответствующий побитовый сдвиг. ну и дальше код, который нужно исправить:

public class Solution {

    public static void main(String[] args) {
        System.out.println(getPowerOfTwo(3));
    }

    public static int getPowerOfTwo(int power) {
        int result = 2;
        for(int i = 0; i < power - 1; i++) {
            result *= 2;
        }
    }
}

Напомню: к условию у меня вопросов или недопонимания нет. И задачу я решил

Если ты о строчке "возвращает число 2 в степени power" это не значит что тебе надо в коде где-то иметь int something = 2;

Это требуется по условию задачи. Из школьной программы мы помним, что число x в степени n равно х перемнтженное на себя n раз. Как это "не значит что тебе надо в коде где-то иметь int something = 2"? А если, к примеру, будет не 2, а функция Scanner cs = new Scanner(System.in);?

Ну вот и вспомни школьную программу. Нулевая степень любого числа чему равна?

Равна 1, Но этот пример подходит только к конкретной цифре два. Обрати внимание на решение от разработчиков:

public static int getPowerOfTwo(int power) {
    if (power >= 0) {
        return 1 << power;
    } else {
        return 1 >> -power;
    }

к твоему примеру подходит идеально, если мы берём 2 и возводим в любую степень. Но если будет не 2, а допустим 5 (0101) и power будет допустим 2... 5 во 2-й степени будет 25, в двоичной системе 11001.. или три во второй степени? да в общем любое число кроме двойки. как тут применить сдвиг?

Кажись я понял что тебя смущает :) Смотри, битовый сдвиг влево сам по себе не возводит в степень ничего, он просто умножает число на два (я об этом писал еще в первом своём ответе). Потому если речь идёт о двойке как основании просто пользуются этим свойством :) Ну т.е. двойка умноженная на двойку это ж степень двойки? а еще раз умноженная на двойку? следующая степень двойки. Потому не мудрствуя лукаво берут единицу как точку отсчёта (нулевая степень - нулевой сдвиг), и сдвигают ее влево на нужное количество разрядов.

1 << 0 = 1 (0001)
1 << 1 = 2 (0010)
1 << 2 = 4 (0100)
1 << 3 = 8 (1000)

Ну и так далее Но конечно же ни с каким основанием КРОМЕ двойки этот фокус не пройдёт.

Вот! Теперь стало понятно. Спасибо!

Однако, чтобы окончательно закрыть для себя эту тему, может быть ты объяснишь мне еще один момент из лекции, но не из задачи: почему 0b00000011 << 20 = 0b001100000000000000000000? ну, т.е. Я понимаю, что в данном случае мы сдвигаем число типа int, но где тут указано, что это именно int, а не byte, short, или long? и почему тогда: 0b11000011 >> 20 = 0b00000000, а не 0b000000000000000000001100?

Тут я тебе сильно не подскажу, очень похоже что под капотом происходит расширение типа до int (но не более). Сдвиг за пределы выделенного диапазона очевидно должен обнулять значение, если он этого не делает, значит это как-то хендлится на уровне языка. Вот можно с таким кодом поиграться:

public static void main(String[] args) {
    byte b = 0b000011;
    System.out.printf("Raw B: %d\n", b);
    System.out.printf("Shift by value stored in B: %d\n", b << 20);
    b <<= 20;
    System.out.printf("Shift result stored in B: %d\n", b);
    System.out.printf("Result of shift on literal: %d", 0b000011 << 20);
}

Как видишь, сама операция выполняется нормально, ну т.е. идет расширение до int. Если попытаться сохранить результат в byte очевидно мы потеряем информацию безвозвратно. Свыше int тип не расширяется, если ты сделаешь сдвиг на 33 бита (больше чем доступные 32, то фактически получаешь 6-ку (3 * 2, твоё искомое число один раз сдвинулось влево), можно еще поиграться и понять что сдвиг при выходе за диапазон фактически происходит по формуле N % 32 где N это требуемый сдвиг, а 32 это максимальное количество битов в типе int. Но почему именно так я тебе ответить не могу, тут скорее доки нужно читать если интересно.

Хорошо. Спасибо. В любом случае сильно выручил.

читаю весь вечер, не пойму, а почему тогда ответ 64,ведь 1<<6 дает такой результат, а в задаче сверху указано power(3).......неужели все так просто... System.out.println(getPowerOfTwo(3)); что two(3) это 6?????

Задача - написать реализацию метода, который возводит двойку в степень. Он будет возводить в любую степень, хоть в 3, хоть в 6, хоть в 20. В зависимости от того, с каким параметром его вызвать, такой результат и получишь.

Ничего не понял, но очень интересно