Os dados mais altos

19

Desafio:

Aqui temos os 100 primeiros itens de uma sequência:

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,...

Como esta sequência é formada? Primeiro, temos o número no intervalo [6, 1](todos os valores possíveis de um único dado, do mais alto para o mais baixo). Em seguida, temos os números [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](todos os valores possíveis possíveis de dois dados do maior para o menor). Etc.
Isso está relacionado à sequência OEIS A057436: Contém apenas os dígitos de 1 a 6 , mas com todos os números com a mesma quantidade de dígitos classificados para trás na sequência.

O desafio é escolher uma dessas três opções para sua função / programa com a sequência acima:

  1. Pegue uma entrada e produza o ésimo valor dessa sequência, onde ela pode ser indexada em 0 ou 1.nn
  2. Pegue uma entrada e imprima os primeiros valores ou desta sequência.nnn+1
  3. Envie os valores da sequência indefinidamente.

Obviamente, qualquer formato de saída razoável pode ser usado. Pode ser como strings / inteiros / decimais / etc .; poderia ser como uma lista (infinita) / array / stream / etc .; pode ser enviado com espaço / vírgula / nova linha / outro delimitador para STDOUT; etc. etc. Por favor, indique qual E / S e a opção que você está usando em sua resposta!

Regras gerais:

  • Isso é , então a resposta mais curta em bytes vence.
    Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
  • As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
  • As brechas padrão são proibidas.
  • Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
  • Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Aqui estão alguns casos de teste maiores, se você escolher a opção 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
Kevin Cruijssen
fonte
1
De acordo com a edição sugerida, a tag de complexidade kolmogorov não se aplica a sequências, apenas a uma saída constante, finita e fixa. Uma sequência continua para sempre.
mbomb007 23/02
Além do que o @ mbomb007 disse, também permito gerar o n-ésimo valor ou o primeiro n / n + 1 com base em uma entrada, enquanto os desafios do KC nunca terão entradas.
Kevin Cruijssen 23/02

Respostas:

12

Perl 6 , 24 23 bytes

-1 byte graças a nwellnhof

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

Experimente online!

Produz a sequência infinitamente separada por espaços / novas linhas. Ou, por mais alguns bytes, podemos ter uma lista infinita e lenta que podemos indexar.

Perl 6 , 27 bytes

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

Experimente online!

Explicação:

{                         }    # 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
Brincadeira
fonte
6

R , 43 bytes

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

Experimente online!

Imprime a sequência indefinidamente

  • -9 graças a @Kirill L.
digEmAll
fonte
1
@ tk3: sem o segundo parâmetro, concatenará o último valor da sub-sequência de elementos com n dígitos, com o primeiro valor da sub-sequência de elementos com n + 1 dígitos. por exemplo6 5 4 3 2 166 65 64...
digEmAll 15/02
6

Bash, 31 bytes

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

TIO

update from comments, o n-ésimo valor indexado em 1, + ferramentas GNU + perl, 64 bytes, 7 bytes salvos graças a @manatwork

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

64 bytes

Nahuel Fouilleul
fonte
Não ajuda muito, mas o na 2ª solução é mais curto para escapar o ponto e vírgula do que o dobro citando a expressão inteira: bc<<<obase=6\;$1. Mas se você mudar para dc, não há nada a fuga: dc<<<6o$1p.
manatwork
graças, de fato, ele economiza 7 bytes, mas por causa da numeração bijetiva, ele ainda não está funcionando em um mix bash perl (66 bytes)dc<<<6o$1p|perl -pe '1while s/(.)0/($1-1).6/e;s/0//'|tr 1-6 654321
Nahuel Fouilleul 15/02
5

MATL , 11 bytes

`6:P!V@Z^DT

Emite os valores indefinidamente.

Experimente online!

Explicação

`      % 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)
Luis Mendo
fonte
5

Haskell, 38 34 bytes

Uma lista infinita de números:

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

Experimente online!

Duas soluções anteriores que fornecem listas infinitas de cadeias de caracteres, cada uma usando 38 bytes:

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

Experimente online!

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

Experimente online!

Peneiradores cristãos
fonte
A 36; versão em bytes , com base na sua replicate.
dfeuer 16/03
5

JavaScript (ES6), 26 bytes

n

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

Experimente online!

Arnauld
fonte
5

Haskell , 28 bytes

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

Experimente online!

