Виклик:

Тут ми маємо перші 100 елементів послідовності:

6,5,4,3,2,1,66,65,64,63,62,61,56,55,54,53,52,51,46,45,44,43,42,41,36,35,34,33,32,31,26,25,24,23,22,21,16,15,14,13,12,11,666,665,664,663,662,661,656,655,654,653,652,651,646,645,644,643,642,641,636,635,634,633,632,631,626,625,624,623,622,621,616,615,614,613,612,611,566,565,564,563,562,561,556,555,554,553,552,551,546,545,544,543,542,541,536,535,534,533,...

Як формується ця послідовність? Спочатку у нас є число в діапазоні [6, 1](всі можливі значення одиничного штампу від найвищого до найнижчого). Потім у нас є числа [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](усі можливі чіткі значення двох кубиків від найвищої до найнижчої). І т. Д.
Це пов'язано з послідовністю OEIS A057436: Містить цифри від 1 до 6 , але всі числа з однаковою кількістю цифр відсортовані назад у послідовності.

Завдання полягає у виборі одного з цих трьох варіантів для вашої функції / програми з послідовністю, наведеною вище:

1. Візьміть вхід та виведіть -ве значення цієї послідовності, де воно може бути або 0-індексованим, або 1-індексованим.$n$$n$
2. Візьміть вхід і виведіть перші або значення цієї послідовності.$n$$n$$n+1$
3. Виведіть значення з послідовності нескінченно.

Звичайно, можна використовувати будь-який розумний вихідний формат. Можуть бути як рядки / цілі числа / десяткові числа / тощо; може бути як (нескінченний) список / масив / потік / тощо; може бути виведений з пробілом / комою / новою лінією / іншим роздільником для STDOUT; тощо. Будь-ласка, вкажіть, який I / O та варіант ви використовуєте у своїй відповіді!

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з мов, що не кодують гольф. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Для вашої відповіді застосовуються стандартні правила з правилами вводу / виводу за замовчуванням , тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу повернення. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду (тобто TIO ).
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Ось кілька великих тестових випадків, якщо ви виберете варіант 1:

n         0-indexed output    1-indexed output

500       5624                5625
750       4526                4531
1000      3432                3433
9329      11111               11112
9330      666666              11111
9331      666665              666666
10000     663632              663633
100000    6131232             6131233

Желе , 5 байт

ḃ6ạ7V

Спробуйте в Інтернеті!

1-індексоване n-е значення.

Perl 6 , 24 23 байти

-1 байт завдяки nwellnhof

{.put;.[]X~(6...1)}...*

Спробуйте в Інтернеті!

Виводить послідовність нескінченно розділених пробілами / новинками. Або ще на кілька байтів ми можемо мати ледачий нескінченний список, на який можемо індексувати.

Perl 6 , 27 байт

{flat {@=.[]X~(6...1)}...*}

Спробуйте в Інтернеті!

Пояснення:

{                         }    # Anonymous code block
 flat                          # Return the flattened
                      ...*       # Infinite sequence
      {              }             # Defined as
         .[]                       # The previous element arrayified
            X~                     # Each concatenated with
              (6...1)              # All of 6 to 1
       @=                          # Arrayified

Python 2 , 39 38 34 байт

f=lambda n:n and-n%6+1+f(~-n/6)*10

Спробуйте в Інтернеті!

Виводи 1-індексованого числа

R , 43 байти

p='';repeat cat(p<-sapply(p,paste0,6:1),'')

Спробуйте в Інтернеті!

Друкує послідовність нескінченно

• -9 завдяки @Kirill L.

Баш, 31 байт

f()(x+={6..1};eval echo $x;f);f

ТІО

оновлення від коментарів, n-ї значення 1-індексований, + інструменти GNU + perl, 64 байти, 7 байт збережено завдяки @manatwork

dc<<<6o$1p|perl -pe 's/(.)0/($1-1).6/e?redo:s/0//'|tr 1-6 654321

64 байти

MATL , 11 байт

`6:P!V@Z^DT

Виводить значення нескінченно.

Спробуйте в Інтернеті!

Пояснення

`      % Do...while
  6:   %   Push [1 2 3 4 5 6]
  P    %   Flip: gives [6 5 4 3 2 1]
  !    %   Transpose: turns the row vector into a column vector
  V    %   Convert the number in each row to the corresponding char
  @    %   Push current iteration index, starting from 1
  Z^   %   Cartesian power. Gives a matrix where each row is a Cartesian tuple
  D    %   Display immediately
  T    %   Push true. This is used as loop condition, to give an infinite loop
       % End (implicit)

Haskell, 38 34 байт

Нескінченний список номерів:

d=[6,5..1]
l=d++[10*m+n|m<-l,n<-d]

Спробуйте в Інтернеті!

