Задача состоит в том, чтобы сгенерировать все строки от 'a' до '999', включая символы в верхнем регистре, например:

'a', 'b', 'c' ... 'y', 'z', 'A', 'B', 'C' ... 'Y', 'Z', '0', '1', 2' ... 
'8', '9', 'aa', 'ab', 'ac' ... 'az', 'aA', 'aB' ... 'aZ', 'a0' ... 'a9', 'ba'

и так далее (заполнение пробелов), необязательно начиная с пустой строки.

Входные данные:

• Количество последовательных символов, которое программа должна распечатать до.

Выход:

• Массив, содержащий каждую строку ИЛИ одну строку на строку

Разъяснения:

• Порядок не имеет значения, вы можете сначала печатать заглавные или строчные буквы, если хотите.

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

• Ввод 3будет выводить всю строку из 'a'(или '') в '999'‚ввод 5до '99999'и так далее.

Желе , 7 байт

ØWṖṗR;/

Это монадическая ссылка, которая принимает целое число в качестве входных данных и возвращает массив строк.

Попробуйте онлайн!

Как это устроено

ØWṖṗR;/  Main link. Argument: n

ØW       Yield 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_'.
  Ṗ      Remove the last element (underscore).
    R    Range; yield [1, ..., n].
   ṗ     Cartesian product. For each k in the range, this yields the arrays of all
         strings of alphanumeric characters.
     ;/  Concatenate the arrays of strings of each length.

Haskell, 65 байт

a#b=[a..b]
k n=mapM id.('a'#'z'++'A'#'Z'++'0'#'9'<$)=<<(1#)<$>1#n

Пример использования: k 3-> ["a","b","c",....,"997","998","999"].

Как это устроено

a#b = [a..b]        -- helper function that builds a list from a to b


        (1#n)<$>    -- map the function (1#), i.e. "build the list from 1 up to" 
                1#n -- on the list from 1 to n

                    -- now we have [[1],[1,2],[1,2,3]]

              =<<   -- map over this list (and combine results in a single list)
  (        <$)      -- a function that makes length of input copies of
 'a'#'z'++ ... '9'  -- all characters we need

                    -- now we have [["a..9"],["a..9","a..9"],["a..9","a..9","a..9"]]

mapM id.            -- and make the cartesian product of each sublist 

Python, 86 байт

f=lambda n:n*[1]and[x+chr(y)for x in['']+f(n-1)for y in range(128)if chr(y).isalnum()]

Выводит список непустых строк. Рекурсивно добавляет каждый алфавитно-цифровой символ к каждому выводу n-1и пустой строке.

JavaScript (Firefox 30-57), 108 байт

f=n=>n?[for(s of['',...f(n-1)])for(c of(t='abcdefghijklmnopqrstuvwxyz')+t.toUpperCase()+'0123456789')s+c]:[]

Сохранено 3 байта с помощью toUpperCase. Вычисление 62 символов отнимает у меня дополнительные 10 байтов.

Корица, 15 байтов

0000000: 689b b718 05be a345 9c4b c283 d077 de    h......E.K...w.

Недостаточно коротко, несмотря на то, что это было именно то, для чего была создана Cinnamon Gum :(

Сжатие путем преобразования из биективной базы 96 в базу 256. Попробуйте онлайн. Входы больше 2 вызовут проблемы на TIO.

объяснение

Это распаковывает в регулярное выражение [a-zA-Z0-9]{1,%s}. Затем hрежим подставляет входные данные в %sи выводит все строки, соответствующие регулярному выражению.

Рубин, 82 байта

Создает декартовы произведения из символов, заданных до заданной длины. Набор символов генерируется путем захвата всех символов между 0и zи отфильтровывая несловарные символы, а также _.

->n{a=(?0..?z).grep(/\w/)-[?_];r=[]
n.times{|i|r+=a.product(*[a]*i).map &:join};r}

05AB1E , 9 8 байт

Код:

ƒžj¨Nã€,

Объяснение:

ƒ          # For N in range(0, input + 1), do:
 žj        #   Push predefined literal [a-zA-Z0-9_]
   ¨       #   Remove the last character (the underscore)
    N      #   Push N
     ã     #   Take the Cartesian product, with N repetitions.
      €,   #   For each element in the array, print with a newline

Использует кодировку CP-1252 . Попробуйте онлайн! ,

Python 2,7, 136 134 байта

Спасибо Maltysen и NonlinearFruit за сохранение 2 байтов

from itertools import*;from string import*;f=lambda n:[''.join(a) for i in range(1,n+1) for a in product(ascii_letters+digits,repeat=i)]

Берет ascii_lettersи digitsиз строкового модуля и использует декартово произведение как productиз itertools для вычисления всех комбинаций.

Выход

out = f(3)

print out[:10]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

print out[100:110]
['aM', 'aN', 'aO', 'aP', 'aQ', 'aR', 'aS', 'aT', 'aU', 'aV']

print out[-10:]
['990', '991', '992', '993', '994', '995', '996', '997', '998', '999']

Pyth - 13 12 байт

1 байт сохранен благодаря @Jakube.

sm^s+rBG1UTh

Попробуйте это онлайн здесь .

s                    Add up the lists of different lengths  
 m          (Q)      Map implicitly over input
  ^     h(d)         Cartesian product of string to implicit lambda var + 1
   s                 Add up list
    ++               Concat up three things
     G               Alphabet
     rG1             Uppercase alphabet
     UT              All digits

Python 2, 106 97 байт

from string import*
f=lambda n,r=['']:n and r+f(n-1,[x+y for x in r for y in letters+digits])or r

Попробуйте это на Ideone .

MATL , 12 байт

:"3Y24Y2h@Z^

Это принимает число в качестве ввода.

Попробуйте онлайн!

объяснение

:       % Implicitly take input, say N. Generate range [1 2... N]
"       % For each number in that range
  3Y2   %   Predefined literal: string with all letters, uppercase and lowercase
  4Y2   %   Predefined literal: string with all digits
  h     %   Concatenate horizontally
  @     %   Push number of characters corresponding to current iteration
  Z^    %   Cartesian power. Each result is a row 
        % End for each. Implicitly display

𝔼𝕊𝕄𝕚𝕟 21 символ / 27 байт

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)ė)

Try it here (Firefox only).

Нет. Нет. Нет.

объяснение

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)ė) // implicit: 
Ⓐïⓜ                    // [...Array(input)].map(($,_)=>...)
    ᵖ                   // push to stack:
     ɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)   // list of n-digit numbers in [a-zA-Z0-9]-ary
                     ė) // formatted into a matrix (no spaces)
                        // implicit stack output, newline-separated

