Hauptaufgabe

Ihre Aufgabe ist es, ganze Zahlen in absteigender Reihenfolge auszudrucken, beginnend mit 1 und steigend, wenn Sie erneut 1 drücken, bis die angegebene Eingabe erreicht ist, und dann den Rest auszudrucken, bis Sie erneut 1 drücken. Beispiel mit Eingabe 6:

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321

Eingang

Ihr Code kann jede Art von Eingabe (grafisch, STDIN) in Form einer ganzen Zahl oder Zahl annehmen.

Ausgabe

Ihr Code sollte die oben beschriebene Sequenz ausgeben, bis die eingegebene Nummer erreicht ist, und dann die Ausgabe beenden, bis wieder 1 erreicht ist. Bei der Ausgabe kann es sich um eine beliebige Zahl, einen String, eine Ganzzahl oder eine grafische Ausgabe handeln. Es ist erforderlich, eine einzelne Zahl auszudrucken (keine Zeilenumbrüche, wenn es sich um eine Zeichenfolge handelt). Ihre Ausgabe kann mit beliebig vielen Zeichen ein- und ausgegeben werden (z []. B. ).

Da es einige Missverständnisse gab, ist hier ein Regex-Muster, mit dem Sie Ihre Ausgaben testen können.

^(\D*(\d)+\D*)$

Regeln

• Die Ausgabe muss eine vollständige Zahl sein, die nicht durch irgendetwas aufgeteilt wird, auch nicht durch Zeilenumbrüche.
• Der Algorithmus sollte für die erste Instanz von N nicht , in irgendeiner Weise erscheinen (zB 21in 121321), sondern eher für die erste Instanz von N als die tatsächlichen Anzahl.
• Eine einzelne abschließende Zeile ist zulässig.
• Der Umgang mit negativen Eingaben liegt ganz bei Ihnen, negative Zahlen sind keine Fälle, die Sie testen sollten.

Testfälle

Input: 6
Output: 121321432154321654321


Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Gewinner

Der Gewinner wurde ausgewählt! Es war ErikGolfers Antwort mit beeindruckenden 5 Bytes! Herzliche Glückwünsche!

Gelee , 5 Bytes

RRUVV

Probieren Sie es online!

Formel nicht meins.

Ich vermute, hier ist zu viel los ...

[ANTWORT AKZEPTIERT] Ich hätte Dennis 5 Wiederholungen gegeben, aber dies ist kein Reputationsaustausch. Dennis hat mir das VVVerhalten gezeigt. Zu meiner Überraschung ist dies kürzer als 05AB1E.

05AB1E , 6 Bytes

L€LíJJ

Probieren Sie es online!

Erläuterung

Beispieleingabe 4

L       # range [1 ... input]
        # STACK: [1,2,3,4]
 €L     # map: range
        # STACK: [[1],[1,2],[1,2,3],[1,2,3,4]]
   í    # reverse each
        # STACK: [[1],[2,1],[3,2,1],[4,3,2,1]]
    J   # join inner lists
        # STACK: ['1','21','321','4321']
     J  # join list
        # OUTPUT: 1213214321

JavaScript (ES6), 37 Byte

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

Demo

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

console.log(f(6))

Alternative Methode für n <10, 34 Bytes (nicht konkurrierend)

f=(n,s='1')=>--n?s+f(n,++s[0]+s):s

In JavaScript sind Zeichenfolgen unveränderlich. Daher ist es unmöglich, den Inhalt des N-ten Zeichens einer Zeichenfolge zu ändern, sindem Sie einen neuen Wert zuweisen s[N].

Der Ausdruck ++s[N]ist jedoch gültig und wird wie erwartet ausgewertet, auch wenn die Zeichenfolge unverändert bleibt. Zum Beispiel:

++"1"[0] // equals 2

Und im weiteren Sinne:

s = "21"
++s[0] + s // equals "321"

V, 29 28 27 23 19 17 16 Bytes

8 Bytes gespart dank @DJMcMayhem

3 Bytes gespart dank @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Versteckte Zeichen:

"apÀ<C-x>ñÄ<C-x>òy$jpkgJ

C-x ist Strg + x.

Probieren Sie es online! Nimmt Eingaben über Befehlszeilenargumente entgegen

Hexdump:

0000000: 2261 70c0 adf1 c418 f279 246a 706b 674a  "ap......y$jpkgJ

Erläuterung

"ap            Paste the argument
À<C-x>         Argument minus 1 times (so that we exclude the 0)
ñ ... ò        Loop (for some weird reason the ò closes the ñ)
Ä<C-x>         paste current line above and decrement it