Два попередні рішення, які дають нескінченний список рядків, кожен з яких використовує 38 байт:

[1..]>>=sequence.(`replicate`"654321")

Спробуйте в Інтернеті!

do n<-[1..];mapM id$[1..n]>>["654321"]

Спробуйте в Інтернеті!

JavaScript (ES6), 26 байт

$n$

f=n=>n--&&[f(n/6|0)]+6-n%6

Спробуйте в Інтернеті!

Haskell , 28 байт

l=(+).(10*)<$>0:l<*>[6,5..1]

Спробуйте в Інтернеті!

Створює нескінченний список чисел l. Використання <$>та <*>скорочення байту:

29 байт

l=[10*n+d|n<-0:l,d<-[6,5..1]]

Спробуйте в Інтернеті!

Підхід схожий на фіксований вхідний рядок відповіді Haskell Output All String "654321", і пропускає вихід порожнього рядка, змінюючи місце, де це передбачено.

30 байт

l=[n++[d]|n<-"":l,d<-"654321"]

Спробуйте в Інтернеті!

05AB1E , 10 байт

Виводить послідовність нескінченно.

¸[6LRâJD»,

Спробуйте в Інтернеті!

Пояснення

¸           # initialize the stack with a list containing the empty string
 [          # loop
  6L        # push [1 ... 6]
    R       # reverse
     â      # cartesian product
      J     # join each inner list
       D    # duplicate (saving a copy for next iteration)
        »,  # join on newline and print

Perl 5, 40 37 байт

-3байт завдяки @Xcali

map{say}<"$_">while s//{6,5,4,3,2,1}/

37 байт

40 байт

Java (JDK) , 48 байт

String f(int n){return n-->0?f(n/6)+(6-n%6):"";}

Спробуйте в Інтернеті!

Це повертає 1-індексований n- ^й елемент.

Рекурсія ніби перемагає ітеративну лямбда.

Ітеративна версія, 49 байт

n->{var r="";for(;n-->0;n/=6)r=6-n%6+r;return r;}

Спробуйте в Інтернеті!

Брахілог , 13 11 байт

Завдяки Fatalize за 2 байти

6~d{⟧₁∋}ᵐẉ⊥

Виходи нескінченно. Спробуйте в Інтернеті!

$n$

Пояснення

6~d           Start with a number, all of whose digits are 6's
              Brachylog considers these in the order 6, 66, 666, 6666...
   {   }ᵐ     Map this predicate to each of those digits:
    ⟧₁         1-based reverse range: [6,5,4,3,2,1]
      ∋        The output digit must be a number in that range
              Brachylog considers possible outputs in this order: 6, 5, 4, 3, 2, 1, 66, 65...
         ẉ    Write a possible output with newline
          ⊥   Force the predicate to fail and backtrack to the next possibility

C # (.NET Core) , 38 байт

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;

Спробуйте в Інтернеті!

Виводить n-е значення (на основі 1).

Japt, 14 байт

Має бути коротше рішення з використанням функціональних методів та / або декартового продукту, але (на даний момент?) Найкращим, яким я можу керувати, є порт JS-рішення Арнальда, тож не забудьте також звернути увагу на нього.

©ß´Uz6)s+6-Uu6

Спробуйте або випробуйте умови0-1000

Мова Вольфрама (Mathematica) , 88 78 байт

(l=d=c=7-Range@6;While[Length@c<#,d=Flatten[(10#+l)&/@d];c=c~Join~d;];c[[#]])&

Спробуйте в Інтернеті!

збережено 4 + 6 байт завдяки @IanMiller

Список 1 індексований, виводить n-е число.

Математика, 56 байт

Flatten[FromDigits/@Tuples[7-Range@6,#]&/@Range@#][[#]]&

$\frac{6}{5}(6^n-1)$

Піп -l , 16 байт

x:YP6-,6W1PxCP:y

Виводить послідовність нескінченно. Спробуйте в Інтернеті!

Пояснення

У -lпрапорі означає , що списки друкуються з кожним елементом по своїй лінії; якщо елемент сам є списком, його елементи об'єднуються без роздільника. Наприклад, список [1 [2 3] [4 [5 6]]]буде надруковано як

1
23
456

З цим вияснилося:

x:YP6-,6W1PxCP:y
      ,6          Range(6): [0 1 2 3 4 5]
    6-            Subtract each element from 6: [6 5 4 3 2 1]
  YP              Yank that value into the y variable, and also print it
x:                Assign that value also to x
        W1        While 1 (infinite loop):
           xCP:    Assign to x the cartesian product of x with
               y   the list [6 5 4 3 2 1]
          P        Print it

Після першої ітерації циклу xвиглядає так [[6;6];[6;5];[6;4];...;[1;1]]; після другої ітерації [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]; і так далі. Нам не потрібно турбуватися про вирівнювання списків, тому -lщо це ефективно робить нас.

Вугілля деревне , 18 байт

ＮθＷθ«←Ｉ⊕﹪±θ⁶≔÷⊖θ⁶θ

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. 1-індексований. Пояснення:

Ｎθ

Вхідні дані n

Ｗθ«

Повторюйте, поки nне досягне нуля.

←Ｉ⊕﹪±θ⁶

Зменшіть -nмодуль 6, потім збільште результат і виведіть справа наліво.

≔÷⊖θ⁶θ

Декрет nі ціле число ділимо його на 6.

Сітківка 0,8,2 , 36 байт

.+
$*_
+`(_*)\1{5}(_+)
$1$.2
T`7-1`d

Спробуйте в Інтернеті! Посилання включає тестові випадки. 1-індексований. Пояснення:

.+
$*_

Перетворити в одинарне. (Retina 1 збереже тут 2 байти.)

+`(_*)\1{5}(_+)
$1$.2

Перетворити в бієктивну базу 6 повторним дівмодом. Зауважимо, що використання засобів +означає, що витягнута цифра завжди є числом від 1 до 6 замість 0 до 5 для регулярного перетворення базових 6. ( (_{6})*швидше, але витрачає байти, витягуючи коефіцієнт.)

T`7-1`d

Перенесіть цифри так, щоб 6-го було першим, а 1-м останнім. (Немає 7 або 0, але це дозволяє мені використовувати dярлик.

Cubix , 22 байти

Це виведе послідовність нескінченно. Загальна думка полягає в тому, що він має базове число, до якого додається 6 - 1. Для кожного додавання результат виводиться множиться на 10, який висувається на нижню частину стека, щоб потім використовуватись у послідовності. Потім база вискакує і починається наступна база.

..w.06+ONo*w;|uW!(pq;;

Спробуйте в Інтернеті!

    . .
    w .
0 6 + O N o * w
; | u W ! ( p q
    ; ;
    . .

Дивись, як це працює

C # (.NET Core) , нескінченна друк, 181 180 88 байт.

string[] s=new string[]{" "},t;int i,j,k,l=1;while(true){j=l;t=new string[l=6*j];for(i=6;i>0;i--)for(k=(6-i)*j;k<l;)t[k]=i+s[k++%j];
for(k=0;k<l;)System.Console.Write(t[k++]);s=t;}

На жаль, він заморожує repl.it замість належного виведення в нескінченну версію, як написано (я вважаю, що це помилка в repl.it, оскільки він не видає так, як програма циклікує, як слід), тому кожен, хто сподівається перевірити, потребує комп’ютер. Якщо додати читання в передній частині цикла, воно також працює у repl.it.

Виходи на консоль, очевидно.

У будь-якій кінцевій системі код, швидше за все, в кінцевому підсумку вийде з ладу поза помилкою пам'яті.

Переробив код, щоб використовувати лямбда @dana.

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;++i>0;)System.Console.Write(f(i)+" ");

Спробуйте в Інтернеті!

Четвертий (gforth) , 63 байти

: f recursive dup 6 < if 6 - abs 1 .r else 6 /mod 1- f f then ;

Спробуйте в Інтернеті!

0-індексовані виходи n-го значення

Пояснення

Якщо N менше 6, виведіть абсолютне значення N - 6. В іншому випадку отримайте коефіцієнт і залишок ділення N на 6. Викличте функцію рекурсивно на коефіцієнт, а потім викликайте її на залишок.

Пояснення коду

: f                 \ start a new word definition
  recursive         \ declare that this word is recursive so we can call it from itself
  dup 6 <           \ check if n is less than 6
  if                \ if it is:
    6 - abs 1 .r    \ subtract 6, get the absolute value, then print with no appended space
  else              \ else if it's greater than 6:
    6 /mod          \ get the quotient and remainder of dividing n by 6
    1-              \ subtract 1 from the quotient (because we're 0-indexed)
    f               \ call f on the result
    f               \ call f on the remainder (shortcut to format and print, it's always < 6)
  then              \ end the if/else
;                   \ end the word definition

APL (NARS), 27 символів, 54 байти

{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}

перекладіть рішення на сьогодні /codegolf//a/179980 в APL ... тест:

  f←{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}
  f 500
5625
  f¨750 1000 9329 9331 10000 100000
4531 3433 11112 666666 663633 6131233 
  f¨⍳9
6 5 4 3 2 1 66 65 64 

C #, друкувати від початку до n, ??? байт

Подяка @dana за вираз лямбда.

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;i<int.Parse(a[0]);)System.Console.Write(f(++i)+" ");

Операція: запустіть з командним рядком 0-й аргумент, рівний цілому числу, яке ви хочете рахувати. (Слід зазначити, що a[0]це посилання на інакше не згаданий масив аргументів командного рядка, і я не знаю, як його рахувати.)