From 06506329fa89a0513048a000bd06314472c10f2c Mon Sep 17 00:00:00 2001 From: ame Date: Thu, 7 Dec 2023 16:01:43 -0600 Subject: string stuff & closed file from reading --- src/io.c | 43 +++++- src/io.h | 27 ++++ src/sort.c | 426 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/sort.h | 20 +++ src/table.c | 451 ++++++------------------------------------------------------ src/table.h | 25 +--- 6 files changed, 561 insertions(+), 431 deletions(-) create mode 100644 src/sort.c create mode 100644 src/sort.h (limited to 'src') diff --git a/src/io.c b/src/io.c index 3f2922c..6d07a44 100644 --- a/src/io.c +++ b/src/io.c @@ -30,7 +30,48 @@ int l_readfile(lua_State* L){ } out[count] = '\0'; lua_pushstring(L, out); - + + fclose(fp); free(out); return 1; }; + +lua_Debug i_get_debug(lua_State* L){ + lua_Debug ar; + lua_getstack(L, 1, &ar); + lua_getinfo(L, "nSl", &ar); + return ar; +} + +int l_debug(lua_State* L){ + size_t input_len = 0; + char* input = (char*)luaL_checklstring(L, 1, &input_len); + lua_Debug debug = i_get_debug(L); + printf(color_gray"[ debug ] (%s:%i) %s\n"color_reset, debug.source, debug.currentline, input); + return 0; +} + +int l_log(lua_State* L){ + size_t input_len = 0; + char* input = (char*)luaL_checklstring(L, 1, &input_len); + lua_Debug debug = i_get_debug(L); + printf(color_green"[ log ] (%s:%i)"color_gray" %s\n"color_reset, debug.source, debug.currentline, input); + return 0; +} + +int l_warn(lua_State* L){ + size_t input_len = 0; + char* input = (char*)luaL_checklstring(L, 1, &input_len); + lua_Debug debug = i_get_debug(L); + printf(color_yellow"[ warn ] (%s:%i) %s\n"color_reset, debug.source, debug.currentline, input); + return 0; +} + +int l_error(lua_State* L){ + size_t input_len = 0; + char* input = (char*)luaL_checklstring(L, 1, &input_len); + lua_Debug debug = i_get_debug(L); + printf(color_red"[ error ] (%s:%i) %s\n"color_reset, debug.source, debug.currentline, input); + return 0; +} + diff --git a/src/io.h b/src/io.h index ccfe5cc..7cbca95 100644 --- a/src/io.h +++ b/src/io.h @@ -1,8 +1,35 @@ #include "lua.h" +#define color_black "\e[30m" +#define color_red "\e[31m" +#define color_green "\e[32m" +#define color_yellow "\e[33m" +#define color_blue "\e[34m" +#define color_magenta "\e[35m" +#define color_cyan "\e[36m" +#define color_lgray "\e[37m" +#define color_gray "\e[90m" +#define color_lred "\e[91m" +#define color_lgreen "\e[92m" +#define color_lyellow "\e[93m" +#define color_lblue "\e[94m" +#define color_lmagenta "\e[95m" +#define color_lcyan "\e[96m" +#define color_white "\e[97m" +#define color_reset "\e[0m" + int l_readfile(lua_State*); +int l_debug(lua_State*); +int l_log(lua_State*); +int l_warn(lua_State*); +int l_error(lua_State*); static const luaL_Reg io_function_list [] = { {"readfile",l_readfile}, + {"debug",l_debug}, + {"log",l_log}, + {"warn",l_warn}, + {"error",l_error}, + {NULL,NULL} }; diff --git a/src/sort.c b/src/sort.c new file mode 100644 index 0000000..ee9a40b --- /dev/null +++ b/src/sort.c @@ -0,0 +1,426 @@ +#include "table.h" +#include + +int i_hoarepartition(double* arr, int low, int high){ + double pivot = arr[((int)((high - low) / 2)) + low]; + int i = low - 1; + int j = high + 1; + + for(;;){ + i++; j--; + + while(arr[i] > pivot) i++; + while(arr[j] < pivot) j--; + if(i >= j) return j; + + i_swap(arr[i],arr[j]); + } +} + +void i_quicksort(double* arr, int low, int high){ + if(low >= 0 && high >= 0 && low < high){ + int p = i_hoarepartition(arr, low, high); + i_quicksort(arr, low, p); + i_quicksort(arr, p + 1, high); + } +} + +int l_quicksort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + + i_quicksort(nums, 0, len - 1); + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} + +void i_merge(double* arr, int b, int m, int e){ + int n1 = m - b + 1; + int n2 = e - m; + + double* left = malloc(sizeof * left * n1); + double* right = malloc(sizeof * right * n2); + + for(int i = 0; i < n1; i++) left[i] = arr[b + i]; + for(int i = 0; i < n2; i++) right[i] = arr[m + 1 + i]; + + int l_ind = 0; + int r_ind = 0; + int k = b; + + for(; l_ind < n1 && r_ind < n2; k++){ + if(left[l_ind] >= right[r_ind]){ + arr[k] = left[l_ind]; + l_ind++; + } else { + arr[k] = right[r_ind]; + r_ind++; + } + } + + for(; l_ind < n1; k++){ + arr[k] = left[l_ind]; + l_ind++; + } + for(; r_ind < n2; k++){ + arr[k] = right[r_ind]; + r_ind++; + } + + free(left); + free(right); +} + +void i_mergesort(double* arr, int b, int e){ + if(b < e){ + int mid = (b + e) /2; + i_mergesort(arr, b, mid); + i_mergesort(arr, mid + 1, e); + i_merge(arr, b, mid, e); + } +} + +int l_mergesort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + + i_mergesort(nums, 0, len - 1); + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} + +void i_heapify(double* arr, int n, int i){ + int largest = i; + int left = 2 * i + 1; + int right = 2 * i + 2; + + if(left < n && arr[left] < arr[largest]) + largest = left; + + if(right < n && arr[right] < arr[largest]) + largest = right; + + if(largest != i){ + i_swap(arr[i],arr[largest]); + i_heapify(arr,n,largest); + } +} + +int l_heapsort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + for(int i = len / 2 - 1; i >= 0; i--) + i_heapify(nums,len,i); + + for(int i = len - 1; i >= 0; i--){ + i_swap(nums[i],nums[0]); + i_heapify(nums, i, 0); + } + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + free(nums); + return 1; +} + +int l_shellsort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + + for(int interval = len/2; interval > 0; interval /=2){ + for(int i = interval; i < len; i++){ + double temp = nums[i]; + int j; + for(j = i; j >= interval && nums[j - interval] < temp; j -= interval){ + nums[j] = nums[j - interval]; + } + nums[j] = temp; + } + } + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} + +int l_bubblesort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + + int n = len; + for(;n > 0;){ + int new = 0; + + for(int i = 0; i != n-1; i++){ + if(nums[i+1]>nums[i]){ + double temp = nums[i]; + nums[i] = nums[i+1]; + nums[i+1] = temp; + + new = i+1; + } + } + + n = new; + } + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} + +int l_countingsort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + int* nums = malloc(sizeof * nums * len); + int* out = malloc(sizeof * nums * len); + int max = 0; + for(int i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + out[i] = 0; + + if(nums[i]<0) p_fatal("array.countingsort() requires all indices to be >= 0"); + max = max < nums[i] ? nums[i] : max; + + lua_pop(L,1); + } + + int* count = calloc(max + 1, sizeof * count); + + for(size_t i = 0; i < len; i++){ + count[nums[i]]++; + } + + for(size_t i = 1; i <= max; i++){ + count[i] += count[i - 1]; + } + + for(int i = len - 1; i >= 0; i--){ + out[count[nums[i]] - 1] = nums[i]; + count[nums[i]]--; + } + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,out[i]); + lua_settable(L, -3); + } + + free(count); + free(nums); + free(out); + return 1; +} + +int i_sorted(double* arr, size_t len){ + for(size_t i = 0; i != len - 1; i++) + if(arr[i] > arr[i+1]) return 0; + return 1; +} + +int l_miraclesort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + + for(;!i_sorted(nums,len);); + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} + +int l_stalinsort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + size_t rlen = 0; + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + double n = luaL_checknumber(L, -1); + if(rlen == 0 || nums[rlen - 1] <= n){ + nums[rlen] = n; + rlen++; + } + + lua_pop(L,1); + } + + + lua_newtable(L); + for(size_t i = 0; i != rlen; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} + +void i_slowsort(double* arr, int i, int j){ + if(i >= j) return; + + int m = (i + j) /2; + + i_slowsort(arr, i, m); + i_slowsort(arr, m + 1, j); + + if(arr[j] < arr[m]){ + i_swap(arr[j], arr[m]); + } + + i_slowsort(arr, i, j - 1); +} + +int l_slowsort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(int i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + + i_slowsort(nums, 0, len - 1); + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} + +int l_bogosort(lua_State* L) { + luaL_checktype(L, 1, LUA_TTABLE); + size_t len = lua_objlen(L,1); + double* nums = malloc(sizeof * nums * len); + for(size_t i = 0; i <= len-1; i++){ + + lua_pushinteger(L,i+1); + lua_gettable(L,1); + + nums[i] = luaL_checknumber(L, -1); + lua_pop(L,1); + } + + for(;!i_sorted(nums, len);){ + i_shuffle(nums, len); + } + + lua_newtable(L); + for(size_t i = 0; i != len; i++){ + lua_pushnumber(L,i+1); + lua_pushnumber(L,nums[i]); + lua_settable(L, -3); + } + + free(nums); + return 1; +} diff --git a/src/sort.h b/src/sort.h new file mode 100644 index 0000000..1b54164 --- /dev/null +++ b/src/sort.h @@ -0,0 +1,20 @@ +#include "lua.h" +#include "i_util.h" +#include "i_common.h" + +//comparison sorts +int l_quicksort(lua_State*); //[double+int] -> arr[N] (greatest -> least) +int l_mergesort(lua_State*); //[double+int] -> arr[N] (greatest -> least) +int l_shellsort(lua_State*); //[double+int] -> arr[N] (greatest -> least) +int l_bubblesort(lua_State*); //[double+int] -> arr[N] (greatest -> least) +int l_heapsort(lua_State*); //[double+int] -> arr[N] (greatest -> least) + +//non-comparison sorts + //good for large arrays filled with small values +int l_countingsort(lua_State*); //[int] (arr[N] >= 0) -> arr[N] (least -> greatest) + +//esoteric sorts +int l_miraclesort(lua_State*); //[double+int] -> arr[-∞<=N<=∞] (greatest -> least) +int l_stalinsort(lua_State*); //[double+int] -> arr[?<=N] (greatest -> least) +int l_slowsort(lua_State*); //[double+int] -> arr[N] (greatest -> least) +int l_bogosort(lua_State*); //[double+int] -> arr[N] (greatest -> least) diff --git a/src/table.c b/src/table.c index aae709f..4e99cf1 100644 --- a/src/table.c +++ b/src/table.c @@ -1,5 +1,6 @@ #include "table.h" #include +#include int l_len(lua_State* L) { luaL_checktype(L, 1, LUA_TTABLE); @@ -172,426 +173,52 @@ int l_sindexof(lua_State* L) { return 1; } -int i_hoarepartition(double* arr, int low, int high){ - double pivot = arr[((int)((high - low) / 2)) + low]; - int i = low - 1; - int j = high + 1; +int l_split(lua_State* L){ + size_t input_len = 0; + size_t split_len = 0; + char* input = (char*)luaL_checklstring(L, 1, &input_len); + char* split = (char*)luaL_checklstring(L, 2, &split_len); + size_t table_len = 0; + lua_newtable(L); - for(;;){ - i++; j--; - - while(arr[i] > pivot) i++; - while(arr[j] < pivot) j--; - if(i >= j) return j; - - i_swap(arr[i],arr[j]); - } -} - -void i_quicksort(double* arr, int low, int high){ - if(low >= 0 && high >= 0 && low < high){ - int p = i_hoarepartition(arr, low, high); - i_quicksort(arr, low, p); - i_quicksort(arr, p + 1, high); - } -} - -int l_quicksort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ + size_t current_len = 0; + char current[input_len]; + memset(current, 0, input_len); - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); + for(size_t i = 0; i <= (input_len - 1) - (split_len - 1); i++){ + int match = 1; + for(size_t z = 0; z <= split_len - 1 && match; z++){ + if(split[z] != input[z + i]) match = 0; } - - i_quicksort(nums, 0, len - 1); - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); + if(match){ + lua_pushnumber(L, table_len++); + lua_pushstring(L, current); lua_settable(L, -3); - } - - free(nums); - return 1; -} - -void i_merge(double* arr, int b, int m, int e){ - int n1 = m - b + 1; - int n2 = e - m; - - double* left = malloc(sizeof * left * n1); - double* right = malloc(sizeof * right * n2); - - for(int i = 0; i < n1; i++) left[i] = arr[b + i]; - for(int i = 0; i < n2; i++) right[i] = arr[m + 1 + i]; - - int l_ind = 0; - int r_ind = 0; - int k = b; - - for(; l_ind < n1 && r_ind < n2; k++){ - if(left[l_ind] >= right[r_ind]){ - arr[k] = left[l_ind]; - l_ind++; - } else { - arr[k] = right[r_ind]; - r_ind++; - } - } - - for(; l_ind < n1; k++){ - arr[k] = left[l_ind]; - l_ind++; - } - for(; r_ind < n2; k++){ - arr[k] = right[r_ind]; - r_ind++; - } - - free(left); - free(right); -} - -void i_mergesort(double* arr, int b, int e){ - if(b < e){ - int mid = (b + e) /2; - i_mergesort(arr, b, mid); - i_mergesort(arr, mid + 1, e); - i_merge(arr, b, mid, e); - } -} - -int l_mergesort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); + memset(current, 0, input_len); + current_len = 0; + } else { + current[current_len] = input[i]; + current_len++; } - - i_mergesort(nums, 0, len - 1); - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } - - free(nums); - return 1; -} - -void i_heapify(double* arr, int n, int i){ - int largest = i; - int left = 2 * i + 1; - int right = 2 * i + 2; - - if(left < n && arr[left] < arr[largest]) - largest = left; - - if(right < n && arr[right] < arr[largest]) - largest = right; - - if(largest != i){ - i_swap(arr[i],arr[largest]); - i_heapify(arr,n,largest); } -} - -int l_heapsort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); - } - for(int i = len / 2 - 1; i >= 0; i--) - i_heapify(nums,len,i); - - for(int i = len - 1; i >= 0; i--){ - i_swap(nums[i],nums[0]); - i_heapify(nums, i, 0); - } - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } - free(nums); - return 1; -} - -int l_shellsort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); - } - - for(int interval = len/2; interval > 0; interval /=2){ - for(int i = interval; i < len; i++){ - double temp = nums[i]; - int j; - for(j = i; j >= interval && nums[j - interval] < temp; j -= interval){ - nums[j] = nums[j - interval]; - } - nums[j] = temp; - } - } - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } + lua_pushnumber(L, table_len++); + lua_pushstring(L, current); + lua_settable(L, -3); - free(nums); - return 1; + return 1; } -int l_bubblesort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); - } - - int n = len; - for(;n > 0;){ - int new = 0; - - for(int i = 0; i != n-1; i++){ - if(nums[i+1]>nums[i]){ - double temp = nums[i]; - nums[i] = nums[i+1]; - nums[i+1] = temp; - - new = i+1; - } - } - - n = new; - } - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } - - free(nums); - return 1; -} - -int l_countingsort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - int* nums = malloc(sizeof * nums * len); - int* out = malloc(sizeof * nums * len); - int max = 0; - for(int i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - out[i] = 0; - - if(nums[i]<0) p_fatal("array.countingsort(
) requires all indices to be >= 0"); - max = max < nums[i] ? nums[i] : max; - - lua_pop(L,1); - } - - int* count = calloc(max + 1, sizeof * count); - - for(size_t i = 0; i < len; i++){ - count[nums[i]]++; - } - - for(size_t i = 1; i <= max; i++){ - count[i] += count[i - 1]; - } - - for(int i = len - 1; i >= 0; i--){ - out[count[nums[i]] - 1] = nums[i]; - count[nums[i]]--; - } - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,out[i]); - lua_settable(L, -3); - } - - free(count); - free(nums); - free(out); - return 1; -} - -int i_sorted(double* arr, size_t len){ - for(size_t i = 0; i != len - 1; i++) - if(arr[i] > arr[i+1]) return 0; - return 1; -} - -int l_miraclesort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); - } - - for(;!i_sorted(nums,len);); - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } - - free(nums); - return 1; -} - -int l_stalinsort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - size_t rlen = 0; - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - double n = luaL_checknumber(L, -1); - if(rlen == 0 || nums[rlen - 1] <= n){ - nums[rlen] = n; - rlen++; - } - - lua_pop(L,1); - } - - - lua_newtable(L); - for(size_t i = 0; i != rlen; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } - - free(nums); - return 1; -} - -void i_slowsort(double* arr, int i, int j){ - if(i >= j) return; - - int m = (i + j) /2; - - i_slowsort(arr, i, m); - i_slowsort(arr, m + 1, j); - - if(arr[j] < arr[m]){ - i_swap(arr[j], arr[m]); - } - - i_slowsort(arr, i, j - 1); -} - -int l_slowsort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(int i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); - } - - i_slowsort(nums, 0, len - 1); - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } - - free(nums); - return 1; -} - -int l_bogosort(lua_State* L) { - luaL_checktype(L, 1, LUA_TTABLE); - size_t len = lua_objlen(L,1); - double* nums = malloc(sizeof * nums * len); - for(size_t i = 0; i <= len-1; i++){ - - lua_pushinteger(L,i+1); - lua_gettable(L,1); - - nums[i] = luaL_checknumber(L, -1); - lua_pop(L,1); - } - - for(;!i_sorted(nums, len);){ - i_shuffle(nums, len); - } - - lua_newtable(L); - for(size_t i = 0; i != len; i++){ - lua_pushnumber(L,i+1); - lua_pushnumber(L,nums[i]); - lua_settable(L, -3); - } - - free(nums); - return 1; +int l_to_char_array(lua_State* L){ + size_t input_len = 0; + char* input = (char*)luaL_checklstring(L, 1, &input_len); + lua_newtable(L); + + for(size_t i = 0; i <= input_len - 1; i++){ + lua_pushnumber(L, i + 1); + char uwu = input[i]; + lua_pushstring(L, &uwu); + lua_settable(L, -3); + } + return 1; } diff --git a/src/table.h b/src/table.h index f3c68ff..bf27ffc 100644 --- a/src/table.h +++ b/src/table.h @@ -1,6 +1,9 @@ #include "lua.h" #include "i_util.h" #include "i_common.h" +#include "sort.h" + +void i_shuffle(double*, size_t); int l_len(lua_State*); //[double+int] -> i int l_reverse(lua_State*); //[double+int] -> arr[N] @@ -11,24 +14,8 @@ int l_sum(lua_State*); //[double+int] -> i int l_indexof(lua_State*); //[double+int], item -> i int l_sindexof(lua_State*);//[double+int] (greatest -> least), item -> i - -//comparison sorts -int l_quicksort(lua_State*); //[double+int] -> arr[N] (greatest -> least) -int l_mergesort(lua_State*); //[double+int] -> arr[N] (greatest -> least) -int l_shellsort(lua_State*); //[double+int] -> arr[N] (greatest -> least) -int l_bubblesort(lua_State*); //[double+int] -> arr[N] (greatest -> least) -int l_heapsort(lua_State*); //[double+int] -> arr[N] (greatest -> least) - -//non-comparison sorts - //good for large arrays filled with small values -int l_countingsort(lua_State*); //[int] (arr[N] >= 0) -> arr[N] (least -> greatest) - -//esoteric sorts -int l_miraclesort(lua_State*); //[double+int] -> arr[-∞<=N<=∞] (greatest -> least) -int l_stalinsort(lua_State*); //[double+int] -> arr[?<=N] (greatest -> least) -int l_slowsort(lua_State*); //[double+int] -> arr[N] (greatest -> least) -int l_bogosort(lua_State*); //[double+int] -> arr[N] (greatest -> least) - +int l_split(lua_State*); +int l_to_char_array(lua_State*); static const luaL_Reg array_function_list [] = { {"len",l_len}, @@ -37,6 +24,8 @@ static const luaL_Reg array_function_list [] = { {"least",l_least}, {"shuffle",l_shuffle}, {"sum",l_sum}, + {"split",l_split}, + {"to_char_array", l_to_char_array}, {"index",l_indexof}, {"sindex",l_sindexof}, -- cgit v1.2.3