Produz uma lista infinita de números l. Usando <$>e <*>cortando um byte:

29 bytes

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

Experimente online!

A abordagem é semelhante à sequência de entrada fixa "654321" da resposta de todas as seqüências de caracteres de saída de Haskell e ignorando a saída de sequência de caracteres vazia, alterando o local em que é precedida.

30 bytes

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

Experimente online!

xnor
fonte
Isso é ótimo! Vi que é mais curto começar com 0(ou ""), mas não encontrei uma maneira barata de não tê-la no resultado ...
Christian Sievers
4

05AB1E , 10 bytes

Produz a sequência indefinidamente.

¸[6LRâJD»,

Experimente online!

Explicação

¸           # 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
fonte
1
Nunca soube ¸no início cria uma lista contendo uma string vazia. E 2 bytes mais curto que a solução que eu usei para gerar os casos de teste, portanto, é claro, um +1 de mim. :)
Kevin Cruijssen
4

Perl 5, 40 37 bytes

-3bytes graças a @Xcali

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

37 bytes

40 bytes

Nahuel Fouilleul
fonte
37 bytes
Xcali
Uso brilhante de glob. +1
msh210 23/02
3

Java (JDK) , 48 bytes

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

Experimente online!

Isso retorna o n- ésimo elemento indexado .

A recursão parece superar a lambda iterativa.


Versão iterativa, 49 bytes

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

Experimente online!

Olivier Grégoire
fonte
3

Braquilog , 13 11 bytes

Graças a Fatalize por 2 bytes

6~d{⟧₁∋}ᵐẉ⊥

Saídas indefinidamente. Experimente online!

n

Explicação

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
fonte
Você está em um rolo Brachylog!
Fatalize 18/02
1
Você pode salvar 2 bytes usando um loop-driven fracasso, como são chamados em Prolog: 6~d{⟧₁∋}ᵐẉ⊥. Você basicamente encerra seu programa com "false", que o forçará a imprimir todas as soluções.
Fatalize 18/02
Ooh legal. Sim, eu tenho gostado muito!
DLosc 18/02
3

C # (.NET Core) , 38 bytes

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

Experimente online!

Emite o n-ésimo valor (com base em 1).

dana
fonte
Qual deles está resolvendo?
Stackstuck 20/02
@Stackstuck - Agora eu especifiquei isso na minha resposta.
dana
1
Oh bom! Não estamos nos sobrepondo. Acabei de escrever a impressora infinita.
Stackstuck 20/02
2

Japonês, 14 bytes

Tem que haver uma solução mais curta usando métodos de função e / ou produto cartesiano, mas (por enquanto?) O melhor que consigo gerenciar é uma porta da solução JS de Arnauld, portanto, também o vota.

©ß´Uz6)s+6-Uu6

Experimente ou teste os termos0-1000

Shaggy
fonte
2

Wolfram Language (Mathematica) , 88 78 bytes

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

Experimente online!

economizou 4 + 6 bytes graças a @IanMiller

A lista é 1 indexada, gera o enésimo número.

