[Question]
  [
*([Related](https://codegolf.stackexchange.com/q/1775/42963))*
Given an integer `n > 1`,  
1) Construct the range of numbers `n, n-1, n-2, ... 3, 2, 1` and calculate the sum  
2) Take the individual digits of that number and calculate the product  
3) Take the individual digits of *that* number and calculate the sum  
4) Repeat steps 2 and 3 until you reach a single digit. That digit is the result.
The first twenty terms of the sequence are below:
```
3, 6, 0, 5, 2, 7, 9, 2, 7, 9, 1, 9, 0, 0, 9, 6, 7, 0, 0, 6
```
Note: This sequence is NOT in OEIS.
## I/O and Rules
* Numbers will get very large quickly, so the solution must be able to handle input numbers up to 100,000 without failure (it's fine if your code can handle past that).
* The input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
## Examples
```
n     output
1234   9
3005   3
5007   5
9854   8
75849  8
100000 0
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~77~~ ~~72~~ ~~71~~ ~~62~~ 60 bytes
```
lambda n:reduce(lambda x,c:eval(c.join(`x`)),'*+'*n,-n*~n/2)
```
*Thanks to @xnor for golfing off 2 bytes!*
[Try it online!](https://tio.run/##LchLDoIwFEbhsa7inxBauGgpII9EN6ImIBTF4IUQMDhx66iJZ/ad/jXeOtZLjT1OS1s8LlUBzgZTTaURf89UZuZZtKLc3LuGRT7nUpLtuLbD5LHz5q2WS90NYDSMoeCrEZqgtYSLo6@DkBAoFREipWJCmkTfE0dJmBJ89eucrVf90PAI29pN8A42LDChFiyXDw "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
LOΔSPSO
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fx//clOCAYP///81NLUwsAQ "05AB1E – Try It Online")
**Exlpanation**
```
L         # push range [1 ... input]
 O        # sum range
  Δ       # loop until top of stack stops changing
   SP     # product of digits
     SO   # sum of digits
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
RSDPDƲÐL
```
[Try it online!](https://tio.run/##y0rNyan8/z8o2CXA5dimwxN8/v//bw4A "Jelly – Try It Online")
Full program (it returns a singleton array containing the result, but the brackets aren't visible in STDOUT).
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~15~~ 13 bytes
In tribute to the [Language of the month](https://codegolf.meta.stackexchange.com/questions/16337/language-of-the-month-for-may-2018-matl?cb=1):
```
:`sV!UpV!Utnq
```
[Try it online!](https://tio.run/##y00syfn/3yqhOEwxtACIS/IK//83NjAwBQA "MATL – Try It Online")
I don't think there's a simpler way to get the digits of a number than to convert the number to a string `V`, then transposing it `!`, and converting this vertical vector back to a numeric one `U`.
Saved 2 bytes thanks to the Creator1 himself! I forgot the implicit end, meaning I could remove `]`, and instead of comparing the number of elements with `1`, I could simply decrement that value and use it as a boolean directly.
So, the explanation goes like this:
```
                 % Grab input n implicitly
:                % Range from 1 ... n inclusive
 `               % Do ... while
  s               % sum the vector
   V!U            % Convert the number to digits
      p           % Take the product of these digits
       V!U        % Convert the product into digits
          t       % Duplicate the result
           n      % Count the number of elements
            q     % Decrement the number of elements
                  % Loop until the number of elements is 1
                 % Implicit end
```
1... of MATL, Luis Mendo.
[Answer]
# JavaScript (ES6), 60 bytes
```
f=(n,k=n*++n/2)=>k>9?f(!n,eval([...k+''].join('*+'[+!n]))):k
```
[Try it online!](https://tio.run/##FY5BboMwFET3PYWzsh1PXX@DAyQyXfUUiIVFoE1A31US5fokjDSLp9GT5pqe6T7cLv@PT87ncV2nqBhz5L0x/OV1bOe2@Z7UjjE@06I6a@1spOztNV9Yyb2Rndlxr7U@zuup8yhQIuCACjUakAMRyIMKUAkKoAOoAtWgBt7Bb2tRonAuIDhXoQp1uYlb@g875dtPGv4Ui9iKIfM9L6Nd8q@SSUlhBL8rtYhig0nx@8n6Ag "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (                     // f = recursive function taking:
  n,                      //   n = original input
  k = n * ++n / 2         //   k = current value, initialized to sum(i=1..n)(i)
) =>                      //
  k > 9 ?                 // if k has more than 1 digit:
    f(                    //   recursive call to f() with:
      !n,                 //     a logical NOT applied to n
      eval(               //     the result of the expression built by:
        [...k + '']       //       turning k into a list of digits
        .join('*+'[+!n])  //       joining with '*' on even iterations or '+' on odd ones
      )                   //     end of eval()
    )                     //   end of recursive call
  :                       // else:
    k                     //   stop recursion and return the last value
```
---
# Alternate version, 59 bytes (non-competing)
A non-recursive version that only works for **n < 236172**. (It covers the requested range but does not qualify as a valid generic algorithm.)
```
n=>[...'*+*+'].map(o=>n=eval([...n+''].join(o)),n*=++n/2)|n
```
[Try it online!](https://tio.run/##FYtBboMwFET3OYV3tvHU9Tc4EEVm11NEWVgEWiL6jUiUVe9O45FmMe9p7umVHsM2r88Pzrdxn@LOsb9Ya2VlKiOv9jetKsee4/hKiyqGjXzze55ZZa3BVTSGP73@4/188ajRIOCIFh1OIAcikAfVoAYUQEdQC@pAJ3gHX2zdoHYuIDjXog1dU44l14Od8vaVhh/FIvZiyPzIy2iX/K1kUlIYwe9KLaIoY1Kstd7/AQ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~72~~ 71 63 bytes
```
g=map(read.pure).show
f n=until(<10)(sum.g.product.g)$sum[1..n]
```
Thanks to @BMO for a byte and @nimi for 8 bytes!
[Try it online!](https://tio.run/##FchBDoMgEADAe1@xBw@YkM1SJdZE@hHjgVRFUkCCkD6ftnOcQ1/vzblajfI6srTpFWNJW4vXcX5uOwRVQraOTYJadhWPBmM61/LKaNrmF7NADEv12gZQEJMNGRrYYWqeMIt71/OOSHJJNPBBPvqRC/pb6hc "Haskell – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax),  ~~14~~   ~~13~~  10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ñu┌↕a√äJ²┐
```
[Run and debug it](http://stax.tomtheisen.com/#p=a475da1261fb844afdbf&i=1234%0A&a=1)
Was pretty fun to make. I wonder if there is a more concise way to do the comparison at the end.
**Explanation**
```
|+wE:*E|+c9>                 # Full Program Unpacked
|+                           # Create range and sum it
   wE:*                      # Start loop, digitize number, product of digits
       E|+                   # Digitize number, sum digits
          c9>                # Duplicate, check length is = 1
                             # Otherwise loop back to the 'w' character
```
-1 bytes thanks to ovs
-3 bytes thanks to Scrooble
[Answer]
# [R](https://www.r-project.org/), ~~152 130~~ 109 bytes
```
function(w,x=w*(w+1)/2,y=prod(d(x)),z=sum(d(y)))"if"(z>9,f(,z),z)
d=function(x)x%/%10^(0:max(0,log10(x)))%%10
```
[Try it online!](https://tio.run/##PYzLCoMwEEX3/QoRhJk6xUlM8EHTTymIkiL4QitGfz7VTc/qci6c2dvg@Qi8XYf6244DbOTMdoctFphI2s00jw004BDpMMvan3tHxLC1IRyvgizQcV54a8y/4dBFSST4DVz2lQOmbvwIviIYnd4v1TR1O9QgSylIyFRRyqxJM2dU5FpRpnNVkOALpMCi9z8 "R – Try It Online")
@Giuseppe found ~~21~~ 42 bytes with various R things I'm not used to yet, along with a way to get the digits of a number without coercing to string and back, and with fewer bytes!
```
# Old
d=function(x)strtoi(el(strsplit(paste(x),"")))
# New
d=function(x)x%/%10^(0:max(0,log10(x)))%%10
```
`options(scipen=9)` ~~is~~ was required for the case of 9854 for the old function, because the first product stage ends up as 80000, which R prints as 8e+05. 
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 16 bytes
-4 thanks to @user
```
f←{⍎¨⍕×/⍎¨⍕+/⍵}⍣≡⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR719h1Y86p16eLo@jKkNZG2tfdS7@FHnwke9m4EKFcxNLUwsudIUDA1AAAA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 7 bytes
```
ωöΣdΠdΣ
```
[Try it online!](https://tio.run/##yygtzv7//3zn4W3nFqecW5BybvH////NAQ "Husk – Try It Online")
[Answer]
# [Pyth](https://pyth.readthedocs.io), 11 bytes
```
usj*FjGTTsS
```
[Try it here!](https://pyth.herokuapp.com/?code=usj%2aFjGTTsS&input=1234&test_suite=1&test_suite_input=1234%0A3005%0A5007%0A75849%0A100000&debug=0)
```
usj*FjGTTsS – Full program. N = The input.
          S – Range. Yield [1, N] ⋂ ℤ.
         s  – Sum.
u           – While no two consecutive iterations yield the same result, do (var: G):
   *FjGT    – Digital product.
 sj     T   – Digital sum.
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes
```
≔Σ…·¹ＮθＷ›θ⁹≔ΣΠθθＩθ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@xuDgzPU8juDRXwzMvOae0OLMsNSgxLz1Vw1BHwTOvoLTErzQ3KbVIQ1NTU0ehUNOaqzwjMydVQcO9KDWxBCheqKNgqampgGROQFF@SmlyiUYhTEdAUWZeiYZzYjFYzPr/f3NTCxPL/7plOQA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔Σ…·¹Ｎθ
```
Sum the integers up to the input.
```
 Ｗ›θ⁹≔ΣΠθθ
```
While the result is greater than 9, take the sum of digits of the product of digits.
```
Ｉθ
```
Cast the result to string and implicitly print it.
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), 8 bytes
```
┅⟨Σ₸∨Π⟩°
```
[Try it online!](https://tio.run/##ASEA3v9nYWlh///ilIXin6jOo@KCuOKIqM6g4p@pwrD//zEyMzQ "Gaia – Try It Online")
The old explanation (before fixing a bug that is Gaia’s fault IMO :P):
```
┅⟨ΣΠ⟩° – Full program. N = The input.
┅      – Range. Push [1, N] ⋂ ℤ to the stack.
 ⟨  ⟩° – While no two consecutive iterations yield the same result, do:
  Σ    – Sum (or digital sum, when applied to an integer).
   Π   – Digital product.
```
Saved 1 byte thanks to [Dennis](https://codegolf.stackexchange.com/users/12012/dennis).
[Answer]
## F#, 175 bytes
```
let d n=seq{for i in(string n).ToCharArray() do yield string i|>uint64}
let c n=
 let mutable r=Seq.sum{1UL..n}
 while r>9UL do r<-d r|>Seq.reduce(fun a x->x*a)|>d|>Seq.sum
 r
```
[Try it online!](https://tio.run/##LY7BasMwEETv@oolULALNnJjNzHEglJ6y6HQ5lR6UC05Edhys5ZamzjfrkpO97AM7MzbaYak7lE610oDAnQ1yPOl6REUKB0NBpU@go7T9/75xPEJkU9RDKKHSclWwL9BzcwqbR7zKwmc2nMIBNVZw79aCVi9yXM62O6SHfZpqq8Efk8qHFh52Ace7hIBOLPgQylsLaPGauAwJmy85/HMxO3oIQTQfexetMHptfd/2efytuPKB/D4AxUQCF5lJMLCGSFhcOvo9cx8R7@@fXvTaFjd2VW8RAlQ57KHde7WlBauoHTjym2Ru02xzUuX0TB/)
The only caveat to the function is that the input value must be of type `uint64`.
Ungolfed it's a little like this:
```
let d n=seq{for i in(string n).ToCharArray() do yield string i|>uint64}
let c n =
 let mutable r = Seq.sum {1UL..n}
 while r > 9UL do
  r<-d r
  |> Seq.reduce(fun a x->x*a)
  |> d
  |> Seq.sum
 r
```
The function `d n` converts the number `n` into its component digits. It first converts to a string, then gets each character in the string. Each character must then be converted back into a string, otherwise the characters will be converted to their ASCII values instead of their "real" values.
The `c n` function is the main function, with `n` as the initial value. In this function `r` is our running value. The `while` loop does the following:
* Convert `r` into its component digits (`d r`).
* Get the product of all those digits. This uses [`Seq.reduce`](https://msdn.microsoft.com/visualfsharpdocs/conceptual/seq.reduce%5b%27t%5d-function-%5bfsharp%5d) which takes a function with the accumulated value (`a`) and the next value in the sequence (`x`) and in this case returns the product. The initial value is the first element in the sequence.
* Convert this product value into its component digits (`d`).
* Sum the digits from before, and assign this to `r`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 57 bytes
```
->n{("*+"*n).chars.reduce(-~n*n/2){|x,y|eval x.digits*y}}
```
[Try it online!](https://tio.run/##FcHdCoMgGADQVxEhKPflzJTqol4kumhlKxgy/BlFtld37BzjH0dc2ph3@kwxuWGiMzqto7HUqNlPKs2/mug7z86wwxHUZ3yhnc7bc3OWHNcVe8Ip5QUUvBRQMiZBMlZBU0sBlaxFAwX7G6gap/UMLqC3dxbhxKK2Q4nFSe8ALb0bhiv@AA "Ruby – Try It Online")
[Answer]
# Befunge, 136 bytes
```
101p&::*+2/>:82+%01g*01p82+/:#v_$01gv
X      v_v# #:/+82p10+g10%+82: <p100<
v:g10$ >#<#^                 #<^
>82+/#v_.@
      >101p^
```
You can [try it here](http://www.quirkster.com/iano/js/befunge.html).
While not all interpreters have a large enough cell size, it works with small numbers for pretty much anyone out there. For a larger number of `n` you might need a interpreter like [BefunExec](https://www.mikescher.com/programs/view/BefunUtils).
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), ~~35~~ 33 bytes
```
1AY:P*2,TYMR*YR+:a(?Bt
:a(qlBaSD$
```
[Try it online!](https://tio.run/##S8/PScsszvhv6Oju6Wrt7vffyDHSKkDLSCcyxzdIKzInSNsqUcPeySJIkQvMSAx2Ufn/34jLmMuEy5TLjMucy4LLksvQgMvQyNiEy9jAwJTL1MDAnMvSwtSEy9zUwgQkCQIA "Gol><> – Try It Online")
-2 bytes by Jo King.
Extensive use of functions and implicit infinite loops.
### Example full program & How it works
```
1AGIE;GN
2AY:P*2,YlMR*YlR+:a(?B8R!
:a(?BaSD$
<main program>
1AG       Register row 1 as function G
   IE;    Take number input; halt on EOF
      GN  Call G and print the result as number
          Repeat indefinitely
<function G>
2AY            Register row 2 as function Y
   :P*2,       Sum of 1 to n
        Y      Call Y (break into digits)
         lMR*  Product
Y              Call Y
 lR+           Sum (an implicit zero is used)
    :a(?B      Return if the result is less than 10
         8R!   Skip initial 8 commands
               Repeat indefinitely
<function Y>
:a(?B      Return if the top is less than 10
     aSD   Divmod by 10; [... n] => [... n/10 n%10]
        $  Swap top two, so the "div" goes to the top
```
[Answer]
# Japt, ~~16~~ ~~14~~ 13 bytes
```
_ì ×ìx}gN®õ x
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=X+wg1+x4fWdOrvUgeA==&input=OTg1NA==)
---
## Explanation
```
                  :Implicit input of integer U
         ®        :Map
        N         :The array of inputs (which just contains U)
          õ       :  Range [1,U]
            x     :  Reduce by addition
_     }g          :Take the last element of N, run it through the following function and push the result to N
                  : Repeat U times and then return the last element of N
 ì                :  Split to an array of digits
   ×              :  Reduce by multiplication
    ìx            :  Split to an array of digits and reduce by addition
```
[Answer]
# PHP 7, 89 bytes
```
for($a=$argn*-~+$argn/2;$a>9;)$a=array_sum(($s=str_split)(array_product($s($a))));echo$a;
```
Run as pipe with `-r` or [try it online](http://sandbox.onlinephpfunctions.com/code/d941fd16493db3862b495c31fb417589bf084271).
* PHP always takes input as string, so I have to use `+` to cast to int for `~` to work as wanted.
* Pre-increment would not work: no matter where I put it, it would effect both operands.
* But: It doesn´t matter if the single digit takes place before or after the iteration (additional iterations wouldn´t change a thing); so I can use `for()` instead of `do ... while()`.
* PHP 7 or later is required for the inline assignment of the function name.  
Older PHP requires one more byte: `for($s=str_split,$a=...;$a>9;)$a=array_sum($s(...));`  
(Not assigning `str_split` to a variable at all would waste another byte.)
[Answer]
# [Perl 6](http://perl6.org/), 49 bytes
```
{($_*.succ/2,{[+] ([*] .comb).comb}...9>=*).tail}
```
[Try it online!](https://tio.run/##HcTRCoIwGAbQV/kQCV3xN3VLB20vIjJsNBAUQ@tCxp59UefivJ7bfEvLgZOHTqHILaP949y1voT@PKDo2QBy6/Io/0ciUkazkt7jNMe0jwey3EIbBI/cxgx@3XCv6kag4VxCct5CdVKglZ1QqPiPSV8 "Perl 6 – Try It Online")
[Answer]
# [Tcl](http://tcl.tk/), 118 bytes
```
proc S n {set r [expr $n*($n+1)/2]
while \$r>9 {set r [expr [join [split [expr [join [split $r ""] *]] ""] +]]}
set r}
```
[Try it online!](https://tio.run/##bY@9DoIwAIT3PsWFdFAZLH8BHHwCNsbSgWATa0ppSo0mhGdHxMGYeMuXfLkbznd6WawbOtQwmEbp4cDl0zpQc9hRE0b7YyzI46q0REPdufxt8dugDPhotfL/FHUIAoGDEBtDIWay7edFmc5BEa96iUm31kpzQQX@8WJGzMhXR3GSImEsQ8ZYjrLIUuRZkZaI2DuE6L616wlaYbJ3P64HTg14vVLMyws "Tcl – Try It Online")
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 91 101 93 bytes
```
Function F($a){$o=$a*($a+1)/2;1,2|%{$o=[char[]]"$([char[]]"$o"-join'*'|iex)"-join'+'|iex};$o}
```
[Try it online!](https://tio.run/##TVBta4MwEP5sfsUhKU3q2cW3qojQL/MX7JuUIS6jDjGdWlZQf7vTbGt3HMfz3CVP7slFfcm2O8u6tkvVynnOrk3ZV6qBjNGCD1SltNgt0HL4k5s46I6btZmX56LNTyeTsgdUpv2hqma7246VvPFfZmk2JVRND/UX2fVkIAYt0iPjxMirpl80mLvfuw63jsxxPR89IQIMhAgxjgIfwyDyY3TEGhxG2MAAtIB0LRawDOgrT2AixqIrbxdZ9vJtmZoewgFBIAQILkKIEP8Djq5CZ6xPhn/0oDuevhjpFCYxqndYPkSbMxFMsOUn3N/j6059e5UwwXPdyZ8VJzIRsnqevwE "PowerShell Core – Try It Online")
Ungolfed a little...
```
Function F ($a)
{
    $o=$a*($a+1)/2;
    1..2 | % {
        $o = [char[]]"$o"-join '*' | iex;
        $o = [char[]]"$o"-join '+' | iex;
    }
    $o | Write-Output
}
```
First steps were to split the integers into digits -- did this by splitting the integer into an array of stringscharacters. Afterwards, insert the operand, and then evaluate the string as a command. Then, it's a matter of doing the multiple-add cycle until the input is one digit.
`iex` is an alias for `Invoke-Command` which evaluates a string passed into the first param position.
Edit: As requested by [@AdmBorkBork](https://codegolf.stackexchange.com/users/42963/admborkbork), I have added a function header to the byte count. Also, I did a little math and realized that an upper bound on the number of iterations is `< log log 10^6 < log 6 < 2`, so that saved another six bytes.
Edit x2: [@AdmBorkBork](https://codegolf.stackexchange.com/users/42963/admborkbork) found a more terse way of converting the integer into a math expression, and then suggested piping it into `iex`. This saved 8 bytes. Thank you!
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 61 bytes
```
$_*=$_/2+.5;$_=eval((eval s/./$&*/gr.1)=~s/./+$&/gr)while$_>9
```
[Try it online!](https://tio.run/##K0gtyjH9/18lXstWJV7fSFvP1Fol3ja1LDFHQwNEKhTr6@mrqGnppxfpGWra1oG42ipqQK5meUZmTqpKvJ3l//@GBv/yC0oy8/OK/@sWAAA "Perl 5 – Try It Online")
[Answer]
# Java 8, 129 bytes
```
n->{long r=1,i=n;for(;i>1;r+=i--);for(;r>9;r=(i+"").chars().map(p->p-48).sum(),i=1)for(int s:(r+"").getBytes())i*=s-48;return r;}
```
[Try it online.](https://tio.run/##bVGxboMwEN37FadMdikISFBCXDN0b5aMbQeXkPRSMMg2kaKIb6c2UIlIsWxL7/zu7r3zWVyEfz789nkptIZ3gfL2BIDSFOoo8gJ2DgKUtTxBTmwcJGU21NljtzbCYA47kMChl352G5iKRy/IJTvWijDMIqY8jr5Px4DKUqY4QW@xoEH@I5QmNKhEQxo/a/zVhga6rQi1FSLqElxXvSVq4J8K83Y1hU2h@My1pTNVmFZJUKzr2Sirab9LK2tSd6nxAJW1RvZGoTx9fIGgo6//8shjBvgau9vz6PAGYNsYgoPfCUTxcjXHyzBM5jgJw/Ucp5vkjr9ONqv0rmDo1oORDqJHAU7fpHd/1aaogro1QWOtmFK6MW4/zcKTgf0fOlXq@j8)
**Explanation:**
```
n->{            // Method with integer parameter and long return-type
  long r=1,     //  Result-long, starting at 1
       i=n;     //  Temp integer, starting at the input `n`
  for(;i>1;     //  Loop as long as `i` is not 1 yet
      r+=i--);  //   And increase `r` by `i`
  for(;r>9      //  Loop as long as `r` is not a single digit yet
      ;         //    After every iteration:
       r=(i+"").chars().map(p->p-48).sum(),
                //     Set `r` to the sum of digits of `i`
       i=1)     //     And reset `i` to 1
    for(int s:(r+"").getBytes())i*=s-48;
                //    Set `i` to the product of the digits of `r`
  return r;}    //  Return `r` as result
```
[Answer]
# [Julia 0.6](http://julialang.org/), 56 bytes
```
f(n,k=(n+1)n÷2)=k>9?f(0,sum(digits(prod(digits(k))))):k
```
[Try it online!](https://tio.run/##yyrNyUw0@/8/TSNPJ9tWI0/bUDPv8HYjTdtsO0v7NA0DneLSXI2UzPTMkmKNgqL8FBg7WxMErLL/5yYWACUy80py8h51zEjTUdAwNDI20VEwNjAw1VEwNTAw11GwtDAFipibWphY6igYGoCApuZ/AA "Julia 0.6 – Try It Online")
Pretty straightforward: calculate `(n+1)n÷2` for sum from 1..n, check if it's a single digit number (`>9`), if it's not, try again with k set to the sum of the digits of the product of the digits of k, else return k. 
[Answer]
# [J-uby](https://github.com/cyoce/J-uby), 38 bytes
This is me resisting forking J-uby to add a bunch of single-character aliases for useful functions.
```
:+|:sum|:!~&((d=:digits)|:/&:*|d|:sum)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700K740qXLBIjfbpaUlaboWN9WstGusiktza6wU69Q0NFJsrVIy0zNLijVrrPTVrLRqUsCymlDVdgUKbtGGRsYmsVwglrGBgSmEZWpgYA5hWVqYQmXNTS1MLCFMQwMQiIWYsmABhAYA)
## Explanation
```
:+ | :sum | :!~ & ((d = :digits) | :/ & :* | d | :sum)
:+ | :sum |                                             # Range 1..n, then sum, then
            :!~ & (                                  )  # Until a fixed point is reached...
                  ((d = :digits) |                      #   Get digits (while saving the function to d for later), then
                                   :/ & :* |            #   Reduce with product, then
                                             d | :sum   #   Get digits, then sum
```
]