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

переменные:
КоличествоБарабанов - это количество барабанов на замке
МаксимальноеЗначение - это максмальное значение барабана
минимальное значение - это минимальное значение барабана

Надо через обработку вывести все возможные комбинации

не могу никак сообразить как написать правильно код!
Спасибо всем и не судите строго!

(75) Вот тут не понял:  

Для Инд = Мин По Макс Цикл
        Сообщить(Инд);
    КонецЦикла;

Допустим, максимум цифра 7, минимум 3.  Как будет работать алгоритм?

(81) -1 это барабанов столько или цифра на барабане?

(83) Прим. минимум = -2 максимальное = 2

(81) +

(75) Для Инд = Мин По Макс Цикл
        Сообщить(Инд);
    КонецЦикла;

он начинает перебирать абсолютно все цифры подряд
а надо в пределах
значений барабана

(84) можно конечно доработать, но интереса уже нет, да и подход наверно должен быть другой

(86) да точно, в топку решение

я тоже не сдал

Для положительных целых:
&НаКлиенте
Функция ПечатьКомбинации(МассивРазрядов)
    //печать новой комбинации
    ТекущаяКомбинация = "";
    Для Каждого Разряд Из МассивРазрядов Цикл
        ТекущаяКомбинация = Формат(Разряд, "ЧН=") + ТекущаяКомбинация;
    КонецЦикла;
    Сообщить(ТекущаяКомбинация);
КонецФункции

&НаКлиенте
Процедура Команда1(Команда)
    
    МинЦифра = 3;
    МаксЦифра = 7;
    КоличествоРазрядов = 3;
    
    // инициализация и печать первой комбинации
    МассивРазрядов = Новый Массив;
    Для НомерРазряда = 1 По КоличествоРазрядов Цикл
        МассивРазрядов.Добавить(МинЦифра);
    КонецЦикла;
    ПечатьКомбинации(МассивРазрядов);
    
    ПереборОкончен = Ложь;
    Пока НЕ ПереборОкончен Цикл
        // получение новой комбинации
        Для ИндексРазряда = 0 По КоличествоРазрядов - 1 Цикл
            МассивРазрядов[ИндексРазряда] = МассивРазрядов[ИндексРазряда] + 1;
            Если МассивРазрядов[ИндексРазряда] > МаксЦифра Тогда
                Если ИндексРазряда = КоличествоРазрядов - 1 Тогда
                    ПереборОкончен = Истина;
                    Прервать;
                Иначе
                    МассивРазрядов[ИндексРазряда] = МинЦифра;
                КонецЕсли;
            Иначе
                Прервать;
            КонецЕсли;
        КонецЦикла;
        // печать новой комбинации
        Если НЕ ПереборОкончен Тогда
            ПечатьКомбинации(МассивРазрядов);
        КонецЕсли;
    КонецЦикла;
    
КонецПроцедуры

Одноразрядных. Но легко доработать для многоразрядных.

хорошо что не перестановки попросилил.там то код существенно посложнее


&НаКлиенте
Процедура КрутимБарабаны(Команда)
    КоличествоБарабанов = 3;
    МаксимальноеЗначение = 7;
    МинимальноеЗначение = 3;
    
    Основание = МаксимальноеЗначение-МинимальноеЗначение+1;
    КоличествоВариантов = Pow(Основание, КоличествоБарабанов);
    Для НомерВарианта = 0 По КоличествоВариантов-1 Цикл
        тЗначение = НомерВарианта;
        тРезультат = "";
        Пока тЗначение > 0 Цикл
            тРезультат = ""+((тЗначение%Основание)+МинимальноеЗначение) + " " + тРезультат;
            тЗначение = Цел(тЗначение/Основание);
        КонецЦикла;
        
        ЧислоРазрядов = СтрЧислоВхождений(тРезультат," ");
        ДобавитьСправа = КоличествоБарабанов-ЧислоРазрядов;
        Для Сч = 1 По ДобавитьСправа Цикл
            тРезультат = тРезультат+МинимальноеЗначение+" ";
        КонецЦикла;
        
        Сообщить(""+тРезультат);
    КонецЦикла;
    
