The problem reduces the runner-and-swimmer geometry for a regular \(n\)-gon to a critical constant \(\lambda_n\). The implementations first verify two reference cases, the circular limit and the square, and then apply the same formula to the regular hexagon, which is the actual target.
The computation is not a simulation. Instead, it becomes a finite search for the correct angular branch, followed by one closed-form reconstruction of an angle \(\alpha\), and finally the conversion \(\lambda_n=1/\cos\alpha\).
Let
$$\theta=\frac{\pi}{n}.$$
The derivation used by the implementation expresses the critical ratio through an auxiliary angle \(\alpha\). The formula is piecewise, because the geometry changes when \(2\alpha\) crosses multiples of \(\theta\).
A regular \(n\)-gon is invariant under rotation by one side and reflection across the midpoint of a side. Because of that symmetry, the extremal configuration can be described inside a single half-sector of opening \(\theta=\pi/n\).
Instead of tracking a full trajectory, we only need one angle \(\alpha\) that captures the critical geometry. Once \(\alpha\) is known, the desired constant is simply
$$\lambda_n=\frac{1}{\cos\alpha}.$$
So the whole problem is reduced to determining the correct value of \(\alpha\).
The trigonometric derivation is piecewise. On each branch, an integer \(K\) counts how many full angular steps of size \(\theta\) have been crossed before the critical point is reached. The implementation determines \(K\) by scanning integers \(k=0,1,\dots,n\) and evaluating
$$f(k)=\sin(k\theta)-(k+n)\tan\theta\,\cos(k\theta).$$
The chosen branch index is the largest \(K\) satisfying
$$f(K)\lt 0.$$
This search is guaranteed to stop because
$$f(0)=-n\tan\theta\lt 0,\qquad f(n)=2n\tan\theta\gt 0.$$
So a sign change must occur between \(0\) and \(n\), and the last negative value selects the correct branch of the geometric formula.
For a fixed branch \(K\), the geometry collapses to one cosine equation:
$$\cos(2\alpha-K\theta)=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta).$$
If we denote the right-hand side by \(A_K\), then
$$A_K=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta),$$
and therefore
$$\alpha=\frac12\left(K\theta+\arccos(A_K)\right).$$
In exact arithmetic, the chosen branch gives \(A_K\in[-1,1]\). Numerically, it is still wise to clip the value into that interval before applying \(\arccos\).
After \(\alpha\) has been reconstructed, the answer follows immediately:
$$\lambda_n=\frac{1}{\cos\alpha}.$$
So the regular-polygon part of the problem has a compact computational form: first a linear search for \(K\), then one inverse cosine, then one reciprocal cosine.
For the actual target \(n=6\), the scan gives \(K=2\). Substituting \(\theta=\pi/6\) yields
$$A_2=\frac{2\sin(\pi/3)}{8\tan(\pi/6)}-\cos(\pi/3)=-\frac18,$$
so the hexagon constant is
$$\lambda_6=\frac{1}{\cos\left(\frac12\left(\frac{\pi}{3}+\arccos\left(-\frac18\right)\right)\right)}.$$
The C++ implementation also validates the limiting circular case. As \(n\to\infty\), we have \(\theta=\pi/n\to0\), and the discrete quantity \(K\theta\) approaches a continuous angle \(\mu\). Using
$$n\tan\left(\frac{\pi}{n}\right)\to\pi,$$
the branch-boundary equation \(f(K)=0\) becomes
$$\sin\mu-(\mu+\pi)\cos\mu=0.$$
Dividing by \(\cos\mu\) gives
$$\tan\mu=\mu+\pi,$$
or equivalently
$$\mu+\pi-\tan\mu=0.$$
Once \(\mu\) is found, the limit constant is
$$\lambda_{\circ}=\frac{1}{\cos\mu}.$$
This is exactly the reference value checked numerically before the polygon case is used.
Take \(n=4\). Then \(\theta=\pi/4\) and \(\tan\theta=1\). Evaluate the branch test:
$$f(0)=-4\lt 0,\qquad f(1)=\sin\left(\frac{\pi}{4}\right)-5\cos\left(\frac{\pi}{4}\right)=-2\sqrt2\lt 0,$$
$$f(2)=\sin\left(\frac{\pi}{2}\right)-6\cos\left(\frac{\pi}{2}\right)=1\gt 0.$$
So \(K=1\). The cosine argument becomes
$$A_1=\frac{2\sin(\pi/4)}{5\tan(\pi/4)}-\cos(\pi/4)=\frac{\sqrt2}{5}-\frac{\sqrt2}{2}=-\frac{3\sqrt2}{10}.$$
Hence
$$\alpha=\frac12\left(\frac{\pi}{4}+\arccos\left(-\frac{3\sqrt2}{10}\right)\right),$$
and therefore
$$\lambda_4=\frac{1}{\cos\alpha}\approx 5.78859314.$$
This matches the square validation used by the implementation and shows that the branch rule and the closed form are consistent.
The C++, Python, and Java implementations all follow the same structure. For a regular \(n\)-gon, they compute \(\theta=\pi/n\) and \(\tan\theta\), scan \(k=0\) to \(n\) until the sign test stops being negative, and keep the last valid branch index \(K\).
They then evaluate the cosine argument, clip it into \([-1,1]\) to neutralize round-off drift, recover \(\alpha\) with \(\arccos\), and return \(1/\cos\alpha\). The C++ implementation also performs two sanity checks: it solves the circular limit equation by bisection, and it compares the square result against the known reference value before computing the hexagon case.
No large tables, recursion, or iterative optimization are involved. The whole computation is a direct translation of the trigonometric formulas above.
For a regular \(n\)-gon, the branch scan costs \(O(n)\) time because it checks at most \(n+1\) integers. All remaining work is constant-time trigonometric evaluation, so the polygon calculation uses \(O(1)\) extra memory.
The circular validation uses bisection with a fixed number of iterations, so it is \(O(I)\) with constant \(I\), and still \(O(1)\) memory. For the actual problem instance \(n=6\), the computation is effectively constant time.
Die Aufgabe reduziert die Geometrie des Problems Runner and Swimmer für ein regelmäßiges \(n\)-Eck auf eine kritische Konstante \(\lambda_n\). Die Implementierungen prüfen zunächst zwei Referenzfälle, den Kreisgrenzfall und das Quadrat, und wenden danach dieselbe Formel auf das regelmäßige Sechseck an, das das eigentliche Ziel ist.
Die Berechnung ist keine Simulation. Stattdessen besteht sie aus einer endlichen Suche nach dem richtigen Winkelzweig, einer geschlossenen Rekonstruktion eines Winkels \(\alpha\) und schließlich der Umrechnung \(\lambda_n=1/\cos\alpha\).
Setze
$$\theta=\frac{\pi}{n}.$$
Die von der Implementierung verwendete Herleitung beschreibt das kritische Verhältnis über einen Hilfswinkel \(\alpha\). Die Formel ist stückweise, weil sich die Geometrie ändert, sobald \(2\alpha\) Vielfache von \(\theta\) überschreitet.
Ein regelmäßiges \(n\)-Eck ist invariant unter Rotation um eine Seite und unter Spiegelung an der Mittelsenkrechten einer Seite. Deshalb kann die Extremalkonfiguration innerhalb eines einzigen Halbsektors mit Öffnungswinkel \(\theta=\pi/n\) beschrieben werden.
Statt eine ganze Bahn zu verfolgen, genügt ein einziger Winkel \(\alpha\), der die kritische Geometrie kodiert. Sobald \(\alpha\) bekannt ist, erhält man die gesuchte Konstante direkt aus
$$\lambda_n=\frac{1}{\cos\alpha}.$$
Damit reduziert sich das gesamte Problem auf die Bestimmung des richtigen \(\alpha\).
Die trigonometrische Herleitung ist stückweise. In jedem Zweig zählt eine ganze Zahl \(K\), wie viele vollständige Winkelschritte der Größe \(\theta\) vor dem kritischen Punkt überschritten wurden. Die Implementierung bestimmt \(K\), indem sie \(k=0,1,\dots,n\) durchläuft und
$$f(k)=\sin(k\theta)-(k+n)\tan\theta\,\cos(k\theta)$$
auswertet. Gewählt wird der größte Index \(K\) mit
$$f(K)\lt 0.$$
Diese Suche endet sicher, denn es gilt
$$f(0)=-n\tan\theta\lt 0,\qquad f(n)=2n\tan\theta\gt 0.$$
Also muss zwischen \(0\) und \(n\) ein Vorzeichenwechsel auftreten, und der letzte negative Wert wählt genau den korrekten geometrischen Zweig aus.
Für einen festen Zweig \(K\) fällt die Geometrie auf eine einzige Kosinusgleichung zurück:
$$\cos(2\alpha-K\theta)=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta).$$
Bezeichnet man die rechte Seite mit \(A_K\), dann gilt
$$A_K=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta),$$
und damit
$$\alpha=\frac12\left(K\theta+\arccos(A_K)\right).$$
In exakter Arithmetik liegt \(A_K\) im Intervall \([-1,1]\). Numerisch ist es trotzdem sinnvoll, den Wert vor \(\arccos\) auf dieses Intervall zu begrenzen.
Nachdem \(\alpha\) rekonstruiert wurde, folgt die Antwort sofort:
$$\lambda_n=\frac{1}{\cos\alpha}.$$
Der Polygonteil des Problems hat damit eine sehr kompakte Form: zuerst eine lineare Suche nach \(K\), dann ein inverser Kosinus, dann ein reziproker Kosinus.
Für das eigentliche Ziel \(n=6\) liefert die Suche \(K=2\). Mit \(\theta=\pi/6\) erhält man
$$A_2=\frac{2\sin(\pi/3)}{8\tan(\pi/6)}-\cos(\pi/3)=-\frac18,$$
also
$$\lambda_6=\frac{1}{\cos\left(\frac12\left(\frac{\pi}{3}+\arccos\left(-\frac18\right)\right)\right)}.$$
Die C++-Implementierung validiert zusätzlich den Grenzfall des Kreises. Für \(n\to\infty\) gilt \(\theta=\pi/n\to0\), und die diskrete Größe \(K\theta\) geht in einen stetigen Winkel \(\mu\) über. Mit
$$n\tan\left(\frac{\pi}{n}\right)\to\pi$$
wird aus der Zweiggleichung \(f(K)=0\)
$$\sin\mu-(\mu+\pi)\cos\mu=0.$$
Nach Division durch \(\cos\mu\) folgt
$$\tan\mu=\mu+\pi,$$
oder äquivalent
$$\mu+\pi-\tan\mu=0.$$
Ist \(\mu\) gefunden, dann lautet die Grenzkonstante
$$\lambda_{\circ}=\frac{1}{\cos\mu}.$$
Genau dieser Referenzwert wird numerisch geprüft, bevor der Polygonfall benutzt wird.
Nimm \(n=4\). Dann ist \(\theta=\pi/4\) und \(\tan\theta=1\). Für den Zweigtest erhält man
$$f(0)=-4\lt 0,\qquad f(1)=\sin\left(\frac{\pi}{4}\right)-5\cos\left(\frac{\pi}{4}\right)=-2\sqrt2\lt 0,$$
$$f(2)=\sin\left(\frac{\pi}{2}\right)-6\cos\left(\frac{\pi}{2}\right)=1\gt 0.$$
Also ist \(K=1\). Das Kosinusargument wird zu
$$A_1=\frac{2\sin(\pi/4)}{5\tan(\pi/4)}-\cos(\pi/4)=\frac{\sqrt2}{5}-\frac{\sqrt2}{2}=-\frac{3\sqrt2}{10}.$$
Daraus folgt
$$\alpha=\frac12\left(\frac{\pi}{4}+\arccos\left(-\frac{3\sqrt2}{10}\right)\right),$$
und somit
$$\lambda_4=\frac{1}{\cos\alpha}\approx 5.78859314.$$
Das stimmt mit der in der Implementierung verwendeten Quadrat-Validierung überein und bestätigt, dass Zweigwahl und geschlossene Formel zusammenpassen.
Die Implementierungen in C++, Python und Java folgen alle derselben Struktur. Für ein regelmäßiges \(n\)-Eck berechnen sie \(\theta=\pi/n\) und \(\tan\theta\), durchsuchen \(k=0\) bis \(n\), bis der Vorzeichentest nicht mehr negativ ist, und behalten den letzten gültigen Zweigindex \(K\).
Danach wird das Kosinusargument berechnet, auf \([-1,1]\) begrenzt, um Rundungsfehler abzufangen, \(\alpha\) per \(\arccos\) rekonstruiert und schließlich \(1/\cos\alpha\) zurückgegeben. Die C++-Implementierung führt außerdem zwei Plausibilitätsprüfungen aus: Sie löst die Kreisgrenzgleichung per Bisektion und vergleicht den Quadratwert mit dem bekannten Referenzwert, bevor der Sechseckfall berechnet wird.
Große Tabellen, Rekursion oder iterative Optimierung werden nicht benötigt. Die gesamte Berechnung ist eine direkte Umsetzung der obigen trigonometrischen Formeln.
Für ein regelmäßiges \(n\)-Eck kostet die Zweigsuche \(O(n)\) Zeit, da höchstens \(n+1\) ganzzahlige Kandidaten geprüft werden. Alle übrigen Schritte sind trigonometrische Auswertungen in konstanter Zeit, also benötigt die Polygonberechnung \(O(1)\) Zusatzspeicher.
Die Kreis-Validierung verwendet eine Bisektion mit fester Iterationszahl und kostet daher \(O(I)\) mit konstantem \(I\), ebenfalls bei \(O(1)\) Speicher. Für den konkreten Fall \(n=6\) ist die gesamte Berechnung praktisch konstant.
Problem, düzgün \(n\)-gen için runner and swimmer geometrisini kritik bir \(\lambda_n\) sabitine indirger. Uygulamalar önce iki referans durumu, daire limiti ile kareyi, doğrular; ardından aynı formülü asıl hedef olan düzgün altıgen için kullanır.
Buradaki hesap bir benzetim değildir. Süreç; doğru açısal dalı bulmak için sonlu bir arama, sonra \(\alpha\) açısını kapalı formda geri kurma ve en sonda \(\lambda_n=1/\cos\alpha\) dönüşümünden oluşur.
Şunu tanımlayalım:
$$\theta=\frac{\pi}{n}.$$
Uygulamanın kullandığı türetim, kritik oranı yardımcı bir \(\alpha\) açısı üzerinden yazar. Formül parçalıdır; çünkü \(2\alpha\), \(\theta\)'nın katlarını geçtikçe geometrik durum değişir.
Düzgün \(n\)-gen, bir kenar kadar döndürmeye ve bir kenarın orta dikmesine göre yansımaya karşı değişmezdir. Bu nedenle uç durum, açıklığı \(\theta=\pi/n\) olan tek bir yarım sektörde tanımlanabilir.
Tüm yolu izlemek yerine, kritik geometriyi temsil eden tek bir \(\alpha\) açısına ihtiyaç duyarız. \(\alpha\) bilindiğinde aranan sabit doğrudan
$$\lambda_n=\frac{1}{\cos\alpha}$$
olur. Yani bütün problem doğru \(\alpha\) değerini bulmaya indirgenir.
Trigonometrik türetim parçalıdır. Her dalda bir tamsayı \(K\), kritik noktaya gelmeden önce \(\theta\) büyüklüğündeki kaç tam açısal adımın geçildiğini sayar. Uygulama \(k=0,1,\dots,n\) için
$$f(k)=\sin(k\theta)-(k+n)\tan\theta\,\cos(k\theta)$$
değerini hesaplar. Seçilen dal indeksi,
$$f(K)\lt 0$$
koşulunu sağlayan en büyük \(K\)'dir.
Bu arama mutlaka biter; çünkü
$$f(0)=-n\tan\theta\lt 0,\qquad f(n)=2n\tan\theta\gt 0.$$
Dolayısıyla \(0\) ile \(n\) arasında bir işaret değişimi vardır ve son negatif değer geometrik formülün doğru dalını seçer.
Sabit bir \(K\) dalında geometri tek bir kosinüs denklemine iner:
$$\cos(2\alpha-K\theta)=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta).$$
Sağ tarafı \(A_K\) ile gösterirsek
$$A_K=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta),$$
ve buradan
$$\alpha=\frac12\left(K\theta+\arccos(A_K)\right)$$
elde edilir. Tam aritmetikte seçilen dal \(A_K\)'yi \([-1,1]\) aralığında verir. Sayısal hesapta ise \(\arccos\) öncesinde bu aralığa sıkıştırmak güvenlidir.
\(\alpha\) bulunduktan sonra cevap doğrudan gelir:
$$\lambda_n=\frac{1}{\cos\alpha}.$$
Böylece düzgün çokgen kısmı çok kısa bir hesap şemasına dönüşür: önce \(K\) için doğrusal tarama, sonra bir ters kosinüs, sonra bir ters kosinüsün kosinüse göre karşılığı olan \(1/\cos\alpha\).
Asıl hedef olan \(n=6\) için tarama \(K=2\) verir. \(\theta=\pi/6\) yazınca
$$A_2=\frac{2\sin(\pi/3)}{8\tan(\pi/6)}-\cos(\pi/3)=-\frac18,$$
dolayısıyla altıgen sabiti
$$\lambda_6=\frac{1}{\cos\left(\frac12\left(\frac{\pi}{3}+\arccos\left(-\frac18\right)\right)\right)}$$
olur.
C++ uygulaması dairesel limit durumu ayrıca doğrular. \(n\to\infty\) iken \(\theta=\pi/n\to0\) olur ve ayrık büyüklük \(K\theta\), sürekli bir \(\mu\) açısına yaklaşır. Şunu kullanırsak
$$n\tan\left(\frac{\pi}{n}\right)\to\pi,$$
dal sınırı denklemi \(f(K)=0\) şu hale gelir:
$$\sin\mu-(\mu+\pi)\cos\mu=0.$$
\(\cos\mu\)'ya bölünce
$$\tan\mu=\mu+\pi,$$
ve eşdeğer olarak
$$\mu+\pi-\tan\mu=0$$
elde edilir. \(\mu\) bulunduğunda limit sabit
$$\lambda_{\circ}=\frac{1}{\cos\mu}$$
olur. Çokgen hesabına geçmeden önce sayısal olarak doğrulanan referans değer tam budur.
\(n=4\) alalım. O zaman \(\theta=\pi/4\) ve \(\tan\theta=1\) olur. Dal testi için
$$f(0)=-4\lt 0,\qquad f(1)=\sin\left(\frac{\pi}{4}\right)-5\cos\left(\frac{\pi}{4}\right)=-2\sqrt2\lt 0,$$
$$f(2)=\sin\left(\frac{\pi}{2}\right)-6\cos\left(\frac{\pi}{2}\right)=1\gt 0$$
elde edilir. Demek ki \(K=1\). Kosinüs argümanı
$$A_1=\frac{2\sin(\pi/4)}{5\tan(\pi/4)}-\cos(\pi/4)=\frac{\sqrt2}{5}-\frac{\sqrt2}{2}=-\frac{3\sqrt2}{10}$$
olur. Buradan
$$\alpha=\frac12\left(\frac{\pi}{4}+\arccos\left(-\frac{3\sqrt2}{10}\right)\right),$$
ve sonuç olarak
$$\lambda_4=\frac{1}{\cos\alpha}\approx 5.78859314$$
çıkar. Bu, uygulamanın kullandığı kare doğrulamasıyla aynıdır ve dal seçiminin doğru çalıştığını gösterir.
C++, Python ve Java uygulamaları aynı iskeleti izler. Düzgün \(n\)-gen için önce \(\theta=\pi/n\) ve \(\tan\theta\) hesaplanır, sonra \(k=0\)'dan \(n\)'ye kadar gidilip işaret testi negatif kalmadığı ana kadar tarama yapılır ve son geçerli dal indeksi \(K\) saklanır.
Daha sonra kosinüs argümanı hesaplanır, yuvarlama hatalarını bastırmak için \([-1,1]\) aralığına sıkıştırılır, \(\arccos\) ile \(\alpha\) elde edilir ve \(1/\cos\alpha\) döndürülür. C++ uygulaması ayrıca iki sağlık kontrolü yapar: daire limit denklemini bisection ile çözer ve altıgen hesabından önce kare sonucunu bilinen referans değerle karşılaştırır.
Büyük tablolar, özyineleme veya nümerik optimizasyon yoktur. Hesap bütünüyle yukarıdaki trigonometrik formüllerin doğrudan uygulanmasıdır.
Düzgün \(n\)-gen için dal taraması en fazla \(n+1\) tamsayıyı denediği için süre maliyeti \(O(n)\)'dir. Kalan işlemler sabit zamanda yapılan trigonometrik değerlendirmelerdir; bu yüzden çokgen hesabı \(O(1)\) ek bellek kullanır.
Daire doğrulaması sabit iterasyon sayılı bisection kullandığı için \(O(I)\) zamanda çalışır; burada \(I\) sabittir. Bellek yine \(O(1)\)'dir. Asıl problemde \(n=6\) olduğundan pratikte hesap sabit zamandır.
El problema reduce la geometría de Runner and Swimmer para un \(n\)-gono regular a una constante crítica \(\lambda_n\). Las implementaciones comprueban primero dos casos de referencia, el límite circular y el cuadrado, y después aplican la misma fórmula al hexágono regular, que es el objetivo real.
El cálculo no es una simulación. Se convierte en una búsqueda finita de la rama angular correcta, seguida por una reconstrucción en forma cerrada de un ángulo \(\alpha\), y finalmente por la conversión \(\lambda_n=1/\cos\alpha\).
Definimos
$$\theta=\frac{\pi}{n}.$$
La derivación usada por la implementación expresa la razón crítica mediante un ángulo auxiliar \(\alpha\). La fórmula es por tramos, porque la geometría cambia cuando \(2\alpha\) cruza múltiplos de \(\theta\).
Un \(n\)-gono regular es invariante bajo una rotación de un lado y bajo la reflexión respecto de la mediatriz de un lado. Por eso, la configuración extrema puede describirse dentro de un único semisector de apertura \(\theta=\pi/n\).
En lugar de seguir toda una trayectoria, basta con un solo ángulo \(\alpha\) que codifica la geometría crítica. Una vez conocido \(\alpha\), la constante buscada es
$$\lambda_n=\frac{1}{\cos\alpha}.$$
Así, todo el problema queda reducido a encontrar el valor correcto de \(\alpha\).
La derivación trigonométrica es por tramos. En cada tramo, un entero \(K\) cuenta cuántos pasos angulares completos de tamaño \(\theta\) se han cruzado antes de llegar al punto crítico. La implementación determina \(K\) recorriendo \(k=0,1,\dots,n\) y evaluando
$$f(k)=\sin(k\theta)-(k+n)\tan\theta\,\cos(k\theta).$$
La rama elegida es el mayor \(K\) tal que
$$f(K)\lt 0.$$
La búsqueda termina necesariamente porque
$$f(0)=-n\tan\theta\lt 0,\qquad f(n)=2n\tan\theta\gt 0.$$
Por lo tanto, hay un cambio de signo entre \(0\) y \(n\), y el último valor negativo selecciona la rama geométrica correcta.
Para una rama fija \(K\), la geometría se reduce a una sola ecuación de coseno:
$$\cos(2\alpha-K\theta)=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta).$$
Si llamamos \(A_K\) al lado derecho, entonces
$$A_K=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta),$$
y por tanto
$$\alpha=\frac12\left(K\theta+\arccos(A_K)\right).$$
En aritmética exacta, la rama elegida produce \(A_K\in[-1,1]\). Numéricamente sigue siendo prudente recortar el valor a ese intervalo antes de aplicar \(\arccos\).
Una vez reconstruido \(\alpha\), la respuesta sale de inmediato:
$$\lambda_n=\frac{1}{\cos\alpha}.$$
De este modo, la parte del polígono regular tiene una forma computacional compacta: primero una búsqueda lineal de \(K\), luego un coseno inverso y finalmente un coseno recíproco.
Para el objetivo real \(n=6\), el recorrido da \(K=2\). Sustituyendo \(\theta=\pi/6\) se obtiene
$$A_2=\frac{2\sin(\pi/3)}{8\tan(\pi/6)}-\cos(\pi/3)=-\frac18,$$
y por eso la constante del hexágono es
$$\lambda_6=\frac{1}{\cos\left(\frac12\left(\frac{\pi}{3}+\arccos\left(-\frac18\right)\right)\right)}.$$
La implementación en C++ también valida el caso límite circular. Cuando \(n\to\infty\), se tiene \(\theta=\pi/n\to0\), y la cantidad discreta \(K\theta\) tiende a un ángulo continuo \(\mu\). Usando
$$n\tan\left(\frac{\pi}{n}\right)\to\pi,$$
la ecuación de frontera de rama \(f(K)=0\) se convierte en
$$\sin\mu-(\mu+\pi)\cos\mu=0.$$
Al dividir por \(\cos\mu\) resulta
$$\tan\mu=\mu+\pi,$$
o de forma equivalente
$$\mu+\pi-\tan\mu=0.$$
Una vez hallado \(\mu\), la constante límite es
$$\lambda_{\circ}=\frac{1}{\cos\mu}.$$
Ese es exactamente el valor de referencia que se comprueba numéricamente antes de usar el caso poligonal.
Tomemos \(n=4\). Entonces \(\theta=\pi/4\) y \(\tan\theta=1\). Para la prueba de rama se obtiene
$$f(0)=-4\lt 0,\qquad f(1)=\sin\left(\frac{\pi}{4}\right)-5\cos\left(\frac{\pi}{4}\right)=-2\sqrt2\lt 0,$$
$$f(2)=\sin\left(\frac{\pi}{2}\right)-6\cos\left(\frac{\pi}{2}\right)=1\gt 0.$$
Por tanto, \(K=1\). El argumento del coseno pasa a ser
$$A_1=\frac{2\sin(\pi/4)}{5\tan(\pi/4)}-\cos(\pi/4)=\frac{\sqrt2}{5}-\frac{\sqrt2}{2}=-\frac{3\sqrt2}{10}.$$
Así,
$$\alpha=\frac12\left(\frac{\pi}{4}+\arccos\left(-\frac{3\sqrt2}{10}\right)\right),$$
y por consiguiente
$$\lambda_4=\frac{1}{\cos\alpha}\approx 5.78859314.$$
Esto coincide con la validación del cuadrado usada por la implementación y confirma que la regla de selección de rama es coherente con la fórmula cerrada.
Las implementaciones en C++, Python y Java siguen exactamente la misma estructura. Para un \(n\)-gono regular calculan \(\theta=\pi/n\) y \(\tan\theta\), recorren \(k=0\) hasta \(n\) hasta que la prueba de signo deja de ser negativa, y conservan el último índice de rama válido \(K\).
Después evalúan el argumento del coseno, lo recortan al intervalo \([-1,1]\) para neutralizar errores de redondeo, reconstruyen \(\alpha\) con \(\arccos\) y devuelven \(1/\cos\alpha\). La implementación en C++ añade dos comprobaciones de sanidad: resuelve la ecuación del límite circular por bisección y compara el resultado del cuadrado con el valor de referencia antes de calcular el caso hexagonal.
No hacen falta tablas grandes, recursión ni optimización iterativa. Todo el cálculo es una traducción directa de las fórmulas trigonométricas anteriores.
Para un \(n\)-gono regular, el barrido de ramas cuesta \(O(n)\) tiempo porque revisa como máximo \(n+1\) enteros. Todo lo demás son evaluaciones trigonométricas en tiempo constante, así que el cálculo del polígono usa \(O(1)\) memoria adicional.
La validación circular usa bisección con un número fijo de iteraciones, de modo que cuesta \(O(I)\) con \(I\) constante, y también \(O(1)\) memoria. Para la instancia real \(n=6\), el cálculo es efectivamente constante.
这道题把 Runner and Swimmer 在正 \(n\) 边形中的几何问题压缩成一个临界常数 \(\lambda_n\)。实现会先验证两个参考情形：圆形极限与正方形，然后再把同一套公式用于真正需要的正六边形。
整个过程不是做数值仿真，而是先确定正确的角度分支，再用闭式公式还原辅助角 \(\alpha\)，最后通过 \(\lambda_n=1/\cos\alpha\) 得到答案。
记
$$\theta=\frac{\pi}{n}.$$
实现所依据的推导把临界比值写成辅助角 \(\alpha\) 的函数。这个公式是分段的，因为当 \(2\alpha\) 穿过 \(\theta\) 的整数倍时，对应的几何构型会发生变化。
正 \(n\) 边形对“按一个边长对应的旋转”以及“关于某条边中垂线的镜像”都保持不变。因此，极值构型只需要在一个开角为 \(\theta=\pi/n\) 的半扇形中描述即可。
这意味着我们不必追踪完整轨迹，只需要一个辅助角 \(\alpha\) 来编码临界几何关系。一旦 \(\alpha\) 已知，目标常数立即写成
$$\lambda_n=\frac{1}{\cos\alpha}.$$
所以整个问题的核心，就是如何准确求出 \(\alpha\)。
推导是分段的。对每一段来说，一个整数 \(K\) 表示在到达临界位置之前，已经跨过了多少个大小为 \(\theta\) 的完整角步长。实现通过扫描 \(k=0,1,\dots,n\) 并计算
$$f(k)=\sin(k\theta)-(k+n)\tan\theta\,\cos(k\theta)$$
来确定这个分支。被选中的分支指标是满足
$$f(K)\lt 0$$
的最大整数 \(K\)。
这个扫描一定会停止，因为
$$f(0)=-n\tan\theta\lt 0,\qquad f(n)=2n\tan\theta\gt 0.$$
也就是说，在 \(0\) 与 \(n\) 之间必定发生符号变化，而“最后一个负值”正好对应正确的几何分支。
当 \(K\) 固定以后，几何关系会收缩成一个单独的余弦方程：
$$\cos(2\alpha-K\theta)=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta).$$
把右边记作 \(A_K\)，则
$$A_K=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta),$$
于是
$$\alpha=\frac12\left(K\theta+\arccos(A_K)\right).$$
在精确数学中，正确分支对应的 \(A_K\) 一定落在 \([-1,1]\) 内。数值实现中仍然会先把它截断到这个区间，以避免浮点误差把 \(\arccos\) 的输入推到区间之外。
\(\alpha\) 一旦求出，答案就直接是
$$\lambda_n=\frac{1}{\cos\alpha}.$$
因此，正多边形部分的计算流程非常紧凑：先做一次关于 \(K\) 的线性扫描，再算一次反余弦，最后再算一次倒数余弦。
对题目真正关心的 \(n=6\)，扫描结果是 \(K=2\)。把 \(\theta=\pi/6\) 代入后可得
$$A_2=\frac{2\sin(\pi/3)}{8\tan(\pi/6)}-\cos(\pi/3)=-\frac18,$$
因此正六边形的常数写成
$$\lambda_6=\frac{1}{\cos\left(\frac12\left(\frac{\pi}{3}+\arccos\left(-\frac18\right)\right)\right)}.$$
C++ 实现还额外验证了圆形极限。令 \(n\to\infty\)，则 \(\theta=\pi/n\to0\)，离散量 \(K\theta\) 会趋向某个连续角 \(\mu\)。利用
$$n\tan\left(\frac{\pi}{n}\right)\to\pi,$$
分支边界方程 \(f(K)=0\) 会变成
$$\sin\mu-(\mu+\pi)\cos\mu=0.$$
再除以 \(\cos\mu\)，就得到
$$\tan\mu=\mu+\pi,$$
也就是
$$\mu+\pi-\tan\mu=0.$$
一旦求出 \(\mu\)，圆形极限常数就是
$$\lambda_{\circ}=\frac{1}{\cos\mu}.$$
这正是程序在进入多边形计算之前先用二分法验证的参考值。
取 \(n=4\)。此时 \(\theta=\pi/4\)，并且 \(\tan\theta=1\)。先看分支测试：
$$f(0)=-4\lt 0,\qquad f(1)=\sin\left(\frac{\pi}{4}\right)-5\cos\left(\frac{\pi}{4}\right)=-2\sqrt2\lt 0,$$
$$f(2)=\sin\left(\frac{\pi}{2}\right)-6\cos\left(\frac{\pi}{2}\right)=1\gt 0.$$
所以 \(K=1\)。对应的余弦参数为
$$A_1=\frac{2\sin(\pi/4)}{5\tan(\pi/4)}-\cos(\pi/4)=\frac{\sqrt2}{5}-\frac{\sqrt2}{2}=-\frac{3\sqrt2}{10}.$$
于是
$$\alpha=\frac12\left(\frac{\pi}{4}+\arccos\left(-\frac{3\sqrt2}{10}\right)\right),$$
从而
$$\lambda_4=\frac{1}{\cos\alpha}\approx 5.78859314.$$
这个数值与实现中使用的正方形校验完全一致，也说明“先选分支、再代入闭式”的方法是自洽的。
C++、Python 和 Java 三个实现遵循同一套流程。对于正 \(n\) 边形，先计算 \(\theta=\pi/n\) 与 \(\tan\theta\)，然后从 \(k=0\) 扫到 \(n\)，直到符号测试不再为负，并把最后一个有效分支指标 \(K\) 保留下来。
接着计算余弦参数，把它截断到 \([-1,1]\) 以抵消浮点舍入漂移，再用 \(\arccos\) 还原 \(\alpha\)，最后返回 \(1/\cos\alpha\)。C++ 实现还会做两个健全性检查：先用二分法求圆形极限方程的根，再把正方形结果与已知参考值比对，然后才计算正六边形。
整个过程中不需要大表、不需要递归，也不需要数值优化。它本质上就是把上面的三角公式逐步翻译成代码。
对于正 \(n\) 边形，分支扫描最多检查 \(n+1\) 个整数，因此时间复杂度是 \(O(n)\)。其余操作都是常数时间的三角函数计算，所以多边形部分只使用 \(O(1)\) 额外空间。
圆形极限验证采用固定迭代次数的二分法，因此复杂度是 \(O(I)\)，其中 \(I\) 为常数，空间仍为 \(O(1)\)。对本题实际需要的 \(n=6\) 而言，整体计算可以视为常数时间。
Задача сводит геометрию Runner and Swimmer для правильного \(n\)-угольника к критической константе \(\lambda_n\). Реализации сначала проверяют два опорных случая, круговой предел и квадрат, а затем применяют ту же формулу к правильному шестиугольнику, который и требуется в задаче.
Это не имитационное моделирование. Вычисление распадается на конечный поиск правильной угловой ветви, затем на замкнутое восстановление угла \(\alpha\), а в конце на преобразование \(\lambda_n=1/\cos\alpha\).
Положим
$$\theta=\frac{\pi}{n}.$$
Вывод, заложенный в реализации, выражает критическое отношение через вспомогательный угол \(\alpha\). Формула кусочная, потому что геометрическая конфигурация меняется, когда \(2\alpha\) пересекает кратные \(\theta\).
Правильный \(n\)-угольник инвариантен относительно поворота на одну сторону и отражения относительно серединного перпендикуляра к стороне. Поэтому экстремальную конфигурацию можно описывать внутри одного полусектора с углом \(\theta=\pi/n\).
Вместо отслеживания полной траектории достаточно одного угла \(\alpha\), который кодирует критическую геометрию. Как только \(\alpha\) найден, искомая константа равна
$$\lambda_n=\frac{1}{\cos\alpha}.$$
Тем самым вся задача сводится к нахождению правильного \(\alpha\).
Тригонометрический вывод является кусочным. На каждой ветви целое число \(K\) показывает, сколько полных угловых шагов величины \(\theta\) пройдено до критической точки. Реализация определяет \(K\), просматривая \(k=0,1,\dots,n\) и вычисляя
$$f(k)=\sin(k\theta)-(k+n)\tan\theta\,\cos(k\theta).$$
Выбирается наибольшее \(K\), для которого выполнено
$$f(K)\lt 0.$$
Этот поиск обязательно заканчивается, поскольку
$$f(0)=-n\tan\theta\lt 0,\qquad f(n)=2n\tan\theta\gt 0.$$
Следовательно, между \(0\) и \(n\) обязательно происходит смена знака, а последнее отрицательное значение и задает правильную геометрическую ветвь.
Для фиксированной ветви \(K\) вся геометрия сводится к одному уравнению с косинусом:
$$\cos(2\alpha-K\theta)=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta).$$
Обозначим правую часть через \(A_K\). Тогда
$$A_K=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta),$$
и поэтому
$$\alpha=\frac12\left(K\theta+\arccos(A_K)\right).$$
В точной арифметике выбранная ветвь дает \(A_K\in[-1,1]\). В численном коде все равно полезно ограничить это значение данным интервалом до вызова \(\arccos\), чтобы погасить ошибки округления.
После восстановления \(\alpha\) ответ получается сразу:
$$\lambda_n=\frac{1}{\cos\alpha}.$$
Тем самым вычислительная схема для правильного многоугольника очень компактна: сначала линейный поиск по \(K\), затем один арккосинус и затем один обратный косинус в виде \(1/\cos\alpha\).
Для реального целевого случая \(n=6\) сканирование дает \(K=2\). При \(\theta=\pi/6\) получаем
$$A_2=\frac{2\sin(\pi/3)}{8\tan(\pi/6)}-\cos(\pi/3)=-\frac18,$$
так что константа шестиугольника равна
$$\lambda_6=\frac{1}{\cos\left(\frac12\left(\frac{\pi}{3}+\arccos\left(-\frac18\right)\right)\right)}.$$
Реализация на C++ дополнительно проверяет предельный круговой случай. При \(n\to\infty\) имеем \(\theta=\pi/n\to0\), а дискретная величина \(K\theta\) стремится к непрерывному углу \(\mu\). Используя
$$n\tan\left(\frac{\pi}{n}\right)\to\pi,$$
получаем, что граничное уравнение ветви \(f(K)=0\) переходит в
$$\sin\mu-(\mu+\pi)\cos\mu=0.$$
После деления на \(\cos\mu\) имеем
$$\tan\mu=\mu+\pi,$$
или эквивалентно
$$\mu+\pi-\tan\mu=0.$$
Когда \(\mu\) найден, предельная константа равна
$$\lambda_{\circ}=\frac{1}{\cos\mu}.$$
Именно это эталонное значение проверяется численно до перехода к многоугольнику.
Возьмем \(n=4\). Тогда \(\theta=\pi/4\) и \(\tan\theta=1\). Для проверки ветви имеем
$$f(0)=-4\lt 0,\qquad f(1)=\sin\left(\frac{\pi}{4}\right)-5\cos\left(\frac{\pi}{4}\right)=-2\sqrt2\lt 0,$$
$$f(2)=\sin\left(\frac{\pi}{2}\right)-6\cos\left(\frac{\pi}{2}\right)=1\gt 0.$$
Следовательно, \(K=1\). Аргумент косинуса равен
$$A_1=\frac{2\sin(\pi/4)}{5\tan(\pi/4)}-\cos(\pi/4)=\frac{\sqrt2}{5}-\frac{\sqrt2}{2}=-\frac{3\sqrt2}{10}.$$
Отсюда
$$\alpha=\frac12\left(\frac{\pi}{4}+\arccos\left(-\frac{3\sqrt2}{10}\right)\right),$$
и значит
$$\lambda_4=\frac{1}{\cos\alpha}\approx 5.78859314.$$
Это совпадает с квадратной проверкой, используемой в реализации, и показывает, что правило выбора ветви согласуется с замкнутой формулой.
Реализации на C++, Python и Java следуют одной и той же схеме. Для правильного \(n\)-угольника они вычисляют \(\theta=\pi/n\) и \(\tan\theta\), затем перебирают \(k=0\) до \(n\), пока знак теста остается отрицательным, и запоминают последний допустимый индекс ветви \(K\).
После этого вычисляется аргумент косинуса, он ограничивается интервалом \([-1,1]\) для компенсации погрешностей округления, затем через \(\arccos\) восстанавливается \(\alpha\), и возвращается \(1/\cos\alpha\). Реализация на C++ также делает две проверки корректности: решает уравнение кругового предела методом бисекции и сравнивает результат для квадрата с известным эталоном до вычисления случая шестиугольника.
Никаких больших таблиц, рекурсии или численной оптимизации здесь не требуется. Весь код представляет собой прямой перевод приведенных выше тригонометрических формул.
Для правильного \(n\)-угольника перебор ветвей занимает \(O(n)\) времени, поскольку проверяется не более \(n+1\) целых значений. Все остальные действия являются тригонометрическими вычислениями постоянной стоимости, поэтому дополнительная память равна \(O(1)\).
Проверка кругового предела использует бисекцию с фиксированным числом итераций, то есть имеет сложность \(O(I)\) при постоянном \(I\), и тоже требует \(O(1)\) памяти. Для фактического случая \(n=6\) вычисление по существу является константным.
تختزل هذه المسألة هندسة Runner and Swimmer في مضلع منتظم ذي \(n\) أضلاع إلى ثابت حرج \(\lambda_n\). وتتحقق التطبيقات أولًا من حالتين مرجعيتين، هما حد الدائرة وحالة المربع، ثم تطبق الصيغة نفسها على السداسي المنتظم، وهو المطلوب الفعلي في المسألة.
الحساب هنا ليس محاكاة عددية للمسار. بل يتكوّن من بحث منتهٍ عن الفرع الزاوي الصحيح، ثم إعادة بناء زاوية مساعدة \(\alpha\) بصيغة مغلقة، وأخيرًا تحويلها إلى \(\lambda_n=1/\cos\alpha\).
لنعرّف
$$\theta=\frac{\pi}{n}.$$
الاشتقاق المعتمد في التطبيق يعبّر عن النسبة الحرجة بواسطة الزاوية المساعدة \(\alpha\). وهذه الصيغة مقطعية، لأن البنية الهندسية تتغير كلما تجاوز \(2\alpha\) أحد مضاعفات \(\theta\).
المضلع المنتظم ثابت تحت الدوران بمقدار ضلع واحد، وثابت كذلك تحت الانعكاس حول العمود المنصف لأحد الأضلاع. لذلك يمكن وصف الوضع المتطرف داخل نصف قطاع واحد زاويته \(\theta=\pi/n\).
وبدل تتبع المسار كاملًا، يكفي استعمال زاوية واحدة \(\alpha\) تلخص الهندسة الحرجة. وما إن تُعرف \(\alpha\)، فإن الثابت المطلوب يساوي مباشرة
$$\lambda_n=\frac{1}{\cos\alpha}.$$
وهكذا تصبح المسألة كلها مسألة إيجاد القيمة الصحيحة لـ \(\alpha\).
الاشتقاق المثلثي مقطعي. وفي كل فرع يعدّ العدد الصحيح \(K\) عدد الخطوات الزاوية الكاملة من الحجم \(\theta\) التي تم تجاوزها قبل الوصول إلى الموضع الحرج. ويحدّد التطبيق هذا العدد عبر فحص \(k=0,1,\dots,n\) وحساب
$$f(k)=\sin(k\theta)-(k+n)\tan\theta\,\cos(k\theta).$$
ويُختار أكبر \(K\) يحقق
$$f(K)\lt 0.$$
وهذا الفحص لا بد أن يتوقف لأن
$$f(0)=-n\tan\theta\lt 0,\qquad f(n)=2n\tan\theta\gt 0.$$
إذًا يوجد تغير في الإشارة بين \(0\) و\(n\)، وآخر قيمة سالبة هي التي تحدد الفرع الهندسي الصحيح.
عند تثبيت الفرع \(K\)، تنكمش الهندسة إلى معادلة جيب تمام واحدة:
$$\cos(2\alpha-K\theta)=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta).$$
إذا رمزنا للطرف الأيمن بـ \(A_K\)، فإن
$$A_K=\frac{2\sin(K\theta)}{(K+n)\tan\theta}-\cos(K\theta),$$
ومن ثم
$$\alpha=\frac12\left(K\theta+\arccos(A_K)\right).$$
في الحساب الدقيق يجب أن يقع \(A_K\) داخل المجال \([-1,1]\). لكن من الناحية العددية يبقى من الحكمة قصّه إلى هذا المجال قبل تطبيق \(\arccos\) حتى لا تدفعه أخطاء التقريب خارجه.
بعد استرجاع \(\alpha\)، يصبح الجواب مباشرًا:
$$\lambda_n=\frac{1}{\cos\alpha}.$$
وبذلك تصبح صيغة الحساب في حالة المضلع المنتظم مضغوطة جدًا: مسح خطي لإيجاد \(K\)، ثم جيب تمام عكسي واحد، ثم مقلوب جيب تمام واحد.
في الحالة المطلوبة فعلًا \(n=6\)، يعطي المسح \(K=2\). وبالتعويض عن \(\theta=\pi/6\) نحصل على
$$A_2=\frac{2\sin(\pi/3)}{8\tan(\pi/6)}-\cos(\pi/3)=-\frac18,$$
ومن ثم يكون ثابت السداسي
$$\lambda_6=\frac{1}{\cos\left(\frac12\left(\frac{\pi}{3}+\arccos\left(-\frac18\right)\right)\right)}.$$
تتحقق نسخة C++ أيضًا من الحالة الحدية الدائرية. عندما \(n\to\infty\)، يكون \(\theta=\pi/n\to0\)، وتقترب الكمية المنفصلة \(K\theta\) من زاوية متصلة نرمز لها بـ \(\mu\). وباستخدام
$$n\tan\left(\frac{\pi}{n}\right)\to\pi,$$
تتحول معادلة حد الفرع \(f(K)=0\) إلى
$$\sin\mu-(\mu+\pi)\cos\mu=0.$$
وبالقسمة على \(\cos\mu\) نحصل على
$$\tan\mu=\mu+\pi,$$
أو بصورة مكافئة
$$\mu+\pi-\tan\mu=0.$$
وبمجرد إيجاد \(\mu\)، يكون الثابت الحدي
$$\lambda_{\circ}=\frac{1}{\cos\mu}.$$
وهذه هي القيمة المرجعية نفسها التي تُفحص عدديًا قبل الانتقال إلى حالة المضلع.
لنأخذ \(n=4\). عندئذٍ \(\theta=\pi/4\) و\(\tan\theta=1\). وبالنسبة لاختبار الفرع نجد
$$f(0)=-4\lt 0,\qquad f(1)=\sin\left(\frac{\pi}{4}\right)-5\cos\left(\frac{\pi}{4}\right)=-2\sqrt2\lt 0,$$
$$f(2)=\sin\left(\frac{\pi}{2}\right)-6\cos\left(\frac{\pi}{2}\right)=1\gt 0.$$
إذًا \(K=1\). ويصبح وسيط جيب التمام
$$A_1=\frac{2\sin(\pi/4)}{5\tan(\pi/4)}-\cos(\pi/4)=\frac{\sqrt2}{5}-\frac{\sqrt2}{2}=-\frac{3\sqrt2}{10}.$$
ومن هنا
$$\alpha=\frac12\left(\frac{\pi}{4}+\arccos\left(-\frac{3\sqrt2}{10}\right)\right),$$
وبالتالي
$$\lambda_4=\frac{1}{\cos\alpha}\approx 5.78859314.$$
وهذا يطابق تحقق المربع المستخدم في التطبيق، ويؤكد أن قاعدة اختيار الفرع منسجمة مع الصيغة المغلقة.
تتبع تطبيقات C++ وPython وJava البنية نفسها. ففي حالة مضلع منتظم ذي \(n\) أضلاع، تحسب أولًا \(\theta=\pi/n\) و\(\tan\theta\)، ثم تمسح القيم من \(k=0\) إلى \(n\) حتى يتوقف اختبار الإشارة عن كونه سالبًا، وتحتفظ بآخر مؤشر فرع صالح \(K\).
بعد ذلك تحسب وسيط جيب التمام، وتقصه إلى \([-1,1]\) لمنع انجرافات التقريب العائم، ثم تستعيد \(\alpha\) بواسطة \(\arccos\)، وأخيرًا تعيد \(1/\cos\alpha\). وتضيف نسخة C++ اختبارين للتحقق: تحل معادلة حد الدائرة بطريقة التنصيف، وتقارن نتيجة المربع بالقيمة المرجعية المعروفة قبل حساب حالة السداسي.
لا توجد جداول كبيرة ولا عودية ولا تحسين عددي تكراري. فالحساب كله ترجمة مباشرة للعلاقات المثلثية المذكورة أعلاه.
في حالة مضلع منتظم ذي \(n\) أضلاع، يكلف مسح الفروع \(O(n)\) زمنيًا لأنه يفحص على الأكثر \(n+1\) قيمة صحيحة. أما بقية العمل فهو تقييمات مثلثية بزمن ثابت، لذا يستهلك حساب المضلع ذاكرة إضافية من الرتبة \(O(1)\).
ويستخدم تحقق حد الدائرة طريقة التنصيف بعدد ثابت من التكرارات، لذا فهو \(O(I)\) مع \(I\) ثابت، وبذاكرة \(O(1)\) أيضًا. وفي الحالة الفعلية للمسألة حيث \(n=6\)، يكون الحساب كله عمليًا بزمن ثابت.