Bonfire: Binary Agents

Mi-a mai revenit puțin moralul. Mai jos este soluția pe care am găsit-o eu la acest bonfire:

function binaryAgent(str) {
str = str.replace(/([0-9]+)(\s)?/g, function(match, p1, p2){ p1 = String.fromCharCode(parseInt(p1, 2)); p2 = ''; return p1+p2; });
return str;
}

console.log(binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111"));

Spor 🙂

Încerc să-ncep să fiu programator

Cu cât avansez pe Free Code Camp, îmi dau seama că sunt tămâie când vine vorba de programare.

Cel mai recent exemplu a fost Bonfire: Steamroller (se cere să returnezi un array de o singură dimensiune) la care am stat ore bune ca să găsesc o soluție simplă și n-am reușit așa că pe la 3 noaptea m-am dat bătut și am căutat soluția pe google, soluție care e extrem de simplă și foarte elegantă:

function steamroller(arr) {

  if (Array.isArray(arr) && arr.length > 0) {
    var head = arr[0];
    var tail = arr.slice(1);
    return steamroller(head).concat(steamroller(tail));
  }
  return [].concat(arr);

};

console.log(steamroller([[[[[[1]]]]], {}, [3, [[4]]]]));

Să fie oare doar lipsa exercițiului sau sunt eu prea praf… hmmmm

Apropo, soluția am găsit-o pe https://codedmalarkey.wordpress.com/2015/08/18/bonfire-35-steamroller/

Bonfire: Smallest Common Multiple

Am citit într-un articol că pentru a reuși într-un domeniu, ai nevoie de preseverență. Mai jos e soluția mea pentru acest bonfire:

function smallestCommons(arr) {
var arrMin = Math.min.apply(Math, arr);
var arrMax = Math.max.apply(Math, arr);
var arrTotal = [];
var num = arrMax;
var found;

for ( var i = arrMin; i <= arrMax; i += 1 ) {
  arrTotal.push(i);
}

while ( ! found ) {
  num += 1;
  found = arrTotal.every(function(el){
    //console.log(num%el + " | num: " +num+ "el:"+el);
    return num % el === 0;
  });
  //console.log(num + ' => ' + found);
}

return num;
}
console.log(smallestCommons([1,5]));

Cu siguranță sunt și alte metode mult mai bune decât aceasta dar la nivelul la care mă aflu, aceasta e singura soluție  cu care am putut să vin.

Bonfire: Sum All Primes

„E grele” când lipsește exercițiul. Mi-a luat câteva ore să vin cu o soluție proprie pentru rezolvarea acestui bonfire.

function sumPrimes(num) {
  var arr = [];
  var isPrime;
 
// prime number if it can only be divided by itself, even
 
  for ( var i = num; i > 1; i -= 1 ) {
 
    for ( var j = 2; j < num-1; j += 1 ) {
 
      isPrime = true;
 
      if ( i % j === 0 && i != j ) {
        // console.log(i + ' // ' + j);
        isPrime = false;
        // break in order to keep prime false
        break;
      }
 
    }
// console.log(isPrime + ' - ' + i);
    if ( isPrime ) {
      arr.push(i);
    }
 
  }
 
  arr = arr.reduce(function(a,b){
    return a+b;
  });
 
 
  return arr;
}

sumPrimes(10);


M-am ajutat puțin de video-ul acesta:

 

Bonfire: Spinal Tap Case

La acest bonfire a trebuit să construiesc un regex care să ia în considerare și camelCase. După câteva ore am ajuns la această soluție:

function spinalCase(str) {
 // "It's such a fine line between stupid, and clever."
 // --David St. Hubbins
 return str.replace(/([a-z](?=[A-Z]))|(\s|_|-)+/g, '$1-').toLowerCase();
}

console.log(spinalCase('thisIsSpinalTap'));

Super! Prin exercițiu se învață cel mai bine, doar avem o vorbă: „Repetiția, mama învățăturii”. Trebuie să mai exersez Regular Expressions pentru că sunt foarte folositoare. Foarte de folositor: https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions

Tot înainte cu programarea 🙂