КонецПроцедуры


Плиз потестите мое (93) на скорость в сравнении с другими

(93) Выглядит рабочим. И не знаю как там скорость, но явно симпатичнее моего. Плюсую :)

(95) Основано на системе счисления по произвольному основанию.

Только подстановку "0" впереди (тут получилось позади) сделал слегка криво уже потом.
Надо бы вставить в сам алгоритм и будет короче.

(96) У меня тоже. Но у тебя красивее код. Но недоработано. Как минимум, много лишнего выводит.

(96) Недопилено. Проверь на
    КоличествоБарабанов = 2;
    МаксимальноеЗначение = 4;
    МинимальноеЗначение = 3;

(98) Ага не с той стороны вставляет "0"

&НаКлиенте
Процедура КрутимБарабаны(Команда)
    КоличествоБарабанов = 3;
    МаксимальноеЗначение = 4;
    МинимальноеЗначение = 3;
    
    Основание = МаксимальноеЗначение-МинимальноеЗначение+1;
    КоличествоВариантов = Pow(Основание, КоличествоБарабанов);
    Сообщить("Количество вариантов: "+КоличествоВариантов);
    
    Для НомерВарианта = 0 По КоличествоВариантов-1 Цикл
        тЗначение = НомерВарианта;
        тРезультат = "";
        Пока тЗначение > 0 Цикл
            тРезультат = ""+((тЗначение%Основание)+МинимальноеЗначение) + " " + тРезультат;
            тЗначение = Цел(тЗначение/Основание);
        КонецЦикла;
        
        ЧислоРазрядов = СтрЧислоВхождений(тРезультат," ");
        ДобавитьСправа = КоличествоБарабанов-ЧислоРазрядов;
        Для Сч = 1 По ДобавитьСправа Цикл
            тРезультат = ""+МинимальноеЗначение+" "+тРезультат;
        КонецЦикла;
        
        Сообщить(""+тРезультат);
    КонецЦикла;
    
КонецПроцедуры

Перечитал задание в (0).
Я правильно понимаю. Есть некий замок (строение), которое строят из неких барабанов (кирпичей). Кирпичей очень много, но они имеют нумерацию от минимального до максимального значения. Необходимо показать все варианты как могут лежать эти номера кирпичей при строительстве здания.
т.е. бесконечное количество кирпичей с номером 1, бесконечное количество кирпичей с номером 2 и т.д.

Если номер кирпичей может быть только с номером 1, то у нас получается один вариант, при любой размерности строения.
Если здание состоит из 2-х кирпичей и номера бывают только 1 и 2, то получается 4-ре варианта (11,12,21,22).
Если здание состоит из 3-х кирпичей и номера бывают только 1, 2 и 3, то получается 9-ть вариантов (111,112,113,121,122, .... 333).
Так?

три в степени три 27 вариантов - описался....

(101) Как это ни странно но твоя трактовка тоже верна и имеет тоже решение что и с замком (устройство)

(100) Красота нечеловеческая :) Про основание я думал, но плясать от количества вариантов не догадался.

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

может проще субд скормить и она сама все варики сгенерит

жесткая тема) вроде и не пятница ))

(0)да вариантов море: рекурсия, вложененые циклы, запросом (каждый последующий способ из предложенных лучше предыдущего)

можно еще арендовать нейросеть и обучить ее по быстрому на куче вариантов )

(109) это будет хуже, дольше и более ресурсоемко чем  рекурсии

(105) Этот подход я реализовал (90). Но в (100) более интересная и лаконичная реализация.
(110) А предложи свой вариант на рекурсии. Я попробовал, прикинул что красиво не получается и плюнул.

(111)
а рекурсия красивая только для факториала и т.п.

или через 2 вложеных цикла придётся делать на каждом начиная со второго шага рекурсии или ненормальная вложенность...

ВЫБРАТЬ
    "1" КАК В1
ПОМЕСТИТЬ ВТ_1

ОБЪЕДИНИТЬ ВСЕ

ВЫБРАТЬ
    "2"

