Ordinario 1

SF.js

var SF = (function() {
  /*
   * Entrada:
   *   f1(5, 3)
   * Dos números cualesquiera: x e y.
   *
   * Salida:
   *   [[5, 15], [3, 9]] 
   * Dos arreglos anidados con dos elementos: el primero x u y, y el
   * segundo su triple.
   */
  var _f1 = function(x, y) {
    return [
      [x, 3 * x],
      [y, 3 * y]
    ];
  };
  
  /*
   * Entrada:
   *   f2([[1, 2], [3, 4], [5, 6], [7, 8]])
   * n cantidad de arreglos anidados con dos números en su interior.
   *
   * Salida:
   *   [[3], [7], [11], [15]]
   * n cantidad de arreglos anidados, la misma de entrada, con el total
   * de la suma de los elementos en los arreglos anidados de entrada. 
   */
  var _f2 = function(arr_entrada) {
    var arr_salida = [];
    for (var i = 0; i < arr_entrada.length; i++) {
      arr_salida[i] = [arr_entrada[i][0] + arr_entrada[i][1]];
    }
    return arr_salida;
  };
  
  /*
   * Entrada:
   *   f3({“a”: 3, “b”: 5, “c”: -2})
   * Un objeto con llaves “a”, “b” y “c” asociados a distintos números.
   *
   * Salida:
   *   {“a”: -2, “b”: 3, “c”: 5}
   * Un objeto con llaves “a”, “b” y “c” donde “a” está asociado al
   * menor de los 3 números, “b” al siguiente y “c” al mayor.
   */
  var _f3 = function(obj_entrada) {
    var arr_temporal = [obj_entrada.a, obj_entrada.b, obj_entrada.c];
    arr_temporal.sort(function(x, y) {
      return x - y;
    });
    return {
      "a": arr_temporal[0],
      "b": arr_temporal[1],
      "c": arr_temporal[2]
    };
  };
  
  /*
   * Entrada:
   *  f4{“a”: true, “b”: false, “c”: true, “d”: true})
   * Un objeto con n cantidad de llaves, todas asociadas a un valor
   * de tipo booleano.
   *
   * Salida:
   *  {“true”: [“a”, “c”, “d”], “false”: [“b”]}
   * Un objeto con dos llaves, “true” y “false”, asociadas a un vector
   * con las llaves del objeto de entrada que correspondan al tipo
   * booleano “true” o “false”.
   */
  var _f4 = function(obj_entrada) {
    var obj_salida = {"true": [], "false": []};
    for (var llave in obj_entrada) {
      if (obj_entrada[llave] === true) {
        obj_salida["true"].push(llave);
      } else {
        obj_salida["false"].push(llave);
      }
    }
    return obj_salida;
  };
  
  /*
   * Entrada:
   *   f5({“a”: 1, “b”: 2}, {“c”: 3, “a”: 4, “d”: 5})
   * Dos objetos con n cantidad de llaves. Las llaves pueden o no repetirse
   * y tener o no tener el mismo valor
   *
   * Salida:
   *  {“b”: 2, “c”: 3, “d”: 5}
   * Un objeto donde aquellas llaves repetidas en los objetos de entrada sean
   * descartadas, independientemente del valor asociado a ellas.
   */
  var _f5 = function(obja_entrada, objb_entrada) {
    var obj_salida = {};
    for (var i in obja_entrada) {
        obj_salida[i] = obja_entrada[i];
    }
    for (var j in objb_entrada) {
        obj_salida[j] = objb_entrada[j];
    }
    for (var llave in obj_salida) {
      if ((llave in obja_entrada) && (llave in objb_entrada)) {
        delete obj_salida[llave];
      }
    }
    return obj_salida;
  };
  
  return {
    "f1": _f1,
    "f2": _f2,
    "f3": _f3,
    "f4": _f4,
    "f5": _f5
  };
})();

/*

 PRUEBAS:
 
 SF.f1(5, 3);
 SF.f1(-2, -4);
 
 SF.f2([[1, 2], [3, 4], [5, 6], [7, 8]]);
 SF.f2([[1, 2], [3, -4], [-5, 6], [-7, -8]]);

 SF.f3({"a": 3, "b": 5, "c": -2});
 SF.f3({"a": 30, "b": -50, "c": 200});
 
 SF.f4({"a": true, "b": false, "c": true, "d": true});
 SF.f4({"a": false, "b": false, "c": true, "d": false});
 
 SF.f5({"a": 1, "b": 2}, {"c": 3, "a": 4, "d": 5});
 SF.f5({"a": 1, "c": 2}, {"c": 3, "a": 4, "d": 5});
 SF.f5({"a": 5, "b": 6}, {"b": 3, "a": 4});
 
*/

SG.js

