Tarefa principal

Sua tarefa é imprimir números inteiros em ordem decrescente, iniciando em 1 e aumentando à medida que você continua pressionando 1 novamente, até que a entrada fornecida seja alcançada; depois, imprima o restante até pressionar 1 novamente. Exemplo com entrada 6:

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

Entrada

Seu código pode receber qualquer tipo de entrada (gráfica, STDIN) na forma de um número inteiro ou número.

Resultado

Seu código deve gerar a sequência descrita acima, até o número de entrada ser atingido, e terminar a saída até atingir 1 novamente. A saída pode ser qualquer coisa, portanto, números, seqüências de caracteres, números inteiros ou saída gráfica. É necessário imprimir um único número (sem novas linhas, se for uma sequência). Sua saída pode ser ampliada e ampliada com quantos caracteres você precisar (por exemplo []).

Como houve algum mal-entendido, aqui está um padrão de regex em que você pode testar suas saídas.

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

Regras

• A saída deve ser um número inteiro, não dividido por nada, nem mesmo novas linhas.
• O algoritmo não deve verificar para o primeiro exemplo de N aparecendo em qualquer forma (por exemplo, o 21na 121321), mas sim para o primeiro exemplo de N como o número real.
• Uma única nova linha à direita é permitida.
• O tratamento para entrada negativa é totalmente sua escolha; números negativos não são casos que você deve testar.

Casos de teste

Input: 6
Output: 121321432154321654321


Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Vencedora

O vencedor foi escolhido! Foi a resposta de ErikGolfer com impressionantes 5 bytes! Parabéns!

Geléia , 5 bytes

RRUVV

Experimente online!

Fórmula não minha.

Eu suspeito que há muita coisa acontecendo aqui ...

[RESPOSTA ACEITADA] Eu daria cerca de 5 representantes a Dennis, mas isso não é Reputation Exchange. Dennis me mostrou o VVcomportamento. Para minha surpresa, isso é menor que 05AB1E.

05AB1E , 6 bytes

L€LíJJ

Experimente online!

Explicação

Exemplo de entrada 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 bytes

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))

Método alternativo para n <10, 34 bytes (não concorrente)

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

No JavaScript, as strings são imutáveis. Portanto, é impossível alterar o conteúdo do enésimo caractere de uma string satribuindo um novo valor a s[N].

No entanto, a expressão ++s[N]é válida e é avaliada como seria de esperar, mesmo que a sequência permaneça inalterada. Por exemplo:

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

E por extensão:

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

V, 29 28 27 23 19 17 16 bytes

8 bytes salvos graças a @DJMcMayhem

3 bytes salvos graças a @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Personagens ocultos:

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

C-x é Ctrl + x.

Experimente online! recebe entrada por meio de argumentos da linha de comando

Hexdump:

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

Explicação

"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

Agora parece:

1
2
...
n

contínuo...

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

GIF (desatualizado)

(para arg 6)

C #, 72 69 65 bytes

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

Se a saída puder ser retornada, em vez de ser gravada no console

C #, 71 68 64 bytes

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

Agradecemos a @VisualMelon por salvar muitos bytes

Teste aqui (com humor, o compilador on-line quebra em qualquer número acima de 420)

Pure bash, 34

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

Dois níveis de expansão de braçadeira. Com a entrada 6, o primeiro nível se expande para {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Isso então se expande para 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, que é esmagado em uma string com printf %s. evalsão necessários nos dois níveis de expansão - para o primeiro nível, para que o $1parâmetro seja expandido primeiro e para o segundo nível, para que se expanda após o primeiro nível.

Experimente online

Perl, 21 bytes

Usa -Esem custo extra.

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

Uso

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

Pitão, 7 bytes

jks}R1S

Um programa que recebe a entrada de um número inteiro e imprime o resultado.

Experimente Online!

Como funciona

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]]]

Cada linha é inserida separadamente na barra de entrada. A entrada é obtida de uma caixa de entrada.

Aqui está um gif da execução:

Como funciona

Entrando 1implicitamente atribui aa 1, eo InputBoxcomando associa uma caixa de entrada com a. Então, para cada ino {1, 2, 3, ..., a}, a lista {i, i-1, i-2, ..., 1}é criado usando o Sequencecomando, e cada um jnessa lista é convertida para uma string usando Text. Por fim, Joinmescla todas as listas e Sumconcatena todos os elementos em um objeto de texto, que é exibido.

Python 2, 51 bytes

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

Retina , 26 22 bytes

A contagem de bytes assume a codificação ISO 8859-1.

.+
$*

$`¶
1
$.%'
0?¶

Experimente online!

Explicação

.+
$*

Converter entrada para unário.

$`¶

Em cada posição, insira o prefixo até esse ponto, bem como um avanço de linha. Isto cria um intervalo unária a partir 2de n+1, um valor por linha.

1
$.%'

Substitua cada um 1pelo número de caracteres depois na mesma linha. Isso transforma algo como 11111em 43210.

0?¶