ОБЪЕДИНИТЬ ВСЕ

ВЫБРАТЬ
    "3"
;

////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ
    "1" КАК В1
ПОМЕСТИТЬ ВТ_2

ОБЪЕДИНИТЬ ВСЕ

ВЫБРАТЬ
    "2"

ОБЪЕДИНИТЬ ВСЕ

ВЫБРАТЬ
    "3"
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ
    "1" КАК В1
ПОМЕСТИТЬ ВТ_3

ОБЪЕДИНИТЬ ВСЕ

ВЫБРАТЬ
    "2"

ОБЪЕДИНИТЬ ВСЕ

ВЫБРАТЬ
    "3"
;

////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ
ВТ_1.В1+ВТ_2.В1+ВТ_3.В1 как Комбинация
ИЗ
    ВТ_1 КАК ВТ_1,
    ВТ_2 КАК ВТ_2,
    ВТ_3 КАК ВТ_3

пойдет так?

(113) шоита? Давно запрос может конкатенацию?

Точно работает )

Процедура КрутимБарабаны(Количество, Минимум, Максимум)
    СтрокаПолей = "";
    СтрокаТаблиц = "";

    Для к = 1 По Количество Цикл
        СтрокаПолей = СтрокаПолей + "+Т" + Строка(к) + ".З";
        
        СтрокаТаблицы = "
        |    (";
        Для ч = Минимум По Максимум Цикл
            СтрокаТаблицы = СтрокаТаблицы + "
            |    ВЫБРАТЬ """ + Строка(ч) + """ КАК З" + ?(ч < Максимум, "
            |    ОБЪЕДИНИТЬ ВСЕ ", "");
        КонецЦикла;
        СтрокаТаблицы = СтрокаТаблицы + "    ) КАК Т" + Строка(к);
        
        СтрокаТаблиц = СтрокаТаблиц + "," + СтрокаТаблицы;
    КонецЦикла;

    Запрос = Новый Запрос;
    Запрос.Текст = "ВЫБРАТЬ " + Сред(СтрокаПолей, 2) + " КАК З ИЗ " + Сред(СтрокаТаблиц, 2);
    Выборка = Запрос.Выполнить().Выбрать();
    Пока Выборка.Следующий() Цикл
        Сообщить(Выборка.З);
    КонецЦикла;
КонецПроцедуры

(114) проверьте в консоли запросов, работает?

(116) да

(115) Ну или так

    Запрос = Новый Запрос;
    Запрос.МенеджерВременныхТаблиц = Новый МенеджерВременныхТаблиц;
    Запрос.УстановитьПараметр("МинНомер",    МинНомер);
    Запрос.УстановитьПараметр("МаксНомер",    МаксНомер);
    Запрос.Текст = "ВЫБРАТЬ
                   |    0 КАК А
                   |ПОМЕСТИТЬ ВТ_Три
                   |
                   |ОБЪЕДИНИТЬ ВСЕ
                   |
                   |ВЫБРАТЬ
                   |    1
                   |
                   |ОБЪЕДИНИТЬ ВСЕ
                   |
                   |ВЫБРАТЬ
                   |    2
                   |
                   |ОБЪЕДИНИТЬ ВСЕ
                   |
                   |ВЫБРАТЬ
                   |    3
                   |;
                   |
                   |////////////////////////////////////////////////////////////////////////////////
                   |ВЫБРАТЬ РАЗЛИЧНЫЕ ПЕРВЫЕ 11
                   |    3 * ВТ_Три.А + ВТ_Три1.А КАК А
                   |ПОМЕСТИТЬ ВТ_Десять
                   |ИЗ
                   |    ВТ_Три КАК ВТ_Три,
                   |    ВТ_Три КАК ВТ_Три1
                   |
                   |УПОРЯДОЧИТЬ ПО
                   |    А
                   |;
                   |
                   |////////////////////////////////////////////////////////////////////////////////
                   |УНИЧТОЖИТЬ ВТ_Три
                   |;
                   |
                   |////////////////////////////////////////////////////////////////////////////////
                   |ВЫБРАТЬ РАЗЛИЧНЫЕ ПЕРВЫЕ 1001
                   |    100 * ВТ_Десять.А + 10 * ВТ_Десять1.А + ВТ_Десять2.А КАК А
                   |ПОМЕСТИТЬ ВТ_Тысяча
                   |ИЗ
                   |    ВТ_Десять КАК ВТ_Десять,
                   |    ВТ_Десять КАК ВТ_Десять1,
                   |    ВТ_Десять КАК ВТ_Десять2
                   |
                   |УПОРЯДОЧИТЬ ПО
                   |    А
                   |;
                   |
                   |////////////////////////////////////////////////////////////////////////////////
                   |УНИЧТОЖИТЬ ВТ_Десять
                   |;
                   |
                   |////////////////////////////////////////////////////////////////////////////////
                   |ВЫБРАТЬ
                   |    ВТ_Тысяча.А КАК А
                   |ПОМЕСТИТЬ ВТ_Номера
                   |ИЗ
                   |    ВТ_Тысяча КАК ВТ_Тысяча
                   |ГДЕ
                   |    ВТ_Тысяча.А МЕЖДУ &МинНомер И &МаксНомер
                   |;
                   |
                   |////////////////////////////////////////////////////////////////////////////////
                   |УНИЧТОЖИТЬ ВТ_Тысяча";
    Запрос.Выполнить();
    
    ТекстВЫБРАТЬ    = "ВЫБРАТЬ
                   |    ВТ_Позиция1.А КАК Позиция1";
    
    ТекстИЗ            = "
                   |ИЗ
                   |    ВТ_Номера КАК ВТ_Позиция1";
    
    ТекстУПОРЯДОЧИТЬ= "
                   |УПОРЯДОЧИТЬ ПО
                   |    Позиция1";
    
    Для А=2 По КоличествоПозиций Цикл
        
        ТекстВЫБРАТЬ = ТекстВЫБРАТЬ + "
                   |    ,ВТ_Позиция"+ А +".А КАК Позиция"+А;
        
        ТекстИЗ        = ТекстИЗ + "
                   |    ,ВТ_Номера КАК ВТ_Позиция"+ А;
        
        ТекстУПОРЯДОЧИТЬ    = ТекстУПОРЯДОЧИТЬ + "
                   |    ,Позиция" +А;
        
    КонецЦикла;
    
    Запрос.Текст = ТекстВЫБРАТЬ + ТекстИЗ + ТекстУПОРЯДОЧИТЬ;
    ВыборкаЗапроса = Запрос.Выполнить().Выбрать();
    Пока ВыборкаЗапроса.Следующий() Цикл
        
        Текст = ""+ ВыборкаЗапроса.Позиция1;
        
        Для А=2 По КоличествоПозиций Цикл
            Текст = Текст + Символы.Таб + ВыборкаЗапроса["Позиция"+А];
        КонецЦикла;
        
        Сообщить(Текст);
        
    КонецЦикла;

В (118) ограничение, что не более 1001 позиций на барабане (от 0 до 1000).

(115,118) Как вариант, конечно.
Но лично меня всегда коробит, когда банальную алгоритмистику на готовых данных в оперативке заменяют работой с СУБД.
Даже когда это приемлемо на практике, это же все равно явный оверкилл плюс будет иметь больше ограничений для возможного рефакторинга в будущем.
Ну и использование инструментов не совсем по назначению. Это как вместо шуруповерта использовать перфоратор с переходником. Можно, но зачем??

(120) "для возможного рефакторинга в будущем" - в данном случае нет рефакторинга в будущем, так как нет будущего. Рекурсивные сложные алгоритмы всегда сложно сопровождать и поддерживать.
Лучше проще да лучше. СУБД Сгенерирует варианты банально быстрее чем алгоритм 1С. Мы же на 1С пишем, поэтому лучше СУБД.

Рекурсия тоже не сложная. Памяти не занимает, из вычислений только сравнения и +1.
Сравнил со (100) - работает на 20% быстрее.

&НаКлиенте
Процедура КрутимБарабаны(Команда)
    
    СтруктураОграничений = Новый Структура(
        "КоличествоБарабанов,МинимальноеЗначение,МаксимальноеЗначение",
        5, 2, 6);
        
    Если СтруктураОграничений.КоличествоБарабанов = 0 Тогда
        Возврат;
    КонецЕсли;
    
    СтрКомбинация = "";
    КрутимБарабан(1, СтрКомбинация, СтруктураОграничений);
    
КонецПроцедуры

&НаКлиенте
Процедура КрутимБарабан(НомерБарабана, СтрКомбинация, СтруктураОграничений)

    ОбработкаПрерыванияПользователя();
    
    Для Номер = СтруктураОграничений.МинимальноеЗначение По СтруктураОграничений.МаксимальноеЗначение Цикл
    
        Если НомерБарабана = СтруктураОграничений.КоличествоБарабанов Тогда
        
            Сообщить(СтрКомбинация+"-"+Номер);
        
        Иначе
        
            КрутимБарабан(НомерБарабана+1, СтрКомбинация+"-"+Номер, СтруктураОграничений);
        
        КонецЕсли;
    
    КонецЦикла;

КонецПроцедуры

(121) "СУБД Сгенерирует варианты банально быстрее чем алгоритм 1С"
Ну, твой вариант на 100000 комбинаций работает не быстрее, чем вариант в (100). Мой в (90) без оптимизаций в полтора раза медленнее за счет формата и иже с ним. Интерпретатор 1С - такой интерпретатор. Но и накладные расходы при работе с СУБД не стоит недооценивать (тестил на продуктовой конфигурации MSSQL). Плюс лишний серверный вызов.

(122) На 100000 комбинаций у меня получилось в разы быстрее, а не на 20% (во всех тестах я отключаю Сообщить).
Приветствуем победителя с самым красивым и быстрым решением :)

