Каков наиболее компактный способ втиснуть список целых чисел в строку?

Цель:

Уменьшите размер массива целых чисел следующим образом: «[12, 1, -34, 55, 13, 341, 11, 56, 321, -3422, 1222, -4, 237]», сохраняя при этом возможность преобразовать его обратно. в исходное состояние. Сжатый вывод должен быть строкой.

Причина:

Из-за слишком длинных строк менеджер баз данных, который я использую, зависает при взаимодействии с ним. (Строки используются в качестве формата хранения для типов переменных, таких как массивы.)

Контекст:

По сути, я храню список координат сетки следующим образом: [Vector3(1,2,3), Vector3(4,5,6)] -> [1,2,3,4,5,6]

Я строю это в gdscript.

Моя лучшая попытка собрать воедино числа из первого примера целочисленного массива привела к следующему:

"c1-y.Td,y1.bU,w1-ym,cm-4,n7"

Путем присвоения связанных чисел > 9 нечисловому символу (например, 10 = a, 11 = b, 61 = Z) и размещать запятые только между преобразованными числами, состоящими из нескольких символов (а также использовать символ «-» в качестве своего рода запятой (это несколько сложно)). Это уменьшение размера в среднем на 48% без учета пробелов (проверено 200 случайно сгенерированных массивов).

Вопрос:

Есть ли лучший способ сделать то, что я пытаюсь сделать?

Окончательное редактирование:

Вот мое решение в gdscript, если оно кому-то понадобится.

extends Node
var negative_character_index = 50000
#skip all white space characters as well as "." and ","  and "()" 
#these are used for special cases
var start_char = 47

func num_to_char(num: int):
    var x = abs(num)
    if x > negative_character_index:
        #too large
        return
    else:
        x += start_char
        if num < 0:
            x += negative_character_index
        var char = String.chr(x)
        return char

func char_to_num(char : String):
    var x = char.unicode_at(0) - start_char
    if x == null:
        #maybe negative_character_index was changed
        breakpoint
    
    if x > negative_character_index:
        x -= negative_character_index
        x *= -1
        
    return x

#shorten int 
func int_to_compact_int_string(n:int):
    
    var compact_n = ""
    #largest convertable number
    var head = ""
    
    var last_head_int = null
    var last_char = null
    
    var get_zeros_code = func(head):
        
        var zeros = 0
        
        if head.begins_with("0"):
            
            for char2 in head:
                if char2 == "0":
                    
                    zeros += 1
                else:
                    break
            if head.right(1) == "0":
                
                zeros -=1
            if zeros > 0:
                return "("+str(zeros)+")"
        return ""
    
    for num in str(n):
        
        
        
        head += num
        print(head)
        if num != "-":
            
            var head_int = str_to_var(head)
            var char = get_zeros_code.call(head) + num_to_char(head_int)
            print(char)
            if last_head_int != null && char == null:
                compact_n += last_char
                head = ""
                head += num
                
                last_head_int = str_to_var(head)
                last_char = get_zeros_code.call(head) + num_to_char(last_head_int)
            else:
                last_head_int = head_int
                last_char = char
        print("~~~")
    if head != "":
        print(head)
        print(last_char)
        print("~~~")
        compact_n += last_char
    
    
    
    return compact_n



func int_arr_to_compact_str(int_arr):
    var compact_str = ""
    var is_multi = false
    for n in int_arr:
        
        var compact_n:String = int_to_compact_int_string(n)
        if compact_n.length() > 1: #seperate multicharacter compact numbers
            compact_str += ","
            is_multi = true
        elif is_multi:
            compact_str += "."
            is_multi =false
        
        
        
        compact_str += compact_n
        
    return compact_str


func new_compact_int_string_to_int(compact_n:String):
    
    
    var n = ""
    
    var is_zeros = false
    var zeros = ""
    
    for char in compact_n:
        if char == "(":
            is_zeros = true
            zeros = ""
        elif char == ")":
            is_zeros = false
            var i = 0
            
            while i < str_to_var(zeros):
                
                n += "0"
                i+=1
        elif is_zeros:
            zeros += char
        else:
            var index = char_to_num(char)
            if index > negative_character_index:
                index -= negative_character_index
                index *= -1
            
            n += str(index)
    
    
    return str_to_var(n)




func new_compact_str_to_int_arr(compact_str):
    var int_arr = []
    
    var is_multi = false
    var multi_compiler = ""
    for char in compact_str:
        if char == ',' || char == '.':
            is_multi = char == ','
            
            #end compiler
            if multi_compiler.length() >0:
                int_arr.append(new_compact_int_string_to_int(multi_compiler))
                multi_compiler = ""
            
            
            
            
            
        else:
            if is_multi:
                multi_compiler += char
            else:
                int_arr.append(new_compact_int_string_to_int(char))
    
    if multi_compiler.length() > 0:
        int_arr.append(new_compact_int_string_to_int(multi_compiler))
        multi_compiler = ""
    
    return int_arr

func _ready():
    var arr2 = [237, 50001, -5000000003, 250000000]
    
    #print("---")
    #for i in range(999):
        #print(String.chr(i)+" -> "+str(i))
    #print("---")
    
    print(arr2)
    var comp = int_arr_to_compact_str(arr2)
    print(comp)
    var r_arr2 = new_compact_str_to_int_arr(comp)
    print(r_arr2)