Jetzt sieht es so aus:

1
2
...
n

Fortsetzung ...

ò             recursively do (until a breaking error)
y$             yank this line
  jp           paste it down
    kgJ        go up and join
              implicit ò end

GIF (veraltet)

(für arg 6)

C #, 72 69 65 Bytes

n=>{for(int i=0,j;i<n;)for(j=++i;j>0;)System.Console.Write(j--);}

Wenn die Ausgabe nur zurückgegeben werden kann, anstatt in die Konsole geschrieben zu werden

C #, 71 68 64 Bytes

n=>{var s="";for(int i=0,j;i<n;)for(j=++i;j>0;)s+=j--;return s;}

Vielen Dank an @VisualMelon für das Speichern vieler Bytes

Testen Sie es hier (Humorvollerweise bricht der Online-Compiler bei einer beliebigen Zahl über 420 ab)

Pure Bash, 34

eval eval printf %s \\{{1..$1}..1}

Zwei Stufen der Strebendehnung. Mit der Eingabe 6wird die erste Ebene auf erweitert {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Dieser erweitert sich dann zu 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, der zu einer Saite mit zusammengeklebt wird printf %s. evalAuf beiden Expansionsstufen sind 's erforderlich - für die erste Ebene, damit der $1Parameter zuerst expandiert wird, und für die zweite Ebene, damit er nach der ersten Ebene expandiert.

Probieren Sie es online aus

Perl, 21 Bytes

Verwendet -Eohne zusätzliche Kosten.

say map$}=$_.$},1..<>

Verwendungszweck

perl -E 'say map$}=$_.$},1..<>' <<< 6
121321432154321654321

Pyth, 7 Bytes

jks}R1S

Ein Programm, das die Eingabe einer Ganzzahl akzeptiert und das Ergebnis ausgibt.

Probieren Sie es online!

Wie es funktioniert

jks}R1S   Program. Input: Q
jks}R1SQ  Implicit input fill
    R     Map
      SQ  over [1, 2, 3, 4, ..., Q] with i:
   } 1     Yield [i, i-1, i-2, i-3, ..., 1]
  s       Merge
jk        Join
          Implicitly print

GeoGebra , 67 Bytes

1
InputBox[a]
Sum[Join[Sequence[Sequence[Text[j],j,i,1,-1],i,1,a]]]

Jede Zeile wird separat in die Eingabeleiste eingegeben. Die Eingabe erfolgt aus einem Eingabefeld.

Hier ist ein GIF der Ausführung:

Wie es funktioniert

Die 1implizite Eingabe weist azu 1, und der InputBoxBefehl ordnet ein Eingabefeld zu a. Dann wird für jeden iin {1, 2, 3, ..., a}der Liste {i, i-1, i-2, ..., 1}wird mit dem erstellten SequenceBefehl, und jeder jin dieser Liste wird in einen String umgewandelt mit Text. Schließlich Joinverschmilzt alle Listen und Sumverkettet alle Elemente zu einem Text - Objekt, das angezeigt wird.

Python 2, 51 Bytes

r=s=''
n=0
exec'n+=1;s=`n`+s;r+=s;'*input()
print r

Netzhaut , 26 22 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

.+
$*

$`¶
1
$.%'
0?¶

Probieren Sie es online!

Erläuterung

.+
$*

Eingabe in unär umwandeln.

$`¶

Fügen Sie an jeder Position das Präfix bis zu diesem Punkt sowie einen Zeilenvorschub ein. Dies erzeugt einen unären Bereich von 2bis n+1, einen Wert pro Zeile.

1
$.%'

Ersetzen Sie jedes 1Zeichen durch die Anzahl der Zeichen in derselben Zeile. Das macht so etwas wie 11111in 43210.

0?¶

Entfernen Sie alle Zeilenvorschübe und die vorangestellten Nullen.

GameMaker-Sprache, 65 Byte

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(c--)}return b

APL, 10 Bytes

∊⍕¨∘⌽∘⍳¨∘⍳

Z.B:

      (∊⍕¨∘⌽∘⍳¨∘⍳)6
121321432154321654321

Erläuterung:

• ⍳: Erhalte die Zahlen von 1 bis N.
• ⍳¨∘: für jeden von denen erhalten Sie die Zahlen von 1 bis N.
• ⌽∘: kehren Sie diese Liste um
• ⍕¨∘: Ermittelt die Zeichendarstellung jedes Elements (daher werden die Zahlen nicht mit Leerzeichen dazwischen ausgegeben)
• ∊: Reduziere das resultierende Array

Python 2, 71 68 Bytes

