[Question]
  [
Given a sorted list of unique positive floats (none of which are integers) such as:
```
[0.1, 0.2, 1.4, 2.3, 2.4, 2.5, 3.2]
```
Evenly spread out the values that fall between two consecutive integers. So in this case you would get:
```
[0.333, 0.666, 1.5, 2.25, 2.5, 2.75, 3.5]
```
(I have truncated the values 1/3 and 2/3 for ease of presentation.)
  
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata), 8 bytes
```
k≈¢·µâR‚Üí/+j
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6Fmuzjy56uLUz6FHbJH3trCXFScnFUJkFNzWjDfUNDXSMQIShCZhpDCYhbFMQaQySjYXoAAA)
Input and output are both in fractions, because Nekomata doesn't have floating point numbers.
```
k≈¢·µâR‚Üí/+j
k           Floor
                e.g. [1/10,2/10,14/10,23/10,24/10,25/10,32/10] -> [0,0,1,2,2,2,3]
 ≈¢          Tally; returns a list of unique elements and a list of their counts
                e.g. [0,0,1,2,2,2,3] -> [0,1,2,3], [2,1,3,1]
  ·µâR        Range each count, and push the original list
                e.g. [2,1,3,1] -> [[1,2],[1],[1,2,3],[1]], [2,1,3,1]
    ‚Üí       Increment
                e.g. [2,1,3,1] -> [3,2,4,2]
     /      Divide
                e.g. [[1,2],[1],[1,2,3],[1]], [3,2,4,2] -> [[1/3,2/3],[1/2],[1/4,1/2,3/4],[1/2]]
      +     Add
                e.g. [0,1,2,3], [[1/3,2/3],[1/2],[1/4,1/2,3/4],[1/2]] -> [[1/3,2/3],[3/2],[9/4,5/2,11/4],[7/2]]
       j    Join
                e.g. [[1/3,2/3],[3/2],[9/4,5/2,11/4],[7/2]] -> [1/3,2/3,3/2,9/4,5/2,11/4,7/2]