Perl, 113 байт + пробел

@r="";
for (1..shift) {
  @r = sub {
    map { $c=$_; map $c.$_, @{$_[1]} } @{$_[0]}
  }->(\@r, [0..9, "a".."z", "A".."Z"])
}
map say($_), @r

Используйте "perl -E" в приведенном выше аргументе с числом. Вероятно, я мог бы прилично не сосчитать последнее "карта сказать" в подсчете символов.

J, 50 байт

62&(('0123456789',~(,toupper)u:97+i.26){~#~#:i.@^)

Половина байтов, а точнее 25, тратится на генерацию необходимых букв и цифр.

APL, 38 37 байт

{⊃{⍵,,⍺∘.,⍵}/⍵⍴⊂,¨⎕a,⎕d,⍨⎕ucs 96+⍳26}

Утилиты Bash + GNU, 90

printf -vs %$1s
eval printf '%s\\n' ${s// /{=,{a..z\},{A..Z\},{0..9\}\}}|sed s/^=*//\;/=/d

Ввод как параметр командной строки. Выход - это список, разделенный пробелами.

Работает на входах upt и в том числе 3. Недостаточно памяти с 4-мя - eval printfзанимает весь набор 63 ^н. элементов расширения bash.

Утилиты Bash + GNU, 66

Другой (и я думаю, немного новый) подход к моему другому ответу :

dc -e"64 $1^[d2 48^r-P1-d0<m]dsmx"|base64 -w8|sed s_^/*__\;/[+/]/d

• dcотсчитывает от 2 ⁴⁸ -1 до 2 ⁴⁸ -64 ⁿ и Pпечатает каждое результирующее число как поток байтов (т. е. основание 256). Если ввод от 1 до 4 включительно, это гарантированно будет ровно 6 байтов на число.
• base64 преобразует это в вывод base64 и, таким образом, 8 байтов на цифру base64, по одному на строку.
• sedудаляет /начальные символы (цифра 63 из base64), а затем удаляет все строки, содержащие +или /(цифры 62 и 63 из base64). Это оставляет необходимую последовательность.

R , 73 байта

y='';x=c(letters,LETTERS,0:9);for(i in 1:scan())cat(y<-outer(y,x,paste0))

yначинается как пустая строка, xкак базовый вариант 'a','b','c',...,'8','9'. outerпринимает каждый из его входных аргументов, и применяет функцию paste0к каждой комбинации элементов yи xконкатенации строк. yсохраняет результат, catпечатает его, и это повторяет STDIN количество раз, делающих это.

Попробуйте онлайн!

Jq 1,5 , 97 байт

range(.)as$n|[[range(97;123),range(65;91),range(48;58)]|implode/""|combinations($n+1)]|map(add)[]

расширенный

  range(.) as $n           # for each n-digit sequence
| [
      [                    # build array of ordinals for
        range(97;123),     #   a-z
        range(65;91),      #   A-Z
        range(48;58)       #   0-9
      ]
    | implode/""           # make into array of strings
    | combinations($n+1)   # generate array of n-element combinations
  ]
| map(add)[]               # convert to sequence of strings

Попробуйте онлайн!