Suppose we have the following list (very small, can be copied directly into a notebook)

```
{
{1.25, 0},
{1.3, 0.125},
{1.4, 0.175},
{1.5, 0.225},
{1.6, 0.275}, {1.7, 0.275},
{1.8, 0.325},
{1.9, 0.375}, {2., 0.375}, {2.1, 0.375},
{2.2, 0.425}, {2.3, 0.425},
{2.4, 0.475}, {2.5, 0.475}, {2.6, 0.475}, {2.7, 0.475},
{2.8, 0.525}, {2.9, 0.525}, {3., 0.525},
{3.1, 0.575}, {3.2, 0.575}, {3.3, 0.575}, {3.4, 0.575}, {3.5, 0.575},
{3.6, 0.625}, {3.7, 0.625}, {3.8, 0.625}, {3.9, 0.625}, {4., 0.625},
{4.1, 0.675}, {4.2, 0.675}, {4.3, 0.675}, {4.4, 0.675}, {4.5, 0.675}, {4.6, 0.675}, {4.7, 0.675},
...}
```

The special feature of the list is **some adjacent sublists with the same 2nd elements and 1st continuous element**, as the line breaks emphasize. By plotting it, we can see that the aforementioned feature causes the dots to be aligned horizontally in a step-by-step manner.

```
ListPlot(data, Frame -> True, PlotRange -> {{0, 10}, {0, 1}}, ImageSize -> 400, PlotStyle -> {Red, Thick})
```

What I want is a smooth "fit" curve instead of a discrete point plot. To this end, I have tried `Interpolation`

, but it turns out that the increase `InterpolationOrder`

is of no help. Btw, adding an option to `Method -> "Hermite"`

or `Method -> "Spline"`

is useless either. I also tried `Fit(data, {1, x, x^2, x^3}, x)`

, which turns out to be even worse.

```
interpdata = Interpolation(data, InterpolationOrder -> 10);
Plot(interpdata(x), {x, data((1, 1)), data((-1, 1))}, Frame -> True, PlotRange -> All, ImageSize -> 400, PlotStyle -> {Red, Thick})
```

So i want to manipulate the original data by replacing the **adjacent sublists with the same 2nd element** using a procedure like this:

Check the length of the adjacent sublists with the same 2nd element and use the average value of their 1st elements as the 1st element of the new sublist, then replace these sublists with the resulting sublist, that’s -to say, `{mean of 1st elem, the same 2nd elem}`

. For example,

`{1.6, 0.275}, {1.7, 0.275}`

=> `{1.65, 0.275}`

,

`{1.9, 0.375}, {2., 0.375}, {2.1, 0.375}`

=> `{2, 0.375}`

`{2.4, 0.475}, {2.5, 0.475}, {2.6, 0.475}, {2.7, 0.475}`

=> `{2.55,0.475}`

**I guess it can be done with SequenceSplit and the new list should give me a reasonable curve. But i'm having trouble using SequenceSplit in that case.** Could someone help me? It will be great if some

*interpolation method*can be compared to the plot of the new list. Thank you!