SCH382

Step by Step Process

SCH382 uses 62 digits with 64 character keys. This approximately ≈ 5.2×10^14 × a googol ( 10^100)

Process Overview

Input Processing and Initial Conversion
- Receive an input string.
- Calculate a new string by adding a fixed number to the input string's integer representation, raising the result to a power, dividing by another fixed number, and converting to a string.
String Segmentation and Augmentation
- Split this string into segments, alternating between 3 and 1 characters in length.
- Convert each segment into an integer and add a fixed number to each.
Iterative Combination
- Combine these numbers through a sequence of multiplications and divisions, alternating operations based on the position in the sequence.
Reverse and Base Conversion
- Reverse the digits of the final number and convert it into binary, ensuring it is a 256-character string.
Expansion and Fibonacci Modification
- Expand this binary string to 512 characters by repeatedly:
  - Modifying it based on the remainder of division by a fixed number plus one.
  - Adding a sequence-derived number raised to a power plus one to the modification.
  - Reversing the digits of the new number at each step.
Decoding and Re-Encoding
- Split the 512-character binary string into two equal parts.
- Decode each part from binary to decimal.
- Combine these decimals through addition, double the result, and re-encode into a base using a subset of printable characters.
Final Encoding and Truncation
- Encode the entire 512-character binary string into a high base using another subset of printable characters, excluding the first character from the result.
- Decode this string back to decimal, then re-encode into base-62, truncating to the last 64 characters.

Gist

Take an input string and apply mathematical transformations to it, obtaining a new string representation.
This transformation involves:
- Adding a predetermined number to the input's numerical value.
- Raising the result to a specified power.
- Dividing by another predetermined number.
- Converting the final number to a string.
Segment this new string into pieces, alternating between lengths of three and one characters.
Adjust each segment by converting to an integer and adding a fixed value.
Sequentially combine these adjusted values, alternating between multiplication and division, based on their sequence position.
Reverse the digits of the final combined value and convert it to a binary string, adjusting its length to 256 characters by padding with zeros.
Expand this binary representation to 512 characters by:
- Determining a modification factor based on the remainder of division by 17 plus one.
- Calculating a sequence-derived value, raising it to the modification factor, and incrementing by one.
- Adjusting the binary number by this calculated value and a division operation, then incrementing.
- Reversing the digits of the result after each iteration.
Once the binary string reaches the desired length, split it into two halves.
Convert each half from binary to decimal.
Sum these decimal values, double the sum, and encode into a new base using a specific character set.
Encode the entire 512-character binary string into a higher base, excluding the first character of the result.
Decode this high-base string back to decimal and finally re-encode it into base-62, keeping only the last 64 characters of this encoding.

Code

import math
import string
import numpy as np

def s2b(s): return ''.join(bin(ord(c))[2:].zfill(8) for c in s)

def base(d, b):
    c, n, r = string.printable[:90], 1, d
    while r >= b ** n: r -= b ** n; n += 1
    s = ""
    while r > 0: s = c[r % b] + s; r //= b
    return s.zfill(n)

def inverse(c, b):
    chars = string.printable[:90]
    v, l = 0, len(c)
    for i, ch in enumerate(reversed(c)):
        v += chars.index(ch) * (b ** i)
    return v + sum(b ** i for i in range(1, l))

def cF(m):
    if m == 0: return 1
    a, b = 1, 2
    for _ in range(m - 1): a, b = b, a + b
    return b

def sDeterminer(s):
    r, i, p, s = [], 0, [], str((s+7)**8 // 3)
    while i < len(s):
        r.append(s[i:i + (3 if len(r) % 2 == 0 else 1)])
        i += 3 if len(r) % 2 == 0 else 1
    for x in r: p.append(int(x) + 5)
    f = p[0]
    for i in range(1, len(p)): f = f * p[i] if i % 2 == 0 else f / p[i]
    f = str(int(f))[::-1]
    return base(int(f), 2)

def SCH382(s):
    s, x = int(sDeterminer(s)[:256], 2), 5
    while len(bin(s)[2:]) < 512:
        x = s % 17 + 1
        c = cF(x) ** x + 1
        s += math.floor(s / x + c) + 1
        s = int(str(s)[::-1])
        # print(s, c, x)
    s = bin(s)[2:]
    s = s[:512]
    a, b = inverse(s[:256], 2), inverse(s[256:], 2)
    c = base((a + b) * 2, 9)
    y = base(int(s), 89)[1:]
    return base(inverse(y, 90), 62)[-64:]

for i in range(0, 10000):
    result = SCH382(i)
    print(result)

data = s2b('hello world!')
result = SCH382(inverse(data, 2))
result

Lexxos/SCH382

SCH382

Step by Step Process

Process Overview

Gist

Code