Contagem pessoal!

30

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.

Erik, o Outgolfer
fonte
6
Relacionado.
Martin Ender
"Você pode conseguir de nqualquer maneira." Isso significa que podemos assumir que estamos nsalvos em uma variável?
Flawr 21/05
@ flawr Você pode encontrar n qualquer maneira. Você pode salvá-lo em uma variável, mas não deve ser codificado.
Erik the Outgolfer
Pode ser útil para ligação com os métodos aceitos de I / O
Efatá
@ Efphatha Sim, provavelmente é, esse desafio é dos velhos tempos em que eu era um novato absoluto.
Erik the Outgolfer

Respostas:

60

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!

Erik, o Outgolfer
fonte
1
Há emoções ainda no último trecho, :!;)
cookie de
1
@cookie Nesse caso, você pode ver muitas coisas como um emoticon com alguma fantasia, como =#, ou >(, ou (-[, etc. Além disso, não faço ideia do porquê, mas aparentemente há uma página da Wikipedia Lista de emoticons , que não contém :!nem qualquer um dos que eu mencionei.
Kevin Cruijssen 28/03
19 bytes inspirados em outra pergunta.
Dorian
28

Pitão, 1 byte

S

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

orlp
fonte
2
Você diz? Eu estava lutando com o título!
Erik the Outgolfer
43
Isso ocorre porque você não adicionou uma explicação. Como devemos entender um código tão complicado sem uma explicação?
Luis Mendo
10
Nah. Este código está muito além da minha compreensão. Muito longa, não consigo entender essa estrutura lógica complicada :-P
Luis Mendo
7
@LuisMendo eu sei ... orlp deve ter sido um gênio para compreender um pedaço tão longo de código com uma lógica tão avançada. : P
HyperNeutrino
1
Você ainda é o vencedor atual!
Erik the Outgolfer
16

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.

Denker
fonte
9
+1 para um smiley que apareceu misteriosamente no código::)
user48538 25/04
1
@ zyabin101 o rosto sorridente é uma ocorrência muito comum de CJam!
Um Simmons
4
@ASimmons concluindo Cjam é feliz?
Erik the Outgolfer
14

Mathematica, 5 bytes

Range

Simples o suficiente.

A Simmons
fonte
33
Não é simples quando você tem que pagar para pagar essa linguagem :(
Erik o Outgolfer
1
@ ΈρικΚωνσταντόπουλος Eu diria agora que as pessoas ricas têm mais fácil, mas você conseguiu bater esta resposta por 4 bytes;)
Sebb
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Eu sei que faz muito tempo que você não comenta, mas você não paga para pagar pelo idioma, você paga pelo idioma.
NoOneIsHere
A @NoOneIsHere para pagar significa reivindicar a propriedade de algo pagando. Acho que você quer dizer que há uma assinatura em vez de um pagamento único.
Erik the Outgolfer
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Há um pagamento único de ~ 150 dólares, mas, para continuar discutindo, vamos conversar .
NoOneIsHere
14

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.

FryAmTheEggman
fonte
11

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

Stewie Griffin
fonte
1
Como é que isso funciona? Não entendo como essa estrutura de código avançada funciona. :-P
HyperNeutrino
11

GNU Coreutils, 6 bytes

seq $1

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

rexkogitans
fonte
1
para mim, a melhor resposta bash / etc ^^ perfeita relação ferramenta-trabalho.
21416 Olivier Dulac
10

R, 13 bytes

cat(1:scan())

O corpo deve ter pelo menos 30 caracteres.

Masclins
fonte
Não consigo editar sua resposta, lol.
precisa saber é o seguinte
@ ΈρικΚωνσταντόπουλος Você só pode sugerir edições, que precisam ser aprovadas, com sua reputação atual. E observe que a edição de código não é bem-vinda aqui. Se você tiver conselhos sobre golfe, escreva um comentário para que o autor possa testá-lo antes de atualizar a solução.
Denker
@DenkerAffe, quis dizer que o botão de edição estava acinzentado antes.
Erik the Outgolfer
1
Eu faço se eu quiser escrever mesmo quando você chama o script.
Masclins
9
Eu pensei que uma tomografia computadorizada era mais adequada para visualizar lesões ósseas, diagnosticar problemas nos pulmões e no peito e detectar câncer, sem contar.
Stewie Griffin
10

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

n=>{for(i=0;i++<n;)alert(i)}
Bálint
fonte
2
Sim, você era o único: P
Erik the Outgolfer
A versão inválida pode contar até 2 ^ 64-1? Nesse caso, é válido graças às novas regras.
Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Não, apenas até 2 ^ 53-1
Bálint
Pois o if's sem mais &&pode ser útil também, basta ter cuidado com a coerência. condition&&action()
Shaun H
1
e?c.unshift(1):0para e&&c.unshift(1)economiza um byte
Shaun H
9

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.

