I'm not good with experiments, so I decided to simulate it.
tl;dr: probably Answer 3. The result depends on the details of the sound wave propagation in the cradle.
I modeled each sphere as an array of identical springs with very high elastic constant to emulate the elasticity of the metal. Each spring is attached to the ones adjacent to it, unless they belong to a different sphere, as shown in the first figure.
$N_b$ is the number of metal spheres and $N_s$ is the number of springs contained in a sphere. The equation of motion for the position of the center of mass of the spring $i$ is
$\frac{d^2 x_i}{dt^2} = F_i^+ - F_i^- - K_p(x_i-x_i^{\rm rest})$
For $i$ that goes from 1 to $N_b \times N_s$. Here $F_i^+$ and $F_i^-$ are the forces that act on either side of the spring.
The term $K_p(x_i-x_i^{\rm rest})$ is instead emulating the fact that the spheres are suspended in a pendulum. Each spring will have a rest position $x_i^{\rm rest}$, determined by where it is hanged, and will try to swing back there if moved away from it. Here I am exploiting the fact that for small oscillations a pendulum is close to an harmonic oscillator. For the sake of simplicity in this way I am assuming all the springs are individually attached to a pendulum, while in reality it is only maybe the central one, but this doesn't really make any difference for what we are concerned.
Now, if the rest length of the springs is $l_{\rm rest}$, the forces acting on the springs will be
$F_i^+ = F_{i+1}^- = K_s(x_{i+1}-x_i-l_{\rm rest})$
Unless, if the two strings are not attached (e.g. because they belong to different spheres) and $x_{i+1}-x_i-l_{\rm rest} \ge 0$, then
$F_i^+ = F_{i+1}^- = 0$, meaning that the two spheres are not touching at the moment.
$K_s$ is the elastic constant (divided by the mass) of the springs that constitute the metal spheres. Since the metal is very rigid, it is important that $K_s \gg K_p$.
Let's look at what happens with this setup, with $N_b=5$ and $N_s=4$.
In this plot I am showing the position of center of mass of each spring $x_i$ as a function of time. Each line corresponds to one spring and they are colored base on which sphere they belong to. Initially, all the spheres are at rest except the blue one, which as been moved a bit. Once released, it swings back to its rest position and hits the others at $t \approx 1$. Then the blue one stops and most of the motion is transferred to the purple one, as expected for a Newton's cradle. Notice however that also the red one is moving a bit, and the blue one has an almost imperceptible recoil. This is not a problem with the simulation; all these effects are really present in real Newton's cradles, for instance here. I was quite satisfied when I saw this :)
If I increase the number of springs things get even more interesting, here is what happens with 20 springs per sphere. Since each spring is now representing a smaller amount of mass, I increase $K_s$ proportionally to the number of springs, so that the overall elasticity of the spheres is kept constant.
small digression
If you'll allow me a small digression, we can zoom in the region of the first collision to see what is happening there.
After the spheres touch, there is a brief time in which all the five spheres are in contact, and then the purple one detaches.
Disclaimer: while most things in this simulation don't change much if I change the number of springs, the duration of the contact phase is not one of those. I experimented with different numbers of springs and observed that the more springs I put, the longer is the contact phase.
It's even cooler if I color-code this plot according to the spring deformation $(x_{i+1}-x_i-l_{\rm rest})/l_{\rm rest}$
Here you can see how much each spring is deformed. Blue means it's compressed, while red means it's extended. I think it's quite cool to see all the sound waves propagating in the metal.
end of small digression
Consistency check: what happens when we throw two spheres at the same time?
Two spheres come in, two spheres get out, as expected. Now, back to the question.
What happens if two spheres are glued together?
To figure this out we need a practical definition of what it means to glue two spheres. Someone in the comments argued that the glue may deform during the impact and dissipate energy that way, but for the moment I will take a very simple definition. As soon as the blue sphere and the orange sphere touch, the two springs become attached, as if the two spheres had become a single piece of metal. Just that, the simplest kind of inelastic collision.
Under this simple assumption, I ran the simulation and this is the result.
Only the purple sphere is kicked. This seems to favor Answer 1. Interestingly, it seems like in the following collisions also the red sphere starts to be excited, but if I let the simulation run for longer to see what happens:
The situation descends rapidly into chaos, after which all the five spheres start oscillating together, like it sometimes happens with real Newton's cradles. For comparison, here's the same plot, but without glue
From the tests I made, it seems to be possible to delay the insurgence of chaos by increasing $K_s$, at the cost of an increased computational cost. All these tiny vibrating springs act in a way similar to the vibrating atoms in the metal. Even though the equations I am using conserve energy perfectly, the energy tends to move from kinetic energy of the spheres to incoherent thermal vibrations of the springs (that's the second law of thermodynamics in action, yo!). My intuition is that increasing $K_s$ I am making it harder for the springs to vibrate, and thus slowing down the inevitable increase of entropy.
One last experiment before concluding this already long answer. What happens if there is a small gap between the orange sphere and the green sphere? If they are not touching from the start, but there is some space between them, after the blue sphere hits the orange and becomes glued to it, orange and blue would move together for a brief time, and hit together the green one. And we know that in Newton's cradle, if two spheres hit, then two spheres are kicked. But, interestingly, we just saw that if there is no gap, then only one sphere is kicked out. The question is: is a tiny gap sufficient to subvert this conclusion?
The result is very interesting. I tried different gaps between orange and green. The next figure is obtained with a very small gap of 1/10 of the diameter of a sphere.
The result is similar as if there were no gap: one sphere is kicked. But if we increase the gap to 1/4, everything changes.
Here two spheres are kicked! Maybe there is a minimum gap size after which the cradle behaves as if two spheres had been put in motion. But another surprise awaits: if we increase the gap even more, to 1/2 of the sphere diameter we are back again at kicking out only one sphere!
To understand what's going on, it's useful to zoom in at the impact region, and look at the spring deformation.
First, the case with 1/10 gap:
When the blue and orange spheres are glued, there's some strong oscillation going on inside. And the oscillation seems to be in phase at the time of the collision with the green sphere. The result is a strong pulse of pressure waves that traverse the other spheres and kicks the purple one.
In case of gap 1/4 instead, the oscillations are not in phase with the time of collision with the green sphere. The result is a kick to the purple sphere, that only uses about half of the elastic energy. The rest of the energy does another oscillation inside the blue and orange sphere and is then released to kick the red sphere.
So in the end it looks like the result is very sensitive to the geometry of the system, the sound speed and whether the pressure waves are in phase or not at the time of the collisions.
This result was most unexpected, and I feel I have only scratched the surface of what could be said about this topic. Thank you for asking such a nice question. I'm pasting my code here, in case anyone wants to play with it.
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp
# Define the parameters
N_balls = 5
N_springs_per_ball = 20
N_springs = N_springs_per_ball * N_balls
ball_diameter = 1
spring_rest_length = ball_diameter / N_springs_per_ball
# k_spring is the elastic coefficient divided by the mass of the spring
k_spring = 100000*N_springs_per_ball
# I am treating the swing of the pendulum as if it were another harmonic oscillator
# since the oscillations are small. k_pendulum is the elastic coefficient of the
# harmonic oscillator divided by the mass
k_pendulum = np.pi
# Rest positions of the springs
X_rest = np.linspace(0, (N_springs-1)*spring_rest_length, N_springs)
# Insert a gap between orange and green ball
gap_size = 1/10*ball_diameter
for i in range(N_springs_per_ball*2, N_springs):
X_rest[i] += gap_size
# Boolean array that defines whether two adjacent springs can detatch or are
# glued together.
attached = np.ones(N_springs-1).astype(bool)
for i in range(1,N_balls):
attached[i*N_springs_per_ball-1] = False
# When True, glue the first and second sphere together after the first collision
do_glue = True
# Set initial conditions
X0 = X_rest.copy()
X0[:N_springs_per_ball] -= 2*ball_diameter
V0 = np.zeros(X0.shape)
U0 = np.concatenate([X0, V0])
# Set time of the simulation
t_eval = np.linspace(0,1.3,1300)
#t_eval = np.linspace(0,10,1000)
t_span = (t_eval[0], t_eval[-1])
# Define the time of the first contact between the first and the second ball
# After this time, the two balls will be glued together.
# I will determine this time precisely during the integration.
t_contact = t_span[1]
# f is a function that gives the derivatives of position and velocities
def f(t,U):
global t_contact
attached_a = attached.copy()
X = U[:N_springs]
V = U[N_springs:]
F = k_spring * (np.diff(X) - spring_rest_length)
if do_glue == True:
# Determine the time of first contact between the first and second sphere
if F[N_springs_per_ball-1] < 0 and t<t_contact:
t_contact = t
# If we are after first contact, the first two balls are glued together.
if t >= t_contact:
attached_a[N_springs_per_ball-1] = True
# Set to zero the force if the springs are detatched.
F[(~attached_a) & (F>0)] = 0
dVdt = np.diff(F, prepend=0, append=0) - k_pendulum * (X-X_rest)
dXdt = V
dUdt = np.concatenate([dXdt, dVdt])
return dUdt
# Solve the system of equations
res = solve_ivp(f, t_span, U0, t_eval=t_eval)
t = res.t
U = res.y
# Plot the result
for i in range(N_springs):
plt.plot(t, U[i,:], color = f"C{i//N_springs_per_ball}")
plt.xlabel("time")
plt.ylabel("position")
plt.show()
# Spring deformation plot
normalize = mpl.colors.Normalize(vmin=-5, vmax=5)
for i in range(800,1300):
d = (np.diff(U[:N_springs,i])-spring_rest_length)/spring_rest_length*100
tt = np.ones(d.shape)*t[i]
plt.scatter(tt,U[:N_springs-1, i], c=d, norm=normalize, s=1, cmap = "coolwarm")
cb = plt.colorbar()
cb.set_label("spring deformation (%)")
plt.xlabel("time")
plt.ylabel("position")
plt.xlim(0.8,1.3)
plt.show()
Conclusion
In conclusion, I would say Answer 3. The number of balls launched and their velocity depends on the details of the pressure waves oscillations in the spheres. And therefore it depends on the geometry, position, timing, soundspeed.. etc. I would expect it also to depend on the glueing method: in this simulaion I assumed that the two glued spheres become a single piece of metal, i.e. the elastic constat of the spring joining them is equal to the ones of the other springs. But in reality the glue/velcrum/latch could have a different elasticity and this would affect the propagation of sound waves in the spheres.
