Herausforderung:

Hier haben wir die ersten 100 Elemente einer Sequenz:

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

Wie ist diese Sequenz aufgebaut? Wir haben zuerst die Zahl im Bereich [6, 1](alle möglichen Werte eines einzelnen Würfels vom höchsten zum niedrigsten). Wir haben dann die Zahlen [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](alle möglichen zusammengesetzten Werte von zwei Würfeln vom höchsten zum niedrigsten). Usw.
Dies ist auf die Sequenz OEIS bezogenen A057436: Enthält Ziffern 1 bis 6 nur , aber mit allen Zahlen mit gleicher Menge von Ziffern sortierten nach hinten in der Sequenz.

Die Herausforderung besteht darin, eine dieser drei Optionen für Ihre Funktion / Ihr Programm in der oben angegebenen Reihenfolge auszuwählen:

1. Nehmen Sie eine Eingabe und geben Sie den -ten Wert dieser Sequenz aus, wobei diese entweder 0-indiziert oder 1-indiziert sein kann.$n$$n$
2. Nehmen Sie eine Eingabe und geben Sie die ersten oder Werte dieser Sequenz aus.$n$$n$$n+1$
3. Die Werte aus der Sequenz unbegrenzt ausgeben.

Natürlich kann jedes vernünftige Ausgabeformat verwendet werden. Könnte als Zeichenfolgen / Ganzzahlen / Dezimalzahlen / etc. Sein; könnte als (unendliche) Liste / Array / Stream / etc. sein; könnte mit Leerzeichen / Komma / Zeilenvorschub / anderem Trennzeichen nach STDOUT ausgegeben werden; usw. usw. Bitte geben Sie an, welche E / A und welche Option Sie in Ihrer Antwort verwenden!

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Hier einige größere Testfälle, wenn Sie Option 1 wählen:

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

Gelee , 5 Bytes

ḃ6ạ7V

Probieren Sie es online!

1-indizierter n-ter Wert.

Perl 6 , 24 23 Bytes

-1 byte dank nwellnhof

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

Probieren Sie es online!

Gibt die durch Leerzeichen / Zeilenumbrüche voneinander getrennte Sequenz aus. Oder für ein paar Bytes mehr können wir stattdessen eine faule unendliche Liste haben, in die wir indizieren können.

Perl 6 , 27 Bytes

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

Probieren Sie es online!

Erläuterung:

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

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

Probieren Sie es online!

Gibt eine 1-indizierte Zahl aus

R , 43 Bytes

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

Probieren Sie es online!

Druckt die Sequenz auf unbestimmte Zeit

• -9 danke an @Kirill L.

Bash, 31 Bytes

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

TIO

Update von Kommentaren, der n-te Wert 1-indiziert, + GNU-Tools + Perl, 64 Bytes, 7 Bytes dank @manatwork gespeichert

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

64 Bytes

MATL , 11 Bytes

