Introdução

Pode soar estranho, mas não tem um desafio para a contar a partir 1de n, inclusive.

Isto não é a mesma coisa. Esse é um desafio (fechado) não bem explicado.
Isto não é a mesma coisa. Essa é sobre contar indefinidamente.

Desafio

Escreva um programa ou função que imprima todos os números inteiros de 1para ninclusivo.

Regras

• Você pode obter nqualquer maneira.
• Você pode assumir que nsempre será um número inteiro positivo.
• Você pode entrar nem qualquer base, mas sempre deve imprimir em decimal.
• A saída deve ser separada por qualquer caractere (ou padrão) que não esteja 0123456789. Caracteres iniciais ou finais não decimais são permitidos (por exemplo, ao usar matrizes como [1, 2, 3, 4, 5, 6]).
• As brechas padrão são negadas.
• Queremos encontrar a abordagem mais curta em cada idioma, não no idioma mais curto, por isso não aceitarei nenhuma resposta.
• Você deve atualizar suas respostas após esta edição, as respostas postadas antes da última edição devem estar de acordo com a regra de alteração sobre brechas padrão (eu não queria negá-las, mas não queria fazer a comunidade rugir, então Eu os neguei).
• Você pode usar qualquer versão do idioma pós-namoro (ou idioma). Você não pode usar nenhum idioma ou versão de idioma criada apenas para esse desafio.

Bónus

20%

• Seu programa deve poder contar pelo menos até 18446744073709551615( 2^64-1). Por exemplo, se um novo tipo de dados é a única maneira de oferecer suporte a números inteiros grandes, você deve construí-lo. Se o seu idioma não tem como suportar números inteiros enormes até 2 ^ 64-1, o limite superior desse idioma específico deve ser suportado.

EDIT : Alterei o limite de 2^64para 2^64-1para permitir mais respostas.

EDIT : Eu fiz da regra 2 ^ 64-1 um bônus, pois não houve muito interesse nesse desafio. Se sua resposta suportar 2 ^ 64-1, você poderá editá-la para incluir o bônus. Além disso, você pode postar uma resposta que não a suporte, se for mais curta.

MarioLANG , 29 bytes

