2 0    = 1
2 -1   = 0.5
2 -2   = 0.25
2 -3   = 0.125
2 -4   = 0.0625
2 -5   = 0.03125
2 -6   = 0.015625
2 -7   = 0.0078125
2 -8   = 0.00390625
2 -9   = 0.001953125
2 -10  = 0.0009765625
2 -11  = 0.00048828125
2 -12  = 0.000244140625
2 -13  = 0.0001220703125
2 -14  = 0.00006103515625
2 -15  = 0.000030517578125
2 -16  = 0.0000152587890625
2 -17  = 0.00000762939453125
2 -18  = 0.000003814697265625
2 -19  = 0.0000019073486328125
2 -20  = 0.00000095367431640625
2 -21  = 0.000000476837158203125
2 -22  = 0.0000002384185791015625
2 -23  = 0.00000011920928955078125
2 -24  = 0.000000059604644775390625
2 -25  = 0.0000000298023223876953125
2 -26  = 0.00000001490116119384765625
2 -27  = 0.000000007450580596923828125
2 -28  = 0.0000000037252902984619140625
2 -29  = 0.00000000186264514923095703125
2 -30  = 0.000000000931322574615478515625
2 -31  = 0.0000000004656612873077392578125
2 -32  = 0.00000000023283064365386962890625
2 -33  = 0.000000000116415321826934814453125
2 -34  = 0.0000000000582076609134674072265625
2 -35  = 0.00000000002910383045673370361328125
2 -36  = 0.000000000014551915228366851806640625
2 -37  = 0.0000000000072759576141834259033203125
2 -38  = 0.00000000000363797880709171295166015625
2 -39  = 0.000000000001818989403545856475830078125
2 -40  = 0.0000000000009094947017729282379150390625
...

#include <assert.h>
#include <string.h>

typedef unsigned char byte_t;

enum sign_t {_sign_plus = 0, _sign_minus = 1};

// мантисса (significand) содержит 53 двоичных цифры
const int _significand_len = 53; // = DBL_MANT_DIG из <float.h>

// в таком виде с числом удобно работать
struct unpacked_double_t {
  sign_t sign;
  byte_t significand[_significand_len]; // мантисса
  int exponent; // показатель
};

// double -- в формате IEEE 754 (почти на всех платформах)
unpacked_double_t unpack_double(double x) {
  // получаем битовое представление x
  unsigned long long x_bits;
  memcpy(&x_bits, &x, sizeof(double)); // уважаем strict aliasing

  unpacked_double_t result;

  // распаковываем мантиссу (кроме старшей цифры, она не хранится явно)
  for (int i = 0; i < _significand_len - 1; i++) {
    result.significand[_significand_len - 1 - i] = (x_bits >> i) & 0x1;
  }

  int biased_exponent = (x_bits >> 52) & 0x7ff; // 11 бит
  assert(biased_exponent != 2047); // бесконечности и NAN-ы (not a number) не рассматриваем
  if (biased_exponent > 0) {
    // x -- нормализованное число
    result.significand[0] = 1;
    result.exponent = biased_exponent - 1023;
  } else {
    // x -- денормализованное число (возможно, ноль)
    result.significand[0] = 0;
    result.exponent = 1 - 1023;
  }

  result.sign = static_cast<sign_t>(x_bits >> 63);

  return result;
}

int min_decimal_exponent(double x) {
  assert((0 < x) && (x <= 1));
  unpacked_double_t ux = unpack_double(x);
  // ищем последнюю единицу в мантиссе
  for (int i = _significand_len - 1; ; i--) {
    assert(i >= 0); // хотя бы одна единица должна быть, потому что число ненулевое
    if (ux.significand[i] == 1) {
      return ux.exponent - i;
    }
  }
}

int main() {
  // эти числа точно представимы типом double (в отличие от какого-нибудь 0.1)
  assert(min_decimal_exponent(1) == 0);
  assert(min_decimal_exponent(0.125) == -3); // 2**-3
  assert(min_decimal_exponent(0.1796875) == -7); // 2**-3 + 2**-5 + 2**-6 + 2**-7
  return 0;
}