`6:P!V@Z^DT

Gibt die Werte auf unbestimmte Zeit aus.

Probieren Sie es online!

Erläuterung

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

Eine unendliche Liste von Zahlen:

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

Probieren Sie es online!

Zwei frühere Lösungen, die unendliche Listen von Zeichenfolgen mit jeweils 38 Byte enthalten:

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

Probieren Sie es online!

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

Probieren Sie es online!

JavaScript (ES6), 26 Byte

$n$

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

Probieren Sie es online!

Haskell , 28 Bytes

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

Probieren Sie es online!

Erzeugt eine unendliche Liste von Zahlen l. Verwenden <$>und <*>Ausschneiden eines Bytes:

29 Bytes

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

Probieren Sie es online!

Die Vorgehensweise ähnelt der festen Eingabezeichenfolge "654321" für die Antwort " Alle Zeichenfolgen ausgeben" von Haskell und überspringt die leere Zeichenfolgenausgabe, indem sie an der Stelle geändert wird, an der sie vorangestellt ist.

30 Bytes

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

Probieren Sie es online!

05AB1E , 10 Bytes

Gibt die Sequenz auf unbestimmte Zeit aus.

¸[6LRâJD»,

Probieren Sie es online!

Erläuterung

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

-3Bytes dank @Xcali

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

37 Bytes

40 Bytes

Java (JDK) , 48 Byte

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

Probieren Sie es online!

Dies gibt das 1-indizierte n- ^te Element zurück.

Die Rekursion scheint das iterative Lambda zu schlagen.

Iterative Version, 49 Bytes

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

Probieren Sie es online!

Brachylog , 13 11 Bytes

Danke an Fatalize für 2 Bytes

6~d{⟧₁∋}ᵐẉ⊥

Ausgänge auf unbestimmte Zeit. Probieren Sie es online!

Hier ist eine 14-Byte-Version, die die erste ausgibt $n$

Erläuterung

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 Byte

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

Probieren Sie es online!

Gibt den n-ten Wert aus (1-basiert).

Japt, 14 Bytes

Es muss eine kürzere Lösung mit Funktionsmethoden und / oder kartesischem Produkt geben, aber (fürs Erste?) Das Beste, was ich verwalten kann, ist eine Portierung von Arnauld's JS-Lösung.

©ß´Uz6)s+6-Uu6

Probieren Sie es aus oder testen Sie Begriffe0-1000

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[[#]])&

Probieren Sie es online!

4 + 6 Bytes dank @IanMiller gespart

Liste ist 1 indiziert, gibt die n-te Nummer aus.

Mathematica, 56 Bytes

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

Erfordert übermäßig viel Speicher, um tatsächlich ausgeführt zu werden, da alle Zahlen in der Sequenz erstellt werden, deren Länge kleiner oder gleich der Eingabe ist (dh, es werden erstellt$\frac{6}{5}(6^n-1)$

Pip -l , 16 Bytes

x:YP6-,6W1PxCP:y

Gibt die Sequenz auf unbestimmte Zeit aus. Probieren Sie es online!

Erläuterung

Das -lFlag bedeutet, dass Listen mit jedem Element in einer eigenen Zeile gedruckt werden. Wenn ein Element selbst eine Liste ist, werden seine Elemente ohne Trennzeichen verkettet. ZB würde die Liste [1 [2 3] [4 [5 6]]]als gedruckt werden

1
23
456

Mit dem geklärt:

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

Nach der ersten Schleifeniteration xsieht es so aus [[6;6];[6;5];[6;4];...;[1;1]]. nach der zweiten Iteration [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]; und so weiter. Wir brauchen uns keine Sorgen um die Reduzierung der Unterlisten zu machen, da dies -leffektiv für uns erledigt wird.

Kohle , 18 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. 1-indiziert. Erläuterung:

Ｎθ

Eingang n

Ｗθ«

Wiederholen, bis nNull ist.

←Ｉ⊕﹪±θ⁶

-nModulo reduzieren 6, dann das Ergebnis erhöhen und von rechts nach links ausgeben.

≔÷⊖θ⁶θ

Dekrement nund Ganzzahl teilen es durch 6.

Retina 0,8,2 , 36 Bytes

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

Probieren Sie es online! Link enthält Testfälle. 1-indiziert. Erläuterung:

.+
$*_

In Unary konvertieren. (Retina 1 würde hier 2 Bytes sparen.)

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

Wandle es durch wiederholtes DivMod in die bijektive Basis 6 um. Beachten Sie, dass die Verwendung von +bedeutet, dass die extrahierte Ziffer bei einer regulären Basis-6-Konvertierung immer eine Zahl von 1 bis 6 anstelle von 0 bis 5 ist. ( (_{6})*Ist schneller, kostet aber das Extrahieren des Quotienten durch Bytes.)

T`7-1`d

Transponieren Sie die Ziffern so, dass die 6er zuerst und die 1er zuletzt stehen. (Es gibt keine 7er oder 0er, aber dies ermöglicht mir die Verwendung der dVerknüpfung.

Cubix , 22 Bytes

Dadurch wird die Sequenz auf unbestimmte Zeit ausgegeben. Die allgemeine Idee ist, dass es eine Basisnummer hat, zu der 6-1 addiert wird. Für jede Addition wird das Ergebnis mit 10 multipliziert und an den unteren Rand des Stapels verschoben, um später in der Sequenz verwendet zu werden. Die Basis wird dann geknallt und die nächste Basis gestartet.

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

Probieren Sie es online!

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

Beobachten Sie es laufen

C # (.NET Core) , unendliches Drucken, 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;}

Leider friert es repl.it ein, anstatt in der Endlosversion wie geschrieben richtig auszugeben (ich glaube, es ist ein Fehler in repl.it, da es nicht so ausgegeben wird, wie es die Programmschleifen sollten) Computer. Wenn Sie einen Lesevorgang am Anfang der Schleife einfügen, funktioniert dies auch in repl.it.

Ausgaben an die Konsole, offensichtlich.

Auf jedem endlichen System wird der Code höchstwahrscheinlich irgendwann mit einem Speicherfehler abstürzen.

Der Code wurde überarbeitet, um @danas Lambda zu verwenden.

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

Probieren Sie es online!

Viertens (viertens) , 63 Bytes

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

Probieren Sie es online!

0-indizierte Ausgänge n-ter Wert

Erläuterung

Wenn N kleiner als 6 ist, geben Sie den Absolutwert von N - 6 aus. Anderenfalls erhalten Sie den Quotienten und den Rest der Division von N durch 6. Rufen Sie die Funktion rekursiv für den Quotienten auf und rufen Sie sie dann für den Rest auf.

Code-Erklärung

: 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 Zeichen, 54 Byte

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

Übersetzen Sie die Lösung von Dana /codegolf//a/179980 in 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 #, Drucken von Anfang bis n, ??? Bytes

Dank an @dana für den Lambda-Ausdruck.

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

Vorgang: Führen Sie den Befehl mit dem Argument 0 in der Befehlszeile aus, das der Ganzzahl entspricht, bis zu der Sie zählen möchten. (Es sollte beachtet werden, dass dies a[0]ein Verweis auf das ansonsten nicht erwähnte Befehlszeilenarray args ist, und ich weiß nicht, wie ich es zählen soll.)