Défi:

Ici, nous avons les 100 premiers éléments d'une séquence:

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

Comment se forme cette séquence? Nous avons d'abord le nombre dans la plage [6, 1](toutes les valeurs possibles d'un seul dé du plus haut au plus bas). Nous avons alors les nombres [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](toutes les valeurs concaténées possibles de deux dés du plus haut au plus bas). Etc.
Ceci est lié à la séquence OEIS A057436: Contient uniquement les chiffres 1 à 6 , mais avec tous les nombres avec une quantité égale de chiffres triés en arrière dans la séquence.

Le défi est de choisir l'une de ces trois options pour votre fonction / programme avec la séquence ci-dessus:

1. Prendre une entrée et la sortie du -ième valeur de cette séquence, où il peut être 0 ou 1-indexé-indexé.$n$$n$
2. Prenez une entrée et sortez les premières ou valeurs de cette séquence.$n$$n$$n+1$
3. Sortez indéfiniment les valeurs de la séquence.

Bien sûr, tout format de sortie raisonnable peut être utilisé. Peut être sous forme de chaînes / entiers / décimales / etc .; pourrait être une liste (infinie) / tableau / flux / etc .; pourrait être sorti avec un délimiteur espace / virgule / nouvelle ligne / autre vers STDOUT; etc. etc. Veuillez indiquer les E / S et les options que vous utilisez dans votre réponse!

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Voici quelques cas de test plus importants si vous choisissez l'option 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

Gelée , 5 octets

ḃ6ạ7V

Essayez-le en ligne!

Nième valeur indexée 1.

Perl 6 , 24 23 octets

-1 octet grâce à nwellnhof

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

Essayez-le en ligne!

Génère la séquence séparée à l'infini par des espaces / retours à la ligne. Ou, pour quelques octets supplémentaires, nous pouvons avoir une liste infinie paresseuse dans laquelle nous pouvons indexer à la place.

Perl 6 , 27 octets

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

Essayez-le en ligne!

Explication:

{                         }    # 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 octets

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

Essayez-le en ligne!

Sorties nombre indexé 1

R , 43 octets

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

Essayez-le en ligne!

Imprime la séquence indéfiniment

• -9 grâce à @Kirill L.

Bash, 31 octets

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

TIO

mise à jour à partir des commentaires, la nième valeur indexée 1, + outils GNU + perl, 64 octets, 7 octets enregistrés grâce à @manatwork

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

64 octets

MATL , 11 octets

`6:P!V@Z^DT

Sort les valeurs indéfiniment.

Essayez-le en ligne!

Explication

`      % 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 octets

Une liste infinie de nombres:

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

Essayez-le en ligne!

Deux solutions antérieures qui donnent des listes infinies de chaînes, chacune utilisant 38 octets:

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

Essayez-le en ligne!

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

Essayez-le en ligne!

JavaScript (ES6), 26 octets

$n$

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

Essayez-le en ligne!

Haskell , 28 octets

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

Essayez-le en ligne!

Produit une liste infinie de nombres l. Utiliser <$>et <*>couper un octet:

29 octets

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

Essayez-le en ligne!

L'approche est similaire à la réponse Haskell Output All String answer chaîne d'entrée fixe "654321", et en sautant la sortie de chaîne vide en changeant où elle est ajoutée.

30 octets

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

Essayez-le en ligne!

05AB1E , 10 octets

Sort la séquence indéfiniment.