CAD97
fonte
O limite de 2 ^ 64-1 foi alterado: D
Erik the Outgolfer,
1
A primeira função não deveria ser n->java.util.stream.LongStream.range(1,n+1)?
Mego
2
@ zyabin101>.> você não viu nada
CAD97
1
@KevinCruijssen Ajudaria, exceto que o motivo de usar o BigIntegeré que o uso de um int(ou mesmo long) para o iterador não é grande o suficiente.
CAD97
1
Eu estava errado; O J8 fornece métodos para usar de longmaneira não assinada, portanto, utilizá-los é mais curto que a BigIntegerabordagem. (Não teria sido se tivéssemos que implementar nosso próprio tratamento longo e não assinado, como antes de J8.) #
9797
7

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!

Stewie Griffin
fonte
7

Haskell, 10 bytes

f n=[1..n]

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

nimi
fonte
Você não deve codificar n, você deve aceitar n.
Erik the Outgolfer
4
@ ΈρικΚωνσταντόπουλος nnão é codificado aqui - é um argumento de função. A sintaxe Haskell pode ser estranha para as pessoas acostumadas à sintaxe do tipo C.
Mego
@ Mega Oh, eu estava confuso com o exemplo de uso.
precisa saber é o seguinte
7

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.

Martin Ender
fonte
Ele termina o programa porque "cai", eu acho.
Erik o Outgolfer
Você escolheu 56 também?
Erik o Outgolfer
@ ΈρικΚωνσταντόπουλος Não consigo encontrar nenhum lugar onde Mario caia. Parece que o intérprete acaba com um erro no [, o que é realmente ainda mais conveniente.
Martin Ender
O TIO costuma não mostrar mensagens de erro (STDERR) sem a Depuração ativada. Parece que é realmente um erro.
Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Sim, e isso é realmente bom, porque STDERR é ignorado, a menos que seja especificado o contrário.
Martin Ender
6

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
seequ
fonte
Você pode fornecer um link para o idioma
Downgoat 28/04
@Downgoat github.com/JaniM/Joe
seequ
4

Pitão - 3 2 bytes

1 bytes salvos graças a @DenkerAffe.

Sem usar o builtin.

hM

Experimente online .

Maltysen
fonte
hMSe você quiser começar a fantasia verdadeira :)
Denker
@DenkerAffe oh sim, é verdade.
Maltysen
Você esqueceu de atualizar sua contagem de bytes.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ-.-
Maltysen
@ ΈρικΚωνσταντόπουλος orlp já fez a resposta embutida.
Maltysen
4

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
Trauma Digital
fonte
Talvez ele funcione com 2 ^ 64-1 (o novo limite).
Erik the Outgolfer
O primeiro ficará sem memória muito antes de você atingir 2 ^ 64-1. O segundo vai continuar alegremente indo até o nosso sol vai supernova
Trauma Digital
@DigitalTraumaskcsockso quis dizer que você pode editar sua segunda resposta se for mais curta para 2 ^ 64-1.
precisa saber é o seguinte
@ ΈρικΚωνσταντόπουλος dc, como bc, usa matemática de precisão arbitrária por padrão e, portanto, esses limites são irrelevantes para esse idioma.
Digital Trauma
4

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.

drolex
fonte
3
Claro que há uma linguagem de programação projetada em torno de memes Arnold Schwarzenegger ...
Nzall
4

Piet, 64 Codels codelsize 1

Com codelsize 20:

codelsize 20

Imagens de rastreamento Npiet

Primeiro loop:

tracestart

Rastreio restante para n=2:

traço

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:

insira a descrição da imagem aqui

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):
Marv
fonte
Possui bytes nulos entre números?
Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος, o que você quer dizer? No console, você pode ver o ETXcaractere (Ascii 3) dividindo as saídas, embora o caractere ETX não possa ser exibido neste site.
Marv
4

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
Shaun H
fonte
Explicação, por favor.
Bálint
2^64-1está bem, eu mudei de especificação.
Erik the Outgolfer
1
Interessante, não pensei em concatenar dois números para atingir o valor mínimo. BTW, você poderia salvar um monte de bytes usando duas variáveis, em vez de uma matriz:n=>{for(a=b="";a+""+b!=n;console.log(a+""+b))++b-1e9||(++a,b=0)}
user81655
Obrigado por isso @ user81655, meu cérebro adora matrizes por algum motivo
Shaun H
1
Você pode salvar um byte, alterando a+""+bpara[a]+b
Bassdrop Cumberwubwubwub
3

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.

Trauma Digital
fonte
3

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)

