Разрешение & ldquo; другу & rdquo; класс для доступа только некоторые частные члены

итеративная версия, которая широко использует биты

, отмечает, что array можно изменить на любой тип и установить в любом порядке, это «подсчет» цифр в заданном порядке

Для более подробного объяснения посмотрите мой первый ответ (который менее гибкий, но гораздо более быстрый) https://stackoverflow.com/a/31928246/2963099

Чтобы сделать его итеративным , необходимы массивы для сохранения состояния на каждом уровне

. Это также походило на довольно небольшую оптимизацию для мест, которые оптимизатор не мог понять

int bit_val(unsigned int v) {
  static const int MultiplyDeBruijnBitPosition2[32] = {
    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
  };
  return MultiplyDeBruijnBitPosition2[(unsigned int)(v * 0x077CB531U) >> 27];
}

void uniq_digits(const int array[], const int length) {
  unsigned int unused[length-1];                    // unused prior
  unsigned int combos[length-1];                    // digits untried
  int digit[length];                                // printable digit
  int mult[length];                                 // faster calcs
  mult[length-1]=1;                                 // start at 1
  for (int i = length-2; i >= 0; --i)
     mult[i]=mult[i+1]*10;                          // store multiplier
  unused[0]=combos[0]=((1<<(length))-1);            // set all bits 0-length
  int depth=0;                                      // start at top
  digit[0]=0;                                       // start at 0
  while(1) {
    if (combos[depth]) {                            // if bits left
      unsigned int avail=combos[depth];             // save old
      combos[depth]=avail & (avail-1);              // remove lowest bit
      unsigned int bit=avail-combos[depth];         // get lowest bit
      digit[depth+1]=digit[depth]+mult[depth]*array[bit_val(bit)]; // get associated digit
      unsigned int rest=unused[depth]&(~bit);       // all remaining
      depth++;                                      // go to next digit
      if (depth!=length-1) {                        // not at bottom
        unused[depth]=combos[depth]=rest;           // try remaining
      } else {
        show(digit[depth]+array[bit_val(rest)]);    // print it
        depth--;                                    // stay on same level
      }
    } else {
      depth--;                                      // go back up a level
      if (depth < 0)
        break;                                      // all done
    }
  }
}

. Некоторые тайминги с использованием только 1 до 9 с 1000 повторений:

• 15.00s Рекурсивный (измененный для подсчета от 1 до 9) из https://stackoverflow.com/a/31828305/2963099
• реверсия подкачки 3.53s из https://stackoverflow.com/a/31830671/2963099
• 2.74s nextПервая версия ( https: // stackoverflow ./ / 31885811/2963099 )
• 2.34s Это решение
• 1.66s развернутая рекурсивная версия в EDIT из https://stackoverflow.com/ а / 319 28246/2963099