(122) Не даже не так по скорости. Сообщить очень сильно мешает. Если отключить Сообщить и взять пример на 100 тыс комбинаций, то рекурсия будет 2,79 против 10,47 в (100).

(125) На моих замерах выигрыш даже больше. Примерно в пять раз.

Ну и понятно почему. Вычисления проще, вычислений меньше.

Реально самый простой и быстрый вариант. Странно, почему я не допер, ведь прикидывал как на рекурсии сделать. Старею.
Но в (100) - самый интересный.

(125) У меня в консоле вариант из (118) на 100 000 выполняется менее секунды.

К (129) т.е. если взять готовый текст запроса и в консоле (пять барабанов по 10 состояний (от 0 до 9)) и его выполнить, то в результате получите 100 000 записей и время выполнения 0:00:00. Редко секунда. Т.е. выполнение сколько-то времени занимает, но это менее секунды.

я в запрос тз кидаю, у меня получается 1 - 1.5 сек с учетом что сервак на другой тачке развернут т.е. с накладными генерация тз + запрос + резалт, в тз диапазон чисел барабана

(131) Что в ТЗ?

числа одного барабана

(131) "в тз диапазон чисел барабана" - Проще не кидать в ТЗ. Порождающий запрос тебе все сам создаст. Передай параметры 0 и 9.

