R, 74 bytes (partial, probabilistic solution)

A bit of a silly Monte Carlo solution based on the fact that the histogram of eigenvalues of an \$N \times N\$ symmetric matrix with Gaussian entries converges to a semicircle with base \$[-2\sqrt{N}, 2\sqrt{N}]\$ as \$N \rightarrow \infty\$.

Taking \$N = 50^2\$, this is the semicircle with base \$[-100, 100]\$. By a result known as eigenvalue rigidity, the eigenvalue quantiles are all within \$\sim 50/N\$ of the corresponding quantiles of the semicircle.

Hence, we solve this problem by computing the eigenvalues of a \$50^2 \times 50^2\$ matrix with Gaussian entries and finding the quantiles from \$1/n\$ to \$(n-1)/n\$ of the sample:

\(n)round(abs(quantile(eigen(matrix(rnorm(50^4),50^2),T)[[1]],1:(n-1)/n)))

This is obviously not an exact solution, and when a true value is close to the form \$k + 0.5\$ for integer \$k\$, the estimate can be off the true rounded value by \$\pm 1\$.

It also takes a long time to find the eigenvalues of a \$ 50^2 \times 50^2\$ matrix, so in the demonstration I can only run two test cases before timing out.

Attempt This Online!

JavaScript (V8), 87 bytes

Prints the results.

n=>{for(t=0,x=w=1e6;x--+w;t*n>15708e8&&print((x*x)**.5/1e4+.49|(t=0)))t+=(w*w-x*x)**.5}

Try it online!

NB: This gives the same results as the OP for all test cases. We may disagree for some other inputs, but I've no way of knowing.

Commented

n => {                // n = input
  for(                // loop:
    t = 0,            //   start with t = 0
    x = w = 1e6;      //   and x = w = 1000000
    x-- + w;          //   stop when x = -w (decrement x afterwards)
    t * n > 15708e8   //   if t * n > round(pi / 2 * w² / 10^8) * 10^8 ...
    &&                //
    print(            //   ... print floor(abs(x) * 100 / w + 0.49)
      (x * x) ** .5   //
      / 1e4 + .49     //
      | (t = 0)       //   and reset t to 0
    )                 //
  )                   //
    t +=              //   at each iteration, add to t:
      (w * w - x * x) //     sqrt(w² - x²)
      ** .5           //
}                     //

Python, 225 202 152 bytes

-23 bytes thanks to @solid.py

lambda n:[h(pi*abs(a/n-.5))//2for a in range(1,n)]
def h(a,p=0):
 while(d:=a-p*(r:=sqrt(1-p*p))-asin(p))>1E-9:p+=d/r/2
 return 200*p+1
from math import*

Attempt This Online!

Uses Newton's method to find the inverse of the formula \$ \int_0^h 2 \sqrt{1-h²} dh = h \sqrt{1-h²} + \sin^{-1}(h)\$ for the area of a slice of height h from the center in a circle of radius 1.

R, 84 83 bytes

\(n,r=2e8)for(x in -r:r)if((F=F+(r^2-x^2)^.5)>pi*2e16/n)F=!print(abs(round(x/2e6)))

Attempt This Online! (but it will time-out before completing), or Attempt a less-accurate version with only 4 million x-axis steps.

Straightforward loop-over-x-values approach, not as elegant as Damian Pavlyshyn's probabilistic approach in R, but produces a single defined output for any input n.

Calculates the area-so-far in 400 million x-axis steps across the pizza, outputting the rounded x-axis value each time it hits the intended slice-area, and resetting the area-so-far back to zero.
Setting the area-so-far back to zero, instead of subtracting the slice-area and keeping the remainder for the next slice, is rather inaccurate, and so necessitates the huge number of x-axis steps to match all the test-cases.
Subtracting the slice-area at each step would require ≈10,000x less steps to achieve the required accuracy, but costs 5 bytes more.

JavaScript (V8), 93 bytes

n=>{q=2;for(S=x=1;S;x-=1e-6)q<(S+=(1-x*x)**.5/Math.PI*2e-6*n)&&q++*print((x*x)**.5*100+.5|0)}

Try it online!

Charcoal, 69 bytes

Ｎθ≔ＸＥ⊗φ⁻⊕⊗ι⊗φ²ηＵＭηΣ⁻¹÷⁺ιηＸ⊗φ²≔ΣηζＵＭη↨…ηκ¹Ｉ↔÷⁻⁺⁴φ⌕ＡＥΦηκ⁻÷×θιζ÷×θ§ηκζ¹χ

Try it online! Link is to verbose version of code. Explanation:

Ｎθ

Input the desired number of slices.

ＸＥ⊗φ⁻⊕⊗ι⊗φ²η

Generate a list of odd numbers from -1999 to 1999 and square them.

ＵＭηΣ⁻¹÷⁺ιηＸ⊗φ²

For each square odd number, add all of the square odd numbers to it, and count how many are less than 4 million.

≔Σηζ

Get the total "area".

ＵＭη↨…ηκ¹

Get the cumulative area at each potential slice point. Note that there are still 2000 points at this stage, with coordinates from -99.95 to 99.95 in steps of 0.1.

Ｉ↔÷⁻⁺⁴φ⌕ＡＥΦηκ⁻÷×θιζ÷×θ§ηκζ¹χ

Find the slice points where the area increases to the next fraction of the total area and calculate the nearest integer slice points.

Perl 5, 95 bytes

sub{($n,$c,$s)=@_;map$-=.49+abs$_/100,grep$c<($s+=$n/15708*sqrt 1-$_**2/1e8)-1&&++$c,-1e4..1e4}

Try it online!

Python, 146 bytes

lambda n:[round(min(range(900),key=lambda d:abs(tau/n*k+sin(a:=2*acos(d/900))-a))/9)for k in[[i,n-i][i>n/2]for i in range(1,n)]]
from math import*

Attempt This Online!

Python, 126 125 bytes

from math import*
def f(q,m=0):
 for i in range(1,q):exec('m=sin(pi/q*i-pi/2-m*sqrt(1-m*m));'*99999);print(abs(round(m*100)))

Attempt This Online!

Uses an iterative approach to converge to the true answer. This version is extremely slow and will time out.

Python, 134 133 bytes

from math import*
def f(q,m=0):
 for i in range(1,q):
  for j in[0]*99999:m=sin(pi/q*i-pi/2-m*sqrt(1-m*m))
  print(abs(round(m*100)))

Attempt This Online!

This version will not time out.