Remova todos os feeds de linha e os zeros que os precedem.

Linguagem GameMaker, 65 bytes

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

APL, 10 bytes

∊⍕¨∘⌽∘⍳¨∘⍳

Por exemplo:

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

Explicação:

• ⍳: obtenha os números de 1 a N.
• ⍳¨∘: para cada um deles, obtenha os números de 1 a N.
• ⌽∘: reverter essa lista
• ⍕¨∘: obtém a representação de caractere de cada item (para que ele não produza os números com espaços entre eles)
• ∊: achatar a matriz resultante

Python 2, 71 68 bytes

Aposto que uma solução recursiva poderia ser mais curta, mas estou tendo dificuldade em formular isso em um.

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

Experimente online

Atualmente 8 bytes

RR♂RΣRεj

Publicando pela primeira vez uma resposta em Na verdade, provavelmente ela poderá jogar golfe.

Como funciona

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)

Experimente online!

Braquilog , 8 bytes

yb@[rcw\

Experimente online!

Explicação

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..$_}

Um lambda que retorna uma string.

( Experimente online. )

Explicação:

• 1..$_: Intervalo de números inteiros ... (1 2 3 4)
• [,] 1..$_: Reduza ("dobre") o operador de vírgula ... (1 2 3 4)
• [\,] 1..$_: Com resultados intermediários ( redução triangular ) ...((1) (1 2) (1 2 3) (1 2 3 4))
• [\R,] 1..$_: Aplique o meta-operador de reversão à vírgula ...((1) (2 1) (3 2 1) (4 3 2 1))
• [~] flat ...: Remova o aninhamento de lista e dobre o operador concat de cadeia ... 1213214321

Haskell, 35 bytes

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

Exemplo de uso: f 6-> "121321432154321654321".

Para todos os números xem 1 ... xfazer uma lista x,x-1, ... ,1, transforme os números em uma sequência e concatená-los em uma única sequência. Mais uma vez, concatene essas cadeias em uma única cadeia.

C89, 54 bytes

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

56 -2 = 54 graças a 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)])

Resposta mais curta usando recursão:

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

Talvez não seja o mais curto, mas é feito apenas com a compreensão da lista do Python!

(Editado para adicionar a função de impressão e remover o \ n)

(Editado para remover a função de impressão e altere n + 1, k + 1 para n, k + 2)

Pitão, 8 bytes

jks_M._S

Explicação

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

Experimente online!

Mathematica, 36 bytes

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

Lança um monte de avisos que podem ser ignorados com segurança.

Explicação

Usando a entrada 5como um exemplo:

Range@#

Cria um intervalo {1, 2, 3, 4, 5}.

Range[...,1,-1]

Rangeé listável, para que possamos fornecer uma lista para qualquer um de seus argumentos e ele automaticamente encadeará esse argumento. Portanto, isso nos fornece várias listas invertidas:

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

Próximo:

(""<>...)

Isso une a lista aninhada à sequência vazia. Como a lista aninhada não contém realmente nenhuma sequência, ela não pode realmente associar os valores (que é onde os avisos são gerados), mas ""<>tem o efeito colateral de achatar a lista. Então isso nos dá

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

Agora vem o belo recurso do Mathematica que Mapnão se importa com a estrutura que está mapeando. Você normalmente o aplica a uma lista, mas funciona com qualquer cabeçalho. f /@ h[a, b, c]simplesmente te dá h[f[a], f[b], f[c]]. No nosso caso, a cabeça é StringJoine os valores são os números inteiros.

ToString/@...

Então isso simplesmente transforma os números inteiros em strings. Nesse ponto, StringJoin[...]sabe o que fazer com eles e une todos eles em uma única sequência:

"121321432154321"

GolfScript , 14 bytes

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

Experimente online!

Método usual, é claro, mas este é o GolfScript.

Explicação para este trecho de código 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

Observe que a saída é como um número único. À direita \n.

R, 38 33 44 bytes

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

Leva entrada para STDIN e faz um loop de 1 a n, criando a sequência de 1 a 1 para cada etapa e imprimindo-a.

Editar: substituído seq(i,1)por i:1salvar 5 bytes e mostrar por que não devo jogar golfe durante as reuniões.

MATL , 14 11 bytes

:"@:P]v!VXz

Experimente online!

Explicação

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

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

Explicação

>           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

Experimente online!

Python , 63 57 59 bytes

Uma solução recursiva que funciona tanto em Python 2 quanto em 3. Isso provavelmente pode ser ainda mais complicado. Sugestões de golfe são bem-vindas! Experimente online!

Edit: -6 bytes graças a Jonathan Allan. +2 bytes com agradecimentos a mbomb007 por apontar um problema com minha resposta.

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

Salvei um byte porque eu desconectei, obrigado Titus! E outro!

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

Execute da linha de comando com -r.

Resposta bastante simples, passa de 1 a nossa entrada n, alinhando o número no início da string e imprimindo-o.

CJam, 13 bytes

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

intérprete