[Question]
  [
The sequence [A109648](https://oeis.org/A109648) starts with the following numbers
```
53, 51, 44, 32, 53, 49, 44, 32, 52, 52, 44, 32,
51, 50, 44, 32, 53, 51, 44, 32, 52, 57, 44, 32,
52, 52, 44, 32, 51, 50, 44, 32, 53, 50, 44, 32,
53, 50, 44, 32, 52, 52, 44, 32, 51, 50, 44, 32,
53, 49, 44, 32, 53, 48, 44, 32, 52, 52, 44, 32,
51, 50, 44, 32, 53, 51, 44, 32, 53, ...
```
and has the description of
> 
> Sequence is its own ASCII representation (including commas and spaces).
> 
> 
> 
This is the unique sequence with the property. Your task is compute this sequence.
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules and [sequence](/questions/tagged/sequence "show questions tagged 'sequence'") [I/O methods](https://codegolf.stackexchange.com/tags/sequence/info) apply. The shortest code in bytes wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 41 bytes
```
f=lambda n:ord(`map(f,n*[n/4])+[5]`[1+n])
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728oLIkIz_PaMGCpaUlaboWNzXTbHMSc5NSEhXyrPKLUjQSchMLNNJ08rSi8_RNYjW1o01jE6INtfNiNaEa1CpsDbjKMzJzUhUqbIwMDKwKijLzShLSNCo0E7SVdJR0rCu0bQ2tIaph1gAA)
Thanks to @loopywalt
Uses Python's string representation of tuples to get the `,`  parts of the sequence (`44, 32`).
## [Python 2](https://docs.python.org/2/), 42 bytes
```
f=lambda n:ord("5"[n:]or`f(n/4),1`[1+n%4])
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728oLIkIz_PaMGCpaUlaboWN7XSbHMSc5NSEhXyrPKLUjSUTJWi86xi84sS0jTy9E00dQwTog2181RNYjWhOpQqbA24yjMyc1IVDK0KijLzSoBKKzQTtJV0lHSsK7RtDa0hKmF2AAA)
Here are some variations, but I've not been able to get any of them shorter:
```
f=lambda n:ord(`5*(n<1)or f(n/4),1`[1+n%4])
f=lambda n:ord(`0**n*5or f(n/4),1`[1+n%4])
f=lambda n:ord(`[5][n:]or[f(n/4)]*n`[1+n])
f=lambda n:ord(`[5]+[n and f(n/4)]*n`[1+n])
f=lambda n:ord(`0**n*-5or[f(n/4)]*n`[1+n])
f=lambda n:ord(`-~-n*"5"or[f(n/4)]*n`[1+n])
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 39 bytes
```
f=n=>n?[...f(n>>2)+'',28,16][n%4]^48:53
```
[Try it online!](https://tio.run/##FcrRCoIwFADQX7kvsntxDS0LEzbpO8ximMZE72RK0NcvezovZ7Qfu3bBLduB/auPcdCsDdeNUmpANuZIqRDyWMr80jacFO2jKKvzKXaeVz/1avJv/OdbCPaLeZZRq2a7ID4lOAJtYMDdFNBBAnkGWmu4Qg1C3llAtQuCSI3eMQpBagtuRqL4Aw "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~58~~ ~~57~~ ~~55~~ 48 bytes
-1 (-2) thanks to [alephalpha](https://codegolf.stackexchange.com/questions/240278/an-ascii-self-referential-sequence/240290?noredirect=1#comment542669_240290)
```
Nest[Rest@*ToCharacterCode@*ToString,!5,#][[#]]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73y@1uCQ6CEg4aIXkO2ckFiUml6QWOeenpIIEgkuKMvPSdRRNdZRjo6OVY2PV/gcARUr0HdLqHIuKEivrDA3@AwA "Wolfram Language (Mathematica) ‚Äì Try It Online")
Returns the \$n\$th element, 1-indexed.
---
### [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 68 bytes
```
If[#<1,53,Join[48+IntegerDigits@#0@‚åä#/4‚åã,{44,32}][[#~Mod~4+1]]]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73zMtWtnGUMfUWMcrPzMv2sRC2zOvJDU9tcglMz2zpNhB2cDhUU@Xsr7Jo55unWoTEx1jo9rY6GjlOt/8lDoTbcPY2Fi1/wFFmXklDo5FRYmV0Wk6RgY6BrH/AQ "Wolfram Language (Mathematica) ‚Äì Try It Online")
Implements the formula given on the OEIS page.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 26 bytes
```
‚âî‚äó‚äñ‚äóÔºÆŒ∏‚âî5Œ∑Ôº∑‚ÄπÔº¨Œ∑Œ∏‚âî‚™´Ôº•Œ∑‚ÑÖŒ∫, Œ∑‚Ä¶Œ∑Œ∏
```
[Try it online!](https://tio.run/##LYy7DsIwDEV3viLq5EhFKgNTJ1QWEK9fSFOrjkidkqQgvj6kpR6ubOvco0l57ZRN6RCC6RmObmotdnBE7XFAjvO@/k48TvE2DS16kHlK8ZL1Zi0W@6IUlO8PGYsCLhhCDu4jAS2oFCt6dobhqkagUtx9Z1hZeM66bCjk3/LwhiM0X22xIbeg2VCntKuqtH3bHw "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Outputs the first `n` elements, joined with comma and space. Explanation:
```
‚âî‚äó‚äñ‚äóÔºÆŒ∏
```
Calculate the length of the desired output.
```
‚âî5Œ∑
```
Start with the initial `5`, whose ASCII code starts with itself.
```
Ôº∑‚ÄπÔº¨Œ∑Œ∏
```
Until the string is long enough...
```
‚âî‚™´Ôº•Œ∑‚ÑÖŒ∫, Œ∑
```
... join its ASCII codes with comma space.
```
‚Ä¶Œ∑Œ∏
```
Output the desired number of terms.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 10 bytes
```
5?(‚Äõ, jC)·∫é
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCI1PyjigJssIGpDKeG6jiIsIiIsIjMiXQ==)
Outputs the first n terms, although it actually calculates the first n^3 terms.
```
5          # Starting with 5
 ?(     )  # input times...
   ‚Äõ, j    # Join by `, `
       C   # Get charcodes
         ·∫é # At end, get first n
```
[Answer]
# Haskell + [hgl](https://gitlab.com/WheatWizard/haskell-golfing-library), 24 bytes
```
q=53:tl(Or<ic", "(sh<q))
```
This defines `q` an infinite list representing the sequence.
If you want the actual string of the sequence you can do that for 1 more byte:
```
q=ic", "$sh<Or<('5':tl q)
```
## Explanation
So here we define `q` in terms of itself.
A naive answer might look like:
```
q=Or<ic", "(sh<q)
```
Which takes `q` maps `show` across it to convert all the numbers to strings, intercalates `", "` with `ic`, to get the string and maps `Or` to get the char points.
However if we define this the resulting list is just an infinite loop and never manages to produce the first element. So we need to tell it what the first element is. To do this we take what we had, chop off the first element and put the correct answer in it's place.
This allows Haskell to skip to the second element when calculating this list which it can calculate in terms of the first element just fine. And from there every successive element can be calculated just fine.
[Answer]
# [J](http://jsoftware.com/), 40 37 bytes
```
$_2".@}.[:,0&(]', ',~"#.3":"+@u:":)&5
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/VeKNlPQcavWirXQM1DRi1XUU1HXqlJT1jJWslLQdSq2UrDTVTP9rcqUmZ@QrpClYcAG1G3CZGusomBrqKJiY6CgYGwHZQL6JJRIfiqF8LpBaUwNU9Sj6QdgcoV7zPwA "J ‚Äì Try It Online")
-3 thanks to Bubbler's idea of taking first `n` terms with `$` instead of returning the nth term
Inspired by [emanrasu A's answer](https://codegolf.stackexchange.com/a/240280/15469)
Yikes.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
‚ñì‚ñëŒ¥Œì‚ïô√∂√¢'‚ïú√Ñ
```
[Run and debug it](https://staxlang.xyz/#p=b2b0ebe2d3948327bd8e&i=5)
freezes at 10.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 76 bytes
```
f(n){char*s=calloc(n,8),*t=s;for(*s=53;n--;)t+=sprintf(t,"%d, ",*s++);n=*s;}
```
[Try it online!](https://tio.run/##pVLLasMwELznKxaBQbJlSOOYJqjqpfQrkhyMLCemjhIkQQ3Bv153/UgaX0pDBQs7q5lhtSsV75Vq24IadlGHzIZOqqyqTooavmI89NKJ4mQp1tNEmDgWzEfSnW1pfEE9J0HOgfDQRRETRoZONC1ewTErDWVwmQGe3hh0fdbK6xwkkDThkD5xWC45JAvMES/Xd3iMG0ZuOp/yJ/ounh/U/4b/oJ/02@HVP/pHTMQwrJNxfhyZOmj1oe1mhzO7kG39vtjW6zeMlCD/DiekGdTOZianvjxqOmdsqOH@gHZLKU2ua7SaizF9gQXmUdQj1pOHjXWnUxhk944scN5W2tDrFkfvK9EisftE06rG6lWwMbufy/H/kCDJIX6FIIfAbQ0@ynCw/PZuK6XejZ7NrGm/VFFle9fGn98 "C (gcc) ‚Äì Try It Online")
Inputs a \$0\$-based index \$n\$.  
Returns the \$n^\text{th}\$ element.
[Answer]
# [R](https://www.r-project.org/), ~~83~~ ~~79~~ ~~74~~ 59 bytes
```
function(n){x=5
for(i in 1:n)x=utf8ToInt(toString(x))
x[n]}
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNPs7rC1pQrLb9II1MhM0/B0CpPs8K2tCTNIiTfM69EoyQ/uKQoMy9do0JTk6siOi@29n9mXklIfihQhUZxYkFBTqWGoZWhgU6apuZ/AA "R ‚Äì Try It Online")
Credit to Dominic van Essen for -4 bytes
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/index.html), ~~63~~ ~~35~~ 28 bytes
*Edit: -28 and then -7 more bytes (!) thanks to Razetime*
```
{ùï©‚Üë{-‚üú@¬®‚àæ‚àæ‚üú", "¬®‚Ä¢Fmt¬®ùï©}‚çüùï©‚•ä5}
```
[Try it at BQN online REPL](https://mlochbaum.github.io/BQN/try.html#code=QVNDSUlfc3JzIOKGkCB78J2VqeKGkXst4p+cQMKo4oi+4oi+4p+cIiwgIsKo4oCiRm10wqjwnZWpfeKNn/CdlanipYo1fQoKQVNDSUlfc3JzIDgg)
Outputs first n elements of sequence for input n. But, to get this, calculates the first 4^n elements. So times-out (or crashes) on the online REPL for even moderate n.
Ungolfed, commented ([try it here](https://mlochbaum.github.io/BQN/try.html#code=TG9nMTAg4oaQIDEw4oq44ouG4oG8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgYmFzZSAxMCBsb2dhcml0aG0KTjJkIOKGkCBOdW1iZXJfdG9fZGlnaXRzIOKGkCB7KDEw4ouG4oy94oaV4oyITG9nMTAg8J2VqSkoMTB8wrfijIrDtynLnPCdlal9ICMgZ2V0IGJhc2UgMTAgZGlnaXRzCk4ycyDihpAgTnVtYmVyX3RvX3N0cmluZyDihpAgJzAn4oq4K8KoIE4yZCAgICAgICAgICAgICAgICAgICMgc3RyaW5nIHJlcHJlc2VudGF0aW9uClMyYSDihpAgU3RyaW5nX3RvX0FTQ0lJIOKGkCBA4oq4KC3LnCnCqCAgICAgICAgICAgICAgICAgICAgICAjIEFTQ0lJIGNvZGVzIG9mIHN0cmluZwoKQVNDSUlfc3JzIOKGkCB78J2VqeKGkXtTMmHiiL7CtCjiiL7in5wiLCAiKeKImE4yc8Ko8J2VqX3ijZ/wnZWpIOKfqDXin6l9ICAjIHN0YXJ0IHdpdGgg4p+oNeKfqSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyByZXBlYXQgaW5wdXQgdGltZXM6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgIGdldCBzdHJpbmcgcmVwcmVzZW50YXRpb25zLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjICBqb2luICIsICIgdG8gZWFjaCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyAgam9pbiBpdCBhbGwgdG9nZXRoZXIsIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjICBhbmQgY29udmVydCB0byBBU0NJSSBjb2RlczsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBmaW5hbGx5IGdldCBpbnB1dCBlbGVtZW50cy4KQVNDSUlfc3JzIDgg)):
```
Log10 ‚Üê 10‚ä∏‚ãÜ‚Åº                                        # base 10 logarithm
N2d ‚Üê Number_to_digits ‚Üê {(10‚ãÜ‚åΩ‚Üï‚åàLog10 ùï©)(10|¬∑‚åä√∑)Àúùï©} # get base 10 digits
N2s ‚Üê Number_to_string ‚Üê '0'‚ä∏+¬® N2d                  # string representation
S2a ‚Üê String_to_ASCII ‚Üê @‚ä∏(-Àú)¬®                      # ASCII codes of string
ASCII_srs ‚Üê {ùï©‚Üë{S2a‚àæ¬¥(‚àæ‚üú", ")‚àòN2s¬®ùï©}‚çüùï© ‚ü®5‚ü©} 
                                       ‚ü®5‚ü©}  # start with ‚ü®5‚ü©,
                                    ‚çüùï©       # repeat input times:
                              N2s¬®ùï©}         #  get string representations,
                    (‚àæ‚üú", ")‚àò               #  join ", " to each,
                  ‚àæ¬¥                         #  join it all together, 
              {S2a                           #  and convert to ASCII codes;
           {ùï©‚Üë                               # finally get input elements.
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 40 bytes
```
->n{a=*5
n.times{a=(a*", ").bytes}
a[n]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOtFWy5QrT68kMze1GMjRSNRS0lFQ0tRLqixJLa7lSozOi639X6CQFm1oEPsfAA "Ruby ‚Äì Try It Online")
a lambda that returns the n-th element
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 83 bytes
```
a@1={53};a[n_]:=a[n]=Join[a[n-1],ToCharacterCode@StringTake[ToString@a[n-1],{n+1}]]
```
[Try it online!](https://tio.run/##LYqxCgIxEAV/xV6FC2KjBCLprA5MtyzyOIMXzCUQtjvu29eAVm9meAtkjgskTVCfI9otZwIrnLHr@bRdQeXJF9uH7b2mQp2Ohg@h@hkNk8Tm6yu6h7RU3gGfSKH@xP2va9mbjVnHHsXtQGYYWPUL "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) + `-pa`, 42 bytes
```
$_=53;$_.=", ".ord+(/./g)[++$;]while"@F">$
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3tbU2FolXs9WSUdBSS@/KEVbQ19PP10zWltbxTq2PCMzJ1XJwU3JTuX/fyNTs3/5BSWZ@XnF/3ULEnMA "Perl 5 ‚Äì Try It Online")
## Explanation
Naiive approach, builds the string from `53` and appends the `ord`inal values. 0-indexed, prints up to the `n`th term.
Uses `$;` to store the counter to save a byte at the end from the `-p` flag.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 49 bytes
```
f(n)=if(n,Vec(Vecsmall(Str(f(n-1)))[2..n+1]),[5])
```
[Try it online!](https://tio.run/##K0gsytRNL/j/P00jT9M2E0jqhKUmawBxcW5iTo5GcEmRBlBQ11BTUzPaSE8vT9swVlMn2jRW839BUWZeCVDSyEBT8z8A "Pari/GP ‚Äì Try It Online")
1-indexed. Based on the PARI/GP code on the OEIS page.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 15 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
@Zq,√∫2)cY}h#5√¨L
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=QFpxLPoyKWNZfWgjNexM&input=MTA)
[Answer]
# Excel VBA, ~~69~~ 50 bytes
Saved 19 bytes thanks to a total re-write by Taylor Raine
```
?"53";:t=3:Do:k=", "&Asc(t):t=Mid(t &k,2):?k;:Loop
```
The function is typed directly into the immediate window and output is in the same window. It will run until it's stopped (`ESC`) or it hits a software / hardware limitation like running out memory.
Colons are line line breaks in VBA. Here's a version with some nicer formatting and comments.
```
?"53";                 ' Print "53" without a line break at the end
t = 3                  ' Seed the value for t
Do                     ' Start a loop
   k = ", " & Asc(t)   ' Store the ASCII value for the first character in t
   t = Mid(t & k, 2)   ' Set t be everything in t & k except the first character
   ?k;                 ' Print the value of k without a line break at the end
Loop                   ' Go back to "Do"
```
[Answer]
# APL+WIN, 60 bytes
Prompts for required term number. Index origin = 0
```
i‚Üê0‚ãÑs‚Üê53 51 44 32‚ãÑ‚çé‚àä(n‚Üê‚éï)‚ç¥‚äÇ's‚Üês,(‚éïav‚ç≥‚çïs[i‚Üêi+1]),44 32‚ãÑ'‚ãÑs[n]
```
TIO examples generate the first column of the tabular form of the series as depicted in the question.
[Try it online! Thanks to Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcQJanP5BlwPWooz3tfyaI@ai7pRhImxormBoqmJgoGBsBRR719j3q6NLIA0oA9Wg@6t3yqKtJHaSuWEcDKJJY9qh386PeqcXRIDMytQ1jNXVgetVBJkbnxf4H2sH1P43LgCuNy9AISBiZAAljMyBhYgEkzAy4AA "APL (Dyalog Classic) ‚Äì Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 17 bytes
```
‚Üë¬π!¬°»ØmcJ", "ms;53
```
[Try it online!](https://tio.run/##yygtzv7//1HbxEM7FQ8tPLE@N9lLSUdBKbfY2tT4////RgYA "Husk ‚Äì Try It Online")
---
# [Husk](https://github.com/barbuz/Husk), 16 bytes
```
‚Üë¬π!¬°»ØJ", "mosc"5
```
With output as character string (ASCII values represent sequence A109648)
[Try it online!](https://tio.run/##yygtzv7//1HbxEM7FQ8tPLHeS0lHQSk3vzhZyfT///@mBgA "Husk ‚Äì Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
5Œî‚Äû, √Ω√áI¬£
```
Outputs the first \$n\$ results.
[Try it online.](https://tio.run/##yy9OTMpM/f/f9NyURw3zdBQO7z3c7nlo8f//hgYA)
**Explanation:**
```
5          # Start with a 5
 Œî         # Loop until the result no longer changes:
  ‚Äû, √Ω     #  Join with ", " delimiter
      √á    #  Convert it to a list of its codepoint integers
       I¬£  #  Only leave the first input amount of values
           # (after the loop, the resulting list is output implicitly)
```
]