```
[Answer]
# [R](https://www.r-project.org), ~~46~~ 45 bytes
*Edit: -1 byte thanks to pajonk*
```
\(x)sequence(y<-rle(t<-x%/%1)$l)/rep(y+1,y)+t
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMHq1LLUvOKCotTEFNulpSVpuhY3dWM0KjSLUwtLU_OSUzUqbXSLclI1Smx0K1T1VQ01VXI09YtSCzQqtQ11KjW1S6CaDBDmaCRrGOgZ6igY6BnpKBjqmegoGOkZgwgwy1RHwVjPSFMTom_BAggNAA)
A rare use for R's obscure `sequence` function: "For each element of `x` the sequence `1...x` is created. These are concatenated and the result returned."
The documentation also notes: "`sequence` mainly exists in reverence to the very early history of R."
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~18~~ 16 bytes
```
‚àä‚åä(‚äÇ‚ä£+‚çã‚ç§‚ä¢√∑‚â¢‚ç§,)‚å∏‚ä¢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1FH16OeLo1HXU2PuhZrP@rtftS75FHXosPbH3UuAjJ1NB/17ADy/6c9apvwqLfvUVfzo941j3q3HFpv/Kht4qO@qcFBzkAyxMMz@H@agoGeIRAbKRjqmSgY6RkDMYg2VTDWMwIA "APL (Dyalog Unicode) ‚Äì Try It Online") (Using Extended because TIO is out of date)
`‚åä(`‚Ä¶`)‚å∏‚ä¢`‚ÄÉon each unique floor (`‚åä`) and its corresponding argument elements (`‚ä¢`):
‚ÄÉ`‚äÇ`‚ÄÉenclose the
‚ÄÉ`‚ä£`‚ÄÉleft argument, i.e. the floor in question
‚ÄÉ`+`‚ÄÉadded to
‚ÄÉ`‚çã‚ç§‚ä¢`‚ÄÉthe grade (`‚çã` sorting permutation: 1‚Ä¶length) of (`‚ç§`) the right argument (`‚ä¢` the elements)
‚ÄÉ`√∑`‚ÄÉdivided by
‚ÄÉ`‚â¢‚ç§,`‚ÄÉthe count (`‚â¢`) of (`‚ç§`) the concatenation (`,`) of the floor and the elements
`‚àä`‚ÄÉ**e**nlist (flatten)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
√ØŒ≥ŒµƒÅ¬§>/+}Àú
```
[Try it online](https://tio.run/##yy9OTMpM/f//8Ppzm89tPdJ4aImdvnbt6Tn//0cb6BnqKBjoGekoGOqZ6CgY6RmDCDDLVEfBWM8oFgA) or [try it online with step-by-step debug-lines](https://tio.run/##bZC9TsMwEMd3nuKUqVVNaFJYkKBCqkAMPEHV4RofiZFrB38UMXTgPRjZGRA8QGFD6iulsRMQA4vl@/rd/f/a4lJQ0yTXqvbuFBJ2tv2YHiSXUmsTws/XLnFltK8B@R0WpBzQvUcJa5SebGjbvXVtN1gDYVGB04Awz5gkVbpqcWhQlcRBChu3zHbvX08b1qHJgasIJFoHwtEKBjGMk0PQt5HIABUHoQpDq/aCX8j25bznzMRacIqo/xfD8rGtCguDrjjKhn8xRz3ngvMI6dQFJSEqvDFBeRmMiJL7qdHmxzJ0jhSDh0q0BrRrtDdgyHoZr/1@njbNfJxmDMZpziBLjxnk6SQ88XfCYJLmiz0).
**Explanation:**
```
√Ø         # Floor all values in the (implicit) input-list
 Œ≥        # Group it into adjacent equal values
  Œµ       # Map over each group:
   ƒÅ      #  Push a list in the range [1,length] (without popping the list)
    ¬§     #  Push its last item - the length (without popping the list)
     >    #  Increase this length by 1
      /   #  Divide all values in the [1,length]-ranged list by this (length+1)
       +  #  Add it to each floored value of the current group
  }Àú      # After the map: flatten the list of lists
          # (after which the result is output implicitly)
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 45 bytes
```
@(x)(t=fix(x))+sum(triu(u=t==t'))./(sum(u)+1)
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999Bo0JTo8Q2LbMCyNDULi7N1SgpyizVKLUtsbUtUdfU1NPXAAmWamobav6vULBViDbQM9RRMNAz0lEw1DPRUTDSMwYRYJapjoKxnlGsNVca0LT/AA "Octave ‚Äì Try It Online")
### Explanation
```
@(x)(t=fix(x))+sum(triu(u=t==t'))./(sum(u)+1)
@(x)                                           % Anonymuous function
    (t=fix(x))                                 % t: round down x, element-wise
                        u=t==t'                % u: matrix of pairwise comparisons of t
                   triu(       )               % Upper triangular part of u
               sum(            )               % Sum of each column of that
                                    sum(u)+1   % Sum of each column of u, plus 1
                                 ./(        )  % Divide, elemment-wise
              +                                % Add, element-wise
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
·∏ûJ√∑L‚Äò$+∆≤∆ô`F
```
[Try it online!](https://tio.run/##y0rNyan8///hjnleh7f7PGqYoaJ9bNOxmQlu////jzbQM9RRMNAz0lEw1DPRUTDSMwYRYJapjoKxnlEsAA "Jelly ‚Äì Try It Online")
[Answer]
# [Python](https://www.python.org), 95 bytes
```
lambda x:[k+~j/~len(i)for k,[*i]in groupby(x,int)for j in range(len(i))]
from itertools import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=Lc1BDoIwEAXQvaeYZau1QmvRmHgSrAYixSq0pNZENl7EDYnRO3kbKbiZmcy8n3l-mtafrOleart737yar7-HKqvzYwb3TXqZPc6LR1UYpLGyDi4knWqpDZTO3pq8RXeijR9OZ-jXLjNlgUaP5UQ5W4P2hfPWVlfQdWOdn_7f7BvXZ5FCaURjAhFlBGK6JMAoD2WYBAFOmcR4Murecs6DTpIkeBEUE3_L6GpICInHL1039h8)
* -4 bytes thanks to [Unrelated String](https://codegolf.stackexchange.com/questions/263910/evenly-spread-values/263913?noredirect=1#comment577315_263913) for the famous `~-` trick
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 61 bytes
```
x=>x.map(k=v=>(k[v|=0]=~-k[v])/~x.filter(t=>~~t==v).length+v)
```
[Try it online!](https://tio.run/##Hca7DoMgFADQvV/BCCneIraTufyIYSAWrJWCUUIcGn6dPpaT8zTZ7OM2r6kJ8W6rw3qgOuBlVrpgRkWXIb9RaCzNd5pdygFu9sluNKEqJSFmBt6GKT3OmdX@NMawR2/Bx4k6OghoOREgOWnhyomE7sd/N046kJqxvn4A "JavaScript (Node.js) ‚Äì Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 65 bytes
```
x=>x.map(k=v=>(k[v|=0]=-~k[v],v)).map(m=v=>v+(m[v]=~-m[v])/~k[v])
```
[Try it online!](https://tio.run/##HYpBDoMgFET3PQVLfgq/iO3KfC9iWBCrTauI0Ya4MF4dhc3My7z52WDXdvnOfzn5dxd7ihvVGzo784EC1Xxowk7KkDwuMiIAZOmSDHfurpEOmQoe@QKxurV@Wv3Y4eg/vOeNwkIwhVqwAp@CaSxTZHoJVqI2AFU8AQ "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2) `S`, 9 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
Nƒ°ƒ±≈ºnl‚Å∫/+
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPU4lQzQlQTElQzQlQjElQzUlQkNubCVFMiU4MSVCQSUyRiUyQiZmb290ZXI9JmlucHV0PSU1QjAuMSUyQyUyMDAuMiUyQyUyMDEuNCUyQyUyMDIuMyUyQyUyMDIuNCUyQyUyMDIuNSUyQyUyMDMuMiU1RCZmbGFncz1T)
Port of Kevin Cruijssen's 05AB1E answer.
#### Explanation
```
Nƒ°ƒ±≈ºnl‚Å∫/+  # Implicit input
N          # Floor each value
 ƒ°         # Group consecutive
  ƒ±        # Map over this list:
   ≈º       #  Without popping, push [1..length]
    nl     #  Length of the current group
      ‚Å∫    #  Incremented
       /   #  Divide the range by this
        +  #  Add to the group
           # Implicit output, flattened
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 64 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 8 bytes
```
‚åä√∏ƒñ‚Çå…æ‚Ä∫/+f
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyI9IiwiIiwi4oyKw7jEluKCjMm+4oC6LytmIiwiIiwiWzAuMSwgMC4yLCAxLjQsIDIuMywgMi40LCAyLjUsIDMuMl0iXQ==)
*-2 thanks to emanresu*
## Explained
```
‚åäƒ†:@‚Çå…æ‚Ä∫/+f¬≠‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå¬≠
‚åäƒ†          # ‚Äé‚Å°Group the floored values by consecutive items. 
  :@        # ‚Äé‚Å¢Push a copy of that where each item is the corresponding length. 
    ‚Çå…æ‚Ä∫     # ‚Äé‚Å£Push a list [range 1..n for n in top], [n+1 for n in top]
       /    # ‚Äé‚Å§And divide those lists.
        +   # ‚Äé‚Å¢‚Å°Add that to the original grouped values
         f  # ‚Äé‚Å¢‚Å¢Then flatten
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
[Answer]
# JavaScript (ES6), 63 bytes
```
a=>a.map(p=v=>a.map(V=>v^V||n++,n=1,p!=(p=~~v)?q=1:q++)&&p+q/n)
```
[Try it online!](https://tio.run/##NcnLCsIwEEDRX4mbkpDp2KS6Eab@RTeiMNRWlJpHK1mV/np8gJvLgfvgxHM33cOrdP7a54EyU8P45CADpT9batKlXRanNTgyEDb02eua1DGSOUStVVEEHbdO5c672Y89jv4mB3mq0ICo0IIwuANhsf7mpz2IGu1ZqfwG "JavaScript (Node.js) ‚Äì Try It Online")
### Commented
```
a =>                 // a[] = input array
a.map(p =            // initialize p to a NaN'ish value
  v =>               // for each value v in a[]:
  a.map(V =>         //   for each value V in a[]:
    v ^ V || n++,    //     increment n if floor(v) = floor(V)
    n = 1,           //     starting with n = 1
    p != (p = ~~v) ? //     if p is not equal to floor(v)
                     //     (update p to floor(v) afterwards):
      q = 1          //       start a new group with q = 1
    :                //     else:
      q++            //       increment q
  ) &&               //   end of inner map()
  p + q / n          //   the final value is p + q / n
)                    // end of outer map()
```
[Answer]
# [R](https://www.r-project.org), 47 bytes
```
\(x)ave(x,y<-x%/%1,FUN=\(z)seq(z)/sum(1,z^0))+y
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMHSNAUbXYWlpSVpuhY39WM0KjQTy1I1KnQqbXQrVPVVDXXcQv1sYzSqNItTC4GkfnFproahTlWcgaamdiVUm3qaRrKGgZ6hjoKBnpGOgqGeiY6CkZ4xiACzTHUUjPWMNDUhyhcsgNAA)
Not as short as the [answer using `sequence`](https://codegolf.stackexchange.com/a/263925/67312), but `ave` is pretty neat, too.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 19 bytes
```
‚â¶‚åäŒ∏Ôº©Ôº•Œ∏‚Å∫Œπ‚àï‚äï‚Ññ‚Ä¶Œ∏Œ∫Œπ‚äï‚ÑñŒ∏Œπ
```
[Try it online!](https://tio.run/##ZYq9CsIwFEZ3n@KON3AN/dGpk1QEB6F76RDSYIMxMUlb8Oljm9VvOHxwjpxEkE6YlB7ic4lRPy3ejHOBwLPm0AVtZ2xFnHHz6Ak6s0TUBFe96lHh3cqg3srOasTWLXv8lUa1k8v1ixFotuG/89nkNSn1fcFLgoJXBCU/EVS83pHfmaDm1TCk42p@ "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Explanation:
```
  Œ∏                 Input array
‚â¶                   Apply to all elements
 ‚åä                  Floor
     Œ∏              Floored array
    Ôº•               Map over floored elements
       Œπ            Current floored element
      ‚Å∫             Plus
            Œ∏       Floored array
           ‚Ä¶        Truncated to length
             Œ∫      Current index
          ‚Ññ         Count of
              Œπ     Current floored element
         ‚äï          Incremented
        ‚àï           Divided by
                 Œ∏  Floored array
                ‚Ññ   Count of
                  Œπ Current floored element
               ‚äï    Incremented
   Ôº©                Cast to string
                    Implicitly print
```
[Answer]
# [Perl 5](https://www.perl.org/), 61 bytes
```
sub{map{//;map{$'+$_/($c+1)}1..($c=grep$'==int,@_)}0..$_[-1]}
```
[Try it online!](https://tio.run/##lVFNb4JAEL3zKybbTQXcLl9Cq4SUexO99CaGWF2NieAWIdEQfjvdHYlpPLUc3ryd997sZJGiOoZ9cQW6S/pz89UWa9k6TqwLHY1p7ph0M/aszuNcsWRfCUlHSXIoa5bmVudyTvPli7fq@tjYnSrTAPUtEWHpco@By30GHp8w8HmgAVnIIOD@it2dQRBobxRF2h1qjx8OTp@/oj9coX1I/e2WEAWXu4jT6VDudfqvHUJNPXeYOUGMEN@G3QyrRVJcTXooJaPiIq0kpXk8tNP9qU6e6c5MtW7d2thUjw5nx8x4tm2DzuK2Qz2nYijGAE@nppZNDcX6AgFsxeZQrI9njMtK/RAgal5Tz3Cenp2VJP4tq03EphbbmZIVf5TVLZi9bfOoYoSA@FZUyQTegSw@CMyA2LY9X3yCOjEgWYnJzuh/AA "Perl 5 ‚Äì Try It Online")
```
sub {
  map {                #loop ints in $_ from 0 to highest input number as int
    //;                #copies current $_ to $'
    $c=grep$'==int,@_; #$c = count of current int in $_ in input array @_
    map {              #loop 1 to current count in $c
      $' + $_ / ($c+1) #return current outer int + inner int / count+1
    }
    1..$c              #inner loop, no loop and no return if count is 0
  }
  0..$_[-1]            #outer loop
}
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 16 bytes
```
=sMQm+c@XdH1d/+Q
```
[Try it online!](https://tio.run/##K6gsyfj/37bYNzBXO9khIsXDMEVfO/D//2gDPUMdBQM9Ix0FQz0THQUjPWMQAWaZ6igY6xnFAgA "Pyth ‚Äì Try It Online")
### Explanation
```
=sMQm+c@XdH1d/+QdddQ    # implicitly add Q
                        # implicitly assign Q=eval(input()), H=dict()
=  Q                    # assign Q to
 sMQ                    # floor() mapped over Q
    m              Q    # map lambda d over Q
        XdH1            #   H[d]+=1 (or H[d]=1 if d not in H)
       @    d           #   H[d]
      c                 #   divided by
             /   d      #   the count of how many times d appears in
              +Qd       #   Q with d appended
     +            d     #   plus d
```
[Answer]
# [J](http://jsoftware.com/), 21 bytes
```
<.+&;<.<@(#\%1+#)/.<.
```
[Try it online!](https://tio.run/##bY09CwIxEER7f8Vg0PNMHPNhIsQIomAlFrZeJx5i4/@v4iUKNha7DPses888ZtNjG9FAQSMOsyAOl9MxJ8rpJjHtZqKbGCnaJRNzOzrvib@skmv83KXo5uaH7rfHCz00zfCGVsFwpWDpyqrJKzja2qHpnCteCKGYvnDrv5bluro@vwE "J ‚Äì Try It Online")
Repetition of floor `<.` 3 times was surprisingly shorter than alternatives that DRY it out.
* `<..../.<.` For each group of the floor...
* `<@(#\%1+#)` Divide 1...g by (1 + g), where g is the group size. Box it `<@` because we have to box heterogeneous lists.
* `<.+&;` Add the floor elementwise to that unboxed result.
]