(134) ну да, забавно с порождающим, только кода много, через тз там в пять строчек все вместе с текстом запроса

(129) Ну а у меня твой вариант (с отключенным "сообщить" на 100000) в продакшн-инфраструктуре с MSSQL на выделенном сервере выполняется порядка 7 секунд, в то время как вариант (122) - менее одной.
Ты можешь, конечно, сказать, что у меня проблема в инфраструктуре, настройках серверов и т.п. включая кривые руки.
Только вот прелесть в том, что (122) вообще от этого не зависит и может выполняться хоть на клиенте.

(128) Вариант из (100) много секунд. Сообщить убрал.
Вариант не может быть оптимальным, так как в нем присутствуют не простые арифметические операции деления. Сложение -  несколько тактов процессора, умножение и деление несколько десятков тактов процессора.

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

запись байта в память - 2 такта
запись 2 байтов       - 4 такта
запись 4 байтов       - 8 тактов
цикл int (long)       - 6 тактов
int ADD, SUB, MUL     - 6-7 тактов
int DIV               - 235-245 тактов

(130) Да, второй запрос вместе с Выбрать() из (118) действительно выполняется за 0,92 сек. но весь алгоритм за 14,86. Самое долгое
Текст = ""+ ВыборкаЗапроса.Позиция1;
Текст = Текст + Символы.Таб + ВыборкаЗапроса["Позиция"+А];
только они дают 9,28 сек. и 62,4%.

