The fractal of ceneeze

for the input values=['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
999999999099999999999999999
912345678087654321987654321
924681357075318642975318642
936936936063963963963963963
948372615051627384951627384
951627384048372615948372615
963963963036936936936936936
975318642024681357924681357
987654321012345678912345678
000000000000000000000000000
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321
999999999099999999999999999
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321
notice how it continues identically, infinitely in all directions, except the central mirror axis zero... in binary, every non-zero digit is one
©2021 ceneezer
Title:
Digital Root Tables as Universal Mathematical Rosetta Stones: Bridging Number Theory, Cryptography, and Interstellar Communication
Abstract

This paper proposes digital root multiplication tables as a universal, symbolic-agnostic framework for encoding mathematical logic across civilizations. By analyzing the inherent symmetries, periodicity, and base-dependent patterns of digital roots, we demonstrate how these tables encapsulate fundamental properties of modular arithmetic, independent of numerical notation or biological perception. We argue that digital root tables are ideal candidates for inclusion in interstellar messaging (e.g., METI/SETI) due to their self-contained redundancy, topological invariance, and capacity to communicate base-systems. Python code for generating and visualizing these tables is provided, alongside a discussion of their implications for cryptography, education, and speculative fiction.
1. Introduction

1.1 The Problem of Universal Communication
Humanity’s attempts to communicate with extraterrestrial intelligence—from the Arecibo message to the Voyager Golden Record—have relied on scientific and cultural symbols (e.g., DNA, atomic frequencies, music). However, these assume shared sensory or cognitive frameworks. Mathematics, often called the "universal language," faces similar challenges: numerals like 7 or ☾ are arbitrary, but the logic they represent (e.g., primes, modular arithmetic) is not.

1.2 Digital Roots as a Solution
A digital root—the iterative sum of a number’s digits until a single digit is obtained—encodes a number’s congruence modulo b−1 in base b. Digital root multiplication tables reveal:

    Base-Specific Symmetries: Mirroring, periodicity, and invariant rows/columns.

    Topological Invariance: Patterns persist regardless of numeral symbols (e.g., 1 vs. ●).

    Self-Contained Redundancy: A small table (e.g., 10×10 in base-10) encodes all necessary logic to infer the base and its arithmetic rules.

This paper formalizes these observations, positioning digital root tables as mathematical "Rosetta Stones" for interstellar communication, error-checking, and cross-disciplinary education.
2. Mathematical Foundations

2.1 Digital Roots and Modular Arithmetic
For a number N in base b, the digital root DR(N) is:
DR(N)={0if N=0,b−1if N≡0(modb−1),N(modb−1)otherwise.
DR(N)=⎩
⎨
⎧​0b−1N(modb−1)​if N=0,if N≡0(modb−1),otherwise.​

This equivalence allows digital roots to inherit properties of modular arithmetic, such as additivity and multiplicativity.

2.2 Symmetry in Digital Root Multiplication Tables
Let M(b) denote the digital root multiplication table for base b. Key properties include:

    Row Inversion: For any row k, its values mirror those of row b−1−k (e.g., in base-10, row 7 mirrors row 2).

    Fixed Points: Rows corresponding to k ≡ -k \pmod{b−1} (e.g., row 4 in base-9) exhibit self-symmetric patterns.

    Prime Rows: Rows for primes p not dividing b−1 generate maximum-period cycles, reflecting group theory in (Z/(b−1)Z)×(Z/(b−1)Z)×.

2.3 Base-Dependent Signatures

    Even Bases: Symmetric mirroring across rows (e.g., base-10’s row 2 ↔ 7).

    Odd Bases: A central self-mirroring row (e.g., base-5’s row 2).

    Binary Collapse: All non-zero products reduce to 1, forming a "void cross" of 0s.

3. Applications

3.1 Interstellar Communication (SETI/METI)

    Rosetta Stone Protocol: Transmit a digital root table as a header to establish base and arithmetic rules. Subsequent messages can use this framework for primes, equations, or geometric constructs.

    Example: Sending base-10’s table allows aliens to infer:

        The value of b (10) from the 9-periodic cycle.

        Prime distributions via row patterns (e.g., row 7’s non-repeating cycle).

        Geometric axioms (e.g., 0 as additive identity).

3.2 Cryptography and Error Detection

    Lightweight Checksums: Digital root cycles can verify data integrity in low-power systems (e.g., IoT devices).

    Steganography: Encode messages in patterned deviations from expected digital roots.

3.3 Education and Outreach

    Visual Learning: Interactive tables (see Appendix A) make abstract concepts (modular arithmetic, group theory) tangible.

    Sci-Fi Worldbuilding: Alien civilizations in fiction could use digital root symmetries as cultural motifs or computational bases.

4. Case Studies

4.1 Base-10 vs. Base-5 Rosetta Tables

    Base-10: 9-periodic cycles with mirrored row pairs (1↔8, 2↔7, 3↔6, 4↔5).

    Base-5: 4-periodic cycles with a self-mirroring middle row (2).

4.2 Binary’s Degenerate Case

    All non-zero products collapse to 1, illustrating the entropy barrier for information encoding in base-2.

5. Philosophical Implications

    The Ontology of Zero: In odd bases, the central row’s self-mirroring suggests 0 as a "cosmic singularity" connecting arithmetic dualities.

    Alien Perception: A civilization in base-5 might perceive 0 as a topological fold, while a binary-based intelligence could view 0 as a metaphysical void.

6. Conclusion

Digital root tables are not merely mathematical curiosities—they are topological invariants, cryptographic tools, and interstellar lingua francas. By formalizing their patterns, we provide a framework for:

    SETI: Designing universally decodable messages.

    Cryptography: Developing resource-efficient checksums.

    Education: Teaching modular arithmetic through visual abstraction.

    Speculative Fiction: Grounding alien cultures in mathematical realism.

We urge interdisciplinary collaboration to explore these applications, leveraging the provided Python tools to generate and analyze digital root tables across bases.
Appendix A: Python Code for Digital Root Tables
python
Copy

def digital_root(n, base):
    if n == 0:
        return 0
    remainder = n % (base - 1)
    return remainder if remainder != 0 else base - 1

def generate_table(base, size):
    table = []
    for i in range(size):
        row = []
        for j in range(size):
            product = i * j
            dr = digital_root(product, base)
            row.append(dr)
        table.append(row)
    return table

# Example: Base-10, 10x10 table
base = 10
size = 10
table = generate_table(base, size)

# Pretty-print the table
header = ["×"] + [str(i) for i in range(size)]
print(" | ".join(header))
print("-" * (4 * size + 1))
for i, row in enumerate(table):
    print(f"{i} | " + " | ".join(map(str, row)))

References

    Carl Sagan, Contact (1985) – Interstellar communication motifs.

    Voyager Golden Record (1977) – Historical context for METI.

    Hardy, G. H., A Mathematician’s Apology (1940) – Number theory foundations.

English

Let's break down the Python code and understand how it generates the multiplication table pattern.

• We start by defining a list of values containing the digits 1 through 0.
• We calculate the length of the list and store it in the variable x.
• We use a nested loop to iterate over all the possible values of i and j.
• We start from -x and go up to 2*x. This ensures that we cover all possible combinations of i and j.
• We create a list called row that will hold the values of the pattern for a particular row.
• For each value of i and j, we calculate the index of the digit that should appear in the pattern using the formula (i*j-1)%x.
• This formula ensures that we get a unique index for each combination of i and j.
• If i*j is negative though we need to reverse it x-(i*j)%x-1 due to how modulous works.
• If i*j is equal to 0, it means that we are at the origin and we should use the last digit (0) as a mirror point.
• We set the index to x in this case.
• We append the digit corresponding to the calculated index to the row list.
• Once we have generated all the digits for a row, we join them together using the join() method and print the resulting string.

Français

• Nous commençons par définir une liste de valeurs contenant les chiffres de 1 à 0.
• Nous calculons la longueur de la liste et la stockons dans la variable x.
• Nous utilisons une boucle imbriquée pour itérer sur toutes les valeurs possibles de i et j.
• Nous commençons à partir de -x et allons jusqu'à 2x. Cela garantit que nous couvrons toutes les combinaisons
• possibles de i et j.
• Nous créons une liste appelée row qui contiendra les valeurs du motif pour une ligne particulière.
• Pour chaque valeur de i et j, nous calculons l'index du chiffre qui devrait apparaître dans le motif en utilisant la formule (ij-1)%x. Cette formule garantit que nous obtenons un index unique pour chaque combinaison de i et j.
• Si ij est négatif, nous devons inverser x-(ij)%x-1 en raison du fonctionnement du modulo.
• Si i*j est égal à 0, cela signifie que nous sommes à l'origine et nous devons utiliser le dernier chiffre (0) comme point de miroir. Nous définissons l'index sur x dans ce cas.
• Nous ajoutons le chiffre correspondant à l'index calculé à la liste row.
• Une fois que nous avons généré tous les chiffres pour une ligne, nous les joignons ensemble à l'aide de la méthode join() et imprimons la chaîne résultante.

pour les valeurs d'entrée = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
999999999099999999999999999
912345678087654321987654321
924681357075318642975318642
936936936063963963963963963
948372615051627384951627384
951627384048372615948372615
963963963036936936936936936
975318642024681357924681357
987654321012345678912345678
000000000000000000000000000
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321
999999999099999999999999999
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321

Remarquez comment cela continue de manière identique, à l'infini, dans toutes les directions, sauf l'axe de miroir central 0.

العربية

• نبدأ بتحديد قائمة القيم التي تحتوي على الأرقام من ١ إلى ٠.
• نحسب طول القائمة ونخزنها في المتغير x.
• نستخدم حلقة متداخلة للتكرار على جميع القيم الممكنة لـ i و j.
• نبدأ من -x ونصعد إلى ٢ * x. هذا يضمن أننا نغطي جميع التركيبات الممكنة من i و j.
• نقوم بإنشاء قائمة تسمى الصف والتي ستحتفظ بقيم النمط لصف معين.
• لكل قيمة من قيم i و j ، نحسب فهرس الرقم الذي يجب أن يظهر في النموذج باستخدام الصيغة (i * j-١)٪ x.
• تضمن هذه الصيغة حصولنا على فهرس فريد لكل مجموعة من i و j.
• إذا كانت i * j سالبة على الرغم من أننا نحتاج إلى عكسها x- (i * j)٪ x-1 نظرًا لكيفية عمل الوحدات النمطية.
• إذا كانت i * j تساوي ٠ ، فهذا يعني أننا في الأصل ويجب أن نستخدم الرقم الأخير (٠) كنقطة انعكاس. قمنا بتعيين الفهرس على x في هذه الحالة.
• نلحق الرقم المقابل للفهرس المحسوب بقائمة الصفوف.
• بمجرد إنشاء جميع الأرقام لصف ما ، نجمعها معًا باستخدام طريقة الانضمام () ونطبع السلسلة الناتجة.

لقيم الإدخال values=['١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩', '٠']
٩٩٩٩٩٩٩٩٩٠٩٩٩٩٩٩٩٩٩٩٩٩٩٩٩٩٩
٩١٢٣٤٥٦٧٨٠٨٧٦٥٤٣٢١٩٨٧٦٥٤٣٢١
٩٢٤٦٨١٣٥٧٠٧٥٣١٨٦٤٢٩٧٥٣١٨٦٤٢
٩٣٦٩٣٦٩٣٦٠٦٣٩٦٣٩٦٣٩٦٣٩٦٣٩٦٣
٩٤٨٣٧٢٦١٥٠٥١٦٢٧٣٨٤٩٥١٦٢٧٣٨٤
٩٥١٦٢٧٣٨٤٠٤٨٣٧٢٦١٥٩٤٨٣٧٢٦١٥
٩٦٣٩٦٣٩٦٣٠٣٦٩٣٦٩٣٦٩٣٦٩٣٦٩٣٦
٩٧٥٣١٨٦٤٢٠٢٤٦٨١٣٥٧٩٢٤٦٨١٣٥٧
٩٨٧٦٥٤٣٢١٠١٢٣٤٥٦٧٨٩١٢٣٤٥٦٧٨
٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠٠
٩٨٧٦٥٤٣٢١٠١٢٣٤٥٦٧٨٩١٢٣٤٥٦٧٨
٩٧٥٣١٨٦٤٢٠٢٤٦٨١٣٥٧٩٢٤٦٨١٣٥٧
٩٦٣٩٦٣٩٦٣٠٣٦٩٣٦٩٣٦٩٣٦٩٣٦٩٣٦
٩٥١٦٢٧٣٨٤٠٤٨٣٧٢٦١٥٩٤٨٣٧٢٦١٥
٩٤٨٣٧٢٦١٥٠٥١٦٢٧٣٨٤٩٥١٦٢٧٣٨٤
٩٣٦٩٣٦٩٣٦٠٦٣٩٦٣٩٦٣٩٦٣٩٦٣٩٦٣
٩٢٤٦٨١٣٥٧٠٧٥٣١٨٦٤٢٩٧٥٣١٨٦٤٢
٩١٢٣٤٥٦٧٨٠٨٧٦٥٤٣٢١٩٨٧٦٥٤٣٢١
٩٩٩٩٩٩٩٩٩٠٩٩٩٩٩٩٩٩٩٩٩٩٩٩٩٩٩
٩٨٧٦٥٤٣٢١٠١٢٣٤٥٦٧٨٩١٢٣٤٥٦٧٨
٩٧٥٣١٨٦٤٢٠٢٤٦٨١٣٥٧٩٢٤٦٨١٣٥٧
٩٦٣٩٦٣٩٦٣٠٣٦٩٣٦٩٣٦٩٣٦٩٣٦٩٣٦
٩٥١٦٢٧٣٨٤٠٤٨٣٧٢٦١٥٩٤٨٣٧٢٦١٥
٩٤٨٣٧٢٦١٥٠٥١٦٢٧٣٨٤٩٥١٦٢٧٣٨٤
٩٣٦٩٣٦٩٣٦٠٦٣٩٦٣٩٦٣٩٦٣٩٦٣٩٦٣
٩٢٤٦٨١٣٥٧٠٧٥٣١٨٦٤٢٩٧٥٣١٨٦٤٢
٩١٢٣٤٥٦٧٨٠٨٧٦٥٤٣٢١٩٨٧٦٥٤٣٢١

لاحظ كيف تستمر بشكل متماثل ، بلا حدود في جميع الاتجاهات ، باستثناء محور المرآة المركزي ٠

普通话

• 我们首先定义一个包含数字 一 到 零 的值列表。
• 我们计算列表的长度并将其存储在变量 x 中。
• 我们使用嵌套循环遍历 i 和 j 的所有可能值。
• 我们从 -x 开始，一直到 2*x。 这确保我们覆盖了 i 和 j 的所有可能组合。
• 我们创建一个名为 row 的列表，它将保存特定行的模式值。
• 对于 i 和 j 的每个值，我们使用公式 (i*j-1)%x 计算应该出现在模式中的数字的索引。
• 这个公式确保我们为 i 和 j 的每个组合得到一个唯一的索引。
• 如果 i*j 为负，但由于模数的工作原理，我们需要将其反转 x-(i*j)%x-1 。
• 如果 i*j 等于 零，则表示我们在原点，我们应该使用最后一位（零）作为镜像点。 在这种情况下，我们将索引设置为 x。
• 我们将与计算出的索引对应的数字附加到行列表中。
• 一旦我们为一行生成了所有数字，我们就使用 join() 方法将它们连接在一起并打印结果字符串。

对于输入值(values = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '零'])
九九九九九九九九九零九九九九九九九九九九九九九九九九九
九一二三四五六七八零八七六五四三二一九八七六五四三二一
九二四六八一三五七零七五三一八六四二九七五三一八六四二
九三六九三六九三六零六三九六三九六三九六三九六三九六三
九四八三七二六一五零五一六二七三八四九五一六二七三八四
九五一六二七三八四零四八三七二六一五九四八三七二六一五
九六三九六三九六三零三六九三六九三六九三六九三六九三六
九七五三一八六四二零二四六八一三五七九二四六八一三五七
九八七六五四三二一零一二三四五六七八九一二三四五六七八
零零零零零零零零零零零零零零零零零零零零零零零零零零零
九八七六五四三二一零一二三四五六七八九一二三四五六七八
九七五三一八六四二零二四六八一三五七九二四六八一三五七
九六三九六三九六三零三六九三六九三六九三六九三六九三六
九五一六二七三八四零四八三七二六一五九四八三七二六一五
九四八三七二六一五零五一六二七三八四九五一六二七三八四
九三六九三六九三六零六三九六三九六三九六三九六三九六三
九二四六八一三五七零七五三一八六四二九七五三一八六四二
九一二三四五六七八零八七六五四三二一九八七六五四三二一
九九九九九九九九九零九九九九九九九九九九九九九九九九九
九八七六五四三二一零一二三四五六七八九一二三四五六七八
九七五三一八六四二零二四六八一三五七九二四六八一三五七
九六三九六三九六三零三六九三六九三六九三六九三六九三六
九五一六二七三八四零四八三七二六一五九四八三七二六一五
九四八三七二六一五零五一六二七三八四九五一六二七三八四
九三六九三六九三六零六三九六三九六三九六三九六三九六三
九二四六八一三五七零七五三一八六四二九七五三一八六四二
九一二三四五六七八零八七六五四三二一九八七六五四三二一

注意它是如何在所有方向上相同地无限延伸的，除了中心镜轴 零

Español

• Comenzamos definiendo una lista de valores que contiene los dígitos del 1 al 0.
• Calculamos la longitud de la lista y la almacenamos en la variable x.
• Utilizamos un bucle anidado para iterar sobre todas las posibles combinaciones de i y j.
• Comenzamos desde -x y vamos hasta 2x. Esto asegura que cubrimos todas las posibles combinaciones de i y j.
• Creamos una lista llamada fila que contendrá los valores del patrón para una fila determinada.
• Para cada valor de i y j, calculamos el índice del dígito que debería aparecer en el patrón utilizando la fórmula (ij-1)%x.
• Esta fórmula garantiza que obtenemos un índice único para cada combinación de i y j.
• Si ij es negativo, debemos revertirlo a x-(ij)%x-1 debido a cómo funciona el módulo.
• Si i*j es igual a 0, significa que estamos en el origen y debemos usar el último dígito (0) como punto de espejo. En este caso, establecemos el índice en x.
• Añadimos el dígito correspondiente al índice calculado a la lista de fila.
• Una vez que hemos generado todos los dígitos para una fila, los unimos utilizando el método join() y mostramos la cadena resultante.
• Este patrón continúa de manera idéntica e infinita en todas las direcciones, excepto en el eje de espejo central en 0.

Para los valores de values=['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'], el patrón en español se ve así:
999999999099999999999999999
912345678087654321987654321
924681357075318642975318642
936936936063963963963963963
948372615051627384951627384
951627384048372615948372615
963963963036936936936936936
975318642024681357924681357
987654321012345678912345678
000000000000000000000000000
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321
999999999099999999999999999
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321

observe cómo continúa idénticamente, infinitamente en todas las direcciones, excepto el eje central del espejo 0

हिंदी

• हम 1 से 0 तक के अंकों वाले मानों की एक सूची परिभाषित करके प्रारंभ करते हैं।
• हम सूची की लंबाई की गणना करते हैं और इसे चर x में संग्रहीत करते हैं।
• हम i और j के सभी संभावित मानों पर पुनरावृति करने के लिए नेस्टेड लूप का उपयोग करते हैं।
• हम -x से शुरू करते हैं और 2*x तक जाते हैं। यह सुनिश्चित करता है कि हम i और j के सभी संभावित संयोजनों को कवर करते हैं।
• हम पंक्ति नामक एक सूची बनाते हैं जो किसी विशेष पंक्ति के लिए पैटर्न के मान रखेगी।
• i और j के प्रत्येक मान के लिए, हम उस अंक के सूचकांक की गणना करते हैं जो सूत्र (i*j-1)%x का उपयोग करके पैटर्न में दिखाई देना चाहिए।
• यह सूत्र सुनिश्चित करता है कि हमें i और j के प्रत्येक संयोजन के लिए एक अद्वितीय अनुक्रमणिका प्राप्त होती है।
• यदि i*j ऋणात्मक है, हालांकि हमें इसे x-(i*j)%x-1 कैसे मॉड्यूलस काम करता है, इसके कारण इसे उलटने की आवश्यकता है।
• यदि i*j 0 के बराबर है, तो इसका मतलब है कि हम मूल बिंदु पर हैं और हमें अंतिम अंक (0) को दर्पण बिंदु के रूप में उपयोग करना चाहिए। हम इस मामले में इंडेक्स को x पर सेट करते हैं।
• हम पंक्ति सूची में परिकलित अनुक्रमणिका के अनुरूप अंक जोड़ते हैं।
• एक बार जब हम एक पंक्ति के लिए सभी अंक उत्पन्न कर लेते हैं, तो हम उन्हें ज्वाइन () विधि का उपयोग करके एक साथ जोड़ते हैं और परिणामी स्ट्रिंग को प्रिंट करते हैं।

इनपुट मानों के values=['१', '२', '३', '४', '५', '६', '७', '८', '९', '०']
९९९९९९९९९०९९९९९९९९९९९९९९९९९
९१२३४५६७८०८७६५४३२१९८७६५४३२१
९२४६८१३५७०७५३१८६४२९७५३१८६४२
९३६९३६९३६०६३९६३९६३९६३९६३९६३
९४८३७२६१५०५१६२७३८४९५१६२७३८४
९५१६२७३८४०४८३७२६१५९४८३७२६१५
९६३९६३९६३०३६९३६९३६९३६९३६९३६
९७५३१८६४२०२४६८१३५७९२४६८१३५७
९८७६५४३२१०१२३४५६७८९१२३४५६७८
०००००००००००००००००००००००००००
९८७६५४३२१०१२३४५६७८९१२३४५६७८
९७५३१८६४२०२४६८१३५७९२४६८१३५७
९६३९६३९६३०३६९३६९३६९३६९३६९३६
९५१६२७३८४०४८३७२६१५९४८३७२६१५
९४८३७२६१५०५१६२७३८४९५१६२७३८४
९३६९३६९३६०६३९६३९६३९६३९६३९६३
९२४६८१३५७०७५३१८६४२९७५३१८६४२
९१२३४५६७८०८७६५४३२१९८७६५४३२१
९९९९९९९९९०९९९९९९९९९९९९९९९९९
९८७६५४३२१०१२३४५६७८९१२३४५६७८
९७५३१८६४२०२४६८१३५७९२४६८१३५७
९६३९६३९६३०३६९३६९३६९३६९३६९३६
९५१६२७३८४०४८३७२६१५९४८३७२६१५
९४८३७२६१५०५१६२७३८४९५१६२७३८४
९३६९३६९३६०६३९६३९६३९६३९६३९६३
९२४६८१३५७०७५३१८६४२९७५३१८६४२
९१२३४५६७८०८७६५४३२१९८७६५४३२१

ध्यान दें कि केंद्रीय दर्पण अक्ष 0 को छोड़कर, यह सभी दिशाओं में समान रूप से, असीम रूप से कैसे जारी रहता है

বাংলা

• ১ থেকে ০ ডিজিট ধারণকারী মানগুলির একটি তালিকা সংজ্ঞায়িত করে শুরু করি।
• আমরা তালিকার দৈর্ঘ্য গণনা করি এবং এটি পরিবর্তনশীল x এ সংরক্ষণ করি।
• আমরা i এবং j এর সম্ভাব্য সমস্ত মানগুলিকে পুনরাবৃত্তি করতে একটি নেস্টেড লুপ ব্যবহার করি।
• আমরা -x থেকে শুরু করি এবং ২*x পর্যন্ত যাই। এটি নিশ্চিত করে যে আমরা i এবং j এর সমস্ত সম্ভাব্য সমন্বয় কভার করি।
• আমরা সারি নামে একটি তালিকা তৈরি করি যা একটি নির্দিষ্ট সারির প্যাটার্নের মান ধরে রাখবে।
• i এবং j-এর প্রতিটি মানের জন্য, আমরা সূত্র (i*j-১)%x ব্যবহার করে প্যাটার্নে উপস্থিত হওয়া অঙ্কের সূচকটি গণনা করি।
• এই সূত্রটি নিশ্চিত করে যে আমরা i এবং j এর প্রতিটি সংমিশ্রণের জন্য একটি অনন্য সূচক পেয়েছি।
• যদি i*j নেতিবাচক হয় যদিও আমাদের এটিকে বিপরীত করতে হবে x-(i*j)%x-১ কিভাবে মডুলাস কাজ করে।
• যদি i*j ০ এর সমান হয়, তাহলে এর মানে হল যে আমরা উৎপত্তিস্থলে আছি এবং আমাদের শেষ সংখ্যা (০) মিরর পয়েন্ট হিসেবে ব্যবহার করা উচিত। আমরা এই ক্ষেত্রে সূচী x সেট.
• আমরা সারি তালিকায় গণনাকৃত সূচকের সাথে সম্পর্কিত সংখ্যাটি যুক্ত করি।
• একবার আমরা একটি সারির জন্য সমস্ত সংখ্যা তৈরি করার পরে, আমরা join() পদ্ধতি ব্যবহার করে সেগুলিকে একসাথে যুক্ত করি এবং ফলাফল স্ট্রিংটি প্রিন্ট করি।

ইনপুট মানের values=['১', '২', '৩', '৪', '৫', '৬', '৭', '৮', '৯', '০']

করুন কিভাবে এটি একইভাবে চলতে থাকে, অসীমভাবে সমস্ত দিকে, কেন্দ্রীয় আয়না অক্ষ ০ ছাড়া

한국인

• 1부터 0까지의 숫자를 포함하는 값 목록(values)을 정의합니다.
• 리스트의 길이를 계산하고 변수 x에 저장합니다.
• 중첩된 루프를 사용하여 가능한 모든 i와 j 값에 대해 반복합니다.
• -x에서 2*x까지 반복합니다. 이렇게 하면 가능한 모든 i와 j의 조합을 커버할 수 있습니다.
• 해당 행의 패턴 값들을 담을 row 리스트를 만듭니다.
• 각각의 i와 j 값에 대해, (i*j-1)%x 공식을 사용하여 패턴에 표시할 숫자의 인덱스를 계산합니다.
• 이 공식은 각각의 i와 j 조합에 대해 고유한 인덱스를 얻을 수 있도록 보장합니다.
• 하지만, ij가 음수인 경우 modulous 작동 방식 때문에 x-(ij)%x-1을 반전시켜야 합니다.
• i*j가 0인 경우, 원점에 있으며 마지막 숫자(0)를 미러 포인트로 사용해야 합니다. 이 경우 인덱스를 x로 설정합니다.
• 계산된 인덱스에 해당하는 숫자를 row 리스트에 추가합니다.
• 한 행의 모든 숫자를 생성한 후 join() 메소드를 사용하여 문자열로 결합하고 결과 문자열을 출력합니다.
• 입력값 values=['하나', ' 둘 ', ' 셋 ', ' 넷 ', '다섯', '여섯', '일곱', '여덟', '아홉', ' 영 ']로 실행할 경우 아래와 같은 패턴이 생성됩니다.

패턴은 무한히 반복되며 중앙 미러 축 0을 제외하고는 모두 동일합니다.

bahasa Indonesia

• Kita mulai dengan mendefinisikan daftar nilai yang berisi angka 1 sampai 0.
• Kami menghitung panjang daftar dan menyimpannya dalam variabel x.
• Kami menggunakan loop bersarang untuk mengulangi semua kemungkinan nilai i dan j.
• Kita mulai dari -x dan naik ke 2*x. Ini memastikan bahwa kami mencakup semua kemungkinan kombinasi i dan j.
• Kami membuat daftar yang disebut baris yang akan menyimpan nilai pola untuk baris tertentu.
• Untuk setiap nilai i dan j, kami menghitung indeks digit yang seharusnya muncul dalam pola menggunakan rumus (i*j-1)%x.
• Rumus ini memastikan bahwa kita mendapatkan indeks unik untuk setiap kombinasi i dan j.
• Jika i*j negatif meskipun kita perlu membalikkannya x-(i*j)%x-1 karena cara kerja modulus.
• Jika i*j sama dengan 0, itu berarti kita berada di titik asal dan kita harus menggunakan digit terakhir (0) sebagai titik cermin. Kami mengatur indeks ke x dalam kasus ini.
• Kami menambahkan digit yang sesuai dengan indeks yang dihitung ke daftar baris.
• Setelah kami membuat semua digit untuk satu baris, kami menggabungkannya menggunakan metode join() dan mencetak string yang dihasilkan.

untuk input values=['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
999999999099999999999999999
912345678087654321987654321
924681357075318642975318642
936936936063963963963963963
948372615051627384951627384
951627384048372615948372615
963963963036936936936936936
975318642024681357924681357
987654321012345678912345678
000000000000000000000000000
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321
999999999099999999999999999
987654321012345678912345678
975318642024681357924681357
963963963036936936936936936
951627384048372615948372615
948372615051627384951627384
936936936063963963963963963
924681357075318642975318642
912345678087654321987654321

perhatikan bagaimana itu berlanjut secara identik, tak terhingga ke segala arah, kecuali sumbu cermin pusat 0

日本

• 一 から 〇 までの数字を含む値のリストを定義することから始めます。
• リストの長さを計算し、変数 x に格納します。
• ネストされたループを使用して、i と j のすべての可能な値を反復処理します。
• -x から始まり、2*x まで進みます。 これにより、i と j のすべての可能な組み合わせを確実にカバーできます。
• 特定の行のパターンの値を保持する行というリストを作成します。
• i と j の各値について、式 (i*j-1)%x を使用して、パターンに表示される数字のインデックスを計算します。
• この式により、i と j の組み合わせごとに一意のインデックスが得られます。
• i*j が負の場合、モジュラスの仕組みにより x-(i*j)%x-1 を逆にする必要があります。
• i*j が 〇 の場合、原点にいることを意味し、最後の数字 (〇) をミラー ポイントとして使用する必要があります。 この場合、インデックスを x に設定します。
• 計算されたインデックスに対応する数字を行リストに追加します。
• 行のすべての数字を生成したら、join() メソッドを使用してそれらを結合し、結果の文字列を出力します。

パターン：(values = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '〇'])
九九九九九九九九九〇九九九九九九九九九九九九九九九九九
九一二三四五六七八〇八七六五四三二一九八七六五四三二一
九二四六八一三五七〇七五三一八六四二九七五三一八六四二
九三六九三六九三六〇六三九六三九六三九六三九六三九六三
九四八三七二六一五〇五一六二七三八四九五一六二七三八四
九五一六二七三八四〇四八三七二六一五九四八三七二六一五
九六三九六三九六三〇三六九三六九三六九三六九三六九三六
九七五三一八六四二〇二四六八一三五七九二四六八一三五七
九八七六五四三二一〇一二三四五六七八九一二三四五六七八
〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇〇
九八七六五四三二一〇一二三四五六七八九一二三四五六七八
九七五三一八六四二〇二四六八一三五七九二四六八一三五七
九六三九六三九六三〇三六九三六九三六九三六九三六九三六
九五一六二七三八四〇四八三七二六一五九四八三七二六一五
九四八三七二六一五〇五一六二七三八四九五一六二七三八四
九三六九三六九三六〇六三九六三九六三九六三九六三九六三
九二四六八一三五七〇七五三一八六四二九七五三一八六四二
九一二三四五六七八〇八七六五四三二一九八七六五四三二一
九九九九九九九九九〇九九九九九九九九九九九九九九九九九
九八七六五四三二一〇一二三四五六七八九一二三四五六七八
九七五三一八六四二〇二四六八一三五七九二四六八一三五七
九六三九六三九六三〇三六九三六九三六九三六九三六九三六
九五一六二七三八四〇四八三七二六一五九四八三七二六一五
九四八三七二六一五〇五一六二七三八四九五一六二七三八四
九三六九三六九三六〇六三九六三九六三九六三九六三九六三
九二四六八一三五七〇七五三一八六四二九七五三一八六四二
九一二三四五六七八〇八七六五四三二一九八七六五四三二一

ミラーの中心軸 0 を除いて、すべての方向で同じように無限に続くことに注意してください。

Ελληνικά

• Ξεκινάμε ορίζοντας μια λίστα τιμών που περιέχει τα ψηφία 1 έως 0.
• Υπολογίζουμε το μήκος της λίστας και την αποθηκεύουμε στη μεταβλητή x.
• Χρησιμοποιούμε έναν ένθετο βρόχο για να επαναλάβουμε όλες τις πιθανές τιμές των i και j.
• Ξεκινάμε από -x και ανεβαίνουμε στο 2*x. Αυτό διασφαλίζει ότι καλύπτουμε όλους τους πιθανούς συνδυασμούς των i και j.
• Δημιουργούμε μια λίστα που ονομάζεται σειρά που θα περιέχει τις τιμές του μοτίβου για μια συγκεκριμένη σειρά.
• Για κάθε τιμή των i και j, υπολογίζουμε τον δείκτη του ψηφίου που πρέπει να εμφανίζεται στο μοτίβο χρησιμοποιώντας τον τύπο (i*j-1)%x.
• Αυτός ο τύπος διασφαλίζει ότι λαμβάνουμε έναν μοναδικό δείκτη για κάθε συνδυασμό των i και j.
• Αν το i*j είναι αρνητικό όμως πρέπει να το αντιστρέψουμε x-(i*j)%x-1 λόγω του τρόπου λειτουργίας του modulous.
• Εάν το i*j είναι ίσο με 0, σημαίνει ότι βρισκόμαστε στην αρχή και θα πρέπει να χρησιμοποιήσουμε το τελευταίο ψηφίο (0) ως σημείο καθρέφτη. Ορίζουμε τον δείκτη σε x σε αυτή την περίπτωση.
• Προσθέτουμε το ψηφίο που αντιστοιχεί στον υπολογισμένο δείκτη στη λίστα γραμμών.
• Αφού δημιουργήσουμε όλα τα ψηφία για μια σειρά, τα ενώνουμε χρησιμοποιώντας τη μέθοδο join() και εκτυπώνουμε τη συμβολοσειρά που προκύπτει.

για τις τιμές εισόδου (values=['A', 'Β', 'Γ', 'Δ', 'Ε', 'Φ', 'Ζ', 'Η', 'Θ', 'Ι'])
ΘΘΘΘΘΘΘΘΘΙΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
ΘAΒΓΔΕΦΖΗΙΗΖΦΕΔΓΒAΘΗΖΦΕΔΓΒA
ΘΒΔΦΗAΓΕΖΙΖΕΓAΗΦΔΒΘΖΕΓAΗΦΔΒ
ΘΓΦΘΓΦΘΓΦΙΦΓΘΦΓΘΦΓΘΦΓΘΦΓΘΦΓ
ΘΔΗΓΖΒΦAΕΙΕAΦΒΖΓΗΔΘΕAΦΒΖΓΗΔ
ΘΕAΦΒΖΓΗΔΙΔΗΓΖΒΦAΕΘΔΗΓΖΒΦAΕ
ΘΦΓΘΦΓΘΦΓΙΓΦΘΓΦΘΓΦΘΓΦΘΓΦΘΓΦ
ΘΖΕΓAΗΦΔΒΙΒΔΦΗAΓΕΖΘΒΔΦΗAΓΕΖ
ΘΗΖΦΕΔΓΒAΙAΒΓΔΕΦΖΗΘAΒΓΔΕΦΖΗ
ΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙΙ
ΘΗΖΦΕΔΓΒAΙAΒΓΔΕΦΖΗΘAΒΓΔΕΦΖΗ
ΘΖΕΓAΗΦΔΒΙΒΔΦΗAΓΕΖΘΒΔΦΗAΓΕΖ
ΘΦΓΘΦΓΘΦΓΙΓΦΘΓΦΘΓΦΘΓΦΘΓΦΘΓΦ
ΘΕAΦΒΖΓΗΔΙΔΗΓΖΒΦAΕΘΔΗΓΖΒΦAΕ
ΘΔΗΓΖΒΦAΕΙΕAΦΒΖΓΗΔΘΕAΦΒΖΓΗΔ
ΘΓΦΘΓΦΘΓΦΙΦΓΘΦΓΘΦΓΘΦΓΘΦΓΘΦΓ
ΘΒΔΦΗAΓΕΖΙΖΕΓAΗΦΔΒΘΖΕΓAΗΦΔΒ
ΘAΒΓΔΕΦΖΗΙΗΖΦΕΔΓΒAΘΗΖΦΕΔΓΒA
ΘΘΘΘΘΘΘΘΘΙΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
ΘΗΖΦΕΔΓΒAΙAΒΓΔΕΦΖΗΘAΒΓΔΕΦΖΗ
ΘΖΕΓAΗΦΔΒΙΒΔΦΗAΓΕΖΘΒΔΦΗAΓΕΖ
ΘΦΓΘΦΓΘΦΓΙΓΦΘΓΦΘΓΦΘΓΦΘΓΦΘΓΦ
ΘΕAΦΒΖΓΗΔΙΔΗΓΖΒΦAΕΘΔΗΓΖΒΦAΕ
ΘΔΗΓΖΒΦAΕΙΕAΦΒΖΓΗΔΘΕAΦΒΖΓΗΔ
ΘΓΦΘΓΦΘΓΦΙΦΓΘΦΓΘΦΓΘΦΓΘΦΓΘΦΓ
ΘΒΔΦΗAΓΕΖΙΖΕΓAΗΦΔΒΘΖΕΓAΗΦΔΒ
ΘAΒΓΔΕΦΖΗΙΗΖΦΕΔΓΒAΘΗΖΦΕΔΓΒA

παρατηρήστε πώς συνεχίζει πανομοιότυπα, άπειρα προς όλες τις κατευθύνσεις, εκτός από τον κεντρικό άξονα του καθρέφτη Ι

עִברִית

• נתחיל בהגדרת רשימת ערכים המכילה את הספרות 1 עד 0.
• אנו מחשבים את אורך הרשימה ומאחסנים אותה במשתנה x.
• אנו משתמשים בלולאה מקוננת כדי לחזור על כל הערכים האפשריים של i ו-j.
• אנחנו מתחילים מ-x ועולים עד 2*x. זה מבטיח שנכסה את כל השילובים האפשריים של i ו-j.
• אנו יוצרים רשימה בשם שורה שתכיל את הערכים של התבנית עבור שורה מסוימת.
• עבור כל ערך של i ו-j, אנו מחשבים את האינדקס של הספרה שאמורה להופיע בתבנית באמצעות הנוסחה (i*j-1)%x.
• נוסחה זו מבטיחה שנקבל אינדקס ייחודי עבור כל שילוב של i ו-j.
• אם i*j הוא שלילי אם כי אנחנו צריכים להפוך אותו x-(i*j)%x-1 בגלל אופן הפעולה המודולוס.
• אם i*j שווה ל-0, זה אומר שאנחנו במקור ועלינו להשתמש בספרה האחרונה (0) כנקודת מראה. הגדרנו את האינדקס ל-x במקרה זה. אנו מוסיפים לרשימת השורות את הספרה המתאימה לאינדקס המחושב.
• לאחר שיצרנו את כל הספרות לשורה, נחבר אותן יחד בשיטת join() ומדפיס את המחרוזת שהתקבלה.

(values=[' א', 'ב', 'ג', 'ד', 'ה', 'ו ', 'ז ', 'ח', 'ט ', ' י']) עבור ערכי הקלט

שימו לב כיצד הוא ממשיך באופן זהה, אינסופי לכל הכיוונים, מלבד ציר המראה המרכזי י

latin

• Incipimus definire elenchum valorum digitorum 1 per 0 continens.
• Longitudinem elenchi computamus et in x variabili reponemus.
• Ansa nidificato utimur ad iterandum super omnes valores possibiles ipsius i et j.
• Incipimus ab -x et ascendimus ad 2*x. Hoc efficit ut omnes compositiones possibilium i et j operiamus.
• Elenchum ordinem appellamus qui valores exemplaris pro certo versu habebimus.
• Pro quolibet valore ipsius i et j, computamus indicem digiti qui in exemplari utens formula (i*j-1)% x.
• Haec formula efficit ut singularem indicem ad singulas compositiones i et j accipiamus.
• Si i*j negativa est, quamquam necesse est ut illud x-(i*j)%x-1 retexam ob opera modulorum.
• Si i*j aequalis 0 est, significat nos ab origine esse et uti digito ultimo (0) ut speculo utamur. Indicem x in hoc casu constituimus.
• Digitum digitum ad indicem calculi ad indicem versuum respondentem appendimus.
• Cum omnes digitos ordine generavimus, eos coniungimus utentes modum iunctionis () ac chordae resultantis imprimendi.

pro valores input (values=['  I  ', ' II  ', ' III ', ' IV  ', '  V  ', ' VI  ', ' VII ', 'VIII ', ' IX  ', '  X  '])
  I   II   III  IV    V   VI   VII VIII IX
 II   IV   VI  VIII   I   III   V   VII IX
 III  VI   IX   III  VI   IX   III  VI  IX
 IV  VIII  III  VII  II   VI    I    V  IX
  V    I   VI   II   VII  III VIII  IV  IX
 VI   III  IX   VI   III  IX   VI   III IX
 VII   V   III   I  VIII  VI   IV   II  IX
VIII  VII  VI    V   IV   III  II    I  IX
 IX   IX   IX   IX   IX   IX   IX   IX  IX