Count up folks!

Question

Introduction

It may sound strange, but we haven't got ONE challenge for counting from 1 to n, inclusive.

This is not the same thing. That one is a (closed) not well-explained challenge.
This is not the same thing. That one is about counting up indefinitely.

Challenge

Write a program or function that prints every integer from 1 to n inclusive.

Rules

• You can get n any way.
• You can assume that n will always be a positive integer.
• You can get n in any base, but you should always output in decimal.
• Output must be separated by any character (or pattern) not in 0123456789. Non-decimal leading or trailing characters are allowed (for example when using arrays such as [1, 2, 3, 4, 5, 6]).
• Standard loopholes are denied.
• We want to find the shortest approach in each language, not the shortest language, so I will not accept any answer.
• You must update your answer(s) after this edit, answers posted before the last edit must comply with the change rule about standard loopholes (I didn't want to deny them, but I didn't want to make the community roar, so I denied them).
• You can use any post-dating language version (or language). You cannot use any language or language version made just for this challenge.

Bonuses

20%

• Your program must be able to count at least up to 18446744073709551615 (2^64-1). For example, if a new datatype is the only way to support big integers, you must construct it. If your language does not have any way to support huge integers up to 2^64-1, the upper limit of that particular language must be supported instead.

EDIT: I've changed the limit from 2^64 to 2^64-1 to allow more answers.

EDIT: I made the 2^64-1 rule a bonus, since there has not been much interest in this challenge. If your answer supports 2^64-1, you can now edit it to include the bonus. Also, you can post an answer not supporting it, if it is shorter.

Answer 1

MY, 3 * 0.8 = 2.4 bytes

Here's the hex:

1A 49 27

Explanation:

1A - Take input as an integer, then push to stack
49 - Pop n; Push [1 ... n]
27 - Pop n; Output n (with a trailing newline)

MY is written in Python, where integers have no size limit.

Answer 2

Swift 3, 53 bytes

func c(n:UInt){var l:UInt=0;while l<n{l+=1;print(l)}}

Note: this only works on 64-bit devices. Here is a 32-bit device solution (57 bytes):

func c(n:UInt64){var l:UInt64=0;while l<n{l+=1;print(l)}}

Answer 3

Swift 3, 40 bytes

func f(n:UInt){for i in 1...n{print(i)}}

Uses Swift ClosedRange (1...n) type. Prints up to UInt maximum aviable

Answer 4

cQuents, 2.4 bytes (3 bytes - 20%)

::$

Fairly simple, does exactly what the challenge wants. Since cQuents is implemented in Python, it works as long as Python integers can continue growing.

Try it online!

Explanation

      Implicit input n
::    Mode: Sequence 2. Output the sequence up to n
  $   Each item in the sequence is the current (1-based) index

Answer 5

Retina, 18 bytes