(138) 1С всегда со строками работало медленно. + преобразование типов из числа в строку при выводе.

(137) Самым простым и быстрым я назвал вариант (122). А варианту (100) приз за интересность.

(140) Если не подготавливать данные к выводу в сообщить, а результат в ТЗ и показать, то какой результат будет быстрее? :-)

(141) Не твой. Этап подготовки к выводу присутствует во всех вариантах.

(142) В (138) "0,92 сек". В консоле показывает результат моментально. Это на порядок быстрее чем 10 секунд и более.

Запустил у себя алгоритм из 100. Получил около 5 секунд без вывода результата. Это без формирования результата в ТЗ.

В SQL нужно ещё кэш чистить, иначе неправильный результат получишь.

(145) Перед каждым выполнением параметры меняю. Если не менять, то секунду не получу - всегда 0:00:00 получается.

К (146) А если меняю, то иногда получаю 0:00:01. Но менее 50%.

(144) Еще раз. Самый быстрый - вариант в (122) а не в (100).
Но да - если отключить в твоем варианте вообще любую обработку результата (оставить только обход выборки), то получается чуть быстрее чем (122).
А если заменить обход выгрузкой в ТЗ, то чуть медленнее.
(146) А ты прекрати с консолью сравнивать. Еще небось и на файловой.

А когда сравниваете результаты учитываете универсальность алгоритма?

Например если на барабанах (каждом в отдельности) числа от 1 до 999999999999999 что будет?

имхо, оптимально тут через рекурсию.
через систему счисления - будет частный вариант для  единого множества цифр на каждом "барабане" из [0...N]
Через циклы - переписывать под измненнение количества "барабанов"
рекурсией - можно для произвольного множества на каждом шаге, и произвольной глубины...

зы "мы у федоровой бани в барабаны барабаним. выбегают мужики - барабанят в тазики!"©

(149) Я описал данное ограничение. Но можно и порождающий запрос тоже написать динамическим. На миллион записей тоже не долго генерируется результат.
(148) Нет SQL. На файловой думаю не будет быстрее.

А ТС между тем пропал. :)
Закончился его экзамен?

(151) У меня порождающий запрос генерирует 1 000 000 за 20 секунд. Теперь этот 1 000 000 вариантов на барабаны можно умножить и получить какой-то результат. В алгоритме боюсь я устану ждать, поэтому даже запускать не буду.
Если результат надо в ТЗ запихивать, то объем требуемой памяти будет примерно одинаковый. А время выполнения очень разное.

(152) А куда он хоть его сдавал? Внутренний?

(154) в поликлинику...

(151) Ну, фиг его знает.
У меня (122) вместе с подготовкой результата выполняется 1300мс - 1400мс
Твое решение с подготовкой результата - 6800мс - 7500мс
Твое решение без подготовки вообще с голым обходом выборки 400мс - 800мс
Твое решение без подготовки с выгрузкой в ТЗ 700мс - 900мс
Это на 100000 комбинаций
Соглашусь, что если нужна именно ТЗ в таком виде, то в чудесном мире 1С твой вариант будет быстрее.

Но быстрее чисто за счет того, что пакетное "запихивание" результата запроса в ТЗ - готовая библиотечная функция.
Если убрать из (122) строковые операции, то выполнение порядка 600мс, что то же самое, что и с обходом твоей выборки.
Т.е. при "ручном" заполнении коллекции время было бы одинаковым.

Хотя лукавлю. В (122) потребовалось бы несколько больше операций.