¸[6LRâJD»,

Essayez-le en ligne!

Explication

¸           # 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 octets

-3 octets grâce à @Xcali

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

37 octets

40 octets

Java (JDK) , 48 octets

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

Essayez-le en ligne!

Cela renvoie le n ^ème élément indexé 1 .

La récursion semble battre la lambda itérative.

Version itérative, 49 octets

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

Essayez-le en ligne!

Brachylog , 13 11 octets

Merci à Fatalize pour 2 octets

6~d{⟧₁∋}ᵐẉ⊥

Sorties indéfiniment. Essayez-le en ligne!

$n$

Explication

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 octets

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

Essayez-le en ligne!

Sort la nième valeur (basée sur 1).

Japt, 14 octets

Il doit y avoir une solution plus courte utilisant des méthodes de fonction et / ou un produit cartésien mais (pour l'instant?) Le mieux que je puisse gérer est un portage de la solution JS d'Arnauld alors assurez-vous de lui aussi voter.

©ß´Uz6)s+6-Uu6

Essayez-le ou testez les conditions0-1000

Wolfram Language (Mathematica) , 88 78 octets

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

Essayez-le en ligne!

économisé 4 + 6 octets grâce à @IanMiller

La liste est indexée sur 1, affiche le nième numéro.

Mathematica, 56 octets

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

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

Pip -l , 16 octets

x:YP6-,6W1PxCP:y

Sort la séquence indéfiniment. Essayez-le en ligne!

Explication

Le -ldrapeau signifie que les listes sont imprimées avec chaque élément sur sa propre ligne; si un élément est lui-même une liste, ses éléments sont concaténés sans séparateur. Par exemple, la liste [1 [2 3] [4 [5 6]]]sera imprimée comme

1
23
456

Avec cela clarifié:

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

Après la première itération de boucle, xressemble à [[6;6];[6;5];[6;4];...;[1;1]]; après la seconde itération, [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]; etc. Nous n'avons pas à nous soucier d'aplatir les sous-listes, car -lcela le fait efficacement pour nous.

Fusain , 18 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. 1 indexé. Explication:

Ｎθ

Contribution n

Ｗθ«

Répétez jusqu'à ce que nzéro.

←Ｉ⊕﹪±θ⁶

Réduisez le -nmodulo 6, puis augmentez le résultat et la sortie de droite à gauche.

≔÷⊖θ⁶θ

Décrémenter net diviser par entier 6.

Retina 0.8.2 , 36 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. 1 indexé. Explication:

.+
$*_

Convertissez en unaire. (Retina 1 économiserait 2 octets ici.)

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

Convertissez en base bijective 6 par divmod répété. Notez que l'utilisation de +signifie que le chiffre extrait est toujours un nombre de 1 à 6 au lieu de 0 à 5 pour la conversion régulière en base 6. ( (_{6})*est plus rapide mais coûte des octets pour extraire le quotient.)

T`7-1`d

Transposez les chiffres de sorte que les 6 viennent en premier et les 1 en dernier. (Il n'y a pas de 7 ou de 0 mais cela me permet d'utiliser le draccourci.

Cubix , 22 octets

Cela produira la séquence indéfiniment. L'idée générale est qu'il a un nombre de base auquel 6 - 1 est ajouté. Pour chaque ajout, le résultat est multiplié par 10, qui est poussé au bas de la pile pour être utilisé plus tard dans la séquence. La base est ensuite sautée et la base suivante a commencé.

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

Essayez-le en ligne!

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

Regardez-le courir

C # (.NET Core) , impression infinie, 181 180 88 octets.

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

Malheureusement, il fige repl.it au lieu de produire correctement dans la version infinie telle qu'écrite (je crois que c'est une erreur dans repl.it, car il ne sort pas comme le programme boucle comme il se doit), donc toute personne espérant tester a besoin d'un ordinateur. Si vous ajoutez une lecture à l'avant de la boucle, cela fonctionne également dans repl.it.

Sorties vers la console, évidemment.

Sur tout système fini, le code finira très probablement par se bloquer avec une erreur de mémoire insuffisante.

Retravaillé le code pour utiliser le 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)+" ");

Essayez-le en ligne!

Forth (gforth) , 63 octets

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

Essayez-le en ligne!

Sorties indexées 0 nième valeur

Explication

Si N est inférieur à 6, affichez la valeur absolue de N - 6. Sinon, obtenez le quotient et le reste de la division de N par 6. Appelez la fonction récursivement sur le quotient, puis appelez-la sur le reste.

Explication du code

: 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 caractères, 54 octets

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

traduisez la solution par dana /codegolf//a/179980 dans 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 

C #, imprimer du début à n, ??? octets

Nous remercions @dana pour l'expression 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)+" ");

Opération: exécutez avec la ligne de commande 0e argument égal à l'entier que vous souhaitez compter. (Il convient de noter qu'il a[0]s'agit d'une référence au tableau args de ligne de commande autrement non mentionné, et je ne sais pas comment le compter.)