LÖVE

Code: Select all

function alphabetic_order(a, b)
	local g = "abcdefghijklmnopqrstuvwxyz"
	local alphabet = {}
	for i = 1, string.len(g) do table.insert(alphabet, string.sub(g, i, i)) end
	
	local a, b = string.lower(a), string.lower(b)
	for j = 1, math.min(string.len(a), string.len(b)) do
		local aa, bb = string.sub(a, j, j), string.sub(b, j, j)
		if aa ~= bb then
			if table.contains(alphabet, aa) and table.contains(alphabet, bb) then
				if table.contains(alphabet, aa) < table.contains(alphabet, bb) then
					return true
				elseif table.contains(alphabet, aa) > table.contains(alphabet, bb) then
					return false
				end
			elseif table.contains(alphabet, aa) then
				return false
			else
				return true
			end
		elseif j == math.min(string.len(a), string.len(b)) then --virtually similar, return the smallest as first
			return (string.len(a) < string.len(b) and true) or false
		end
	end
end

Code: Select all

table.sort(table, function(a, b)
	return alphabetic_order(table[a], table[b])
end)

Code: Select all

   local g = "abcdefghijklmnopqrstuvwxyz"
   local alphabet = {}
   for i = 1, string.len(g) do table.insert(alphabet, string.sub(g, i, i)) end

Code: Select all

table.sort(t, function (a, b)
	return string.lower(a) < string.lower(b)
end)

Code: Select all

function alphabetic_sort(a,b)
    -- Handle words that are the same until a certain point
    local i = 1
    while a:sub( i, i ) == b:sub( i, i ) do
        i = i + 1
        -- No letter goes before words with letters
        if i > #a then return true end
        if i > #b then return false end
    end
    return a:sub( i, i ) < b:sub( i, i )
end

Code: Select all

table.sort( tab, alphabetic_sort )
-- Reverse alphabetized
table.sort( tab, function( a, b ) return not alphabetic_sort( a, b ) end )

Code: Select all

local t = {
    "something",
    "somewhere",
    "someone",
    "someday",
    "some",
    "so",
    "s",
    "abc"
}

table.sort(t)

for i, v in ipairs(t) do
   print(i, v)
end

--Output:
--1	abc
--2	s
--3	so
--4	some
--5	someday
--6	someone
--7	something
--8	somewhere

Code: Select all

table.sort(t, function (a,b) return string.lower(a) < string.lower(b) end)

Code: Select all

local function pack_n(...)
  return {select('#', ...), ...}
end

local unpack_n
do
  local function unpack_count(x, n)
    if n == x[1] + 1 then
      return
    end
    n = n + 1
    return x[n], unpack_count(x, n)
  end

  function unpack_n(a)
    return unpack_count(a, 1)
  end
end

Code: Select all

local function my_crazy_func()
  return nil, 2, 3, nil, "yes", math.acos(3), false, nil
end

-- Store the returned tuple in a table
local packed = pack_n(my_crazy_func())
-- Retrieve the table as a tuple and print it
print(unpack_n(packed))
-- output: nil	2	3	nil	yes	nan	false	nil

-- By comparison, using the default Lua unpack fails with the nils:
packed = {my_crazy_func()}
print(unpack(packed))
-- output: nil 2 3

Code: Select all

local function pack(...)
	return {n=select("#", ...), ...}
end
local function getSomeValues()
	return 8, nil, "foo"
end
local packed = pack(getSomeValues())
print(unpack(packed, 1, packed.n)) -- 8 nil foo