(158) Взгляните на задачу по другому. Я специально выше привел пример с количеством тактов на выполнение той или иной операции.
В конечном варианте выполняет всё конечная железка, поэтому зависит какое ПО какие алгоритмы использует и собственно какое мы ПО используем. Если алгоритм из 122 или 100 написать на С++ и вызвать только функцию, то можно и быстрее чем SQL, так как SQL по сути тоже скорее всего написан на С++, но он универсальный, а не под конкретную задачу.
Вывод: важно какой алгоритм использует SQL для генерации и работы со множеством в рамках конкретной задачи и на сколько он оптимальный. И что можно предложить более оптимальное под конкретную задачу. Если не чего, то и гадать не чего.
В алгоритме (100) я вижу операции деления в цикле. Возведение в степень - правда один раз. Это не быстрые операции на ассемблере и можно обойтись без них. Алгоритм может и красивый, но не оптимальный по скорости 100%.

(159) там по факту перевод числа из одной разрядности в другую.
Массв-счетчик - будет гораздо проще

(159) (160) Угу я стремился избавиться от лишних массивов и переменных, сократить использование памяти.

Можно тоже самое реализовать на одном массиве где будет по разрядам числа менять как нуна, прибавляя по 1 в требуемой системе счисления.

(161)+ Алгоритм довольно простой для реализации (двоичная для N-ичной все тоже самое):
000

0+1=
001

1+1=0 и 1 в старший разряд
010

0+1=
011
...

(161) так а если это не "система счисления"? т.е. разрядность каждого разряда-своя? (с заполнением каждого разряда просто - там таблица соответсвий для каждого)

(160) Да что ж такое-то. Четвертый раз повторяю что да - алгоритм в (100) неоптимальный. Но интересный. Оптимальный - в (122).
На любом компилируемом языке он отработает заведомо быстрее, чем с обращением к СУБД.

Упс. (164) было к (159)

(164) алгоритм с рекурсией ты называешь оптимальным?

(166) А чем тебе не нравится рекурсия? Имхо, для таких задач она оптимальна.

(0) Фигня какая.
//Начальные значения
Разбег = МаксимальноеЗначение - МинимальноеЗначение +1;
Добавка = МинимальноеЗначение;
ВерхняяГраница=1;
Для Сч=1 По КоличествоБарабанов Цикл
ВерхняяГраница=ВерхняяГраница*Разбег;
КонецЦикла;

//Сам цикл
Для Сч=1 По ВерхняяГраница Цикл
Стрк="";
ТекЗначение=Сч;
Для Сч2=1 По КоличествоБарабанов Цикл
Цифра=ТекЗначение%Разбег;
Стрк=Симв(48+Цифра+Добавка)+Стрк;
ТекЗначение = ТекЗначение/Разбег;
КонецЦикла;
Сообщить(Стрк);
КонецЦикла;

(166) смотря по какому критерию.
но на мой взгляд, она оптимальна тут и для написания, и для выполнения...

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

(168) По сути ты повторил мой (100)

(163) В задаче ТС разрядность барабанов одинакова, если же разная то просто придется еще пару массивов хранить для каждого барабана мин и макс, суть та же

первый барабан цифры: min1...max1
...
n-ный барабан: minn...maxn
min_number:min1min2...minn
max_number: max1max2...maxn
принимаем шаг=1, тогда
for(i = min_number; i<= max_number; i++)
printf(i)

(171) Угуг, все 150 сообщений перечитывать из-за такой мелочной задачи было скучно...

(171)+ Но более грамотно, хотя и менее красиво, у меня изначально была отдельная функция перевода из десятичной системы в любую по нужному основанию.

(168) Суть таже, что и в (100).

(174) мы это поняли... :-)

(172) один массив для каждого барабана. но приведением к системе счисления уже не получится. остаются либо циклы, либо рекурсия

(178) хотя вру, можно прореживать результат для "системы счисления". но все равно, алгорим будет не факт, что быстрее (прореживание сожрет часть времени) - зато менее читаемый.

А через запрос слабо ?))

(180) легко http://oracleplsql.ru/mysql-function-conv.html