Ich wette, eine rekursive Lösung könnte kürzer sein, aber es fällt mir schwer, sie in eine zu formulieren.

n=input()
i=0
o=""
while i<n:
    i+=1;j=i
    while j:o+=`j`;j-=1
print o

Probieren Sie es online aus

Eigentlich 8 Bytes

RR♂RΣRεj

Das erste Mal, wenn Sie eine Antwort in "Eigentlich" posten, kann wahrscheinlich Golf gespielt werden.

Wie es funktioniert

Program takes implicit input, implicit print at EOF
R           Takes the input and creates a range (1, input)   
                STACK = [1,2,..,n]
 R          Reverse the top stack item (our range)
                STACK = [n,..,2,1]
  ♂R        For each item in our range, create a range (1, rangeitem)
                STACK = [[1,2,..,n], .., [1,2], [1]]
    Σ       Stitch the items of the list together
                STACK = [n,..,1,2,3,1,2,1]
     R      Reverse the top stack item again (our answer)
                STACK = [1,2,1,3,2,1,..n]
      εj    Create an empty string and append each item from the list to it.
            (turns non string items into strings)

Probieren Sie es online!

Brachylog , 8 Bytes

yb@[rcw\

Probieren Sie es online!

Erläuterung

yb         The list [1, ..., Input]
  @[       Take a prefix of that list
    rc     Reverse it and concatenate into an integer
      w    Write to STDOUT
       \   Backtrack: try another prefix

Perl 6 , 22 Bytes

{[~] flat [\R,] 1..$_}

Ein Lambda, das eine Zeichenfolge zurückgibt.

( Probieren Sie es online. )

Erläuterung:

• 1..$_: Bereich von ganzen Zahlen ... (1 2 3 4)
• [,] 1..$_: Verkleinern ("Falten") über Kommaoperator ... (1 2 3 4)
• [\,] 1..$_: Mit Zwischenergebnissen ( dreieckig reduzieren ) ...((1) (1 2) (1 2 3) (1 2 3 4))
• [\R,] 1..$_: Wende den umgekehrten Meta-Operator auf das Komma an ...((1) (2 1) (3 2 1) (4 3 2 1))
• [~] flat ...: Listenverschachtelung entfernen und String-Concat-Operator umklappen ... 1213214321

Haskell, 35 Bytes

f x=[1..x]>>= \y->[y,y-1..1]>>=show

Anwendungsbeispiel: f 6-> "121321432154321654321".

Verwandeln Sie für alle Zahlen xin 1 ... xeiner Liste x,x-1, ... ,1die Zahlen in eine Zeichenfolge und verknüpfen Sie sie zu einer einzelnen Zeichenfolge. Verketten Sie diese Zeichenfolgen erneut zu einer einzelnen Zeichenfolge.

C89, 54 Bytes

i,j;f(n){for(i=1;j<=n;j=i++)while(j)printf("%d",j--);}

56 -2 = 54 danke an ErikGolfer!

Python 3, 87 92 83 74 Bytes

lambda n:"".join(["".join([str(i)for i in range(1,k)][::-1])for k in range(1,n+2)])

Kürzere Antwort mit Rekursion:

f=lambda n:f(n-1)+"".join([str(i)for i in range(1,n+1)][::-1])if n>0else""

Vielleicht nicht die kürzeste, aber sie wird nur mit Pythons Listenverständnis erstellt!

(Bearbeitet, um die Druckfunktion hinzuzufügen und die \ n zu entfernen)

(Bearbeitet, um die Druckfunktion zu entfernen und n + 1, k + 1 in n, k + 2 zu ändern.)

Pyth, 8 Bytes

jks_M._S

Erläuterung

jks_M._SQ   Implicit input
       SQ   Get the range [1, 2, ..., N]
     ._     Get each prefix
   _M       Reverse each prefix
jks         Join everything as a string

05AB1E , 6 Bytes

LR.sJJ

Probieren Sie es online!

Mathematica, 36 Bytes

ToString/@(""<>Range[Range@#,1,-1])&

Wirft eine Reihe von Warnungen, die ignoriert werden können.

Erläuterung

Verwenden Sie die Eingabe 5als Beispiel:

Range@#

Erstellt einen Bereich {1, 2, 3, 4, 5}.

Range[...,1,-1]

Rangeist auflistbar, so dass wir ihm eine Liste für eines seiner Argumente geben können, und es wird automatisch über dieses Argument fädeln. Das gibt uns also eine Reihe von umgekehrten Listen:

{{1}, {2, 1}, {3, 2, 1}, {4, 3, 2, 1}, {5, 4, 3, 2, 1}}

Nächster:

(""<>...)

Dies verbindet die verschachtelte Liste mit der leeren Zeichenfolge. Da die verschachtelte Liste eigentlich keine Zeichenfolgen enthält, kann sie die Werte (in denen die Warnungen generiert werden) nicht wirklich verknüpfen, ""<>hat jedoch den Nebeneffekt, dass die Liste abgeflacht wird. Das gibt uns also

1 <> 2 <> 1 <> 3 <> 2 <> 1 <> 4 <> 3 <> 2 <> 1 <> 5 <> 4 <> 3 <> 2 <> 1

Jetzt kommt Mathematicas wundervolle Funktion, die Mapsich nicht um die Struktur kümmert, über die die Zuordnung erfolgt. Normalerweise wenden Sie es auf eine Liste an, aber es funktioniert mit jedem Kopf. f /@ h[a, b, c]gibt dir einfach h[f[a], f[b], f[c]]. In unserem Fall ist der Kopf StringJoinund die Werte sind die ganzen Zahlen.

ToString/@...

Das macht also einfach die ganzen Zahlen zu Strings. An diesem Punkt StringJoin[...]weiß er, was er mit ihnen machen soll und fügt sie alle zu einer einzigen Zeichenfolge zusammen:

"121321432154321"

GolfScript , 14 Bytes

~,{),{)}%-1%}%

Probieren Sie es online!

Übliche Methode natürlich, aber das ist GolfScript.

Erklärung für diesen VAST- Code:

~,{),{)}%-1%}% # Code
               # Initial stack.      ["n"]
