Tâche principale

Votre tâche consiste à imprimer les nombres entiers par ordre décroissant, en partant de 1 et en augmentant au fur et à mesure que vous appuyez à nouveau sur 1, jusqu’à ce que l’entrée donnée soit atteinte, puis imprimez le reste jusqu’à ce que vous frappiez à nouveau 1. Exemple avec entrée 6:

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

Contribution

Votre code peut prendre n'importe quel type d’entrée (graphique, STDIN) sous forme d’entier ou de nombre.

Sortie

Votre code doit sortir la séquence décrite ci-dessus, jusqu'à atteindre le nombre saisi, puis terminer la sortie jusqu'à ce qu'il atteigne à nouveau 1. La sortie peut être n'importe quoi, donc des nombres, des chaînes, des entiers ou une sortie graphique. Il est nécessaire d'imprimer un seul numéro (pas de saut de ligne s'il s'agit d'une chaîne). Votre sortie peut être insérée et créée avec autant de caractères que vous le souhaitez (par exemple []).

Comme il y a eu un malentendu, voici un modèle de regex sur lequel vous pouvez essayer vos sorties.

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

Règles

• La sortie doit être un nombre entier, ne pas être divisé par quoi que ce soit, même pas de nouvelles lignes.
• L'algorithme ne doit pas vérifier si la première instance de N apparaît de quelque manière que ce soit (par exemple, le 21in 121321), mais plutôt pour la première instance de N en tant que nombre réel.
• Un seul retour à la ligne est autorisé.
• Le traitement des entrées négatives est entièrement votre choix, les nombres négatifs ne sont pas des cas à tester.

Cas de test

Input: 6
Output: 121321432154321654321


Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Gagnant

Le gagnant a été choisi! C'était la réponse d' ErikGolfer avec un impressionnant 5 octets! Toutes nos félicitations!

Gelée , 5 octets

RRUVV

Essayez-le en ligne!

La formule n'est pas la mienne.

Je soupçonne que trop de choses se passent ici ...

[REPONSE ACCEPTE] J'aurais donné 5 rep à Dennis, mais ce n'est pas une réputation d'échange. Dennis m'a montré le VVcomportement. À ma grande surprise, c'est plus court que 05AB1E.

05AB1E , 6 octets

L€LíJJ

Essayez-le en ligne!

Explication

Exemple d'entrée 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 octets

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

Démo

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

console.log(f(6))

Autre méthode pour n <10, 34 octets (non en concurrence)

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

En JavaScript, les chaînes sont immuables. Par conséquent, il est impossible de modifier le contenu du Nième caractère d'une chaîne sen affectant une nouvelle valeur à s[N].

Cependant, l'expression ++s[N]est valide et est évaluée comme prévu, même si la chaîne reste inchangée. Par exemple:

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

Et par extension:

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

V, 29 28 27 23 19 17 16 octets

8 octets sauvés grâce à @DJMcMayhem

3 octets sauvegardés grâce à @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Personnages cachés:

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

C-x est Ctrl + x.

Essayez-le en ligne! prend une entrée via des arguments en ligne de commande

Hexdump:

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

Explication

"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

Maintenant, il ressemble à:

1
2
...
n

a continué...

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

GIF (obsolète)

(pour arg 6)

C #, 72 69 65 octets

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

Si la sortie peut simplement être renvoyée plutôt que d'être écrite sur la console

C #, 71 68 64 octets

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

Merci à @VisualMelon pour avoir économisé beaucoup d'octets

Testez-le ici (avec humour, le compilateur en ligne rompt à un nombre supérieur à 420)

Pure bash, 34

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

Deux niveaux d'expansion de corset. Avec l'entrée 6, le premier niveau se développe à {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Cela se développe ensuite à 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, qui est mélangé à une chaîne avec printf %s. eval's sont requis aux deux niveaux d'expansion - pour le premier niveau afin que le $1paramètre soit développé en premier, et pour le deuxième niveau afin qu'il se développe après le premier niveau.

Essayez-le en ligne

Perl, 21 octets

Utilisations -Esans frais supplémentaires.

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

Usage

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

Pyth, 7 octets

jks}R1S

Un programme qui prend l'entrée d'un entier et imprime le résultat.

Essayez-le en ligne!

Comment ça marche

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 octets

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

Chaque ligne est entrée séparément dans la barre de saisie. L'entrée est prise à partir d'une zone de saisie.

Voici un gif de l'exécution:

Comment ça marche

La saisie 1attribue implicitement aà 1et la InputBoxcommande associe une zone de saisie à a. Ensuite, pour chaque ientrée {1, 2, 3, ..., a}, la liste {i, i-1, i-2, ..., 1}est créée à l'aide de la Sequencecommande et chaque élément jde cette liste est convertie en chaîne à l'aide de Text. Enfin, Joinfusionne toutes les listes et Sumconcatène tous les éléments en un seul objet texte affiché.

Python 2, 51 octets

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

Retina , 26 22 bytes

Le nombre d'octets suppose un codage ISO 8859-1.

.+
$*

$`¶
1
$.%'
0?¶

Essayez-le en ligne!

Explication

.+
$*

Convertir une entrée en unaire.

$`¶

À chaque position, insérez le préfixe jusqu’à ce point, ainsi qu’un saut de ligne. Cela crée une plage unaire allant de 2à n+1, une valeur par ligne.

1
$.%'

Remplacez chacun 1par le nombre de caractères après celui-ci sur la même ligne. Cela tourne quelque chose comme 11111dans 43210.