Kai
fonte
1
Você pode substituir o Range [6,1, -1] por 7-Range @ 6 para salvar 4 caracteres
Ian Miller
1
Para regras de codegolf, você também pode escrevê-lo como uma função anônima: (l = d = c = 7-Range @ 6; While [Length @ c <#, d = Flatten [(10 # + l) & / @ d]; c = c ~ Join ~ d;]; c [[#]]) &
Ian Miller
@IanMiller thanks! Eu não tinha certeza de quais eram as regras sobre o formato.
Kai
2

Mathematica, 56 bytes

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

65(6n1)

Ian Miller
fonte
+1, isso é um exagero monstruoso, mas funciona perfeitamente por uma questão de brevidade!
Kai
@ JonathanFrech Obrigado por corrigir meu mathjax. Eu não tinha certeza de como ativá-lo aqui, pois é um pouco diferente do math.se
Ian Miller
Observe que a edição original foi feita por esse usuário .
Jonathan Frech 26/02
Opa, meu mal. Obrigado a @ geza-kerecsenyi também.
Ian Miller
1

Pip -l , 16 bytes

x:YP6-,6W1PxCP:y

Produz a sequência indefinidamente. Experimente online!

Explicação

A -lbandeira significa que as listas são impressas com cada item em sua própria linha; se um item é uma lista, seus elementos são concatenados sem separador. Por exemplo, a lista [1 [2 3] [4 [5 6]]]seria impressa como

1
23
456

Com isso esclarecido:

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

Após a primeira iteração do loop, xparece [[6;6];[6;5];[6;4];...;[1;1]]; após a segunda iteração [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]],; e assim por diante. Não precisamos nos preocupar em achatar as sublistas, porque -lefetivamente faz isso por nós.

DLosc
fonte
1

Carvão , 18 bytes

NθWθ«←I⊕﹪±θ⁶≔÷⊖θ⁶θ

Experimente online! Link é a versão detalhada do código. 1 indexado. Explicação:

Nθ

Entrada n

Wθ«

Repita até que nseja zero.

←I⊕﹪±θ⁶

Reduza o -nmódulo 6e aumente o resultado e a saída da direita para a esquerda.

≔÷⊖θ⁶θ

Decremento ne número inteiro dividem por 6.

Neil
fonte
1

Retina 0.8.2 , 36 bytes

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

Experimente online! O link inclui casos de teste. 1 indexado. Explicação:

.+
$*_

Converta para unário. (A retina 1 salvaria 2 bytes aqui.)

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

Converta na base bijetiva 6 por divmod repetido. Observe que o uso de +significa que o dígito extraído é sempre um número de 1 a 6 em vez de 0 a 5 para a conversão regular da base 6. ( (_{6})*é mais rápido, mas custa bytes extraindo o quociente.)

T`7-1`d

Transponha os dígitos para que os 6s cheguem primeiro e os 1s durem. (Não há 7s ou 0s, mas isso me permite usar o datalho.

Neil
fonte
1

Cubix , 22 bytes

Isso produzirá a sequência indefinidamente. A idéia geral é que ele tenha um número base ao qual 6 - 1 é adicionado. Para cada adição, o resultado é multiplicado por 10, que é empurrado para o fundo da pilha para ser usado posteriormente na sequência. A base é então exibida e a próxima base é iniciada.

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

Experimente online!

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

Assista

MickyT
fonte
1

C # (.NET Core) , impressão infinita, 181 180 88 bytes.

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;}

Infelizmente, congela o repl.it em vez de produzir corretamente na versão infinita, como está escrito (acredito que seja um erro no repl.it, pois não é exibido como o programa faz o loop como deveria), então qualquer pessoa que deseje testar precisa de um computador. Se você adicionar uma leitura na frente do loop, ela também funcionará em repl.it.

Saídas para o console, obviamente.

Em qualquer sistema finito, o código provavelmente trava com um erro de falta de memória.

Retrabalhou o código para usar o lambda de @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)+" ");

Experimente online!

Stackstuck
fonte
Eu não tenho idéia se eu joguei isso bem ou não.
Stackstuck 20/02
Salvou um byte removendo o k ++ desnecessário.
Stackstuck 20/02
(também, eu muito bem-vindos golfe assistência, eu sou muito novo para isso.)
Stackstuck
2
Bem-vindo :) Se você estiver interessado em jogar golfe em C #, consulte este post para obter algumas dicas: codegolf.stackexchange.com/q/173/8340
dana
1

Quarto (gforth) , 63 bytes

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

Experimente online!

Saídas indexadas 0 nésimo valor

Explicação

Se N for menor que 6, insira o valor absoluto de N - 6. Caso contrário, obtenha o quociente e o restante da divisão de N por 6. Chame a função recursivamente no quociente e depois no restante.

Código Explicação

: 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
fonte
1

APL (NARS), 27 caracteres, 54 bytes

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

traduza a solução por dana /codegolf//a/179980 no APL ... test:

  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
fonte
0

C #, imprima do começo para n, ??? bytes

Crédito para @dana pela expressão lambda.

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

Operação: execute com o argumento da linha de comando 0 igual ao número inteiro com o qual você deseja contar. (Note-se que a[0]é uma referência à matriz de argumentos args da linha de comando não mencionada, e não sei como contá-la.)

Stackstuck
fonte
Como parte do código é um snipper em vez de um programa ou função completa, presumo que você esteja usando o Compilador Interativo do Visual C #? Você poderia adicionar um link Experimente com o código de teste? PS: Sua contagem de bytes atual é 102
Kevin Cruijssen
ah merda, não está funcionando o que diabos .
Stackstuck 21/02