Самые высокие кости

19

Вызов:

Здесь у нас есть первые 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. Возьмите вход и выведитеNN -е значение этой последовательности, где оно может быть либо 0-индексированным, либо 1-индексированным.
  2. Возьмите вход и выведите первый илиNNN+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
code-golf  number  sequence  integer 
— Кевин Круйссен
источник
1
Согласно предложенному редактированию, тег сложности колмогорова не применяется к последовательностям, только к постоянному, конечному, фиксированному выводу. Последовательность продолжается вечно.
— mbomb007
В дополнение к тому, что сказал @ mbomb007, я также разрешаю выводить n-ное значение или первые n / n + 1 значения на основе входных данных, тогда как вызовы KC никогда не будут иметь входных данных.
— Кевин Круйссен

Ответы:

12

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
— Джо Кинг
источник
6

R , 43 байта

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

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

Печатает последовательность бесконечно

  • -9 благодаря @Kirill L.
— digEmAll
источник
1
@ tk3: без второго параметра он объединит последнее значение подпоследовательности n-значных элементов с первым значением подпоследовательности n + 1-значных элементов. например6 5 4 3 2 166 65 64...
— digEmAll
6

Баш, 31 байт

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

TIO

обновление по комментариям, 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 байта

— Науэль Фуйе
источник
Разве это не помогает, но во 2 - м раствора короче , чтобы избежать двойной точки с запятой , чем со ссылкой на все выражение: bc<<<obase=6\;$1. Но если вы переключитесь на dc, вам некуда убежать dc<<<6o$1p.
— manatwork
спасибо, действительно, он экономит 7 байт, но из-за биективной нумерации он все еще не работает с миксом bash perl (66 байт)dc<<<6o$1p|perl -pe '1while s/(.)0/($1-1).6/e;s/0//'|tr 1-6 654321
— Науэль Фуйе
5

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)
— Луис Мендо
источник
5

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"]

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

— Кристиан Сиверс
источник
А 36; байтовая версия , основанная на вашей replicate.
— dfeuer
5

Haskell , 28 байт

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

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

Создает бесконечный список чисел l. Используя <$>и <*>обрезает байт:

29 байт

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

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

Этот подход аналогичен ответу фиксированной входной строки "654321" на выходной вопрос Haskell и пропуску пустой строки путем изменения места добавления.

30 байтов

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

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

— XNOR
источник
Замечательно! Я видел, что начинать с 0(или "") короче , но не нашел дешевого способа не получить его в результате ...
— Кристиан Сиверс
4

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
— Emigna
источник
1
Никогда не знал, ¸в начале создает список, содержащий пустую строку. И на 2 байта короче, чем решение, которое я использовал для генерации тестовых случаев, поэтому, конечно, +1 от меня. :)
— Кевин Круйссен
3

Брахилог , 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
— DLosc
источник
Вы находитесь в списке брахилогов!
— Роковая
1
Вы можете сохранить 2 байта с помощью отказа управляемой петли, как они называются в Прологе: 6~d{⟧₁∋}ᵐẉ⊥. Вы в основном заканчиваете свою программу с «ложью», которая заставит ее печатать все решения.
— Роковая
О, мило. Да, мне это очень нравится!
— DLosc
2

Japt, 14 байт

Должно быть более короткое решение, использующее методы функций и / или декартово произведение, но (на данный момент?) Лучшее, чем я могу управлять, - это порт JS-решения Арнаулда, так что не забудьте также оповестить его.

©ß´Uz6)s+6-Uu6

Попробуй или проверь условия0-1000

— мохнатый
источник
2

Wolfram Language (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-ное число.

— Кай
источник
1
Вы можете заменить Range [6,1, -1] на 7-Range @ 6, чтобы сохранить 4 символа
— Ian Miller
1
Для правил codegolf вы также можете написать это как анонимную функцию: (l = d = c = 7-Range @ 6; While [Length @ c <#, d = Flatten [(10 # + l) & / @ d]; c = c ~ Join ~ d;]; c [[#]]) &
— Ian Miller
@IanMiller спасибо! Я не был уверен, какие правила были о формате.
— Кай
2

Mathematica, 56 байт

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

65(6N-1)

— Ян Миллер
источник
+1, это чудовищное излишество, но отлично работает для краткости!
— Кай
@JonathanFrech Спасибо за исправление моего majjax. Я не был уверен, как активировать его здесь, так как он немного отличается от math.se
— Ян Миллер
Обратите внимание, что исходное редактирование было сделано этим пользователем .
— Джонатан Фрех
Ой мой плохой. Благодаря @ geza-kerecsenyi тоже.
— Ян Миллер
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эффективно для нас.

— DLosc
источник
1

Древесный уголь , 18 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. 1-индексироваться. Объяснение:

Ｎθ

вход n

Ｗθ«

Повторите, пока не nстанет ноль.

←Ｉ⊕﹪±θ⁶

Уменьшите -nпо модулю 6, затем увеличьте результат и выведите справа налево.

≔÷⊖θ⁶θ

Уменьшение nи целое число делят его на 6.

— Нил
источник
1

Сетчатка 0.8.2 , 36 байт

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. 1-индексироваться. Объяснение:

.+
$*_

Преобразовать в одинарный. (Retina 1 сохранит 2 байта здесь.)

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

Преобразование в биективное основание 6 повторяется divmod. Обратите внимание, что использование +означает, что извлеченная цифра всегда представляет собой число от 1 до 6 вместо 0 до 5 для обычного преобразования в основание 6. ( (_{6})*быстрее, но стоит извлечь байты частное.)

T`7-1`d

Переставьте цифры так, чтобы 6-е были первыми, а 1-е - последними. (Нет 7 или 0, но это позволяет мне использовать dярлык.

— Нил
источник
1

Cubix , 22 байта

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

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

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

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

Смотреть это работает

— MickyT
источник
1

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)+" ");

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

— Stackstuck
источник
Я понятия не имею, хорошо ли я играл в гольф или нет.
— Stackstuck
Сохраняется один байт, удаляя ненужный k ++.
— Stackstuck
(также, я очень приветствую помощь в игре в гольф, я очень новичок в этом.)
— Stackstuck
2
Добро пожаловать :) Если вы заинтересованы в гольф в C #, вы можете проверить этот пост несколько советов: codegolf.stackexchange.com/q/173/8340
— Dana
1

Forth (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
— reffu
источник
1

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

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

traslate решение дана /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
— RosLuP
источник
0

C #, печатать с начала, ??? байтов

Благодарю @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]это ссылка на массив аргументов командной строки, не упомянутый в противном случае, и я не знаю, как его посчитать.)

— Stackstuck
источник
Поскольку часть кода представляет собой фрагмент кода, а не полную программу или функцию, я предполагаю, что вы используете интерактивный компилятор Visual C #? Не могли бы вы добавить ссылку Попробовать онлайн с тестовым кодом? PS: Ваш текущий счетчик байтов составляет 102
— Кевин Круйссен
ах дерьмо это не работает, что, черт возьми .
— Stackstuck
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.