Squash it ... again!

Question

If you place the positive integers together and read each set of two adjacent digits at the same time, you get: (A136414)

12, 23, 34, 45, 56, 67, 78, 89, 91, 10, 1, 11, ...

However, if you squash that sequence again:

12, 22, 23, 33, 34, 44, 45, 55, 56, 66, 67, 77, 78, 88, 89, 99, 91, 11, 10, 1, 11, 11

and so on.

Your task is to output the sequence of the positive integers squashed m times.

Squashing process

[1, 2, 3, 4, 5]
       ↓
    "12345"
       ↓
[12, 23, 34, 45]

Python squashing script

Rules

• You have to receive m (a positive integer) as the input or you can output the sequences for all m
• Numbers in the sequence can appear more than once
• Leading zeros must be removed (eg. 04 is 4)
• Default sequence rules
• Default Loopholes apply

Test cases

[In]: 1
[Out]: [12, 23, 34, 45, 56, 67, 78, 89, 91, 10, 1, 11, 11, 12, 21, 13, 31, 14, 41, 15, ...]

[In]: 2
[Out]: [12, 22, 23, 33, 34, 44, 45, 55, 56, 66, 67, 77, 78, 88, 89, 99, 91, 11, 10, 1, 11, 11, 11, 11, 11, 12, 22, 21, 11, 13, 33, 31, 11, 14, 44, 41, 11, 15, ...]

[In]: 3
[Out]: [12, 22, 22, 22, 23, 33, 33, 33, 34, 44, 44, 44, 45, 55, 55, 55, 56, 66, 66, 66, 67, 77, 77, 77, 78, 88, 88, 88, 89, 99, 99, 99, 91, 11, 11, 11, 10, 1, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 22, 22, 22, 21, 11, 11, 11, 13, 33, 33, 33, 31, 11, 11, 11, 14, 44, 44, 44, 41, 11, 11, 11, 15, ...]

Answer 1

Haskell, 49 bytes

f(x:z)=read[x,z!!0]:f z
q=[1..]:map(f.(>>=show))q

Attempt This Online!

Haskell loves infinite sequences. Here we get to make an infinite sequence of infinite sequences.

The function f takes infinite string of digits and produces numbers formed from the pairs in order. We combine this with (>>=show) to get a function which takes an infinite sequence and produces the next. We use recursion to create the infinite list of such sequences starting with [1..].

Answer 2

Python 3.8, 121 119 bytes

lambda m,n:m<1and n or(n*0==[]or(n:=range(1,n)))and(d:=''.join(map(str,n)))and z(m-1,[int(i+j)for i,j in zip(d,d[1:])])

Try it online!

m is the number of squashes applied and n controls the length of the output.

---

Same idea, except split over two functions (and somehow the exact same number of characters):

lambda m,n:y(m,range(1,n))
y=lambda m,a:m<1and a or(d:=''.join(map(str,a)))and y(m-1,[int(i+j)for i,j in zip(d,d[1:])])

Try it online!

Answer 3

05AB1E, 7 bytes

∞IFSü«ï

Given \$m\$, output the infinite \$m^{th}\$ sequence.

Try it online or verify the first 25 results of the first 5 \$m\$.

Explanation:

∞        # Push the infinite list of positive integers: [1,2,3,...]
 IF      # Loop the input `m` amount of times:
   S     #  Convert the list of integers to a flattened list of digits
    ü    #  For each overlapping pair of digits:
     «   #   Append them together
      ï  #  Convert it back to an integer to remove the leading 0s
         # (after which the result is output implicitly)

Answer 4

APL(Dyalog Unicode), 21 bytes ^SBCS

Anonymous infix lambda, taking m as left argument and the number of elements of the sequence to generate as right argument.

{⍵↑{⍎¨2,/∊⍕¨⍵}⍣⍺⍳1+⍵}

{…} "dfn"; ⍺ is m and ⍵ is the number of elements to generate.

 1+⍵ increment the number of elements (to handle the case of 1)

 ⍳ generate the integers 1…m+1

 {…}⍣⍺ repeat application of the following function, m times:

  ⍕¨⍵ format each number in the sequence

  ∊ enlist (flatten)

  2,/ concatenate adjacent characters

  ⍎¨ evaluate each

 ⍵↑ take as many elements as requested

Try it on APLgolf!

Answer 5

JavaScript (Node.js), 64 bytes

f=(m,n)=>n?[...f(m,n-1),m--?+f(m,n+2).join``.substr(n-1,2):n]:[]

Try it online!

Answer 6

Husk, 11 bytes

!¡ȯmdẊeṁdN→

Try it online!

Answer 7

Jelly, 11 bytes

ị+D€FVƝƊ⁹¡¥

Try it online!

1-indexed, takes \$m\$ on the right and \$n\$ on the left to give the \$n\$th term of the sequence.

It seems like there should be a non-naive method as well, but the patterns that manifest in the single digits may not be as real as they seem.

        ⁹¡     Repeat m times
 +        ¥    starting with n + m:
  D€           digits of each
   €           (implicitly rangifies on first iteration),
    F          flatten,
     VƝ        concatenate each pair of adjacent digits into an integer.
ị              Get the n'th element of the result.

Answer 8

Python 2, 96 bytes (@math junkie)

def f(n,c=0):
 while n<1:c+=1;yield c
 for s in f(n-1):
  for b in`s`:
    if c:yield int(c+b)
    c=b

