str = "abc(123)def ghij klm (456) opqrs"
maxchars = 10 
position = maxchars + (maxchars - str:sub(1,maxchars):gsub("%b()",""):len())

s="abc(123)def ghij klm (456) opqrs"
maxchar=10
char_of_s_out_maxchar=s:sub((maxchar+1),#s)
position_of_s_out_maxchar=(#s-maxchar)

s:len() - maxchars

f="abcd(123) efgh(456)"
maxchar=10
return f:sub(1,maxchar)

function getSubstrWithoutBrackets(str, len)
	local l = str:len()
	local count = 0
	bracket = false
	local i
	for i = 1, l do
		sub = str:sub(i, i)
		if not bracket then
			if sub == "(" then
				bracket = true
			else
				count = count + 1
				if count >= len then
					return print(str:sub(1, i))
				end
			end
		elseif sub == ")" then
			bracket = false
		end
	end
	return str
end

print(getSubstrWithoutBrackets("abc(123)def ghij klm (456) opqrs", 5))
print(getSubstrWithoutBrackets("abc(123)def ghij klm (456) opqrs", 18))
print(getSubstrWithoutBrackets("abc(123)def ghij klm (456) opqrs", 100))

f="abcd(123) efgh(456)"
maxchar=10
return f:sub(1,maxchar)

-- Parse takes an action table t and computes the fixed point of this grammar + string
function parse(t)
    if t:terminate() then return end
    local peek = t.hash(string.char(t.stream:byte(t.at)))
    t.at = t.at + 1
    t[peek](t)
    return t
end

-- Stack of characters consumed grouped by bracketing level
local stack = {0}
-- Maximum number of characters to parse before breaking
local max_char = 10

function push() table.insert(stack, 1) end
function pop() assert(#stack > 1, 'Dangling )'); table.remove(stack, #stack) end
function count() stack[#stack] = stack[#stack] + 1 end

trace = parse {
    -- This is the string of character we want to parse
    stream = "1234(xx()X(x))5678()90~~~~~~~",
    -- At the end of the run, at will point to the end of the 10 unbracketed characters
    at = 1,
    -- This is a function that maps each character to an action label (so '(' = left, 'r' = right, etc)
    hash = function(char) return ({['('] = 'left', [')'] = 'right', [''] = 'null'})[char] or 'character' end,
    -- What to do when we encounter a normal character
    character = function(t) count(); parse(t) end,
    -- What to do when we encounter a left parenthesis
    left = function(t) push(); parse(t) end,
    -- What to do when we encounter a right parenthesis
    right = function(t) pop(); parse(t) end,
    -- What to do when we encounter the end of the stream
    null = function(t) --[[Reduce stack]] assert(#stack == 1, 'Dangling (') end,
    -- The condition for us to terminate
    terminate = function(t) return stack[1] >= max_char end,
    -- What was parsed/consumed in this trace
    consumed = function(t) return t.stream:sub(1, trace.at - 1) end}

print(trace:consumed())

function weird(str, n)
	--remember the position of the last right bracket
	local lastright = 0
	--find the next pair of balanced brackets
	local left, right = str:find("%b()")
	while left ~= right do
		--if there is a bracket between lastright and the next pair, the brackets are unbalanced
		if str:find("[%(%)]", lastright+1) < left then
			print("unbalanced brackets")
			return nil
		end
		--if we can return in this section, do so
		if left - lastright > n then
			return str:sub(1, lastright + n)
		end
		--decrease remaining characters
		n = n - (left - lastright - 1)
		lastright = right
		left, right = str:find("%b()", right)
	end
	if str:find("[%(%)]", lastright+1) then
		print("unbalanced brackets")
		return nil
	end
	if str:len() - lastright > n then
		return str:sub(1, lastright + n)
	end
	return str
end