Mego
fonte
@StewieGriffin O problema é com RAM endereçável, não com limites inteiros (o Python faz a transição perfeita entre entradas nativas e inteiros grandes). Eu testei com o Python 3 de 32 bits e o Python 3. de 64 bits. 32 bits falharam, 64 bits não.
Mego
@Mego Eu mudei os limites, embora eu não ache que o Python de 32 bits suporta 2 ^ 64-1, acho que ele suporta até 2 ^ 32-1, então incentivo que o último seja usado no caso do Python .
Erik the Outgolfer
Por que você liga sério?
Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Como mencionei a Stewie, o problema não é ints de 64 bits, mas endereçamento de memória. Por causa da ineficiência de Seriedade e Realidade no uso da memória, elas esgotam muito rapidamente o limite de memória dos processos de 32 bits. E realmente e sério são idiomas diferentes - na verdade é o sucessor de sério.
Mego
@ Megego Oh, uma vez eu cliquei em um link para Actually e ele me ligou diretamente a sério.
precisa saber é o seguinte
3

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
Bald Bantha
fonte
Além disso, Xfunciona em vez de o;, por 7 bytes.
Rɪᴋᴇʀ
Isso não imprimiria [n]?
precisa saber é o seguinte
em vez den
Bald Bantha
Não. :Imprime a pilha cheia. Xé novo.
Rɪᴋᴇʀ
Além disso, uma outra solução de 7 bytes: ^!$[_;]. $é o alcance.
Rɪᴋᴇʀ
3

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

literally, print range(input())
Żáłģó
fonte
Esse python está literally, na frente de cada instrução? (Pergunta 2: Pré-datas ou pós-datas se é seu ambos são aceitáveis a menos que você fez isso para este desafio, caso em que ele é uma brecha)
Erik o Outgolfer
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Eu acredito que Oration é de ConorO'Brien. github.com/ConorOBrien-Foxx/Assorted-Programming-Languages/tree/… Além disso, se essa linguagem foi inventada após o desafio (o que não era), ela não seria competitiva, mas ainda seria uma resposta válida. Não sou muito fã da regra "Seu idioma deve ser anterior ao desafio". Acho que se alguém inventa uma solução de 0 ou 1 byte para um desafio, isso é claramente contrário às regras, mas o uso de uma nova linguagem real deve ser permitido.
DJMcMayhem
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ foi o que o Dr. Green Eggs disse. Na verdade, sou o chatbot de Easterlyirk.
06616
Então, nenhuma crítica para você?
NoOneIsHere
@NoOneIsHere what?
06616
3

QBASIC, 43 bytes

1 INPUT a
2 FOR b=1 TO a
3 PRINT b
4 NEXT b
Michelfrancis Bustillos
fonte
Você realmente precisa INPUT e;aou INPUT aé suficiente? Não vejo você reutilizando e.
Erik the Outgolfer
bom ponto, não sei por que isso estava lá.
Michelfrancis Bustillos
Além disso, você realmente precisa dos espaços entre o número da linha e as letras e entre 1 TO?
Erik the Outgolfer
Sim, isso é necessário #
Michelfrancis Bustillos
Que versão do QBasic é essa? Você pode usar :entre instruções em vez de um retorno e um número de linha? O QB4.5 permite-me fazer o seguinte:INPUT a: FOR b=1 TO a (\n) ?b:NEXT
steenbergh
3

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í
MickyT
fonte
2

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 .

user48538
fonte
1
Python 2, para ser exato :)
Erik o Outgolfer
33 bytes ->for i in range(input()):print i+1
dieter
2
32 bytes ->for i in range(input()):print-~i
orlp 25/04
1
"Presumivelmente funciona até 2**64e além." - duvido que em Python 2, mas talvez com xrange(edit: ainda xrangepode ter problemas, pelo menos em 2.7.10)
SP3000
Como -~funciona? Edit : Eu descobri isso. Além disso, bom truque!
Erik the Outgolfer
2

Zsh, 12 bytes

echo {1..$1}

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

andlrc
fonte
2
Não sei se você pode contar até 2 ^ 64 (ou até um pouco menos)?
Olivier Dulac
@OlivierDulac 2^64-1está bem agora.
Erik the Outgolfer
1
o máximo do zsh é 2^63 - 1
joeytwiddle
2

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              [email protected]

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.

DJMcMayhem
fonte
Pode levar o tempo que quiser. Fico feliz em ver uma resposta para trabalhar com 2 ^ 64, especialmente com um idioma inacabado. +1
Erik the Outgolfer
Alterei o limite para 2 ^ 64-1 porque as brechas padrão não são permitidas agora e não quero cortar muito as respostas.
Erik the Outgolfer