0?¶

Supprimez tous les sauts de ligne et les zéros qui les précèdent.

Langue GameMaker, 65 octets

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

APL, 10 octets

∊⍕¨∘⌽∘⍳¨∘⍳

Par exemple:

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

Explication:

• ⍳: obtenez les nombres de 1 à N.
• ⍳¨∘: pour chacune d’elles, obtenez les nombres de 1 à N.
• ⌽∘: inverser cette liste
• ⍕¨∘: obtenir la représentation en caractères de chaque élément (pour ne pas afficher les nombres avec des espaces entre eux)
• ∊: aplatit le tableau résultant

Python 2, 71 68 octets

Je parie qu'une solution récursive pourrait être plus courte, mais j'ai du mal à formuler cela en une.

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

Essayez-le en ligne

En fait 8 octets

RR♂RΣRεj

La première fois que vous postez une réponse dans En fait, vous pouvez probablement jouer au golf.

Comment ça marche

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)

Essayez-le en ligne!

Brachylog , 8 octets

yb@[rcw\

Essayez-le en ligne!

Explication

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 octets

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

Un lambda qui retourne une chaîne.

( Essayez-le en ligne. )

Explication:

• 1..$_: Gamme d'entiers ... (1 2 3 4)
• [,] 1..$_: Réduisez ("pliez") l'opérateur de virgule ... (1 2 3 4)
• [\,] 1..$_: Avec résultats intermédiaires ( réduction triangulaire ) ...((1) (1 2) (1 2 3) (1 2 3 4))
• [\R,] 1..$_: Appliquer le méta-opérateur d' inversion à la virgule ...((1) (2 1) (3 2 1) (4 3 2 1))
• [~] flat ...: Supprimer l'imbrication de la liste et replier l'opérateur de concaténage ... 1213214321

Haskell, 35 octets

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

Exemple d'utilisation: f 6-> "121321432154321654321".

Pour tous les nombres xde 1 ... xla liste x,x-1, ... ,1, convertissez-les en chaîne et concaténez-les en une seule chaîne. Encore une fois, concaténez ces chaînes en une seule chaîne.

C89, 54 octets

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

56 -2 = 54 grâce à ErikGolfer!

Python 3, 87 92 83 74 octets

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

Réponse plus courte en utilisant la récursivité:

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

Ce n'est peut-être pas le plus court, mais il est uniquement réalisé avec la compréhension de liste de Python!

(Edité pour ajouter la fonction d'impression et supprimer le \ n)

(Edité pour supprimer la fonction d'impression et changer n + 1, k + 1 en n, k + 2)

Pyth, 8 octets

jks_M._S

Explication

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 octets

LR.sJJ

Essayez-le en ligne!

Mathematica, 36 octets

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

Lance une série d’avertissements qui peuvent être ignorés en toute sécurité.

Explication

En utilisant l’entrée 5comme exemple:

Range@#

Crée une plage {1, 2, 3, 4, 5}.

Range[...,1,-1]

Rangeest listable afin que nous puissions lui donner une liste pour n’importe lequel de ses arguments et il sera automatiquement passé au-dessus de cet argument. Cela nous donne donc un tas de listes inversées:

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

Prochain:

(""<>...)

Cela joint la liste imbriquée à la chaîne vide. Comme la liste imbriquée ne contient aucune chaîne, elle ne peut pas joindre les valeurs (c'est là que sont générés les avertissements), mais ""<>a pour effet secondaire d’aplatir la liste. Donc cela nous donne

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

Vient maintenant la belle fonctionnalité de Mathematica qui Mapne se soucie pas de la structure sur laquelle elle est en train d'être cartographiée Vous l'appliquez normalement à une liste, mais cela fonctionne avec n'importe quelle tête. f /@ h[a, b, c]vous donne simplement h[f[a], f[b], f[c]]. Dans notre cas, la tête est StringJoinet les valeurs sont les entiers.

ToString/@...

Donc, cela transforme simplement les nombres entiers en chaînes. À ce stade, il StringJoin[...]sait quoi faire avec et les joint tous en une seule chaîne:

"121321432154321"

GolfScript , 14 octets

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

Essayez-le en ligne!

Méthode habituelle bien sûr, mais c'est GolfScript.

Explication de ce code VAST :

~,{),{)}%-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

Notez que la sortie est sous la forme d’un nombre unique. Trailing \n.

R, 38 33 44 octets

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

Prend une entrée dans STDIN, et boucle de 1 à n, créant la séquence i à 1 pour chaque étape et l’imprimant.

Edit: remplacé seq(i,1)par la i:1sauvegarde de 5 octets et montrant pourquoi je ne devrais pas jouer au golf pendant les réunions.

MATL , 14 à 11 octets

:"@:P]v!VXz

Essayez-le en ligne!

Explication

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

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

Explication

>           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

Essayez-le en ligne!

Python , 63 57 59 octets

Une solution récursive qui fonctionne à la fois en Python 2 et 3. Cela peut probablement être joué davantage. Suggestions de golf bienvenues! Essayez-le en ligne!

Edit: -6 octets grâce à Jonathan Allan. +2 octets, merci à mbomb007 pour avoir signalé un problème avec ma réponse.

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 octets

Enregistré un octet parce que j'ai mal compté, merci Titus! Et un autre!

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

Exécuter en ligne de commande avec -r.

Réponse assez simple, boucle de 1 à travers notre entrée n, collant le numéro sur le début de la chaîne et l'imprimer.

CJam, 13 octets

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

interprète