C # - 1 2 4 8 16 32 64 серии - Найти индексы на основе входного числа, рекурсивная функция?

Вот итерационная версия

public static IEnumerable<int> FindIndex(int input)
{
    var power = 0;
    while (input > 0)
    {
        var digit = input % 2;
        if (digit == 1)
        {
            yield return (int)Math.Pow(2, power);
        }
        input /= 2;
        power++;
    }
}

а вот рекурсивная версия

public static void FindIndexRec(int input, int power, ICollection<int> numbers)
{
    if (input == 0)
    {
        return;
    }
    var digit = input % 2;
    if (digit == 1)
    {
        numbers.Add((int)Math.Pow(2, power));
    }
    FindIndexRec(input / 2, ++power, numbers);
}

и вы можете назвать это как

var numbers = new List<int>();
FindIndexRec(input, 0, numbers);

Вы можете использовать битовые маски. На самом деле, зачеркните это - вы должны использовать битовые маски! Почти наверняка именно так был создан код ошибки, и именно так его следует разобрать. Все остальное, скорее всего, смутит вашу аудиторию других программистов.

Я не претендую на то, чтобы представлять всех программистов, и я не претендую на то, чтобы быть хорошим, но я программист, и все остальные ответы сбили меня с толку. Это явно побитовая «проблема», так зачем запутывать?

Нет необходимости даже где-либо сохранять результат, так как его можно быстро пересчитывать каждый раз, например так:

for(int i=0;i<8;++i) {
    if((error&(1<<i))!=0 {
        // 1<<i is in the resulting list.
    }
}

Вот довольно наивное итерированное решение в псевдокоде. Попробуйте взять отсюда куда-нибудь поинтереснее. Вы можете сделать это рекурсивно, вы можете преобразовать целое число в двоичное представление и выполнить итерацию по этой строке, я думаю, есть умный способ сделать это с помощью LINQ очень лаконично и т. д.

v = inputNumber
while(v > 0):
     temp = greatest power of 2 less than v
     print temp
     v -= temp

PS - это явно не хранит рассматриваемую серию - это предполагает степени 2.

Этот будет работать с входными числами больше 256:

   int[] calculate(int input)
    {
        List<int> retVal = new List<int>();
        string output = string.Empty;
        int[] series = new int[] { 1, 2, 4, 8, 16, 32, 64, 128 };
        foreach (int i in series.Reverse<int>())
        {
            while (input >= i)
            {
                retVal.Add(i);
                input -= i;
            }
        }

        return retVal.ToArray();
    }

Пример: var результат = вычислить (284); // результат = 128, 128, 16, 8, 4

    IEnumerable<int> GetFlags(int input,IEnumerable<int> series)
    {
        foreach (int value in series)
            if ((input & value)==value)
                yield return value;
    }

Или LINQ решение проблемы.

IEnumerable<int> GetFlags(int input, IEnumerable<int> series)
{
    return series.Where(x => (x & input) == x);
}

Помимо программирования, вы также можете взглянуть на это математически. Это в основном 2 в степени (целочисленное значение) log(2, input)

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