Problem 836 is not a large-scale numerical search. The statement hides its answer inside a fixed ordered list of bold mathematical words. The task is to read those words in order, take the first letter of each one, normalize the letter to lowercase, and concatenate the letters into a single string.
Because the word list is fixed, there is no optimization, no branching search, and no number-theoretic trick. The entire challenge is recognizing the correct deterministic extraction rule and applying it without disturbing the original order of the words.
Let the ordered word list be
affine, plane, radically, integral, local, field, open, oriented, line, section, jacobian, orthogonal, kernel, embedding.
Write this as
$$W=(w_1,w_2,\dots,w_{14}).$$
For each word define the extracted character by
$$c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
The target answer is then
$$A=c_1c_2\cdots c_{14}.$$
The order of the words is part of the data. If the words were rearranged, the resulting string would change, so the solution must treat the list as an ordered 14-tuple rather than as an unordered set.
In symbols, the extraction is positional: the contribution of \(w_i\) must become the \(i\)-th character of the output.
Each word contributes exactly one character, namely its first letter. Lowercasing makes the mapping uniform even if the source text had mixed capitalization. Formally, the map
$$w_i\longmapsto c_i=\operatorname{lower}(\operatorname{first}(w_i))$$
sends every non-empty word to one lowercase character.
Since all 14 source words are non-empty, the map is well-defined for every entry of the list.
Applying the rule to the 14 words gives
$$\begin{aligned} c_1&=a,& c_2&=p,& c_3&=r,& c_4&=i,& c_5&=l,\\ c_6&=f,& c_7&=o,& c_8&=o,& c_9&=l,& c_{10}&=s,\\ c_{11}&=j,& c_{12}&=o,& c_{13}&=k,& c_{14}&=e. \end{aligned}$$
So the extracted character sequence is
$$\left(a,p,r,i,l,f,o,o,l,s,j,o,k,e\right).$$
Now concatenate the characters in the same order:
$$A=c_1c_2\cdots c_{14}=\text{aprilfoolsjoke}.$$
A useful way to see the structure is to group the letters into natural chunks:
$$A=\underbrace{\text{april}}_{1-5}\underbrace{\text{fools}}_{6-10}\underbrace{\text{joke}}_{11-14}.$$
Thus the hidden message is the phrase “aprilfoolsjoke”.
There is only one ordered list and only one deterministic rule. Every index contributes exactly one lowercase initial, and concatenation preserves order. Therefore the resulting string is unique, and no alternative interpretation is needed once the extraction rule is identified.
Mathematically, this is a direct composition of three simple functions: ordered lookup, first-character extraction, and lowercase normalization, followed by concatenation.
Take the first five words:
affine, plane, radically, integral, local.
Their initials are \(a,p,r,i,l\), so they already form
$$\text{april}.$$
The next five words,
field, open, oriented, line, section,
produce \(f,o,o,l,s\), which gives
$$\text{fools}.$$
The last four words,
jacobian, orthogonal, kernel, embedding,
produce \(j,o,k,e\), which gives
$$\text{joke}.$$
Combining the three groups yields
$$\text{april}+\text{fools}+\text{joke}=\text{aprilfoolsjoke}.$$
The C++, Python, and Java implementations all use the same fixed ordered list of 14 words. They perform a single left-to-right pass over that list, read the first character of each word, convert it to lowercase, and append it to an output string.
One implementation also includes a sanity check that each word is non-empty before reading its initial. After the pass finishes, the implementation prints or returns the concatenated result “aprilfoolsjoke”. The code is therefore a direct transcription of the mathematical mapping above rather than a search procedure.
If the problem is written in general form for \(n\) words with total text length \(L\), then extracting one initial per word takes \(O(n)\) time after tokenization, or \(O(L)\) if the parsing step is counted. Building the output string needs \(O(n)\) space.
For the actual Project Euler instance, \(n=14\) is fixed in advance. That means the real running time and extra memory usage are both constant: \(O(1)\).
Problem 836 ist keine umfangreiche numerische Suche. Die Aufgabenstellung versteckt die Lösung in einer festen geordneten Liste fett gedruckter mathematischer Begriffe. Gesucht ist die Zeichenkette, die entsteht, wenn man die Anfangsbuchstaben dieser Wörter der Reihe nach nimmt, in Kleinbuchstaben umwandelt und direkt aneinanderhängt.
Weil die Wortliste fest vorgegeben ist, gibt es weder Optimierung noch Verzweigungen noch Zahlentricks. Entscheidend ist nur, die deterministische Extraktionsregel korrekt zu erkennen und die Reihenfolge der Wörter unverändert zu lassen.
Die geordnete Wortliste lautet
affine, plane, radically, integral, local, field, open, oriented, line, section, jacobian, orthogonal, kernel, embedding.
Schreibe sie als
$$W=(w_1,w_2,\dots,w_{14}).$$
Für jedes Wort definieren wir das extrahierte Zeichen durch
$$c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
Die gesuchte Antwort ist damit
$$A=c_1c_2\cdots c_{14}.$$
Die Reihenfolge ist Teil der Information. Schon eine Vertauschung zweier Wörter würde die Ausgabekette verändern. Deshalb behandeln wir die Daten als geordnetes 14-Tupel und nicht als ungeordnete Menge.
Positionsgenau bedeutet hier: Das Wort \(w_i\) liefert genau das \(i\)-te Zeichen der Antwort.
Jedes Wort steuert genau ein Zeichen bei, nämlich seinen ersten Buchstaben. Die Umwandlung in Kleinbuchstaben macht die Vorschrift unabhängig von eventueller Großschreibung im Quelltext. Formal lautet die Abbildung
$$w_i\longmapsto c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
Da alle 14 Wörter nicht leer sind, ist diese Abbildung für jeden Eintrag wohldefiniert.
Die Regel liefert für die 14 Wörter
$$\begin{aligned} c_1&=a,& c_2&=p,& c_3&=r,& c_4&=i,& c_5&=l,\\ c_6&=f,& c_7&=o,& c_8&=o,& c_9&=l,& c_{10}&=s,\\ c_{11}&=j,& c_{12}&=o,& c_{13}&=k,& c_{14}&=e. \end{aligned}$$
Damit entsteht die Zeichenfolge
$$\left(a,p,r,i,l,f,o,o,l,s,j,o,k,e\right).$$
Nun werden die Zeichen in derselben Reihenfolge zusammengesetzt:
$$A=c_1c_2\cdots c_{14}=\text{aprilfoolsjoke}.$$
Anschaulich kann man das in drei sinnvolle Blöcke zerlegen:
$$A=\underbrace{\text{april}}_{1-5}\underbrace{\text{fools}}_{6-10}\underbrace{\text{joke}}_{11-14}.$$
Die versteckte Botschaft ist also „aprilfoolsjoke“.
Es gibt genau eine geordnete Wortliste und genau eine deterministische Vorschrift. Jeder Index liefert genau einen Kleinbuchstaben, und die Konkatenation erhält die Reihenfolge. Dadurch ist das Ergebnis eindeutig bestimmt; weitere Fallunterscheidungen oder Alternativen sind nicht nötig.
Mathematisch ist die Lösung einfach die Komposition aus geordnetem Zugriff, Extraktion des ersten Zeichens, Umwandlung in Kleinbuchstaben und anschließender Verkettung.
Betrachte zuerst die ersten fünf Wörter:
affine, plane, radically, integral, local.
Ihre Initialen sind \(a,p,r,i,l\), also
$$\text{april}.$$
Die nächsten fünf Wörter,
field, open, oriented, line, section,
liefern \(f,o,o,l,s\), also
$$\text{fools}.$$
Die letzten vier Wörter,
jacobian, orthogonal, kernel, embedding,
geben \(j,o,k,e\), also
$$\text{joke}.$$
Zusammen folgt
$$\text{april}+\text{fools}+\text{joke}=\text{aprilfoolsjoke}.$$
Die Implementierungen in C++, Python und Java benutzen dieselbe feste geordnete Liste von 14 Wörtern. Danach durchlaufen sie die Liste genau einmal von links nach rechts, lesen jeweils das erste Zeichen, wandeln es in Kleinbuchstaben um und hängen es an eine Ausgabekette an.
Eine Implementierung enthält zusätzlich eine Sicherheitsprüfung, dass kein Wort leer ist, bevor der Anfangsbuchstabe gelesen wird. Nach dem Durchlauf wird das Ergebnis „aprilfoolsjoke“ ausgegeben oder zurückgegeben. Der Code ist also eine direkte Umsetzung der oben beschriebenen Abbildung und kein Suchalgorithmus.
In einer allgemeinen Formulierung mit \(n\) Wörtern und gesamter Textlänge \(L\) kostet die Extraktion der Anfangsbuchstaben \(O(n)\) Zeit nach der Tokenisierung oder \(O(L)\), wenn das Einlesen mitgezählt wird. Für die Ergebniszeichenkette werden \(O(n)\) Speicher benötigt.
Im konkreten Euler-Problem ist \(n=14\) jedoch fest. Deshalb sind reale Laufzeit und zusätzlicher Speicher konstant, also \(O(1)\).
Problem 836 büyük bir sayısal arama problemi değildir. Soru metni, çözümü kalın yazılmış matematiksel terimlerden oluşan sabit sıralı bir listenin içine gizler. Yapılması gereken şey, bu kelimeleri verilen sırayla okuyup her birinin ilk harfini almak, harfi küçük harfe çevirmek ve tüm harfleri tek bir dizgede birleştirmektir.
Kelime listesi sabit olduğu için burada optimizasyon, olasılıksal arama veya sayı kuramına dayalı bir kısayol yoktur. Esas nokta, deterministik çıkarım kuralını doğru fark etmek ve sırayı hiç bozmamaktır.
Sıralı kelime listesi şudur:
affine, plane, radically, integral, local, field, open, oriented, line, section, jacobian, orthogonal, kernel, embedding.
Bunu
$$W=(w_1,w_2,\dots,w_{14})$$
şeklinde gösterelim. Her kelime için çıkarılan karakteri
$$c_i=\operatorname{lower}(\operatorname{first}(w_i))$$
olarak tanımlayalım. O zaman hedef çıktı
$$A=c_1c_2\cdots c_{14}$$
olur.
Kelime sırası verinin bir parçasıdır. İki kelimenin yerini değiştirmek bile oluşan dizgeyi değiştirir. Bu yüzden listeyi sırasız bir küme gibi değil, sıralı bir 14'lü olarak ele almalıyız.
Başka bir deyişle \(w_i\) kelimesi, cevabın tam olarak \(i\). karakterine katkı yapar.
Her kelime yalnızca bir karakter üretir: ilk harfi. Küçük harfe çevirme işlemi, kaynak metinde büyük-küçük harf farkı olsa bile kuralı tek biçimli hale getirir. Dönüşüm
$$w_i\longmapsto c_i=\operatorname{lower}(\operatorname{first}(w_i))$$
şeklindedir. Listedeki 14 kelimenin hiçbiri boş olmadığı için bu dönüşüm her giriş için tanımlıdır.
Kural uygulandığında şu harfler elde edilir:
$$\begin{aligned} c_1&=a,& c_2&=p,& c_3&=r,& c_4&=i,& c_5&=l,\\ c_6&=f,& c_7&=o,& c_8&=o,& c_9&=l,& c_{10}&=s,\\ c_{11}&=j,& c_{12}&=o,& c_{13}&=k,& c_{14}&=e. \end{aligned}$$
Dolayısıyla elde edilen karakter dizisi
$$\left(a,p,r,i,l,f,o,o,l,s,j,o,k,e\right)$$
olur.
Şimdi bu karakterleri aynı sırayla yan yana yazarız:
$$A=c_1c_2\cdots c_{14}=\text{aprilfoolsjoke}.$$
Bu sonucu üç anlamlı parçaya ayırmak da mümkündür:
$$A=\underbrace{\text{april}}_{1-5}\underbrace{\text{fools}}_{6-10}\underbrace{\text{joke}}_{11-14}.$$
Böylece gizli mesajın “aprilfoolsjoke” olduğu görülür.
Ortada tek bir sıralı liste ve tek bir deterministik kural vardır. Her indeks tam bir küçük harf üretir ve birleştirme işlemi sırayı korur. Bu nedenle sonuç tektir; başka yorumlara veya ek aramaya gerek kalmaz.
Matematiksel açıdan çözüm, sıralı erişim, ilk karakter çıkarma, küçük harfe dönüştürme ve ardından birleştirme işlemlerinin bileşimidir.
İlk beş kelimeyi ele alalım:
affine, plane, radically, integral, local.
Baş harfleri \(a,p,r,i,l\) olur ve bunlar
$$\text{april}$$
kelimesini verir.
Sonraki beş kelime,
field, open, oriented, line, section,
\(f,o,o,l,s\) üretir; bu da
$$\text{fools}$$
olur.
Son dört kelime,
jacobian, orthogonal, kernel, embedding,
\(j,o,k,e\) üretir; bu da
$$\text{joke}$$
şeklindedir.
Üç parça birleşince
$$\text{april}+\text{fools}+\text{joke}=\text{aprilfoolsjoke}$$
elde edilir.
C++, Python ve Java uygulamalarının üçü de aynı sabit sıralı 14 kelimelik listeyi kullanır. Daha sonra bu liste üzerinde soldan sağa tek bir tur atarlar, her kelimenin ilk karakterini okurlar, onu küçük harfe çevirirler ve çıktı dizgesine eklerler.
Uygulamalardan biri, ilk harfi okumadan önce her kelimenin boş olmadığını doğrulayan bir güvenlik kontrolü de yapar. Tur tamamlanınca çıktı olarak “aprilfoolsjoke” yazdırılır ya da döndürülür. Yani kod, yukarıdaki matematiksel eşlemenin doğrudan uygulanmış halidir; bir arama algoritması değildir.
Genel biçimde \(n\) kelime ve toplam metin uzunluğu \(L\) varsa, her kelimeden bir baş harf çıkarmak parçalama sonrasında \(O(n)\) zaman alır; okuma da sayılırsa maliyet \(O(L)\) olarak görülebilir. Çıktı dizgesi için gereken bellek \(O(n)\)'dir.
Ancak gerçek Euler örneğinde \(n=14\) sabit olduğundan, fiili çalışma süresi ve ek bellek kullanımı sabittir: \(O(1)\).
El Problema 836 no es una búsqueda numérica pesada. El enunciado esconde la respuesta dentro de una lista fija y ordenada de términos matemáticos en negrita. La tarea consiste en leer esas palabras en el orden dado, tomar la primera letra de cada una, convertirla a minúscula y concatenar todas las letras en una sola cadena.
Como la lista de palabras es fija, no hay optimización, ni ramificación, ni truco aritmético. Todo se reduce a identificar correctamente una regla de extracción completamente determinista y respetar el orden original.
La lista ordenada de palabras es
affine, plane, radically, integral, local, field, open, oriented, line, section, jacobian, orthogonal, kernel, embedding.
La escribimos como
$$W=(w_1,w_2,\dots,w_{14}).$$
Para cada palabra definimos el carácter extraído mediante
$$c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
Entonces la respuesta buscada es
$$A=c_1c_2\cdots c_{14}.$$
El orden es parte esencial de la información. Si las palabras se reordenaran, la cadena resultante cambiaría. Por eso hay que tratar la entrada como una 14-tupla ordenada y no como un conjunto sin orden.
En particular, la contribución de \(w_i\) debe ocupar exactamente la posición \(i\) del resultado final.
Cada palabra aporta exactamente un carácter: su primera letra. Pasar a minúscula unifica la regla aunque hubiera diferencias de capitalización en el texto original. Formalmente, usamos
$$w_i\longmapsto c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
Como las 14 palabras son no vacías, la función está bien definida para cada entrada.
Al aplicar la regla a todas las palabras obtenemos
$$\begin{aligned} c_1&=a,& c_2&=p,& c_3&=r,& c_4&=i,& c_5&=l,\\ c_6&=f,& c_7&=o,& c_8&=o,& c_9&=l,& c_{10}&=s,\\ c_{11}&=j,& c_{12}&=o,& c_{13}&=k,& c_{14}&=e. \end{aligned}$$
La secuencia de caracteres es, por tanto,
$$\left(a,p,r,i,l,f,o,o,l,s,j,o,k,e\right).$$
Ahora concatenamos los caracteres en el mismo orden:
$$A=c_1c_2\cdots c_{14}=\text{aprilfoolsjoke}.$$
También es útil verla como tres bloques con sentido:
$$A=\underbrace{\text{april}}_{1-5}\underbrace{\text{fools}}_{6-10}\underbrace{\text{joke}}_{11-14}.$$
Así se ve claramente que el mensaje oculto es “aprilfoolsjoke”.
Solo hay una lista ordenada y una regla determinista. Cada índice produce exactamente una letra minúscula y la concatenación preserva el orden. Por tanto, el resultado es único y no hace falta considerar interpretaciones alternativas una vez detectada la regla correcta.
Desde el punto de vista matemático, la solución es la composición de acceso posicional, extracción de la primera letra, normalización a minúsculas y concatenación.
Tomemos primero las cinco palabras iniciales:
affine, plane, radically, integral, local.
Sus iniciales son \(a,p,r,i,l\), que forman
$$\text{april}.$$
Las cinco siguientes,
field, open, oriented, line, section,
producen \(f,o,o,l,s\), es decir,
$$\text{fools}.$$
Las cuatro últimas,
jacobian, orthogonal, kernel, embedding,
dan \(j,o,k,e\), es decir,
$$\text{joke}.$$
Al unir los tres bloques obtenemos
$$\text{april}+\text{fools}+\text{joke}=\text{aprilfoolsjoke}.$$
Las implementaciones en C++, Python y Java utilizan la misma lista fija y ordenada de 14 palabras. Luego hacen un único recorrido de izquierda a derecha, toman el primer carácter de cada palabra, lo convierten a minúscula y lo añaden a una cadena de salida.
Una de las implementaciones añade además una comprobación de seguridad para asegurar que cada palabra es no vacía antes de leer su inicial. Al final del recorrido, la implementación imprime o devuelve “aprilfoolsjoke”. Por eso el programa es una traducción directa de la regla matemática y no un procedimiento de búsqueda.
En una formulación general con \(n\) palabras y longitud total \(L\), extraer una inicial por palabra cuesta \(O(n)\) tiempo después de la tokenización, o \(O(L)\) si también se cuenta el análisis del texto. La cadena resultado ocupa \(O(n)\) memoria.
En la instancia real de Project Euler, \(n=14\) está fijado de antemano. Por ello, el tiempo real y la memoria extra son constantes: \(O(1)\).
第 836 题并不是那种需要大规模枚举、筛法优化或高精度数值技巧的题目。它的核心其实是一个完全确定的文本提取规则：题目给出了一组按顺序出现的加粗数学术语，我们只需要依次读取这些词，取出每个词的首字母，将其统一转成小写，然后按原顺序拼接成一个字符串。
因此，本题真正考查的不是计算量，而是对题面结构的识别能力。只要看出“答案藏在这些词的首字母里”这一点，后面的过程就没有分支、没有搜索、没有近似误差，只有一步一步的确定性映射。
按顺序给出的单词列表为
affine, plane, radically, integral, local, field, open, oriented, line, section, jacobian, orthogonal, kernel, embedding。
把它记作
$$W=(w_1,w_2,\dots,w_{14}).$$
对每个单词定义提取出来的字符
$$c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
那么最终答案就是
$$A=c_1c_2\cdots c_{14}.$$
也就是说，这道题本质上是“从有序词列到字符串”的映射问题。
顺序在这里非常关键。如果把这些词打乱，即使单词本身完全相同，最后拼出来的字符串也会改变。因此我们不能把它们当成一个集合，而必须把它们看成一个有顺序的 14 元组。
这意味着第 \(i\) 个单词 \(w_i\) 的贡献，必须出现在答案的第 \(i\) 个位置。位置本身就是信息的一部分。
每个单词只贡献一个字符，也就是它的首字母。为了避免大小写差异影响结果，我们再做一次统一的小写化处理，于是有
$$w_i\longmapsto c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
这个规则对所有非空单词都成立。题目中给出的 14 个词都不是空串，所以这个映射在每一个位置上都定义良好，不存在歧义。
按顺序执行上面的规则，可以得到
$$\begin{aligned} c_1&=a,& c_2&=p,& c_3&=r,& c_4&=i,& c_5&=l,\\ c_6&=f,& c_7&=o,& c_8&=o,& c_9&=l,& c_{10}&=s,\\ c_{11}&=j,& c_{12}&=o,& c_{13}&=k,& c_{14}&=e. \end{aligned}$$
所以得到的字符序列就是
$$\left(a,p,r,i,l,f,o,o,l,s,j,o,k,e\right).$$
这一步已经把题目从“看起来像数学术语堆叠的文本”转换成了“确定的字符流”。
把这些字符依次连接起来，就得到
$$A=c_1c_2\cdots c_{14}=\text{aprilfoolsjoke}.$$
如果按语义再分组，可以看得更清楚：
$$A=\underbrace{\text{april}}_{1-5}\underbrace{\text{fools}}_{6-10}\underbrace{\text{joke}}_{11-14}.$$
因此隐藏的信息就是“aprilfoolsjoke”，也就是 “April Fools Joke” 的无空格小写形式。
本题没有第二层隐藏计算。题目只给出了一组固定顺序的词，而规则又是唯一的：每个位置取一个首字母、统一小写、保持原顺序拼接。于是结果只能有一个，不存在“还要继续推导”的分支。
从数学表达上看，这就是几个简单操作的复合：按索引读取、提取首字符、大小写归一化、最后做串联。每一步都确定，因此整体也是确定的。
先看前五个词：
affine, plane, radically, integral, local。
它们的首字母分别是 \(a,p,r,i,l\)，正好组成
$$\text{april}.$$
再看接下来的五个词：
field, open, oriented, line, section。
它们给出 \(f,o,o,l,s\)，于是得到
$$\text{fools}.$$
最后四个词：
jacobian, orthogonal, kernel, embedding。
对应的首字母是 \(j,o,k,e\)，于是得到
$$\text{joke}.$$
三段合并后就是
$$\text{april}+\text{fools}+\text{joke}=\text{aprilfoolsjoke}.$$
这个例子不仅给出了答案，也说明了为什么分段理解能帮助我们更快看出隐藏短语。
C++、Python 和 Java 三个实现都采用同样的思路：先把这 14 个单词按固定顺序保存下来，然后从左到右遍历一次。遍历到某个词时，读取它的首字符，将其转为小写，再追加到结果字符串后面。
其中一个实现还额外做了一个简单的健全性检查，确认每个单词都不是空串，然后才读取首字母。遍历结束后，程序输出或返回的就是“aprilfoolsjoke”。因此，实现层面并没有任何搜索、回溯或复杂状态管理，它只是把上面的数学规则逐步执行出来。
如果把问题写成一般形式，设共有 \(n\) 个单词，总文本长度为 \(L\)。那么在单词已经分好之后，提取每个词的首字母需要 \(O(n)\) 时间；如果把读入和切分文本也算进去，则可以记为 \(O(L)\)。结果字符串长度为 \(n\)，因此额外空间为 \(O(n)\)。
不过在本题的实际实例里，单词数量固定为 \(14\)。所以真实运行时的时间和额外空间都可以看成常数，即 \(O(1)\)。
Задача 836 не требует тяжёлых численных вычислений, перебора или хитрой оптимизации. Ответ спрятан в фиксированном упорядоченном списке математических терминов, выделенных в тексте. Нужно пройти по этим словам слева направо, взять первую букву каждого слова, перевести её в нижний регистр и склеить все буквы в одну строку.
Итак, суть задачи не в вычислительной сложности, а в распознавании точного правила извлечения. Как только это правило замечено, дальнейшее решение становится полностью детерминированным.
Упорядоченный список слов таков:
affine, plane, radically, integral, local, field, open, oriented, line, section, jacobian, orthogonal, kernel, embedding.
Обозначим его через
$$W=(w_1,w_2,\dots,w_{14}).$$
Для каждого слова определим извлечённый символ формулой
$$c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
Тогда искомая строка равна
$$A=c_1c_2\cdots c_{14}.$$
Порядок слов является частью условия. Если переставить хотя бы два слова, получится другая строка. Поэтому вход нужно рассматривать не как множество, а как упорядоченный 14-кортеж.
Это значит, что слово \(w_i\) обязано дать ровно \(i\)-й символ ответа.
Каждое слово даёт один символ, а именно свою первую букву. Приведение к нижнему регистру делает правило единообразным независимо от исходной капитализации. Формально используется отображение
$$w_i\longmapsto c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
Все 14 слов непустые, следовательно, отображение корректно определено для каждого элемента списка.
Последовательное применение правила даёт
$$\begin{aligned} c_1&=a,& c_2&=p,& c_3&=r,& c_4&=i,& c_5&=l,\\ c_6&=f,& c_7&=o,& c_8&=o,& c_9&=l,& c_{10}&=s,\\ c_{11}&=j,& c_{12}&=o,& c_{13}&=k,& c_{14}&=e. \end{aligned}$$
Значит, получается последовательность
$$\left(a,p,r,i,l,f,o,o,l,s,j,o,k,e\right).$$
Теперь просто конкатенируем символы в исходном порядке:
$$A=c_1c_2\cdots c_{14}=\text{aprilfoolsjoke}.$$
Полезно увидеть здесь три естественных блока:
$$A=\underbrace{\text{april}}_{1-5}\underbrace{\text{fools}}_{6-10}\underbrace{\text{joke}}_{11-14}.$$
Следовательно, скрытая фраза равна «aprilfoolsjoke».
В задаче нет дополнительного вычислительного слоя. Есть единственный фиксированный список и единственное детерминированное правило извлечения. Каждый индекс даёт одну букву, а конкатенация сохраняет порядок, поэтому результат определяется однозначно.
С математической точки зрения это композиция нескольких простых операций: позиционный доступ, взятие первого символа, нормализация регистра и склейка строки.
Сначала рассмотрим первые пять слов:
affine, plane, radically, integral, local.
Их начальные буквы равны \(a,p,r,i,l\), то есть образуют
$$\text{april}.$$
Следующие пять слов,
field, open, oriented, line, section,
дают \(f,o,o,l,s\), то есть
$$\text{fools}.$$
Последние четыре слова,
jacobian, orthogonal, kernel, embedding,
дают \(j,o,k,e\), то есть
$$\text{joke}.$$
Складывая три блока, получаем
$$\text{april}+\text{fools}+\text{joke}=\text{aprilfoolsjoke}.$$
Реализации на C++, Python и Java используют один и тот же фиксированный упорядоченный список из 14 слов. Затем они делают один проход слева направо, берут первый символ каждого слова, переводят его в нижний регистр и добавляют к результирующей строке.
В одной из реализаций есть дополнительная проверка того, что слово не пустое, прежде чем брать его первую букву. После завершения прохода программа печатает или возвращает строку «aprilfoolsjoke». Поэтому код представляет собой прямую реализацию описанного правила, а не поиск по вариантам.
Если записать задачу в общем виде для \(n\) слов суммарной длины \(L\), то извлечение одной начальной буквы из каждого слова занимает \(O(n)\) времени после разбиения текста на слова, либо \(O(L)\), если включить и само чтение текста. Для хранения результата требуется \(O(n)\) памяти.
Но в реальной постановке Project Euler число слов заранее фиксировано и равно \(14\). Значит, фактические время работы и дополнительная память являются константами, то есть \(O(1)\).
المسألة 836 ليست مسألة بحث عددي ضخم ولا تعتمد على تحسين حسابي معقد. الفكرة الحقيقية هي أن نص المسألة يخفي الجواب داخل قائمة ثابتة ومرتبة من مصطلحات رياضية مكتوبة بخط بارز. المطلوب هو قراءة هذه الكلمات بالترتيب، أخذ الحرف الأول من كل كلمة، تحويله إلى حرف صغير، ثم لصق جميع الحروف في سلسلة واحدة.
لذلك فجوهر الحل ليس حسابًا ثقيلًا، بل التعرّف إلى قاعدة استخراج حتمية تمامًا. بعد اكتشاف هذه القاعدة لا يبقى أي تفرع أو تخمين أو تقريب؛ كل خطوة محددة مسبقًا.
قائمة الكلمات المرتبة هي:
affine, plane, radically, integral, local, field, open, oriented, line, section, jacobian, orthogonal, kernel, embedding.
لنرمز إليها بـ
$$W=(w_1,w_2,\dots,w_{14}).$$
ونعرّف الحرف المستخرج من كل كلمة بالعلاقة
$$c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
وعندئذ تكون السلسلة المطلوبة
$$A=c_1c_2\cdots c_{14}.$$
الترتيب هنا جزء من البيانات نفسها. لو بدّلنا موضع كلمتين فقط لتغيّرت السلسلة الناتجة. لذلك يجب التعامل مع القائمة على أنها 14-ترتيبًا مرتبًا، لا مجموعة غير مرتبة.
هذا يعني أن مساهمة الكلمة \(w_i\) يجب أن تظهر في الموضع \(i\) من الجواب النهائي.
كل كلمة تساهم بحرف واحد فقط، وهو أول حرف فيها. ثم نحول هذا الحرف إلى lowercase حتى تصبح القاعدة موحّدة حتى لو وُجد اختلاف في الكتابة الكبيرة والصغيرة. صياغة ذلك هي
$$w_i\longmapsto c_i=\operatorname{lower}(\operatorname{first}(w_i)).$$
وبما أن جميع الكلمات الأربع عشرة غير فارغة، فهذه الدالة معرّفة بشكل صحيح على كل عنصر من عناصر القائمة.
عند تطبيق القاعدة على الكلمات كلها نحصل على
$$\begin{aligned} c_1&=a,& c_2&=p,& c_3&=r,& c_4&=i,& c_5&=l,\\ c_6&=f,& c_7&=o,& c_8&=o,& c_9&=l,& c_{10}&=s,\\ c_{11}&=j,& c_{12}&=o,& c_{13}&=k,& c_{14}&=e. \end{aligned}$$
إذن تسلسل الحروف الناتج هو
$$\left(a,p,r,i,l,f,o,o,l,s,j,o,k,e\right).$$
نلصق الحروف الآن بنفس الترتيب فنحصل على
$$A=c_1c_2\cdots c_{14}=\text{aprilfoolsjoke}.$$
ومن المفيد أيضًا رؤية البنية على شكل ثلاث مقاطع ذات معنى:
$$A=\underbrace{\text{april}}_{1-5}\underbrace{\text{fools}}_{6-10}\underbrace{\text{joke}}_{11-14}.$$
وبذلك يتضح أن الرسالة المخفية هي «aprilfoolsjoke».
لا توجد طبقة حسابية إضافية مخفية بعد هذه الخطوات. لدينا قائمة مرتبة واحدة وقاعدة استخراج واحدة حتمية. كل موضع يعطي حرفًا واحدًا، وعملية اللصق تحفظ الترتيب، لذا فالنتيجة وحيدة بالكامل.
ومن الناحية الرياضية يمكن النظر إلى الحل على أنه تركيب لعدة عمليات بسيطة: الوصول الموضعي، أخذ الحرف الأول، توحيد حالة الأحرف، ثم concatenation للسلسلة.
لنأخذ أول خمس كلمات أولًا:
affine, plane, radically, integral, local.
حروفها الأولى هي \(a,p,r,i,l\)، وهذا يعطينا
$$\text{april}.$$
أما الكلمات الخمس التالية،
field, open, oriented, line, section,
فتعطي \(f,o,o,l,s\)، أي
$$\text{fools}.$$
والكلمات الأربع الأخيرة،
jacobian, orthogonal, kernel, embedding,
تعطي \(j,o,k,e\)، أي
$$\text{joke}.$$
وعند جمع المقاطع الثلاثة نحصل على
$$\text{april}+\text{fools}+\text{joke}=\text{aprilfoolsjoke}.$$
تستخدم تطبيقات C++ وPython وJava القائمة المرتبة نفسها المكوّنة من 14 كلمة. بعد ذلك تنفذ مرورًا واحدًا من اليسار إلى اليمين، وتأخذ أول حرف من كل كلمة، وتحوله إلى حرف صغير، ثم تضيفه إلى سلسلة الخرج.
أحد التطبيقات يضيف أيضًا فحصًا بسيطًا للتأكد من أن الكلمة غير فارغة قبل قراءة حرفها الأول. وبعد انتهاء المرور تطبع الشيفرة أو تعيد السلسلة «aprilfoolsjoke». لذلك فالتنفيذ ليس خوارزمية بحث، بل تطبيق مباشر للقاعدة الرياضية المذكورة.
إذا صغنا المسألة بشكل عام لعدد \(n\) من الكلمات وبطول نصي كلي \(L\)، فإن استخراج حرف أول واحد من كل كلمة يحتاج إلى زمن \(O(n)\) بعد تقسيم النص، أو \(O(L)\) إذا حسبنا القراءة والتحليل معًا. أما تخزين الناتج فيحتاج إلى مساحة \(O(n)\).
لكن في نسخة Project Euler الفعلية يكون \(n=14\) ثابتًا سلفًا، ولذلك فإن زمن التنفيذ الحقيقي والذاكرة الإضافية كلاهما ثابتان، أي \(O(1)\).