[Question]
  [
## Introduction
[OEIS sequence A127421](https://oeis.org/A127421 "OEIS sequence A127421") is the sequence of numbers whose decimal expansion is a concatenation of 2 consecutive increasing non-negative numbers. Put simply, every number in the sequence is formed by putting together *n* with *n+1* for some non-negative, integer value of *n*. The first several terms are:
> 
> 1, 12, 23, 34, 45, 56, 67, 78, 89, 910, 1011, 1112, 1213, 1314, 1415,
>  1516, 1617, 1718, 1819, 1920, 2021, 2122, 2223, 2324, 2425, 2526,
>  2627, 2728, 2829, 2930, 3031, 3132, 3233, 3334, 3435, 3536, 3637,
>  3738, 3839, 3940, 4041, 4142, 4243, 4344, 4445, 4546, …
> 
> 
> 
## Challenge
Given a single positive integer *n*, print the first *n* entries of OEIS sequence A127421 in increasing order.
* Input and output can be in [any acceptable format](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods). Strings or numbers are fine for output.
* Leading zeroes are **not** permitted.
* Either a full program or function is permitted.
* For the purposes of this challenge, *n* will be positive and under 100.
* [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are disallowed by default.
* This question is code golf, so lowest byte-count wins.
* Here is some sample input and output:
```
1 => 1
2 => 1, 12
3 => 1, 12, 23
10 => 1, 12, 23, 34, 45, 56, 67, 78, 89, 910
```
If you have any questions, don't hesitate to ask. Good luck.
*P.S this is my first challenge, so hopefully this all makes sense.*
*EDIT: Removed output restriction to allow numbers or strings.*
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ŻVƝ
```
A monadic link accepting an integer which yields a list of integers
**[Try it online!](https://tio.run/##y0rNyan8///o7rBjc////29iBgA "Jelly – Try It Online")**
### How?
```
ŻVƝ - Link: integer       e.g. 59
Ż   - zero-range               [0,1,2,3,4,5,6, ... ,58,59]
  Ɲ - apply to each pair: i.e: [0,1] or [5,6]  or  [58,59]
 V  -   evaluate* jelly code   1     or 56     or  5859
    -                       -> [1,12,23,45,56, ... 5859]
* When given a list V actually joins the Python string values and evaluates that
  ...so e.g.: [58,59] -> ['58','59'] -> '5859' -> 5859
```
[Answer]
# [Python 3](https://docs.python.org/3/), 39 bytes
```
f=lambda n:1//n or f'{f(n-1)} {n-1}{n}'
```
[Try it online!](https://tio.run/##DYtBCoAgFAXXdYq3U8FQcyd0GCMkob4ibkI8u7magWHyV@9EdoxwPP49Lw9yRilCKgisBU6bER1tojfqbIQZCJFgJHYJK2H0NO3WJZdIlc9FiPED "Python 3 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 32 bytes
```
strtoi(paste0((x=1:scan())-1,x))
```
[Try it online!](https://tio.run/##K/r/v7ikqCQ/U6Mgsbgk1UBDo8LW0Ko4OTFPQ1NT11CnQlPzv@l/AA "R – Try It Online")
Outgolfed by [MickyT](https://codegolf.stackexchange.com/a/168020/67312), so go upvote that answer!
[Answer]
## Haskell, ~~38~~ 37 bytes
```
f n=("":)>>=zipWith(++)$show<$>[1..n]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hz1ZDSclK087OtiqzIDyzJENDW1tTpTgjv9xGxS7aUE8vL/Z/bmJmnoKtQkFRZl6JgopCmoKhwX8A)
Thanks to [Cat Wizard](https://codegolf.stackexchange.com/users/56656/cat-wizard) for a byte!
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 19 bytes
```
I.1.W)>OSo;u.uO;@!-
```
[Try it online!](https://tio.run/##Sy5Nyqz4/99Tz1AvXNPOPzjfulSv1N/aQVH3/39DAwA "Cubix – Try It Online")
This wraps onto the cube as follows
```
    I .
    1 .
W ) > O S o ; u
. u O ; @ ! - .
    . .
    . .
```
[Watch It Run](https://ethproductions.github.io/cubix/?code=ICAgIEkgLgogICAgMSAuClcgKSA+IE8gUyBvIDsgdQouIHUgTyA7IEAgISAtIC4KICAgIC4gLgogICAgLiAuCg==&input=MTAK&speed=20)
Got a little room to play with yet, but at the moment 
* `W` redirect to the top face heading down
* `I1>` set up the stack with the input and 1 then redirect into the main loop
* `OSo;u` output the top of stack, add space to stack, output, remove and uturn
* `-!@;Ou)` subtract TOS from input, if 0 halt else pop result, output TOS, uturn and increment TOS. Back into the main loop.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~19~~ 18 bytes
```
{(^$_ Z~1..$_)X+0}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1ojTiVeIarOUE9PJV4zQtug9n9xYqVCmoahgYGm9X8A "Perl 6 – Try It Online")
Anonymous code block that zips the range 0 to n-1 with 1 to n using the concatenation operator, then adds 0 to every element to force it to a number and remove leading 0s.
[Answer]
# [R](https://www.r-project.org/), ~~30~~ 29 bytes
An extra byte thanks to @Giuseppe
```
10^nchar(n<-1:scan())*(n-1)+n
```
[Try it online!](https://tio.run/##K/r/39AgLi85I7FII89G19CqODkxT0NTU0sjT9dQUzsPKPsfAA "R – Try It Online")
A mostly mathematical solution, except for using `nchar()` rather than `floor(log10())`. I was really surprised that it came in shorter than the [string](https://codegolf.stackexchange.com/a/167836/31347) version.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~13~~ 12 bytes
*1 byte saved thanks to @FrownyFrog*
```
(⍎⍕,∘⍕1∘+)¨⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/9OApMaj3r5HvVN1HnXMAFKGQEpb89CKR72b//9PUzDkSlMwBmJDAwA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 25 bytes
```
f=n=>--n?f(n)+','+n+-~n:1
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbP1k5XN88@TSNPU1tdR107T1u3Ls/K8H9yfl5xfk6qXk5@ukaahqGmpjUXqpARppAxppChAVDsPwA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 6 bytes
```
⟦s₂ᶠcᵐ
```
[Try it online!](https://tio.run/##ASAA3/9icmFjaHlsb2cy///in6Zz4oKC4bagY@G1kP//MTD/Wg "Brachylog – Try It Online")
### Explanation
```
⟦         Range: [0, …, Input]
 s₂ᶠ      Find all substrings of length 2
    cᵐ    Map concatenate
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~42~~ 41 bytes
```
f=lambda n:n-1and f(n-1)+[`n-1`+`n`]or[1]
```
[Try it online!](https://tio.run/##NYuxCoAgFAB3v@KNigW@RqEvMUHDLKGeIi59vbk0HHfLlbddmZYe121w@2cPHkjTjJ4CRD5CSOOGnHTkbK4GbY@5QoJEUD2dB8cJldBQaqI2niQY@xuVEv0D)
Recursive function that returns a mixed list of strings and integers
[Answer]
# [Haskell](https://www.haskell.org/), 34 bytes
```
f n="1":[show=<<[i-1,i]|i<-[2..n]]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hz1bJUMkqujgjv9zWxiY6U9dQJzO2JtNGN9pITy8vNvZ/bmJmnoKtQkFRZl6JgopCmoKhwX8A "Haskell – Try It Online")
[Answer]
# [Blossom](https://github.com/IMP1/blossom), 88 bytes
```
rule e<int x>[1(x)]=>[1(x-1),2(str(x)+str(x+1))];rule c[1(0)]=>[];e!c
```
Blossom is a graph programming language I'm working on. It can only take graphs as inputs, so this programme expects a graph comprising a single node with its label an integer. It returns a graph of connected edges to form the closest to an array I can get, and the resultant graph is printed to output.
An unminified version of the code is this:
```
rule expand <int x>
    [ 1 (x) ]
 => [ 1 (x-1), 2(str(x)+str(x+1)) ]
where x > 0;
rule clean
    [ 1 (0) ]
 => [];
expand! clean
```
It defines two rules: one called `expand`, which (while there is a node with an integer-valued label in the current graph) creates another node with its increment concatenated, and lowers the value.
This rule also has the condition that x is greater than 0.
The `!` executes this rule for as long as it can be applied on the graph, so in this case it will execute until x is 0. And then the `clean` rule removes this 0 node.
Blossom was not made for golfing, but it doesn't do too badly, I don't think., considering what it is.
There currently isn't really an easy way for people to test blossom code (and the interpreter I'm working on at the moment is not quite finished and a little buggy), but this isn't exactly a competing entry!
[Answer]
## [Shakespeare](http://shakespearelang.sourceforge.net/), 703 bytes
```
Q.Ajax,.Ford,.Act I:.Scene I:.[enter Ajax and Ford]Ford:Open mind!Scene V:.Ajax:You is the sum of thyself the sum of myself the sum of a big bad fat old red pig a big bad fat old lie!Ford:Open mind!Is you nicer zero?Ajax:If so, you is twice the sum of the sum of twice thyself twice thyself thyself!If so,Let us Scene V!Ford:You a cat!Open heart!Scene X:.Ajax:You is the sum of thyself a pig!Is you worse than a cat?If so,let us Scene C.Remember thyself.You is the sum of the sum of a big old red cute rich cat a big old red cute joy a big old pig!Speak mind!You is a big old red cute rich cat!Speak mind!Recall!Ford:Open heart!You is the sum of thyself a joy!Open heart!Let us Scene X.Scene C:.[exeunt]
```
[try it here](https://tio.run/##hVJBasMwEPzK@m4E7dGXEAIFQ6E0gZJScpDldaNElowkk7ifdyVLoXIS0ou83llmZkcynRjHd7I80HNOXpSuc7JkFsqCbBhK9MUXSosa/AhQWYOf2vmjeOtQQstlnYXhj2IiKj5VD9yA3SOYvgXVuHIwKJq01d50KFT8GypaQ0MtKFGDxho617tFBMfsykNpYHDCkjPn9ge1WkxmygaMyifIezo5eO7sr4xYNDb/C98ssL2ihd5A3DoY8UtTYNRmk6U9Um1jLtt/c6F@zcsGJ6WNV6YyEC6CqEhFV2SNLbaVWzVykHvsV9leMmW9RdCc7T39PeyghqTtvW06pMcQdBR6QJlOr5FRIZLLCsk8ysKppyHO0t7Gh7nyD/OMvbS7cXx@@gU)
## ungolfed version
```
127421th Night.
Ajax, likes to read the stars.
Ford, someone Ajax can always count on.
Act I:.
Scene I: Ajax reads a star.
[enter Ajax and Ford]
Ford: Open your mind! 
Scene V: Ford counts what ajax has learned.
Ajax: you are the sum of thyself and the sum of myself and the sum of a big bad fat old red pig and a big bad fat old lie!
Ford: Open Your mind! Are you nicer than zero?
Ajax: If so, you are twice the sum of the sum of twice thyself and twice thyself and thyself! 
If so, Let us Scene V!
Ford: You are a cat! Open your heart!
Scene X: Ajax and Ford recall the nights.
Ajax: You are the sum of thyself and a pig! Are you worse than a cat? If so, Let us Scene C.
Remember thyself. 
You are the sum of the sum of a big old red cute rich cat and a big old red cute joy and a big old pig! 
Speak you mind!
You are a big old red cute rich cat! Speak your mind! Recall your finest hour!
Ford: Open your heart! You are the sum of thyself and a joy! Open your heart! Let us Scene X.
Scene C: Fin.
[exeunt]
```
[Answer]
# [Groovy](http://groovy-lang.org/), 35 bytes
```
{(0..<it)*.with{""+it+++it as int}}
```
[Try it online!](https://tio.run/##Sy/Kzy@r/J9m@79aw0BPzyazRFNLrzyzJKNaSUk7s0RbG0goJBYrZOaV1Nb@LygC0jl5Cmkappr/AQ "Groovy – Try It Online")
I came up last minute with the idea of using \*.with instead of .collect. I have no idea what `it+++it` parses to but whether it's `it++ + it` or `it + ++it` they both do the same thing. I tried to think of a way of getting rid of the < in ..< by turning it into 1..it and decrementing but I don't think it would get any shorter.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 44 43 bytes
```
f(i){i--&&printf(" %2$d%d"+5*!f(i),i+1,i);}
```
[Try it online!](https://tio.run/##VYk9DsIgFIB3TvGstgEKRkycanoR44Ag7UsqNYhdmp4dYXT7fowcjEl79Gb62idcP9HifBx78pcmfOSWHEW2opRN8w7oo6MV1OeDrW3VXviuXIGtEsi6LeUPL42eFtBhMMKMOgDnmRcGKwFAR8voFYNMccaiy03dGevIlpI6/QA "C (gcc) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~55 48 47~~ 43 bytes
```
f=lambda n:n-1and f(n-1)+[f"{n-1}{n}"]or[1]
```
[Try it online!](https://tio.run/##NcexCoAgEADQ3a84nDwq8GgL@hJpMOpKqFOkJcJvt5a299J97VH6Wnk8/DkvHmSQjrwswOYDNo7186E8UvQUs6OpcswQIAhkL9tqqCWLQ8pBLsMmICr1h6xFrC8 "Python 3 – Try It Online")
Recursive function that takes an integer and returns a mixed list of strings and numbers.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~9~~ ~~8~~ 6 bytes
```
ms+`dh
```
[Try it online!](https://tio.run/##K6gsyfj/P7dYOyEFSJsAAA "Pyth – Try It Online")
Explanation:
```
       - implicit output
m      - map function with argument d:
  +    -  concatenate
    d  -  argument d
   `   -  to string
     h -  into implicit d + 1
       - into Q (implicit input)
```
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$8\log\_{256}(96)\approx\$ 6.585 bytes
```
Mrx'_Jx}
```
[Try it online!](https://fig.fly.dev/#WyJNcngnX0p4fSIsIjIiXQ==)
```
Mrx'_Jx}
Mrx'     # For every number in the range [0, input)
       } # Input + 1
     Jx  # Prepend the input to that
    _    # Parse as number to remove leading 0s
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
ḶżRV
```
[Try it online!](https://tio.run/##y0rNyan8///hjm1H9wSF/f//39AUAA "Jelly – Try It Online")
### How it works
```
ḶżRV  Main link. Argument: n
Ḷ     Unlength; yield [0, ..., n-1].
  R   Range; yield [1, ... n].
 ż    Zipwith; yield [[0, 1], ..., [n-1, n]].
   V  Eval; cast each array to string and evaluate, yielding integers.
```
[Answer]
# [Python 2](https://docs.python.org/2/), 44 bytes
```
for i in range(input()):print`i`*(i>0)+`i+1`
```
[Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SCFTITNPoSgxLz1VIzOvoLREQ1PTqqAoM68kITNBSyPTzkBTOyFT2zDh/39jAwA "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
>GNJ,N
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fzt3PS8fv/39DAwA "05AB1E – Try It Online")
**Explanation**
```
>G       # for N in [1 ... input]
  N      # push N
   J     # join stack
    ,    # print
     N   # push N (for next iteration)
```
`LεD<ìï` would work for same byte count but with list output
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 9 bytes
```
1,2,/⍕¨∘⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob2pm/qO2CYb/00CkjpGO/qPeqYdWPOqY8ah38///aQqGBgA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 37 bytes
```
f x=[[y-1|y>1]++[y]>>=show|y<-[1..x]]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P02hwjY6ulLXsKbSzjBWWzu6MtbOzrY4I7@8ptJGN9pQT68iNvZ/bmJmnoKtQko@lwIQFBRl5pUoqCikKRii8Y3Q@Mbo6g3@AwA "Haskell – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-m`, ~~6~~ 5 bytes
```
ó2 ¬n
```
[Try it online!](https://tio.run/##y0osKPn///BmI4VDa/L@/9fN5TIyAAA "Japt – Try It Online")
As always, *know the flags*.
### Unpacked & How it works
```
-m       Convert to range and map...
Uó2 q n
Uó2      Construct [U, U+1]
    q    Join
      n  Convert to number
         Implicit output (Array is printed as comma-delimited values)
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~103~~ ~~71~~ ~~64~~ 56 bytes
---
**Golfed** [Try it online!](https://tio.run/##VY9NSwMxEIbv@RVD2ENCP9i2t6a7Ij0JgqAHD9ZD2I4YqLPSTHEl5LevMe62dk4v82SemTR@1njX3zbsWtrcEa@WNVioelfV4a09KkcMXVWabuOMfvr2jB/zbUu@PeD8@egYVSGD6uryppDT0EW5llLHMJmkqE3sjRDZ@vIqIBWj56316KECwi8YGIRMf2sxPcflJa4ucVHmGJM5HYi2eVd/mrMcHP1bpAf59dVQyDT1eeI1hPFt3NHDiXNPgjZ5yqqRDo0rzb0jVHJH6asiCjGyR7T7jLTpfwA "C# (Visual C# Interactive Compiler) – Try It Online")
```
i=>{for(int x=0;x<i;)Write($"{(x>0?$",{x}":"")}{++x}");}
```
---
**Ungolfed**
```
i => {
    for( int x = 0; x < i; )
        Write( $"{( x > 0 ? $",{x}" : "")}{ ++x }" );
}
```
---
**Full code**
```
Action<Int32> a = i => {
    for( int x = 0; x < i; )
        Write( $"{( x > 0 ? $",{x}" : "")}{ ++x }" );
    };
Int32[]
    testCases = new Int32[] {
        1,
        2,
        3,
        10,
    };
foreach( Int32[] testCase in testCases ) {
    WriteLine( $" Input: {testCase}\nOutput:" );
    a(testCase);
    WriteLine("\n");
}
```
---
**Older versions:**
* ***v1.2, 64 bytes***
```
i=>{for(int x=0;x<i;)Write($"{(x>0?$",{x}":"")}{++x}");}
```
* ***v1.1, 71 bytes***
```
i=>{for(int x=0;x<i;)System.Console.Write($"{(x>0?$",{x}":"")}{++x}");}
```
* ***v1.0, 103 bytes***
```
i=>{for(int x=0;x<i;)System.Console.Write($"{(x>0?",":"")}{x++*System.Math.Pow(10,$"{x}".Length)+x}");}
```
---
**Releases**
* **v1.3** - `- 8 bytes` - Removed `Console` thanks again to [raznagul](https://codegolf.stackexchange.com/questions/167818/concatenating-n-with-n-1/167878?noredirect=1#comment405677_167878)
* **v1.2** - `- 7 bytes` - Removed `System` thanks to [raznagul](https://codegolf.stackexchange.com/questions/167818/concatenating-n-with-n-1/167878?noredirect=1#comment405670_167878)
* **v1.1** - `-32 bytes`
* **v1.0** - `103 bytes` - Initial solution.
---
**Notes**
* None
[Answer]
# J, 14 bytes
```
(,&.":>:)"0@i.
```
[Try it online!](https://tio.run/##y/r/P03B1kpBQ0dNT8nKzkpTycAhUw8kaMiVpmAExMZAbGgAAA)
[Answer]
## ABAP, 101 bytes
Not really a golfing language, but I'm having a lot of fun with it
```
WHILE x<w.
CLEAR z.
IF x=1.
WRITE x.
ELSE.
CONCATENATE y x INTO z.
WRITE z.
ENDIF.
y=x.
x=x+1.
ENDDO.
```
W is the input term, X is the counter from 1, Y is X-1 from the second pass onward, Z is concatenated string.
[Answer]
# Powershell, ~~27~~ 26 bytes
```
1.."$args"|%{"$p$_";$p=$_}
```
-1 byte: thanks [AdmBorkBork](https://codegolf.stackexchange.com/users/42963/admborkbork)
Test script:
```
$f = {
1.."$args"|%{"$p$_";$p=$_}
}
&$f 1
""
&$f 2
""
&$f 3
""
&$f 10
""
&$f 46
```
[Answer]
# [Python 2](https://docs.python.org/2/), 41 bytes
```
lambda l:[`n`[:n]+`n+1`for n in range(l)]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHHKjohLyHaKi9WOyFP2zAhLb9IIU8hM0@hKDEvPVUjRzP2f0FRZl6JQpqGoYnmfwA "Python 2 – Try It Online")
]