;
)    <
+===="
>:(-[!
=====#

Experimente online!

Eu sei que meu código está tristemente super-triste ou zangado:

> :(

Feliz MarioLANG, 46 bytes

;
)       <
+======="
>  >((-[!
=:)^====#
 ===

Experimente online!

Uma abordagem mais feliz:

 :)

MarioLANG não emocional, 41 bytes

;
)     <
+====="
> >(-[!
= "===#
 :!
 =#

Experimente online!

Pitão, 1 byte

S

_{O corpo deve ter pelo menos 30 caracteres; você digitou 14.}

Cjam, 5 bytes

{,:)}

Experimente online!

Este é um bloco sem nome que espera nna pilha e deixa uma lista com o intervalo [1...n]nela.
Funciona apenas criando o intervalo ,e, em seguida, incrementando cada elemento do intervalo :)para torná-lo baseado em um.

Mathematica, 5 bytes

Range

Simples o suficiente.

Hexagonia, 19

$@?!{M8.</(=/>').$;

Ou no formato hexagonal expandido:

  $ @ ?
 ! { M 8
. < / ( =
 / > ' ) 
  . $ ;

Um enorme agradecimento a Martin por ter basicamente elaborado este programa, eu apenas o joguei para encaixar em um hexágono lateral de comprimento 3.

Experimente online!

Eu não tenho os fantásticos programas relacionados ao Hexagony do Timwi, então essa explicação não será muito colorida. Em vez disso, você pode ler uma enorme bolha de texto. Isso não é legal?

De qualquer forma, o IP começa no canto superior esquerdo $, movendo-se para o leste, se você imaginar que este programa foi colocado com o Norte voltado para cima em um mapa. O $-nos faz saltar a próxima instrução, o que seria @, o que acabaria com o programa. Em vez disso, executamos o ?que define a borda da memória atual como o número de entrada. Agora chegamos ao final da linha, que nos leva à linha do meio do hexágono, ainda se movendo para o leste.

A maior parte do restante do programa é um loop. Começamos com o .que é um não-op. Em seguida, encontramos um garfo no ... uh ... hexágono ... a <instrução faz com que o IP gire 60 graus para a direita se a borda da memória atual for positiva, caso contrário, giramos 60 graus para a esquerda. Como estamos nos movendo para o leste, acabamos com o rumo sul ou nordeste. Como a entrada é maior que zero (e, portanto, positiva), sempre começamos indo para o sudeste.

Em seguida, atingimos um >que nos redireciona para o leste; esses operadores apenas bifurcam se você tocar na parte do garfo. Em seguida, atingimos o 'que muda a borda da memória que estamos olhando. Em seguida, atingimos )quais incrementos o valor da borda da memória atual. Como todas as bordas da memória começam em 0, na primeira vez que fazemos isso, obtemos o valor 1. Em seguida, saltamos para a segunda linha superior e executamos o !que imprime nosso número. Em seguida, passamos para outra aresta {e armazenamos o valor ASCII de M multiplicado por 10 mais 8 (778). Então, voltamos à penúltima linha do hexágono e atingimos o /. Isso resulta em nos mudarmos para o noroeste. Passamos .pela linha do meio e saímos pela;no canto inferior direito. Isso imprime o mod de borda de memória atual 256 como ASCII. Isso passa a ser uma nova linha. Acertamos o 'que nos leva de volta à primeira margem que tem o valor que lemos. O acerto /que nos leva a avançar para o leste novamente. Então atingimos o (que diminui o valor. =nos leva a encarar a direção certa novamente para o futuro salto da borda da memória.

Agora, como o valor é positivo (a menos que seja zero), voltamos ao fundo do hexágono. Aqui nós batemos, .então pulamos o ;caminho para que nada aconteça e voltamos ao início do loop. Quando o valor é zero, voltamos ao início do programa, onde as mesmas coisas acontecem novamente, mas ?não conseguimos encontrar outro número, e seguimos o outro caminho de ramificação. Esse caminho é relativamente simples: atingimos o {que muda a borda da memória, mas não nos importamos mais, depois atingimos o @final do programa.

MATL, 1 byte

:

Exemplo de saída:

15
1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Experimente online aqui

GNU Coreutils, 6 bytes

seq $1

resposta dividida para o bash puro, veja abaixo ...

R, 13 bytes

cat(1:scan())

O corpo deve ter pelo menos 30 caracteres.

Javascript 182 177 160 154 139 138 132 bytes (válido)

1 byte salvo graças a @ShaunH

n=>{c=[e=0];for(;c.join``!=n;){a=c.length-1;c[a]++;for(;a+1;a--){c[a]+=e;e=0;if(c[a]>9)c[a]=0,e++;}e&&c.unshift(1);alert(c.join``)}}

Precisão arbitrária para o resgate!

Como o javascript pode contar apenas com 2 ^ 53-1 (obrigado ao @ MartinBüttner por apontar), eu precisava criar precisão arbitrária para fazer isso. Ele armazena dados em uma matriz e cada "tick" adiciona 1 ao último elemento, depois passa pela matriz e, se algo exceder 9, define esse elemento como 0 e adiciona 1 ao lado esquerdo.

Experimente aqui! Nota: pressione F12 para realmente ver o resultado, pois não queria fazer você esperar pelas caixas de texto.

Entre: eu era o único, quem não sabia, operadores ternários são tão úteis no codegolf?

if(statement)executeSomething();

é maior que

statement?executeSomething():0;

por 1 byte.

Javascript, 28 bytes (inválido - não pode contar até 2 ⁶⁴ )

n=>{for(i=0;i++<n;)alert(i)}

Java 8, 43/69/94 bytes

^{_{Riscado 44 ainda é um 44 normal - espere, eu não o ri, apenas o substitui :(}}

Se eu puder retornar um LongStream: ( 43 bytes)

n->java.util.stream.LongStream.range(1,n+1)

Este é um lambda para a Function<Long,LongStream>. Tecnicamente, devo usar em rangeClosedvez de range, pois estou cortando uma da minha entrada máxima dessa maneira, mas rangeClosedé maior que range.

Se eu tiver que imprimir na função: ( 69 bytes)

n->java.util.stream.LongStream.range(1,n+1).peek(System.out::println)

Este é um lambda para a Consumer<Long>. Tecnicamente, estou abusando peek, pois é uma operação intermediária , o que significa que este lambda está retornando tecnicamente LongStreamcomo o primeiro exemplo; Eu deveria estar usando em seu forEachlugar. Novamente, o golfe não é um código legal.

Infelizmente, como longo intervalo é um número inteiro de 64 bits assinado , ele não atinge o solicitado 2^64-1, mas apenas 2^63-1.

No entanto , o Java SE 8 fornece funcionalidade para tratar longs como se não fossem assinados, chamando métodos específicos na Longclasse explicitamente. Infelizmente, como Java ainda é Java, isso é bastante demorado, embora mais curto que a versão BigInteger que substitui. ( 94 bytes)

n->{for(long i=0;Long.compareUnsigned(i,n)<0;)System.out.println(Long.toUnsignedString(++i));}

Este é um Consumer<Long>, como o anterior.

^{_{E muito tempo para evitar rolagem.}}

05AB1E , 1 byte

Código:

L

Experimente online! .

Uma abordagem mais interessante:

FN>,

Explicação:

F     # For N in range(0, input):
 N>   #   Push N + 1
   ,  #   Pop and print with a newline

Experimente online! .

MATLAB, 7 bytes

Uma função anônima sem nome:

@(n)1:n

Correr como:

ans(10)
ans =
     1     2     3     4     5     6     7     8     9    10

Teste aqui!

Se um programa completo for necessário, 17 bytes:

disp(1:input(''))
10
     1     2     3     4     5     6     7     8     9    10

Teste aqui!

Haskell, 10 bytes

f n=[1..n]

Exemplo de uso: f 4-> [1,2,3,4].

MarioLANG , 19 bytes

;
)<
+"
:[
(-
>!
=#

Experimente online!

Programas verticais geralmente são mais fáceis de jogar em loops simples no MarioLANG. Não tenho certeza do que o intérprete faz ao encontrar [dentro de um elevador, mas parece encerrar o programa quando a célula atual é 0. Esse é provavelmente um truque útil em geral.

Explicação

MarioLANG é uma linguagem semelhante ao Brainfuck (com uma fita de memória infinita de números inteiros de precisão arbitrária) onde o ponteiro de instruções se assemelha a Mario andando e pulando.

Mario começa no canto superior esquerdo e cai para baixo. ;lê um número inteiro de STDIN e o coloca na célula de memória atual. Agora observe que =é uma célula de chão para Mario andar, "e #formar um elevador ( #sendo o começo) e !faz mario parar no elevador para que ele não saia imediatamente. O >e <definiu sua direção de movimento. Podemos ver que isso fornece um loop simples, contendo o seguinte código:

)   Move memory pointer one cell right.
+   Increment (initially zero).
:   Print as integer, followed by a space.
(   Move memory pointer one cell left.
-   Decrement.
[   Conditional, see below.

Agora, normalmente [, faria Mario pular o próximo, dependendo se a célula atual é zero ou não. Ou seja, desde que o contador seja diferente de zero, isso não fará nada. No entanto, parece que quando Mario encontra um [tempo em um elevador e a célula atual está 0, o programa simplesmente termina imediatamente com um erro, o que significa que nem precisamos encontrar uma maneira de redirecioná-lo corretamente.

Joe - 2 ou 6

Embora você possa usar a variante inclusiva da função range.

1R

..Isto é chato! Vamos pegar a soma cumulativa ( \/+) de uma tabela com a forma n ( 1~T).

\/+1~T

Pitão - 3 2 bytes

1 bytes salvos graças a @DenkerAffe.

Sem usar o builtin.

hM

Experimente online .

Pyke, 1 byte

S

Experimente aqui!

Ou 2 bytes sem o builtin

mh

Experimente aqui!

#h

Experimente aqui!

Lh

Experimente aqui!

dc, 15

?[d1-d1<m]dsmxf

Entrada lida de stdin. Isso é decrescente n, empurrando uma cópia de cada número para a pilha. A pilha é então fimpressa como uma com o comando, para que os números sejam impressos na ordem crescente correta.

Como todos os números são enviados para a pilha, é altamente provável que a memória fique sem antes de chegar perto de 2 ^ 64. Se isso for um problema, podemos fazer isso:

dc, 18

?sn0[1+pdln>m]dsmx

ArnoldC, 415 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE n
YOU SET US UP 0
GET YOUR ASS TO MARS n
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
HEY CHRISTMAS TREE x
YOU SET US UP n
STICK AROUND x
GET TO THE CHOPPER x
HERE IS MY INVITATION n
GET DOWN x
GET UP 1
ENOUGH TALK
TALK TO THE HAND x
GET TO THE CHOPPER x
HERE IS MY INVITATION n
GET DOWN x
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED

A única coisa interessante é usar nx (onde n é o objetivo ex a variável incrementada) para testar o final do loop while em vez de ter uma variável dedicada, então acabo tendo nx e n- (nx) = x em cada ciclo executado

Nota : Só posso contar com 2 ^ 31-1. Bem, acho que os Terminadores não são um perigo real, afinal.

Piet, 64 Codels

Com codelsize 20:

Imagens de rastreamento Npiet

Primeiro loop:

Rastreio restante para n=2:

Notas

• Nenhuma resposta de Piet ainda? Deixe-me consertar isso com meu primeiro programa Piet! Provavelmente isso poderia ser mais curto com melhores rolagens e menos manipulação de ponteiro ...

• O limite superior suportado depende da implementação do intérprete. Teoricamente, seria possível suportar números arbitrariamente grandes com o intérprete correto.

• O delimitador é ETX(Ascii 3), no entanto, isso não pode ser exibido corretamente nesta resposta, então eu os deixarei de fora. Funciona no console:

Saída

Input:  1
Output: 1

Input:  20
Output: 1234567891011121314151617181920

Input:  100
Output: 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

Undefined behaviour:

Input:  -1
Output: 1

Input:  0
Output: 1

Npiet trace for n=2

trace: step 0  (0,0/r,l nR -> 1,0/r,l lB):
action: in(number)
? 2
trace: stack (1 values): 2

trace: step 1  (1,0/r,l lB -> 2,0/r,l nB):
action: push, value 1
trace: stack (2 values): 1 2

trace: step 2  (2,0/r,l nB -> 3,0/r,l nG):
action: duplicate
trace: stack (3 values): 1 1 2

trace: step 3  (3,0/r,l nG -> 4,0/r,l dY):
action: out(number)
1
trace: stack (2 values): 1 2

trace: step 4  (4,0/r,l dY -> 5,0/r,l lY):
action: push, value 1
trace: stack (3 values): 1 1 2

trace: step 5  (5,0/r,l lY -> 6,0/r,l lG):
action: add
trace: stack (2 values): 2 2

trace: step 6  (6,0/r,l lG -> 7,0/r,l lR):
action: duplicate
trace: stack (3 values): 2 2 2

trace: step 7  (7,0/r,l lR -> 10,0/r,l nR):
action: push, value 3
trace: stack (4 values): 3 2 2 2

trace: step 8  (10,0/r,l nR -> 12,0/r,l dR):
action: push, value 2
trace: stack (5 values): 2 3 2 2 2

trace: step 9  (12,0/r,l dR -> 13,0/r,l lB):
action: roll
trace: stack (3 values): 2 2 2

trace: step 10  (13,0/r,l lB -> 14,0/r,l lG):
action: duplicate
trace: stack (4 values): 2 2 2 2

trace: step 11  (14,0/r,l lG -> 15,2/d,r nG):
action: push, value 3
trace: stack (5 values): 3 2 2 2 2

trace: step 12  (15,2/d,r nG -> 15,3/d,r dG):
action: push, value 1
trace: stack (6 values): 1 3 2 2 2 2

trace: step 13  (15,3/d,r dG -> 14,3/l,l lR):
action: roll
trace: stack (4 values): 2 2 2 2

trace: step 14  (14,3/l,l lR -> 13,1/l,r lC):
action: greater
trace: stack (3 values): 0 2 2

trace: step 15  (13,1/l,r lC -> 11,1/l,r nC):
action: push, value 3
trace: stack (4 values): 3 0 2 2

trace: step 16  (11,1/l,r nC -> 10,1/l,r lB):
action: multiply
trace: stack (3 values): 0 2 2

trace: step 17  (10,1/l,r lB -> 9,1/l,r nY):
action: pointer
trace: stack (2 values): 2 2

trace: step 18  (9,1/l,r nY -> 7,1/l,r dY):
action: push, value 2
trace: stack (3 values): 2 2 2

trace: step 19  (7,1/l,r dY -> 6,1/l,r lY):
action: push, value 1
trace: stack (4 values): 1 2 2 2

trace: step 20  (6,1/l,r lY -> 5,1/l,r nM):
action: roll
trace: stack (2 values): 2 2

trace: step 21  (5,1/l,r nM -> 4,1/l,r dM):
action: push, value 3
trace: stack (3 values): 3 2 2

trace: step 22  (4,1/l,r dM -> 3,1/l,r lG):
action: pointer
trace: stack (2 values): 2 2

trace: step 23  (3,1/d,r lG -> 2,3/l,l nG):
action: push, value 3
trace: stack (3 values): 3 2 2

trace: step 24  (2,3/l,l nG -> 2,2/u,r lY):
action: out(char)

trace: stack (2 values): 2 2
trace: white cell(s) crossed - continuing with no command at 2,0...

trace: step 25  (2,2/u,r lY -> 2,0/u,r nB):

trace: step 26  (2,0/u,r nB -> 3,0/r,l nG):
action: duplicate
trace: stack (3 values): 2 2 2

trace: step 27  (3,0/r,l nG -> 4,0/r,l dY):
action: out(number)
2
trace: stack (2 values): 2 2

trace: step 28  (4,0/r,l dY -> 5,0/r,l lY):
action: push, value 1
trace: stack (3 values): 1 2 2

trace: step 29  (5,0/r,l lY -> 6,0/r,l lG):
action: add
trace: stack (2 values): 3 2

trace: step 30  (6,0/r,l lG -> 7,0/r,l lR):
action: duplicate
trace: stack (3 values): 3 3 2

trace: step 31  (7,0/r,l lR -> 10,0/r,l nR):
action: push, value 3
trace: stack (4 values): 3 3 3 2

trace: step 32  (10,0/r,l nR -> 12,0/r,l dR):
action: push, value 2
trace: stack (5 values): 2 3 3 3 2

trace: step 33  (12,0/r,l dR -> 13,0/r,l lB):
action: roll
trace: stack (3 values): 2 3 3

trace: step 34  (13,0/r,l lB -> 14,0/r,l lG):
action: duplicate
trace: stack (4 values): 2 2 3 3

trace: step 35  (14,0/r,l lG -> 15,2/d,r nG):
action: push, value 3
trace: stack (5 values): 3 2 2 3 3

trace: step 36  (15,2/d,r nG -> 15,3/d,r dG):
action: push, value 1
trace: stack (6 values): 1 3 2 2 3 3

trace: step 37  (15,3/d,r dG -> 14,3/l,l lR):
action: roll
trace: stack (4 values): 2 3 2 3

trace: step 38  (14,3/l,l lR -> 13,1/l,r lC):
action: greater
trace: stack (3 values): 1 2 3

trace: step 39  (13,1/l,r lC -> 11,1/l,r nC):
action: push, value 3
trace: stack (4 values): 3 1 2 3

trace: step 40  (11,1/l,r nC -> 10,1/l,r lB):
action: multiply
trace: stack (3 values): 3 2 3

trace: step 41  (10,1/l,r lB -> 9,1/l,r nY):
action: pointer
trace: stack (2 values): 2 3
trace: white cell(s) crossed - continuing with no command at 9,3...

trace: step 42  (9,1/d,r nY -> 9,3/d,l nR):

JavaScript (ES6), 77 76 63 59 58 bytes

n=>{for(s=a=b=0;s!=n;console.log(s=[a]+b))a+=!(b=++b%1e9)}

Recebe entrada ncomo uma sequência, deve suportar até 9007199254740991999999999

Explicado:

n=>{ //create function, takes n as input
    for( //setup for loop
        s=a=b=0; //init s, a, and b to 0
        s!=n; //before each cycle check if s!=n
        console.log(s=[a]+b) //after each cycle concat a and b into to s and print
    )
        a+=!(b=++b%1e9) //During each cycle set b to (b+1)mod 1e9, if b == 0 and increment a
} //Wrap it all up

GNU bc, 23

n=read()
for(;i++<n;)i

Entrada lida de stdin. bclida com números de precisão arbitrários por padrão, portanto, o máximo de 2 ^ 64 não é problema.

Na verdade, 1 byte

R

Aborrecido builtin é chato. Requer uma versão de 64 bits do Python 3 para obter todo o caminho2**64 .

Experimente online! (devido a restrições de memória e comprimento de saída, o intérprete on-line não pode aumentar muito).

Aqui está uma versão de 5 bytes que não requer Python 3 de 64 bits e é um pouco mais agradável no uso de memória:

W;DWX

Experimente online! (veja advertências acima)

Fuzzy-Octo-Guacamole, 7 bytes

^!_[+X]

Explicação:

^ get input to ToS
! set for loop to ToS
_ pop
[ start for loop
+ increment ToS (which aparently happens to be 0)
X print ToS
] end for loop

Oração, 31 bytes (não concorrente)

literally, print range(input())

QBASIC, 43 bytes

1 INPUT a
2 FOR b=1 TO a
3 PRINT b
4 NEXT b

Cubix , 17 bytes

..U;I0-!@;)wONow!

Experimente aqui

Cubix é uma linguagem 2D criada por @ETHProductions onde os comandos são agrupados em um cubo. Esse programa é agrupado em um cubo com um comprimento de borda de 2 da seguinte maneira.

    . .
    U ;
I 0 - ! @ ; ) w
O N o w ! . . .
    . .
    . .

• I obtém a entrada inteira
• 0 empurre 0 para a pilha
• - subtrair itens principais da pilha
• !se realmente pular, o próximo comando será @encerrado
• ; pop o resultado da subtração da pilha
• ) incrementar o topo da pilha
• wmova o ip para a direita e continue. Isso faz com que ele caia para a próxima linha
• O produzir o topo da pilha como um número
• N empurre o avanço de linha (10) para a pilha
• o gerar um avanço de linha
• wmova o ip para a direita e continue. Isso faz com que caia para a próxima face
• ! porque TOS realmente, pule o @ final
• ; pop o avanço de linha da pilha
• Uvire à esquerda para a -subtração e retome a partir daí

Python 2, 37 33 32 33 bytes

for i in xrange(input()):print-~i

Presumivelmente, funciona até 2**64e além.

Derrubado quatro bytes graças a @dieter , e outro graças a @orlp . Mas, aparentemente, como o @ Sp3000 descobriu, range()pode ter problemas com valores mais altos, então a função foi alterada paraxrange() . Nota: xrange()pode haver problemas, pelo menos no 2.7.10 .

Zsh, 12 bytes

echo {1..$1}

Isso funciona porque as variáveis ​​são expandidas antes das chaves.

V, 11 bytes

é1@añYpñdd

Como ele contém UTF-8 desagradável e não imprimíveis, aqui está um hexdump reversível:

00000000: e931 4061 f159 7001 f164 64              .1@a.Yp..dd

V é uma linguagem inacabada que escrevi, mas está funcionando desde o commit 19 . Essa resposta foi um pouco mais detalhada do que eu gostaria, mas isso ocorre principalmente porque V não tem conhecimento de números inteiros, apenas de strings. Portanto, é uma resposta decente! Isso vai funcionar até 2 ^ 64, mas provavelmente vai demorar um muito longo tempo.

Para facilitar a leitura / gravação da minha explicação, trabalharei com esse "formulário legível por humanos", que é como você digitaria isso no vim.

<A-i>1@a<A-q>Yp<C-a><A-q>dd

Explicação:

'Implicit: register "a" == arg 1, and any generated text is printed. 

<A-i>1                       'Insert a single character: "1"
      @a                     ' "a" times, 
        <A-q>       <A-q>    'Repeat the following:
             Yp<C-a>         'Duplicate the line, and increment it
                         dd  'Delete the last line, since we have one too many.

Se forem permitidas brechas, aqui está uma versão mais curta que imprime 1 para n, mas também imprime um 0 (8 bytes):

é0@añYp

E na forma legível:

<A-i>1@a<A-q>Yp<C-a>

Isso é mais curto porque o <A-q> final está implícito; portanto, não precisamos disso se não precisarmos excluir a última linha.