[Question]
  [
# Scramble a Megaminx!
A megaminx is a dodecahedral version of the familiar Rubik's cube. Since 2008, the World Cube Association uses [Stefan Pochmann's](https://codegolf.stackexchange.com/users/40544/stefan-pochmann) [megaminx scrambler](https://www.stefan-pochmann.info/spocc/other_stuff/tools/scramble_megaminx/). The scrambles look like this:
```
R-- D++ R++ D-- R++ D-- R++ D++ R-- D-- U'
R++ D-- R++ D-- R-- D++ R-- D-- R-- D-- U'
R++ D++ R-- D++ R++ D++ R++ D++ R-- D++ U 
R-- D-- R++ D++ R++ D++ R-- D++ R++ D++ U 
R-- D++ R++ D-- R++ D-- R++ D++ R++ D++ U 
R++ D++ R++ D++ R-- D-- R-- D-- R-- D-- U'
R-- D++ R-- D++ R++ D++ R++ D++ R++ D++ U 
```
A scramble has seven lines. Each line has 10 R and D moves, starting with R and alternating R and D moves. Following each letter is randomly chosen direction `++` or `--` with equal probability. At the end of the line is randomly chosen with equal probability `U` (trailing space form `U`  allowed) or `U'`. A trailing newline at the end of the output is permitted.
Your code must take no input and must produce a random scramble.
  
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~73~~ 71 bytes
*Saved two bytes thanks to @vrintle (one directly and another with further golfing)*
```
77.times{|i|$><<(~i%11>0?:RD[i%2]+'+-'[rand 2]*2+' ':?U+?'*rand(2)+$/)}
```
[Try it online!](https://tio.run/##KypNqvz/39xcryQzN7W4uiazRsXOxkajLlPV0NDOwN4qyCU6U9UoVltdW1c9uigxL0XBKFbLSFtdQd3KPlTbXl0LJKZhpKmtoq9Z@/8/AA "Ruby – Try It Online")
`$/` is the input record separator, which is a newline by default.
---
In Ruby 2.7 (newer than the version on TIO), we get 70 bytes using numbered block parameters:
```
77.times{$><<(~_1%11>0?:RD[_1%2]+'+-'[rand 2]*2+' ':?U+?'*rand(2)+$/)}
```
[Answer]
# [Python 2](https://docs.python.org/2/), 91 bytes
```
from random import*
for C in[choice]*7:print' '.join(c+C('+-')*2for c in'RD'*5),'U'+C("' ")
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocaXlFyk4K2TmRSdn5Gcmp8ZqmVsVFGXmlagrqOtl5WfmaSRrO2uoa@uqa2oZgdQmA9WqB7moa5lq6qiHqgMlldQVlDT//wcA "Python 2 – Try It Online")
Alternatively:
```
from random import*
C=choice
exec'print" ".join(c+C("+-")*2for c in"RD"*5),"U"+C("\' ");'*7
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocTnbJmfkZyancqVWpCarFxRl5pUoKSjpZeVn5mkkaztrKGnrKmlqGaXlFykkK2TmKQW5KGmZauoohSqBJGPUFZQ0rdW1zP//BwA "Python 2 – Try It Online")
**[Python 2](https://docs.python.org/2/), 92 bytes**
```
from random import*
C=choice
for c in('RD'*5+'U')*7:print c+[C("+-")*2,C("' ")+"\n"][c>"T"],
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocTnbJmfkZyancqXlFykkK2TmaagHuahrmWqrh6praplbFRRl5pUoJGtHO2soaesqaWoZ6QBZ6gpKmtpKMXlKsdHJdkohSrE6//8DAA "Python 2 – Try It Online")
**[Python 2](https://docs.python.org/2/), 92 bytes**
```
from random import*
for C in[choice]*7:
 for c in'RD'*5:print c+C('+-')*2,
 print'U'+C("' ")
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocaXlFyk4K2TmRSdn5Gcmp8ZqmVtxKYAEk4GC6kEu6lqmVgVFmXklCsnazhrq2rrqmlpGOlwKYDH1UHWgoJK6gpLm//8A "Python 2 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 68 bytes
```
say+(map{map$_.("++ ","-- ")[rand 2],R,D}0..4),U,"'"x rand 2for 0..6
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJbIzexoBqIVeL1NJS0tRWUdJR0dRWUNKOLEvNSFIxidYJ0XGoN9PRMNHVCdZTUlSoUIBJp@UUKQGGz////5ReUZObnFf/X9TXVMzA0AAA "Perl 5 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~135~~ ~~132~~ ~~124~~ ~~123~~ 119 bytes
* -12 thanks to ceilingcat
* -1 by rearranging the inner `for` terms
For each line, I start with `R++` and then flip `R`=>`D` and `++`=>`--` (half the time). This continues ten times and concludes with either `U` or `U'`. Instead of doing string operations, I use XOR for all the manipulations and print the integer as a reinterpreted string.
```
f(j){long i,k=7;for(srand(time(0));k--;puts(rand()%2?"U'":"U"))for(j=10,i=' ++R';j--;printf(&i))i^=22+rand()%2*394752;}
```
[Try it online!](https://tio.run/##NcvfCoIwFIDxe59iDMpz0oGtQmqM3iHwNpDZ5PhnhlpdiK/eyqDbj99nRGmM9xYqnJrOlYziWqfKdj0Mfe4KGKm9QYKoaiHU/TEO8Mu4kmeehfzEM4648Epvk5h0yKLoEqpq0T250cKaEOmqpYz@52Z33KcHqWb/BazNycGzowLZFDBmAVUw@7exTV4OXrw@ "C (gcc) – Try It Online")
[Answer]
# [Python 3.6], 144 121 120 111 bytes
*Huge reduction thanks to Sisyphus, and qwr*
```
from random import*
d=choice
for r in range(35):print(end=f"R{d('-+')*2} D{d('-+')*2} "+r%5//4*f"U{d(' !')}\n")
```
[Try it online](https://tio.run/##K6gsycjPM/7/P60oP1ehKDEvBUhl5hbkF5VocaXYJmfkZyancqXlFykUKWTmgRSkp2oYm2paFRRl5pVopOal2KYpBVWnaKjraqtrahnVKrggc5S0i1RN9fVNtNKUQkHiCorqmrUxeUqa//8DAA)
Each time through the loop prints one pair of entries, one `R` and one `D`. The `r%5//4*f*` control takes care of conditionally printing the `U` entry and the end of line.
[Answer]
# [R](https://www.r-project.org/), 87 bytes
```
s=sample;for(i in 1:7)cat(paste0(c("R","D"),s(c("++","--"),10,T)),s(c("U","U'"),1),"
")
```
[Try it online!](https://tio.run/##K/r/v9i2ODG3ICfVOi2/SCNTITNPwdDKXDM5sUSjILG4JNVAI1lDKUhJR8lFSVOnGMTR1gbydHWBXEMDnRBNqGgoUDBUHSSoqaPEpaT5/z8A "R – Try It Online")
[R](https://www.r-project.org/)'s `paste0` function (to paste text strings together without separator) is conveniently vectorized, so we can exploit [R](https://www.r-project.org/)'s element recycling when the two arguments are different lengths: in this case, the 2-element vector `R,D` is automatically recycled 5 times when `paste0`-ed with the 10-element vector created by `sample`-ing `++,--` ten times. The `T` argument to `sample` indicates that sampling with replacement is `T`rue (needed to take 10 samples from 2-elements).
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 40 bytes
```
7*$(5*$(R-- D-- )U'¶
/--/_?&K`++
%?&`'
```
[Try it online!](https://tio.run/##K0otycxLNPz/n8tcS0XDFIiDdHUVXIBYM1T90DYufV1d/Xh7Ne8EbW0uVXu1BHWu//8B "Retina – Try It Online") Explanation:
```
7*$(5*$(R-- D-- )U'¶
```
Insert 7 lines consisting of `R-- D--`  repeated 5 times followed by `U'`.
```
/--/_?&K`++
```
Match each `--` and then randomly replace each one with `++`.
```
%?&`'
```
On each line, randomly delete `'`.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 56 bytes
```
''' '[?7/2],⍨'U',⍨7 10⍴,/⍉2 70⍴(2/¨'+-')[?70/2],⍨70⍴'RD'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97b@6urqCerS9ub5RrM6j3hXqoeogylzB0OBR7xYd/Ue9nUYK5iC2hpH@oRXq2rrqmkDVBlDlYBn1IBd1kGH/0wA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# JavaScript (ES6), 92 bytes
```
f=k=>k>69?'':'RD'[k&1]+((r=Math.random()*4)&1?'++ ':'-- ')+(k%10>8?r&2?`U'
`:`U
`:'')+f(-~k)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbb1i7bzszSXl3dSj3IRT06W80wVltDo8jWN7EkQ68oMS8lP1dDU8tEU83QXl1bWwGoTFdXQV1TWyNb1dDAzsK@SM3IPiFUnSvBKiEUSKgDpdI0dOuyNf8n5@cV5@ek6uXkp2ukaWhq/gcA "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 93 bytes
A non-recursive approach.
```
_=>`RDRDRDRDRDU
`.repeat(7).replace(/./g,c=>c+[['++ ','-- ',"'"][Math.random()*2|2*(c>'R')]])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1i4hyAUGQ7kS9IpSC1ITSzTMNUGsnMTkVA19Pf10nWRbu2Tt6Gh1bW0FdR11XV0gqaSuFBvtm1iSoVeUmJeSn6uhqWVUY6SlkWynHqSuGRur@T85P684PydVLyc/XSNNQ1PzPwA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 26 bytes
```
Ｅ⁷⪫⮌Ｅ¹¹⎇λ⁺§RDλ×²‽+-…U'⊕‽² 
```
[Try it online!](https://tio.run/##LcvBCoMwEATQX1ly6YbGg1566KnYi0JBpP2AkCwYSDYSrdSvT1PpHGfemEknE7XPeUiOV3zoGS8K@ugYR9ooLXR0da3gSYl12tErGPx7wdvasaUPivEuFHhZhAu0YKNg1GxjQHGuhJRlaHfjqZ3ijOJ1KrhjkygQr2Txbxt5RIGA3@eac642/wU "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 ⁷                          Literal `7`
Ｅ                           Map over implicit range
     ¹¹                     Literal `11`
    Ｅ                       Map over implicit range
           RD               Literal string `RD`
          §  λ              Indexed by inner index
         ⁺                  Concatenated with
                 +-         Literal string `+-`
                ‽           Random character
              ×²            Duplicated
       ⎇λ                   Except for the first entry use
                    U'      Literal string `U'`
                   …        Truncated to length
                       ‽²   Random integer less than 2
                      ⊕     Incremented
   ⮌                        Reversed (so `U` is now last)
  ⪫                         Joined with spaces
                            Implicitly print on separate lines
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~113~~ ~~97~~ 126 bytes
Saved 6 bytes thanks to [qwr](https://codegolf.stackexchange.com/users/17360/qwr)!!!  
Added 29 bytes to fix an error kindly pointed out by [qwr](https://codegolf.stackexchange.com/users/17360/qwr).
```
from random import*
f=lambda n=5,r=choice:n and f"R{r('-+')*2} D{r('-+')*2} "+f(n-1)or'U'+r(" '")
for i in range(7):print(f())
```
[Try it online!](https://tio.run/##TY1BCsIwEADvfcWSS3Ybe1ARoZCbLxB8QGy7NmA2YclFxLfHevM0DAxMedU1y7E11pxAg8wbYipZa9@xf4Z0nwOIP@3UT2uO0zIKbBWwub4V7eAs9YcPXP7FOEYZ9pTV3qxTNGANdZwVIkT5XR4LnmksGqUiI1FrXw "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 34 [bytes](https://github.com/DennisMitchell/jelly/iki/Code-page)
```
7µ5,6ṁ11ż2Xx¤€$+0¦2ị“+-' RDU”KFṖ)Y
```
**[Try it online!](https://tio.run/##ATsAxP9qZWxsef//N8K1NSw24bmBMTHFvDJYeMKk4oKsJCswwqYy4buL4oCcKy0nIFJEVeKAnUtG4bmWKVn//w "Jelly – Try It Online")**
### How?
```
7µ5,6ṁ11ż2Xx¤€$+0¦2ị“+-' RDU”KFṖ)Y - Link: no argments
7                                  - seven
 µ                              )  - for each (v in [1..7]):
  5,6                              -   [5,6]
     ṁ11                           -   mould like 11 -> [5,6,5,6,5,6,5,6,5,6,5]
              $                    -   last two links as a monad:
             €                     -     for each:
            ¤                      -       nilad followed by link(s) as a nilad:
         2                         -         two
          X                        -         random integer (from [1,2])
           x                       -         repeat (two) times -> [1,1] or [2,2]
        ż                          -     zip together -> [[5,[2,2]],[6,[1,1],...]
                0¦                 -   apply to index 0 (rightmost):
               +  2                -     add two (e.g. [5,[1,1]] -> [7,[3,3]])
                    “+-' RDU”      -   "+-' RDU"
                   ị               -   index into (i.e. 1 -> '+' ... 7 -> 'U')
                             K     -   join with space characters
                              F    -   flatten
                               Ṗ   -   pop (remove the repeated space or quote from the right)
                                 Y - join with newline characters
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 28 bytes
```
V7jd+m+@"RD"d*2O"+-"T+\UO" '
```
[Try it online!](https://tio.run/##K6gsyfj/P8w8K0U7V9tBKchFKUXLyF9JW1cpRDsm1F9JQf3/fwA "Pyth – Try It Online")
```
V7jd+m+@"RD"d*2O"+-"T+\UO" '   
V7                             Perform the following 7 times:
     m              T          Map d over 0-9:
               O"+-"             Choose + or - at random
             *2                  Double it
       @"RD"d                    Choose R for even d, D for odd
      +                          Concatenate the previous two results
                        O" '   Choose space or ' at random
                     +\U       Append to "U"
    +                          Append the previous result to the list of moves
  jd                           Join the list on spaces, implicit print with newline
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), ~~24~~ 23 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
7{ûRD5*môû+-w∞ ûU'1w╛╡n
```
[Try it online.](https://tio.run/##AS0A0v9tYXRoZ29sZv//N3vDu1JENSptw7TDuystd@KIniDDu1UnMXfilZvilaFu//8)
Could be 22 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py) if we're allowed to output in lowercase instead of uppercase, by changing the `ûRD` to `╢x` (and `U'` to `u'`): [try it online.](https://tio.run/##AS0A0v9tYXRoZ29sZv//N3vilaJ4NSptw7TDuystd@KIniDDu3UnMXfilZvilaFu//8)
**Explanation:**
```
7{                       # Loop 7 times:
  ûRD                    #  Push string "RD"
     5*                  #  Repeat it 5 times: "RDRDRDRDRD"
       m                 #  Map over each character,
        ô                #  using the following six character as inner code-block:
         û+-             #   Push string "+-"
            w            #   Pop and push a random character from this string
             ∞           #   Double it
                         #   Push a space character " "
               ûU'      '#  Push string "U'"
                  1w     #  Push a random integer in the range [0,1]
                    ╛    #  If this integer is truthy (thus 1):
                     ╡   #   Discard the right character of the string
                      n  #  Push a newline character "\n"
                         # (after the loop, the entire stack joined together is output
                         #  implicitly as result)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 25 bytes
**Credit goes to Kevin Cruijssen for coming up with this way shorter program!**
```
„RDÞε„+-Ωº«}Tôε„U'ηΩª}7£»
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcO8IJfD885tBTK0dc@tPLTr0OrakMNbwAKh6ue2A4VW1ZofWnxo9///AA "05AB1E – Try It Online")
# How this?
```
„RDÞ                                        # Push RDRDRDRDRDRDRDRDRDRD... as a list
    ε      }                                # For every R or D:
     „+-Ω                                   #   Pick random from + and -
         º                                  #   Double the sign
          «                                 #   And join it to the R or D
            Tô                              # Split the list into pieces of 10 elements
              ε      }                      # For each item in the list:
               „U'ηΩ                        #   Choose a random choice between U' & U
                    ª                       #   Append it to the list
                      7£»                   # Join the first 7 lists with linefeeds
                                            # Print the result at the end (implicitly)!
```
---
My old program:
# [05AB1E](https://github.com/Adriandmen/05AB1E), 36 bytes
```
8G„RD5×S"++ -- "3ôTи2ô€ΩøJ…U'U2ôΩªJ,
```
[Try it online!](https://tio.run/##AT0Awv9vc2FiaWX//zhH4oCeUkQ1w5dTIisrIC0tICIzw7RU0Lgyw7TigqzOqcO4SuKAplUnVTLDtM6pwqpKLP// "05AB1E – Try It Online")
# How that?
```
8G                                          # Repeat 7 times the full code
  „RD5×                                     # Push "RDRDRDRDRD"
        "++ -- "3ô                          # Push the list/array ["++ ", "-- "]
                  Tи2ô                      # Repeat the list 10 times
                      €Ω                    # Pick a random item from each list
       S                øJ        J         # Zip the random items with "RDRDRDRDRD"
                                            # e.g => "R++ D-- R++ D-- R++ D-- R++ D-- R++ D-- "
                          …U'U2ôΩ           # Pick random between "U'" and "U"
                                 ª          # Append the result to the last result
                                  ,         # Print it with a linefeed
```
[Answer]
# [Actually](https://github.com/Mego/Seriously), 40 bytes
```
7"RD""35"≈*⌠"+-"Jτ+R⌡M╡⌠2"UU'"╡J@+' j⌡Mi
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/99cKchFScnYVOlRZ4fWo54FStq6Sl7nW7SDHvUs9H00dSFQyEgpNFRdCcj2ctBWV8gCSWT@/w8A "Actually – Try It Online")
```
 "RD"                                    # Push RD,
     "35"≈*                              # and repeat it 35 times.
           ⌠        ⌡M                   # For each turn,
           ⌠"+-"J   ⌡M                   # pick either + or -,
           ⌠     τ  ⌡M                   # double it,
           ⌠      +R⌡M                   # and add it to the end of each turn.
7                     ╡                  # Split the list into 7 sublists (of length 10).
                       ⌠             ⌡M  # For each sublist,
                       ⌠2"UU'"╡J     ⌡M  # pick either U or U',
                       ⌠        @+   ⌡M  # add it to the end of each turn,
                       ⌠          ' j⌡M  # and join with spaces.
                                       i # Push each sublist to the stack.
                                         # Implicitly output the stack joined with newlines.
```
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 86 bytes
A golfed version of [xnor's answer](https://codegolf.stackexchange.com/a/216302/83605), which he didn't approved. Perhaps, because his answer is in Python 2.
```
from random import*
for C in[choice]*7:print(*(c+C('+-')*2for c in'RD'*5),'U'+C("' "))
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P60oP1ehKDEvBUhl5hbkF5VocaXlFyk4K2TmRSdn5Gcmp8ZqmVsVFGXmlWhoaSRrO2uoa@uqa2oZgVQlA1WpB7moa5lq6qiHqgMlldQVlDQ1//8HAA "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~78~~, 75 bytes
Saved **3 bytes** by modifying the jump in the third line and changing how the register was checked and decremented.
```
7_a*&"DR"d1.  >x"-"v
>x"'"oao&:&?!;^\"+">$:o$:oo$" "od1&1-:&a%?.~~"U"o
.>51
```
New link:
[Try it online!](https://tio.run/##S8sszvj/3zw@UUtNySVIKcVQT0HBrkJJV6mMC0ipK@Un5qtZqdkrWsfFKGkr2alY5QNRvoqSglJ@iqGaoa6VWqKqvV5dnVKoUj6Xnp2p4f//AA "><> – Try It Online")
Old link: [Try it online!](https://tio.run/##S8sszvj/3zw@UUtNySVIKcVQT0HBrkJJV6mMC0ipK@Un5qtZqdkrWsfFKGkr2akZ6qqpWOUDUb6KkoJSfoohUDZR1V6vrk4pVCmfS8HO1FDv/38A "><> – Try It Online")
This code also runs in [\*><>](https://github.com/redstarcoder/go-starfish) (Starfish) because [\*><>](https://github.com/redstarcoder/go-starfish) is a super set of [><>](https://esolangs.org/wiki/Fish).
\*><>: [Try it online!](https://tio.run/##Ky5JLErLLM74/988PlFLTcklSCnFUE9Bwa5CSVepjAtIqSvlJ@arWanZK1rHxShpK9mpWOUDUb6KkoJSfoqhmqGulVqiqr1eXZ1SqFI@l56dqeH//wA "*><> – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 25 bytes
```
₀(‛RD5*ƛ‛+-℅d+;\U‛U'"℅JṄ,
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%82%80%28%E2%80%9BRD5*%C6%9B%E2%80%9B%2B-%E2%84%85d%2B%3B%5CU%E2%80%9BU%27%22%E2%84%85J%E1%B9%84%2C&inputs=&header=&footer=)
## Explanation
```
₀(‛RD5*ƛ‛+-℅d+;\U‛U'"℅JṄ,
 (                         For n
₀                          in range(10):
  ‛RD                        Push "RD"
     5*                      Repeat 5 times
       ƛ      ;              Map:
        ‛+-                    Push "+-"
           ℅                   Choose random
            d                  Double
             +                 Concatenate top two
               \U            Push "U"
                 ‛U'         Push "U'"
                    "        Join top two into a pair
                     ℅       Choose random
                      J      Join top two
                       Ṅ     Join with spaces
                        ,    Print
```
[Answer]
# [Nim](http://nim-lang.org/), 129 bytes
```
import random
randomize()
for _ in 0..6:
 var l=["U","U'"].sample
 for i in 0..9:l="RD"[i mod 2]&["++","--"].sample&" "&l
 echo l
```
[Try it online!](https://tio.run/##y8vM/f8/M7cgv6hEoSgxLyU/lwtCZValamhypeUXKcQrZOYpGOjpmVlxKZQlFink2EYrhSrpKIWqK8XqFSfmFuSkcimAFGZCFVpa5dgqBbkoRWcq5OanKBjFqkUraWsDdejqwnWoKSkoqeVwKaQmZ@Qr5Pz/DwA "Nim – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~28~~ 27 bytes
```
⁵µ⁾RDẋ5;⁾+-XḤ¤$€“U“U'”X¤ṭ)G
```
[Try it online!](https://tio.run/##y0rNyan8//9R49ZDWx817gtyebir29QayNLWjXi4Y8mhJSqPmtY8apgTCsLqjxrmRhxa8nDnWk33//8B "Jelly – Try It Online")
## Explanation
```
⁵µ⁾RDẋ5;⁾+-XḤ¤$€“U“U'”X¤ṭ)G  Main niladic link
⁵                            10 [implicitly casted to [1..10]]
 µ                       )   Map:
  ⁾RD                          "RD"
     ẋ5                        Repeat 5 times
               €               Map
              $                (
       ;                         Join with
             ¤                   (
        ⁾+-                        "+-"
           X                       Choose random
            Ḥ                      Unhalve (double)
             ¤                   )
              $                )
                        ṭ      Append
                       ¤       (
                “U“U'”           ["U", "U'"]
                      X          Choose random
                       ¤       )
                          G  Format as a grid
```
]