도전:

시퀀스의 처음 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 및 옵션을 명시하십시오!

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 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 번째 값.

펄 6 , 24 23 바이트

nwellnhof 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

공백 / 개행 문자로 구분 된 시퀀스를 출력합니다. 또는 몇 바이트를 더 사용하면 지연 인덱스 목록을 가질 수 있습니다.

펄 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

파이썬 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),'')

온라인으로 사용해보십시오!

시퀀스를 무기한으로 인쇄합니다

• @Kirill L. 덕분에 -9

배쉬, 31 바이트

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

TIO

@manatwork 덕분에 주석에서 n 번째 값 1 인덱스, + GNU 도구 + perl, 64 바이트, 7 바이트 저장

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)

하스켈, 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"]

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 26 바이트

$n$

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

온라인으로 사용해보십시오!

하스켈 , 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

펄 5, 40 37 바이트

@Xcali 덕분에 -3bytes

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

37 바이트

40 바이트

자바 (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;}

온라인으로 사용해보십시오!

Brachylog , 13 11 바이트

2 바이트의 Fatalize 덕분에

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 코어) , 38 바이트

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

온라인으로 사용해보십시오!

n 번째 값을 출력합니다 (1 기반).

apt, 14 바이트

함수 방법 및 / 또는 직교 제품을 사용하는 더 짧은 솔루션이 있어야하지만 (지금은?) 내가 관리 할 수있는 최선의 방법은 Arnauld의 JS 솔루션의 포트이므로 너무 그를지지하십시오.

©ß´Uz6)s+6-Uu6

사용해 보거나 용어를 테스트 하십시오.0-1000

Wolfram Language (Mathematica) , 88 78 바이트

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

온라인으로 사용해보십시오!

@IanMiller 덕분에 4 + 6 바이트 절약

List는 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

Ｗθ«

n0이 될 때까지 반복하십시오 .

←Ｉ⊕﹪±θ⁶

-n모듈로를 줄인 6다음 결과를 늘리고 오른쪽에서 왼쪽으로 출력합니다.

≔÷⊖θ⁶θ

감소 n및 정수는로 나눕니다 6.

레티 나 0.8.2 , 36 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 1- 색인. 설명:

.+
$*_

단항으로 변환합니다. (Retina 1은 여기에 2 바이트를 저장합니다.)

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

반복 된 divmod를 사용하여 bijective base 6으로 변환하십시오. 사용 +한다는 것은 추출 된 숫자가 규칙적인 기본 6 변환을 위해 항상 0에서 5 대신 1에서 6 사이의 숫자임을 의미합니다. ( (_{6})*빠르지 만 몫을 추출하는 바이트 비용이 듭니다.)

T`7-1`d

6이 1이되고 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) , 무한 인쇄, 181180 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}

APL에서 dana /codegolf//a/179980 에 의해 솔루션을 traslate ... 테스트 :

  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]달리 언급되지 않은 명령 줄 args 배열에 대한 참조이며 계산 방법을 모르겠습니다.)