var SG = (function() {
  /*
   * Entrada:
   *   f1(2, 3, 5)
   * Tres números cualesquiera: x, y y z.
   *
   * Salida:
   *   [[5, 6], [8, 15]] 
   * Dos arreglos anidados con dos elementos: el primer arreglo con la
   * suma y múltiplicación de x e y, y el segundo arreglo con la suma y
   * múltiplicación de y y z.
   */
  var _f1 = function(x, y, z) {
    return [
      [x + y, x * y],
      [y + z, y * z]
    ];
  };
  
  /*
   * Entrada:
   *   f2([[1, 2], [3, 4], [5, 6], [7, 8]])
   * n cantidad de arreglos anidados con dos números en su interior.
   *
   * Salida:
   *   [[2], [12], [30], [56]]
   * n cantidad de arreglos anidados, la misma de entrada, con el total
   * de la multiplicación de los elementos en los arreglos anidados de
   * entrada.
   */
  var _f2 = function(arr_entrada) {
    var arr_salida = [];
    for (var i = 0; i < arr_entrada.length; i++) {
      arr_salida.push([arr_entrada[i][0] * arr_entrada[i][1]]);
    }
    return arr_salida;
  };
  
  /*
   * Entrada:
   *   f3({“a”: -3, “b”: 5, “c”: 2})
   * Un objeto con llaves “a”, “b” y “c” asociados a distintos números.
   *
   * Salida:
   *   {“a”: 5, “b”: 2, “c”: -3}
   * Un objeto con llaves “a”, “b” y “c” donde “a” está asociado al mayor
   * de los 3 números, “b” al siguiente y “c” al menor.
   */
  var _f3 = function(obj_entrada) {
    var arr_temporal = [obj_entrada.a, obj_entrada.b, obj_entrada.c];
    arr_temporal.sort(function(x, y) {
      return x - y;
    });
    return {
      "a": arr_temporal[2],
      "b": arr_temporal[1],
      "c": arr_temporal[0]
    };
  };
  
  /*
   * Entrada:
   *   f4{“a”: true, “b”: false, “c”: true, “d”: true})
   * Un objeto con n cantidad de llaves, todas asociadas a un valor de
   * tipo booleano.
   *
   * Salida:
   *   {“true”: 3, “false”: 1}
   * Un objeto con dos llaves, “true” y “false”, asociadas a la cantidad
   * de llaves del objeto de entrada que correspondan al tipo booleano
   * “true” o “false”.
   */
  var _f4 = function(obj_entrada) {
    var obj_salida = {"true": 0, "false": 0};
    for (var llave in obj_entrada) {
      if (obj_entrada[llave] === true) {
        obj_salida["true"] += 1;
      } else {
        obj_salida["false"] += 1;
      }
    }
    return obj_salida;
  };
  
  /*
   * Entrada:
   *   f5({“a”: 10, “b”: 2}, {“c”: 3, “a”: 4, “d”: 5})
   * Dos objetos con n cantidad de llaves. Las llaves pueden o no repetirse
   * y tener o no tener el mismo número asociado.
   *
   * Salida:
   *   {“a”: 14, “b”: 2, “c”: 3, “d”: 5}
   * Un objeto donde aquellas llaves repetidas en los objetos de entrada
   * tengan asociado la suma de sus valores.
   */
  var _f5 = function(obja_entrada, objb_entrada) {
    var obj_salida = {};
    for (var i in obja_entrada) {
        obj_salida[i] = obja_entrada[i];
    }
    for (var j in objb_entrada) {
        obj_salida[j] = objb_entrada[j];
    }
    for (var llave in obj_salida) {
      if ((llave in obja_entrada) && (llave in objb_entrada)) {
        obj_salida[llave] = obja_entrada[llave] + objb_entrada[llave];
      }
    }
    return obj_salida;
  };
  
  return {
    "f1": _f1,
    "f2": _f2,
    "f3": _f3,
    "f4": _f4,
    "f5": _f5
  };
})();

/*

 PRUEBAS:
 
 SG.f1(2, 3, 5);
 SG.f1(5, 6, 7);

 SG.f2([[1, 2], [3, 4], [5, 6], [7, 8]]);
 SG.f2([[5, 6], [7, 8]]);

 SG.f3({"a": -3, "b": 5, "c": 2});
 SG.f3({"a": 30, "b": -50, "c": 200});

 SG.f4({"a": true, "b": false, "c": true, "d": true});
 SG.f4({"a": false, "b": false, "c": true, "d": false});

 SG.f5({"a": 1}, {"c": 3, "a": 4, "d": 5});
 SG.f5({"a": 1, "c": 2}, {"c": 3, "a": 4, "d": 5});
 SG.f5({"a": 5, "b": 6}, {"b": 3, "a": 4});

*/