Who can use V language to implement the algorithm in JavaScript language

[Avey777]

//tkk = '441865.2154418832';
var nu = function (a, b) {
    for (var c = 0; c < b.length - 2; c += 3) {
        var d = b.charAt(c + 2);
        d = "a" <= d ? d.charCodeAt(0) - 87 : Number(d);
        d = "+" == b.charAt(c + 1) ? a >>> d : a << d;
        a = "+" == b.charAt(c) ? a + d & 4294967295 : a ^ d
    }
    return a
},

pu = function (a) {
    tkk='441865.2154418832';
    var d = tkk.split(".");
    var b = Number(d[0]);
    for (var e = [], f = 0, g = 0; g < a.length; g++) {
        var h = a.charCodeAt(g);
        128 > h ? e[f++] = h :
            (2048 > h ? e[f++] = h >> 6 | 192 :
                    (55296 == (h & 64512) && g + 1 < a.length && 56320 == (a.charCodeAt(g + 1) & 64512) ? (h = 65536 + ((h & 1023) << 10) + (a.charCodeAt(++g) & 1023), e[f++] = h >> 18 | 240, e[f++] = h >> 12 & 63 | 128) :
                        e[f++] = h >> 12 | 224, e[f++] = h >> 6 & 63 | 128), e[f++] = h & 63 | 128)
    }
    a = b;
    for (f = 0; f < e.length; f++)
        a += e[f],
        a = nu(a, "+-a^+6");
    a = nu(a, "+-3^+b+-f");
    a ^= Number(d[1]) || 0;
    0 > a && (a = (a & 2147483647) + 2147483648);
    a %= 1E6;
    return (a.toString() + "." + (a ^ b))
};

[lv37]

@[direct_array_access; inline]
fn nu(initial_value i64, str string) int {
	mut out := initial_value
	runes := str.runes()
	for i := 0; i < runes.len - 2; i += 3 {
		operation := runes[i]
		char_code := runes[i + 2]
		char_value := if `a` <= char_code { char_code - 87 } else { runes[i + 2].str().u8() }
		shifted_value := if `+` == runes[i + 1] {
			i64(out >>> char_value)
		} else {
			i64(u64(out) << char_value)
		}
		out = if `+` == operation { (out + shifted_value) & 4294967295 } else { out ^ shifted_value }
	}
	return int(out)
}

@[direct_array_access]
fn pu(str string) string {
	tkk := '441865.2154418832'
	tkk_parts := tkk.split('.')
	base_value := tkk_parts[0].i64()
	runes := str.runes()
	mut utf8_chars := []i64{cap: runes.len}
	mut char_idx := 0
	for char_idx < runes.len {
		mut char_code := i64(runes[char_idx])
		if char_code < 128 {
			utf8_chars << char_code
		} else {
			if char_code < 2048 {
				utf8_chars << (char_code >> 6) | 192
			} else if char_code >= 55296 && char_idx + 1 < runes.len && runes[char_idx + 1] >= 56320 {
				char_idx++
				char_code = 65536 + i64(u64(char_code & 1023) << 10) + (char_code & 1023)
				utf8_chars << (char_code >> 18) | 240
				utf8_chars << (char_code >> 12) & 63 | 128
			} else {
				utf8_chars << (char_code >> 12) | 224
				utf8_chars << (char_code >> 6) & 63 | 128
			}
			utf8_chars << (char_code & 63) | 128
		}
		char_idx++
	}

	mut result := base_value
	for b in utf8_chars {
		result += b
		result = nu(result, '+-a^+6')
	}

	result = nu(result, '+-3^+b+-f')
	if tkk_parts.len > 1 { result = int(result) ^ int(tkk_parts[1].i64()) }
	if result < 0 {
		result = (result & 2147483647) + 2147483648
	}

	result %= 1000000

	return result.str() + '.' + (result ^ base_value).str()
}

[Avey777]

fn main(){
t := pu("你好")
println(t)
}

output is： 207028.366269

The result of js execution is： 705327.818470

[lv37]

I fixed it (I edited the comment)

[JalonSolov]

You could likely simplify the code a bit by just using runes instead of characters. The for loop in fn pu would be

for char_code in str.runes() {

and you wouldn't have to call all the utf8 functions, wouldn't have to keep track of indexes, etc., since each rune is a UTF-8 character, properly parsed out.

[Avey777]

Yes
It's right now, that's great; Thank you very much for your efforts