+`^1
$%'$n1
1+
$.0

Try it online!

Answer 6

Brainfuck, 24 bytes (-4.8 = 19.2)

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

Technically it can go as high as you want as long as you set your cell size high enough.

Also all I/O is in ascii.

How it works is first it takes input into the third cell, then it duplicates itself (self-destructively) into the next two cells, and taking one away from the second one, repeating that unit it reaches 0. Then, it prints 1 and then goes back two spaces and prints until it reaches the beginning, where we skipped two spaces so it would terminate.

Answer 7

Charcoal, 4 bytes

Ｉ⊕…Ｎ

Try it online!

Explanation

Ｉ     Cast (recursively vectorizes)
  ⊕    Incremented
   …Ｎ Range from 0 to next input as number (excluding the number itself)

Answer 8

Implicit, 10 5 bytes

¡(%ß;)

Try it online!

¡(%ß;)   implicit integer input
¡        push 1..n
 (...)   while top of stack truthy
  %       print
   ß      print space
    ;     pop

---

Old version:

$(:-1);(%;)

Input is implicit. When the first : is reached, there's nothing on the stack to duplicate so it reads an integer. This code is therefore equivalent to $(:-1);(%;). Explanation:

$(:-1);(%;)
$            read integer input
 (...)       do-while
  :           duplicate
   -1         decrement
      ;      pop the zero
       (..)  do-while
        %;   print and pop

Take the input 3:

$(:-1);(%;)
$             read input (stack contains 3)
 (:-1)        push 2, 1, 0 (stack contains 3, 2, 1, 0)
      ;       pop zero
       (%;)   print 1, 2, 3

Try it online! (Nonworking with (:-1);(%;) until TIO's SimpleStack interpreter is updated)

Answer 9

ABCR, 16 (-20%=12.8) bytes

iBBaC.72Bc)qOC.x

Output separated by null bytes.

Explanation:

i                   Read n to the register.
 BB                 Enqueue it to queue B twice.
   a                Since we need to count UP, we'll reset the register to 0.
    C               Save the current register value in queue C.
     .7             If not(the difference between the register (0) and n (from B)):
       2B           Clone n back to queue B, since calculating the difference
                        consumes the front of the queue
         c)q        Print the register value as a number, restoring its value 
                     from C and incrementing 
            O       Print out a null byte separator 
                       (the default value from queue A as a character)
            
             C      Store it back in C
              .x    If the difference between the register and n is 0, exit

Answer 10

Tcl, 26 bytes

time {puts [incr i]} $argv

Try it online!

First approach can't get more than 2^32-1 as it says integer value too large to represent as non-long integer if n is bigger.

The limit can be even less, as I don't see output, but I am using an online compiler so I can not guarantee what happens on a local one.

For 2123456789 there is output.

---

Tcl, 32 bytes - 20% = 25.6 bytes

while {[incr i]<$argv} {puts $i}

Try it online!

Answer 11

Fortran (GFortran), 45 - 20% = 36 bytes

INTEGER(16)I
READ*,R
DO1 I=1,R
1 PRINT*,I
END

Try it online!

The entire first line can be suppressed if the bonus is optional. In that case, the program will have only 32 bytes, i.e., the bonus is not worth of it! The default integer type in Fortran (which is implicitly assigned to variables whose names starts with I-N) uses only 4 bytes, then this lengthy declaration is necessary to handle such large numbers...

Fortran (GFortran), 32 bytes

READ*,R
DO1 I=1,R
1 PRINT*,I
END

Try it online!

Answer 12

Canvas, 2 1 bytes

Ｒ

Try it online!

Answer 13

F#, 36 bytes

Try it online!

let x n=for i=1 to n do printfn"%i"i

Pretty straight-forward. This version does not count towards the bonus, because in F# you can only use int32 values for the for...to...do loops.

For the bonus you can use this for 45 bytes:

let r n=Seq.iter(fun x->printfn"%u"x)[1UL..n]

Creates an array of n numbers, and prints each one out. The only thing is that it takes a lot of time and RAM. It's using about 20GB on my PC already, and it hasn't even printed a number yet. But hey, the code is small, right?

Answer 14

Gol><>, 6 - 1.2 (20%) = 4.8 bytes

IFPD|;

Try it online!

The output looks like this:

[1]
[2]
[3]
...
[n]

How it works

IFPD|;

I       Take input as int
 F  |   Pop n and repeat n times...
  PD    Increment top and print stack content as `[x]`
        Uses implicit zero on first iteration
     ;  Halt

Answer 15

Wren, 15 bytes - 3 = 12 bytes

This is the exact same result before an interation of the thing.

Fn.new{|n|1..n}

Try it online!

Wren, 24 bytes - 4.8B = 19.2 bytes

Wren supports large integers by default, so... can I have the bonus?

(Technically a returned operand of a function is a kind of output. Also the challenge didn't explicitly say that it has to be in Standard Output.)

Fn.new{|n|(1..n).toList}

Try it online!

Wren, 38 bytes

If this has to be in Standard Output I could do this...

Fn.new{|n|System.print((1..n).toList)}

Try it online!

Answer 16

Ly, 15 bytes

1>n1-[<:1+>1-]<

Try it online!

More playing with Ly... It uses two stacks, one to hold the list of numbers to print, and the other holds the loop counter.

Push 1 on the default stack, shift stack to the right.

1>

Read the number of iterations onto the stack, decrement by one (since we already pushed the first number)

  n1-

Then loop until the counter is 0 with:

     [    >1-]<

The body of the loop, just switches back to the stack where the output is accumulating, duplicates the last entry and increments the copy.

      <:1+

Finally, printing the output just requires switching to the stack holding the list of numbers to output once the loop ends.

              <

Answer 17

PostL 20 bytes

PostL is a postfix-notation stack-based language based purely on the stack, a single variable, and many operators, and its interpreter is currently written in Java.

1N0,$)B>\`]`=>1+.6;>

Explanation:

1N0,$)B>\`]`=>1+.6;>
1                    Push 1 onto the stack
 N                   Negate it (gives -1; negative literals don't exist)
  0                  Push 0 onto the stack
   ,$                Take the input and parse it to an number
     )               Take the range, counting by -1, to 0, starting at whatever the input was
      B>             Check whether or not the stack is empty, and push that onto the stack (0 for not, 1 for empty)
        \`           Push on a SKIP processor flag, and move the value of the emptiness of the stack back to the top (swap the top two)
          ]`         Push on a TERMINATE processor flag, and swap the top two.
            =        Switch, based on whether or not the stack is empty. If not, retrieve the SKIP flag, and if so, retrieve the TERMINATE flag.
             >       Process whatever flag is there. If it's a SKIP flag, it doesn't do anything, but if it's a TERMINATE flag, it means that the stack is empty, and it terminates.
              1+     Add 1 (because the range is 0 to n - 1)
                .    Pop it off the stack and print it
                 6;> Go to index 6 (where the program checks if the stack is empty).

Answer 18

Factor, 16 * 0.8 = 12.8 bytes

[ [1,b] stack. ]

Try it online!

Factor's integer type is a fixnum that automatically promotes to bignum when required.

Explanation

• [1,b] Create a range from 1 to a number, inclusive.
• stack. Prettyprint each element of a sequence, one per line.

Answer 19

J, 5 bytes

>:@i.

Try it online!

Answer 20

Python, 21 - 20% = 16.8 Bytes

lambda x:range(1,x+1)

A range object is basically all the integers from the first argument to the second argument, ecluding the second argument. For example, range(1,10) is the numbers from 1 to 10, excluding 10 (a.k.a 1 to 9). It can actually handle 2**2048.

Answer 21

Go, 44 - 20% = 35.2 bytes

func(n uint64){for i:=0;i<n;i++{println(i)}}

Attempt This Online!

Prints to STDERR, with each number on its own line.

Answer 22

Maple, 9 bytes

seq(1..n)

Usage:

> seq(1..10);
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Answer 23

Ruby 17Byte

1.upto(n){|i|p i}