Attempt This Online!

TIL: Apparently one can mix spaces and tabs in Python 2.

Old Python 2, 101 bytes

def f(n,c=0):
 while n<1:c=c+1;yield c
 for s in f(n-1):
  for b in`s`:
   if c:yield int(c+b)
   c=b

Attempt This Online!

Answer 9

Burlesque, 20 bytes

J+.ro{im2CO}3MVE!j.+

Try it online!

J    # Duplicate M
+.ro # Range [1..M+1]
{
 im  # Implode (concatenate digits)
 2CO # Chunks with overlap length 2 ("ABC"2CO -> "AB" "BC")
}
3MV  # Move the 3rd item (N) to top of stack
E!   # Evaluate that many times
j.+  # Keep the top M numbers

Burlesque, 13 bytes (invalid violates default sequence rules)

ro{im2CO}x/E!

Try it online!

ro    # Range 1..N
{
 im   # Implode (concatenate digits)
 2CO  # Chunks with overlap length 2 ("ABC"2CO -> "AB" "BC")
}
x/    # Reorder stack putting `m` on top
E!    # Eval `m` times

Answer 10

Vyxal, 10 bytes

Tɾ$(ṅ2lĖ)Ẏ

Try it Online!

Takes number of items to generate then how many times to squash

Answer 11

Rust + Itertools, 249 bytes

use itertools::*;let f=|s:Box<dyn std::iter::Iterator<Item=u32>>|Box::new(s.flat_map(|a|(0..=a.log10()).rev().map(move|t|a/10u32.pow(t)%10)).tuple_windows().map(|k:(u32,u32)|k.0*10+k.1));let g=|n|{let mut k=f(Box::new(1..));for _ in 0..n{k=f(k)};k};

Playground link: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=11fa065d958a13e4a9d68dc2de7b9b12

Answer 12

Java 10, 143 139 bytes

n->m->{int r[]=new int[n],i,j=0;for(;j++<m;){var s="";for(i=0;i<n;r[i]=new Byte(s.substring(i,i+++2)))s+=j<2?i-~i+""+-~i*2:r[i];}return r;}

Takes inputs \$n,m\$ and outputs the first \$n\$ values of the \$m^{th}\$ sequence.

Try it online.

Explanation:

n->m->{                  // Method with two integer parameters & integer-array result
  int r[]=new int[n],    //  Create the result-list of `n` amount of 0s
      i,                 //  Index-integer `i`, uninitialized for now
  j=0,i;for(;j++<m;){    //  Loop `j` in the range [1,m):
    var s="";            //   String `s`, starting empty
    for(i=0;i<n          //   Inner loop `i` in the range [0,n):
        ;                //     After every iteration:
         r[i]=           //      Replace the i'th value in the result-array to:
           new Byte(     //       Convert the following String to an integer,
                         //       (to put it in the integer-array & to remove leading 0s)
            s.substring( //        A substring of String `s`,
              i,i+++2))) //        in the character index-range [i,i+2)
                         //        (and increase `i` by 1 afterwards with `i++`)
      s+=                //    Append to String `s`:
         j<2?            //     If `j` is 1, thus the first iteration of loop `j`:
             i-~i        //      Append (2*i+1) to the String
             +""+-~i*2   //      as well as (2*i+2)
                         //      (so the .substring-indices won't be out-of-bounds)
           :             //     Else:
            r[i];        //      Append the i'th integer of the result-array instead
  }return r;}            //  After the loops: return the result-array

Answer 13

Jelly, 12 bytes

‘RDFṡ2ḌƲ⁴¡³ị

Try it online!

Answer 14

Pyth, 16 bytes

LsM.:jkb2<yFShQE

Try it online!

Takes n (number of elements to generate) then m on separate lines.

LsM.:jkb2<yFShQE
L                 Create a lambda with variable b:
     jkb           - Concatenate elements of b
                     (e.g. [1,2,3,4] -> "1234")
   .:   2          - Produce all 2-element sub-strings
                     (e.g. "1234" -> ["12","23","34"])
 sM                - Convert to integers
                     (e.g. ["12","23","34"] -> [12,23,34])
            ShQ   Range from 1 to n+1
          yF   E  Apply the above lambda m times
         <        Keep the first n elements

Answer 15

lin, 41 bytes

$`1`d \; `it
\ns `' `flat2`xp \; `'
`_` N

Try it here! Generates an infinite list of infinite lists.

Pretty-printed output version (run with -i flag if using local interpreter):

; ( 40`t ) `' 10`t `__ wrap_
$`1`d \; `it
\ns `' `flat2`xp \; `'
`_` N

lin is a stack-based language I began working on a few years back, but have recently been dusting off with new features and inspirations.

Explanation

• $` 1`d push infinite list [1..]
• \; `it iterate infinitely...
  • \ns `' `flat convert each number to digit list and flatten
  • 2`xp \; `' pairwise map...
    • `_` N convert pair to number

Answer 16

Python 2, 102 bytes

def z(m,n):a=range(1,n);exec'd="".join(map(str,a));a=[int(i+j)for i,j in zip(d,d[1:])];'*m;return a[m]

Try it online!

It's not the shortest Python 2 script here, but the approach is very different to @loopy walt's so I thought it was worth sharing anyways.

The first version of the code, when given an input n, returned a sequence containing at least the first n elements, but @math junkie pointed out that this is not allowed in the sequence rules.