273 lines
8.1 KiB
JavaScript
273 lines
8.1 KiB
JavaScript
let queue = [];
|
|
let final_queue = [];
|
|
let resultado = 0;
|
|
let cantidad_nums = 0;
|
|
let operation_order = ['+','-','/','*','^'];
|
|
let tally = 0;
|
|
|
|
function q_print(){
|
|
for (k=0; k < queue.length; k++){
|
|
setTimeout(console.log("Índice N°"+k+" es "+queue[k]),500);
|
|
}
|
|
return;
|
|
}
|
|
|
|
function a_print(array){
|
|
for (k=0; k < array.length; k++){
|
|
console.log("Índice N°"+k+" es "+array[k]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
function q_display(q_array) {
|
|
output.innerHTML = '';
|
|
for (i=0; i < q_array.length; i++) {
|
|
output.innerHTML += q_array[i];
|
|
}
|
|
return;
|
|
}
|
|
|
|
function q_manage(type, item){
|
|
if (type == 'add') {
|
|
queue.push(item);
|
|
q_display(queue);
|
|
} else if (type == 'remove') {
|
|
queue.splice(-1,1);
|
|
q_display(queue);
|
|
} else {
|
|
output.innerHTML = 'Entrada inválida';
|
|
}
|
|
return;
|
|
}
|
|
|
|
function a_concatnum(z_array) {
|
|
let a_length = z_array.length;
|
|
var a_concat = [];
|
|
var cont = 0;
|
|
var num = "";
|
|
let j = 0;
|
|
|
|
z_array.push(true); // push something other than number or string to trigger last exectuion
|
|
|
|
for (i=0; i < a_length; i++){
|
|
if (typeof(z_array[i]) == 'number'){
|
|
cont++;
|
|
} else {
|
|
for (j=0; j < cont; j++){
|
|
num = num + String(z_array[(j)]);
|
|
}
|
|
if (num != '') {
|
|
a_concat.push(parseInt(num))
|
|
}
|
|
num = "";
|
|
if (typeof(z_array[i] == 'string')) {
|
|
a_concat.push(z_array[i]);
|
|
}
|
|
z_array.splice(0,cont+1);
|
|
cont = 0;
|
|
i=-1;
|
|
a_length = z_array.length;
|
|
}
|
|
}
|
|
z_array = a_concat;
|
|
z_array.splice(-1,1); // remove that something i put in earlier
|
|
return z_array;
|
|
}
|
|
|
|
function a_split(l_array) {
|
|
function a_search_char(s_array,char, direction_from,excluded_points){
|
|
if (direction_from == 'right') {
|
|
s_array.reverse();
|
|
} else if (direction_from == 'left'){
|
|
} else {
|
|
output.innerHTML = 'Error en la dirección de búsqueda';
|
|
}
|
|
|
|
outerLoop: for (i=0; i < s_array.length; i++){
|
|
// Chequea si el punto encontrado está en la exclusión (para evitar repetidos)
|
|
innerLoop: for (j=0; j <= excluded_points.length; j++){
|
|
if (i == excluded_points[j]){
|
|
continue outerLoop;
|
|
}
|
|
}
|
|
if (s_array[i] == char) {
|
|
if (direction_from == 'right'){
|
|
return (s_array.length-i-1);
|
|
}
|
|
return i;
|
|
}
|
|
}
|
|
return -1; // No se ha encontrado
|
|
}
|
|
|
|
function array_divider(a_array, d_points){
|
|
let start = 0;
|
|
let divided_array = [];
|
|
for (i=0; i <= d_points.length; i++){
|
|
|
|
divided_array.push(a_array.slice(start,d_points[i]));
|
|
start =+ d_points[i] +1;
|
|
}
|
|
return divided_array;
|
|
}
|
|
|
|
/* Búsqueda de paréntesis
|
|
No lo voy a implementar esto, es un montón, intenté pensar
|
|
en un algoritmo pero no se me occurió, y busqué pero no quiero
|
|
usar un algoritmo tipo Shuning Yard, la idea de este código es
|
|
hacerlo sin ayudas, incluso si es ineficiente (este código tiene
|
|
O^n execution time, más recursión tiene esta cosa. */
|
|
|
|
// Buscar puntos dónde se encuentran caracteres en un array
|
|
function find_location_points(f_array,char) {
|
|
let location_points = [];
|
|
for (i=0; i < f_array.length; i++){
|
|
let search_result = a_search_char(f_array,char,'left',location_points);
|
|
// Break si ya no encuentra más
|
|
if ( search_result == -1 ){
|
|
break;
|
|
} else {
|
|
location_points.push(search_result);
|
|
}
|
|
}
|
|
return location_points;
|
|
}
|
|
|
|
function branch(b_array,char) {
|
|
b_array = array_divider(
|
|
b_array,
|
|
find_location_points(b_array,char));
|
|
return b_array;
|
|
}
|
|
|
|
function branching(b2_array){
|
|
// First
|
|
b2_array = branch(b2_array,'+');
|
|
|
|
// Second
|
|
for (l=0; l < b2_array.length; l++) {
|
|
b2_array[l] = branch(b2_array[l],operation_order[1]);
|
|
}
|
|
|
|
// Third
|
|
for (k=0; k < b2_array.length; k++) {
|
|
for (m=0; m < b2_array[k].length; m++){
|
|
b2_array[k][m] = branch(b2_array[k][m],operation_order[2]);
|
|
}
|
|
}
|
|
|
|
// Fourth
|
|
for (k=0; k < b2_array.length; k++) {
|
|
for (m=0; m < b2_array[k].length; m++){
|
|
for (n=0; n < b2_array[k][m].length; n++){
|
|
b2_array[k][m][n] = branch(b2_array[k][m][n],operation_order[3]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fifth
|
|
for (k=0; k < b2_array.length; k++) {
|
|
for (m=0; m < b2_array[k].length; m++){
|
|
for (n=0; n < b2_array[k][m].length; n++){
|
|
for (o=0; o < b2_array[k][m][n].length; o++){
|
|
b2_array[k][m][n][o] = branch(b2_array[k][m][n][o],operation_order[4]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return b2_array;
|
|
|
|
}
|
|
l_array = branching(l_array);
|
|
return l_array;
|
|
}
|
|
|
|
function a_calculate(array) {
|
|
// Exponenciation
|
|
for (k=0; k < array.length; k++) {
|
|
for (m=0; m < array[k].length; m++){
|
|
for (n=0; n < array[k][m].length; n++){
|
|
outerFor: for (o=0; o < array[k][m][n].length; o++){
|
|
innerFor: for (z = 0; z < array[k][m][n][o].length; z++){
|
|
// There is an extra [0] at the end of each exponenciation compensating extra nesting (?)
|
|
if (array[k][m][n][o].length == 1){
|
|
array[k][m][n][o] = array[k][m][n][o][0][0];
|
|
continue outerFor;
|
|
}
|
|
array[k][m][n][o][0] = array[k][m][n][o][0][0] ** array[k][m][n][o][1][0];
|
|
array[k][m][n][o].splice(1,1);
|
|
}
|
|
array[k][m][n][o] = array[k][m][n][o][0];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Multiplication
|
|
for (k=0; k < array.length; k++) {
|
|
for (m=0; m < array[k].length; m++){
|
|
outerFor: for (n=0; n < array[k][m].length; n++){
|
|
innerFor: for (z = 0; z < array[k][m][n].length; z++){
|
|
if (array[k][m][n].length == 1){
|
|
array[k][m][n]= array[k][m][n][0];
|
|
continue outerFor;
|
|
}
|
|
array[k][m][n][0] = array[k][m][n][0] * array[k][m][n][1];
|
|
array[k][m][n].splice(1,1);
|
|
}
|
|
array[k][m][n] = array[k][m][n][0];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Division
|
|
for (k=0; k < array.length; k++) {
|
|
outerFor: for (m=0; m < array[k].length; m++){
|
|
innerFor: for (z = 0; z < array[k][m].length; z++){
|
|
if (array[k][m].length == 1){
|
|
array[k][m]= array[k][m][0];
|
|
continue outerFor;
|
|
}
|
|
array[k][m][0] = array[k][m][0] / array[k][m][1];
|
|
array[k][m].splice(1,1);
|
|
}
|
|
array[k][m] = array[k][m][0];
|
|
}
|
|
}
|
|
|
|
// Subtraction
|
|
outerFor: for (k=0; k < array.length; k++) {
|
|
innerFor: for (z = 0; z < array[k].length; z++){
|
|
if (array[k].length == 1){
|
|
array[k]= array[k][0];
|
|
continue outerFor;
|
|
}
|
|
array[k][0] = array[k][0] - array[k][1];
|
|
array[k].splice(1,1);
|
|
}
|
|
array[k] = array[k][0];
|
|
}
|
|
|
|
// Addition
|
|
outerFor: for (k=0; k < array.length; k++) {
|
|
innerFor: for (z = 0; z < array.length; z++){
|
|
if (array.length == 1){
|
|
continue outerFor;
|
|
}
|
|
array[0] = array[0] + array[1];
|
|
array.splice(1,1);
|
|
}
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
|
|
function q_execute() {
|
|
//q_concatnum();
|
|
queue = a_concatnum(queue);
|
|
queue = a_split(queue);
|
|
queue = a_calculate(queue);
|
|
q_display(queue);
|
|
return;
|
|
} |