So I made this code to transform a regular string into a zalgo text. Basically it adds a ton of diacritics between each character in a string. Diacritics are things that change letters like ' ~ ^ that makes ô õ ó for example. Each diacritic is added in a string right after a character, but there is not limit on how many you can add per character. You can add multiple diacritics making a text look glitchy like this:
ȏ̴̜͉̬͖̼͔͋̈̄́̄̑̈́̄̾̕i̷̢̛̳̩̱̫̼̒̃̾́́̈́̎͂͒̃̔̉ͅ
The complexity of the distortion is determined on how many top and bottom diacritics I will add per character. The problem in my program is if I increase the complexity the program just freezes. And I'm not saying increasing the complexity by a ton, just increasing it to 10 is enough to make it freeze. Is there a limit on the memory by default that my program can use? What is going on help! haha
This is my code: `
``
/* specifications Zalgo program\
*The program must convert a user typed text to zalgo. It must also let the user choose level of complexity of the zalgo
*
*There are three type of diacritics(character modifiers used in lanauges), upper, middle and lower ones, each of them change the
* upper, middle and lower parts of each character. The three of them must be used to make it more crazy
*
* The diacritics exist in unicode, Try to make a vector that contains ALL of the diacritics. One vector for each type of diacritics
*(upper,middle and lower)
*
* Thats all, and its gonna be a lot of work 乂 __ 乂
*
*
*/
use rand::{random, Rng}; // You'll need the rand crate to randomly apply the diacritics
use std::{fs::read, io};
use colored::*;
fn main() {
print!("{}",format!("A{}{}{}{}",ZALGO_UP[22],ZALGO_UP[20],ZALGO_UP[19],ZALGO_UP[0]));
let complexity: u32 = read_complexity();
println!("{}",complexity);
println!("{}",zalgo_transform(complexity, "I am a pixel".to_string()));
}
fn zalgo_transform(complexity: u32, inputstr: String) -> String{
let mut zalgo_string = String::new();
let mut rng = rand::thread_rng();
for cha in inputstr.chars(){
println!("Transformin char:{}", cha);
zalgo_string.push(cha);// ad new character
for i in 0.plexity {// add top diacritics
let random_int1 = rng.gen_range(0..ZALGO_UP.len());// later on should make a different gen to each type of mod
println!("top Iteration {}, generated the number {}, which is the diacritic {} ", i,random_int1, ZALGO_UP[random_int1] );
// println!("number generated: {}", random_int1);
zalgo_string.push(ZALGO_UP[random_int1]);
}
/*for i in 0.plexity {// add middle diacritics
let random_int2 = rng.gen_range(0..ZALGO_MIDDLE.len());// later on should make a different gen to each type of mod
println!("mid Iteration {}, generated the number {}, which is the diacritic {} ", i,random_int2, ZALGO_MIDDLE[random_int2] );
// println!("number generated: {}", random_int2);
zalgo_string.push(ZALGO_MIDDLE[random_int2]);
}*//*
for i in 0..2 {// add middle diacritics
let random_int2 = rng.gen_range(0..ZALGO_MIDDLE.len());// later on should make a different gen to each type of mod
println!("mid Iteration {}, generated the number {}, which is the diacritic {} ", i,random_int2, ZALGO_MIDDLE[random_int2] );
// println!("number generated: {}", random_int2);
zalgo_string.push(ZALGO_MIDDLE[random_int2]);
}*/
for i in 0.plexity {// add bottom(down) diacritics
let random_int3 = rng.gen_range(0..ZALGO_DOWN.len());// later on should make a different gen to each type of mod
println!("Down Iteration {}, generated the number {}, which is the diacritic {} ", i,random_int3, ZALGO_DOWN[random_int3] );
// println!("mid Iteration {}", i);
println!("number generated: {}", random_int3);
zalgo_string.push(ZALGO_DOWN[random_int3]);
}
}
return zalgo_string;
}
/*
fn read_types_of_distortion(){
print!
}*/
fn read_complexity() -> u32{
let mut int_complexity_choice: u32;
loop {
let mut complexity_choice = String::new();
println!("Type the amount of complexity in the zalgo generation:"); // Assuming this function prints out the complexity options
io::stdin()
.read_line(&mut complexity_choice)
.expect("Failed to read line");
int_complexity_choice = match complexity_choice.trim().parse() {
Ok(num) => num,
Err(_) => {
println!("{}", "\n\nInput a positive number! :C ".bright_red());
continue;
},
};
if int_complexity_choice <= 0 {
println!("{}", "\n\nPrint a valid number!! One bigger than 0".bright_red());
continue;
} else {
return int_complexity_choice
}
}
}
// ALL DIACRITICS THAT EXIST IN UNICODE ACCORDING TO CHAT GPT
const ZALGO_UP: &[char] = &[
'\u{0300}', // Grave accent
'\u{0301}', // Acute accent
'\u{0302}', // Circumflex
'\u{0303}', // Tilde
'\u{0304}', // Macron
'\u{0305}', // Overline
'\u{0306}', // Breve
'\u{0307}', // Dot above
'\u{0308}', // Diaeresis
'\u{0309}', // Hook above
'\u{030A}', // Ring above
'\u{030B}', // Double acute accent
'\u{030C}', // Caron
'\u{030F}', // Double grave accent
'\u{0310}', // Candrabindu
'\u{0311}', // Inverted breve
'\u{0313}', // Greek koronis
'\u{0314}', // Greek psili
'\u{031B}', // Horn
'\u{033D}', // X above
'\u{0340}', // Grave tone mark
'\u{0341}', // Acute tone mark
'\u{0342}', // Greek perispomeni
'\u{0343}', // Greek koronides
'\u{0344}', // Dialytika tonos (Greek)
'\u{0346}', // Bridge above
'\u{034F}', // Combining grapheme joiner
'\u{0350}', // Right arrowhead above
'\u{0351}', // Left half ring above
'\u{0352}', // Fermata
'\u{0357}', // Right half ring above
'\u{0358}', // Dot above right
'\u{035B}', // Reversed comma above
'\u{0363}', // Greek letters in superscript (some accents on vowels)
'\u{036F}', // Nonspacing (various small marks)
];
//const ZALGO_UP: &[char] = &[
const ZALGO_MIDDLE: &[char] = &[
'\u{0334}', // Combining tilde overlay
'\u{0335}', // Combining short stroke overlay
'\u{0336}', // Combining long stroke overlay (strikethrough)
'\u{0337}', // Combining short solidus overlay (short slash)
'\u{0338}', // Combining long solidus overlay (long slash)
'\u{20E5}', // Combining reverse slash
'\u{0346}', // Combining bridge above (used in scripts like Cyrillic)
'\u{034A}', // Combining left right arrowhead below (double arrow overlay)
'\u{034B}', // Combining right arrowhead below
'\u{034C}', // Combining right arrowhead above
'\u{20D2}', // Combining enclosing square
'\u{20D3}', // Combining enclosing diamond
'\u{20D4}', // Combining enclosing circle
'\u{20D5}', // Combining enclosing circle backslash
'\u{20D6}', // Combining left arrow above
'\u{20D7}', // Combining right arrow above
'\u{20E6}', // Combining double vertical stroke overlay
'\u{20E7}', // Combining ankh above
'\u{20E8}', // Combining long vertical line overlay
'\u{20E9}', // Combining left arrow below
];
const ZALGO_DOWN: &[char] = &[
'\u{0316}', // Subscript grave
'\u{0317}', // Subscript acute
'\u{0318}', // Subscript circumflex
'\u{0319}', // Subscript inverted breve
'\u{031C}', // Left half ring below
'\u{031D}', // Right half ring below
'\u{031E}', // Left tack below
'\u{031F}', // Right tack below
'\u{0320}', // Long stroke below
'\u{0323}', // Dot below
'\u{0324}', // Diaeresis below
'\u{0325}', // Ring below
'\u{0326}', // Comma below
'\u{0327}', // Cedilla
'\u{0328}', // Ogonek
'\u{0329}', // Vertical line below
'\u{032A}', // Bridge below
'\u{032B}', // Inverted double arch below
'\u{032C}', // Caron below
'\u{032D}', // Circumflex below
'\u{032E}', // Breve below
'\u{032F}', // Inverted breve below
'\u{0330}', // Tilde below
'\u{0331}', // Macron below
'\u{0332}', // Low line (underscore)
'\u{0333}', // Double low line (double underscore)
'\u{0339}', // Left half ring below
'\u{033A}', // Right half ring below
'\u{033B}', // Reversed comma below
'\u{033C}', // Reversed double arch below
'\u{0345}', // Iota subscript (Greek)
'\u{0347}', // Equals sign below
'\u{0348}', // Double vertical line below
'\u{0349}', // Left arrowhead below
'\u{034A}', // Right arrowhead below
'\u{034B}', // Left right arrowhead below
'\u{034C}', // Right arrowhead below
'\u{0353}', // X below
'\u{0359}', // Vertical tilde below
'\u{035A}', // Double breve below
];