~              # Eval ToS.           [n]
 ,             # ToS' lowered range. [[0..n)]
  {),{)}%-1%}  # Block. 1 argument.  [a]
   )           # Increment.          [a+1]
    ,          # Range.              [[0..a)]
     {)}       # Block. 1 argument.  [b]
      )        # Increment.          [b+1]
        %      # Map.                [[1..a]]
         -1    # Integer. -1         [[1..a] -1]
           %   # Each nth element.   [[a..1]]
             % # Map.                [[[1],[2,1],...,[n..1]]]
               # Implicit output.    121...n..1

Beachten Sie, dass die Ausgabe als einzelne Zahl erfolgt. Nachlauf \n.

R, 38 33 44 Bytes

if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")

Übernimmt die Eingabe in STDIN und durchläuft eine Schleife von 1 bis n, wobei für jeden Schritt die Sequenz i bis 1 erstellt und gedruckt wird.

Bearbeiten: Ersetzt seq(i,1)durch i:1Speichern von 5 Bytes und Anzeigen, warum ich während Besprechungen nicht Golf spielen sollte.

MATL , 14 11 Bytes

:"@:P]v!VXz

Probieren Sie es online!

Erläuterung

:      % Input N implicitly. Push range [1 2 ...N]
"      % For each k in [1 2 ...N]
  @:   %   Push range [1 2 ... k]
  P    %   Reverse
]      % End
v!     % Concatenate all arrays horizontally
V      % Convert to string
Xz     % Remove spaces. Display implicitly

Brainfuck, 17 Bytes

>,[>[+.>]+.[<]>-]

Erläuterung

>           keep the first cell at 0
 ,          input of the decimal number into the cell
  [>        start a conditionnal loop and go to the next cell
   [+.>]    while it don't find 0, increment each cells and output the value
    +.      increment the new cell and output
     [<]    go to the first cell
      >-]   decrement the second cell and restart

Probieren Sie es online!

Python , 63 57 59 Bytes

Eine rekursive Lösung, die sowohl in Python 2 als auch in Python 3 funktioniert. Golfvorschläge willkommen! Probieren Sie es online!

Edit: -6 Bytes dank Jonathan Allan. +2 Bytes mit Dank an mbomb007 für das Hinweisen auf ein Problem mit meiner Antwort.

f=lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

Ungolfing

def f(n):
    s = ""
    for i in range(n+1):
        m = map(str, range(n, 0, -1))
        s += "".join(m)
    return s

PHP, 35 34 33 Bytes

Ein Byte gespeichert, weil ich falsch gezählt habe, danke Titus! Und ein anderer!

while($i++<$argv[1])echo$s=$i.$s;

Führen Sie von der Kommandozeile aus mit -r.

Ziemlich einfache Antwort, durchläuft unsere Eingabe von 1 n, setzt die Zahl auf den Anfang der Zeichenfolge und druckt sie aus.

CJam, 13 Bytes

ri,:){,:)W%}%

Dolmetscher