Kumite

Start a new Kumite

Kumite (ko͞omiˌtā) is the practice of taking techniques learned from Kata and applying them through the act of freestyle sparring.

You can create a new kumite by providing some initial code and optionally some test cases. From there other warriors can spar with you, by enhancing, refactoring and translating your code. There is no limit to how many warriors you can spar with.

A great use for kumite is to begin an idea for a kata as one. You can collaborate with other code warriors until you have it right, then you can convert it to a kata.

moraga

Failed Tests

Remover itens duplicados

Além de trazer novidades na escrita da linguagem, ES6 também trouxe novas classes.

Exercício:

Remover os itens duplicados do array sem percorrer o array

const main = () => {
  
  let links = [
    'https://www.uol',
    'https://www.bol.com.br',
    'https://www.uol',
    'https://noticias.uol.com.br',
    'https://www.bol.com.br',
  ];
  
  // converter para ES6
  var uniqueLinks = links.reduce(function (carry, item) {
    if (carry.indexOf(item) === -1) {
      carry.push(item);
    }
    return carry;
  }, []);
  
  
  return uniqueLinks.length;
};

moraga

Async / await em Promises

Async / await vieram para facilitar a execução de código assíncrono, muitas vezes encapsulado em Promises e dar maior controle sobre o fluxo de execução, dando a possibilidade de transformar trechos assíncronos em síncronos evitando callbacks excessivos (callback from hell).

Exercício:

Converta a execução da Promise para async/await.

function monteCarlo() {
  return new Promise(function (resolve, reject) {
    resolve([{
      titulo: 'UOL - O Melhor conteúdo'
    }]);
  });
}

async function main() {

  // converter para ES6
  monteCarlo().then(function(response) {
    console.log(response)
  });
  
  return true;
}

describe("Solution", function(){
  it("should test for something", async function(){
    Test.assertEquals(await main(), true, "This is just an example of how you can write your own TDD tests");
  });
});

moraga

Interando um Generator

"Você precisa disso para agora?"

Ou então apenas repasse.

Generator é uma instrução que fica na espera, somente é executada quando necessário.

Exercício:

Percorrer o generator na função main e para cada item imprimir no console seu valor.

function* lazyRange(start, stop) {
  while (start <= stop) {
    console.log(`Interando ${start}`);
    yield start;
    ++start;
  }
}

function createRange() {
  console.log("Criando um range");
  return lazyRange(1, 10);
}

function getData() {
  let theRange = createRange();
  console.log("Repassando o range");
  return {theRange};
}

function main() {
  let resp = getData();
  
  // percorra o generator executando o trecho comentado abaixo
  // console.log(`Valor ${item}`);
  
  return 1;
}

describe("Solution", function(){
  it("should test for something", function(){
    Test.assertEquals(main(), 1, "This is just an example of how you can write your own TDD tests");
  });
});

moraga

Failed Tests

Alinhando Generators

LazyRange cria um range de um número até outro com generators. O benefício do generator é que o range só será criado quando necessário.

E se pudermos alinhar generators de forma que várias instruções sejam executadas porém somente quando necessário, evitando percorrer o mesmo array diversas vezes?

Estamos falando de pura performance.

Exercício:

Implementar a função plusOne que some 1 em cada item de doubleRangeValue e retorne os valores sob demanda (generator).

function* lazyRange(start, stop) {
  while (start <= stop) {
    console.log(`Interando ${start}`);
    yield start;
    ++start;
  }
}

function* doubleRangeValue(...args) {
  for (let value of lazyRange(...args)) {
    value *= 2;
    console.log(`Dobro ${value}`);
    yield value;
  }
}

function* plusOne() {
  // implemente
}

async function main() {
  let resp = [...plusOne(1, 5)];
  return resp.join(',');
}

describe("Solution", function(){
  it("should test for something", async function(){
    Test.assertEquals(await main(), "3,5,7,9,11", "Victory");
  });
});

moraga

Failed Tests

For vs forEach vs Map vs Reduce

Quando usar for, forEach, map ou reduce?

Todos percorrem uma lista. Então se o problema exige percorrer uma lista qualquer um deles resolvem.

Mas cada um foi projetado para resolver um tipo de problema e quando aplicado tende a deixar o código mais legível e com menos linhas.

Exercício:

Resposta cada função com "for", "forEach", "map" ou "reduce" no return.

function a() {
  "Atualizar o array com o dobro de seus valores"
  
  let a = [1, 2, 3, 4];
  
  a.forEach((item, index) => {
    a[index] = item * 2;
  });
  
  // responda: for, forEach, map ou reduce
  return '';
}

function b() {
  "Em uma nova variável atribuir a soma dos valores do array"
  
  let a = [4, 10, 23, 99];
  let r = 0;
  
  a.map(item => {
    r += item;
  });
  
  // responda: for, forEach, map ou reduce
  return '';
}

function c() {
  "Em um novo array o quadrado dos itens de A"
  
  let a = [4, 8, 16];
  let r = a.map(item => Math.pow(item, 2));
  
  // responda: for, forEach, map ou reduce
  return '';
}

function d() {
  "Encontrar no array um item que seja maior ou igual a 2"
  
  let a = [1, 2, 3, 4];
  let resp = null;
  
  a.forEach((item, index) => {
    if (item >= 2) {
      resp = item;
      break;
    }
  });
  
  // responda: for, forEach, map ou reduce
  return '';
}

function e() {
  "Um novo array com valores únicos de A"
  
  let a = [1, 2, 2, 3, 4];
  let b = [];
  
  for (const item of a) {
    if (!b.includes(item))
      b.push(b);
  }
  
  // responda: for, forEach, map ou reduce
  return '';
}

function f() {
  "Novo array com itens de índice par"
  
  let a = ['a', 'b', 'c', 'd'];
  let b = [];
  
  a.map((item, index) => {
    if (index % 2 == 0) {
      b.push(item);
    }
  });
  
  // responda: for, forEach, map ou reduce
  return '';
}

function g() {
  "Executar chamadas http de forma assíncrona"
  
  let a = ['/p=1', '/p=2', '/p=3'];
  
  for (let path of a) {
    let xhr = new function() {};
    // ...
  }
  
  // responda: for, forEach, map ou reduce
  return '';
}

function h() {
  "Novo array com apenas titulo e descrição de uma resposta no Monte Carlo"
  
  let results = [{titulo: '..', descricao: '', tags: [], photo: '...'}];
  
  let resp = results.map(({titulo, descricao}) => ({titulo, descricao}));
  
  // responda: for, forEach, map ou reduce
  return '';
}

function i() {
  "Descompactar a matriz em uma lista"
  
  let a = [[1, 2], [4, 5], [4, 5]];
  let resp = a.reduce((carry, row) => ([...carry, ...row]), []);
  
  // responda: for, forEach, map ou reduce
  return '';
}

function j() {
  "Multiplicar matrizes"
  
  let a = [1, 2, 3];
  let b = [4, 5, 6];
  
  let resp = a.reduce((carry, v, i) => carry + v * b[i], 0);
  
  // responda: for, forEach, map ou reduce
  return '';
}

function k() {
  "Transformar as letras em maiúsculas"
  
  let a = ['Fred', 'John', 'Paul'];
  
  for (const [index, value] of a.entries()) {
    a[index] = value.toUpperCase();
  }
  
  // responda: for, forEach, map ou reduce
  return '';
}

function l() {
  "Exibir no console as chaves e os valores"
  
  let config = {portal: 'UOL', channel: 'Notícias', slug: 'uol'};
  
  for (const prop in config) {
    console.log(prop, config[prop]);
  }
  
  // responda: for, forEach, map ou reduce
  return '';
}

function m() {
  "Exibir no console os itens do array"
  
  let tags = ['São Paulo', 'Sudeste', 'Brasil'];

  for (const k in tags) {
    console.log(tags[k]);
  }
  
  // responda: for, forEach, map ou reduce
  return '';
}

/*

*/

describe("Solution", function(){
  it("should test for something", function(){
    Test.assertEquals(a(), "forEach", "Um novo array com a mesma quantidade de itens, mas com valor modificados: map");
    Test.assertEquals(b(), "reduce", "Reduzir o array a um número cuja representa a soma de todos os itens: reduce");
    Test.assertEquals(c(), "map", "Mesma quantidade de itens, valores modificados: map");
    Test.assertEquals(d(), "forEach", "Altera o array principal e ainda mais dados sem referência: forEach");
    Test.assertEquals(e(), "reduce", "O array é reduzido, removendo duplicados: reduce");
    Test.assertEquals(f(), "reduce", "forEach seria a melhor escolha se reduce não tivesse o índice do item: reduce");
    Test.assertEquals(g(), "for", "Percorrer os itens do array executando alguma operação: for. Caso tivesse que garantir a ordem das chamadas http seria necessário outra solução.");
    Test.assertEquals(h(), "map", "Um novo array com a mesma quantidade de itens, mas com alguns valores modificados: map");
    Test.assertEquals(i(), "reduce", "Um novo array modificado: reduce");
    Test.assertEquals(j(), "reduce", "Somatória de um cálculo envolvendo matrizes: reduce");
    Test.assertEquals(k(), "forEach", "Naturalmente forEach traz o índice do array: forEach");
    Test.assertEquals(l(), "for", "For in acessa as chaves do objeto");
    Test.assertEquals(m(), "for", "For com resalva de ser for-of");

  });
});

moraga

Criando uma Classe

Antes do ES6 não havia classes no Javascript. Combinando new e function conseguíamos algo parecido, criando um escopo para this. E com protótipo simular uma herança. Velhos tempos! (Que fique no passado).

Exercício:

Reescreva o código usando class.

function Component(dom) {
  this.dom = dom;

  this.onCreate = function() {
    return this.dom;
  }
}

describe("Solution", function(){
  it("Testando a classe", function(){
    Test.assertEquals((new Component(1)).onCreate(), 1, "Victory");
  });
});

Dreadnought8975

Estranged Matrix Row

Graphs

Data Structures

Algorithms

Logic

Given a matrix return the row that is of different length than other rows, it can be greater or lesser than the other rows. The rows can contain anything (numbers, characters, strings,floats,etc). The matrix will always have more than 2 rows and only one row will be estranged from the others.

Some examples:

estranged_row([[1,2,3,4],
[5,6,7,8],
[9,10,11]])
will return a value of 2(the last row)

estranged_row([[9,2],
[24],
['a',8]])
will return a value of 1 (the middle row)

estranged_row([[9,'a',0.1,'alpha'],
[22,'a',46,(82,24)],
[9,3,22,11],
[(1,8),22,35,72],
[18,22,['fox','rabbit','clover']]])
will return a value of 4 (the last row)

from collections import Counter

def estranged_row(m:list) -> int:
    estr= Counter([len(a) for a in m]).most_common(1)[0][0]
    for index,items in enumerate(m):
        if len(items) != estr:
            return index

Test.describe("Basic tests")
test.assert_equals(estranged_row([[1,2,3,4],[5,6,7,8],[9,10,11]]),2)
test.assert_equals(estranged_row([[1,2,3,3,4],[2,3,4],[2,8,9]]),0)

Test.describe("Testing different data types")
test.assert_equals(estranged_row([[9,2],[24],['a',8]]),1)
test.assert_equals(estranged_row([[9,'a',0.1,'alpha'],
                                  [22,'a',46,(82,24)],
                                  [9,3,22,11],
                                  [(1,8),22,35,72],
                                  [18,22,['fox','rabbit','clover']]]),4)

moraga

Method shorthand e computed property names

Com ES6 a criação de métodos ficou mais simples, não precisa mais da keyword "function".

Além disso podemos definir o nome das propriedades de forma dinâmica na definição do objeto.

Exercício:

Reescreva o código usando ES6
Simplifique a definição do método myFunc
Declare a propriedade de nome dinâmico no objeto na definição principal.

// reescreva usando ES6

var prop = 'myProp';

var obj = {
  myFunc: function() {
    return this[prop];
  } 
};

obj[prop] = 123;

describe("Solution", function(){
  it("Conectando ao Universo", function(){
    Test.assertEquals(obj.myFunc(), 123, "Victory");
  });
});

evgeniy_pp

Failed Tests

Proxy Decoder

Idea for Kata
You are given an endpoint server and an array of objects {server-sender, server-receiver}. The task is to find the initial server from which the request was submitted.

Example:
proxyDecoder('Vanuatu174', [{from: 'Tonga6120', to: 'SouthAfrica1124' }, { from: 'SouthAfrica1124', to: 'Paraguay8257' }, { from: 'Paraguay8257', to: 'Vanuatu174' }] -> 'Tonga6120'

I have already written several functions for creating a random array to test. It is necessary to create a function that combines endpoint and array, to randomize the sorting and to add extra queries that are not related to the task. And find bugs, of course

function getRandomServer () {
let countries = ["Afghanistan","Albania","Algeria","Andorra","Angola","AntiguaBarbuda","Argentina","Armenia","Australia","Austria","Azerbaijan","Bahamas","Bahrain","Bangladesh","Barbados","Belarus","Belgium","Belize","Benin","Bhutan","Bolivia","BosniaHerzegovina","Botswana","Brazil","Brunei","Bulgaria","BurkinaFaso","Burundi","CaboVerde","Cambodia","Cameroon","Canada","Chad","Chile","China","Colombia","Comoros","Congo","CostaRica","CoteD’Ivoire","Croatia","Cuba","Cyprus","Czech","Denmark","Djibouti","Dominica","Ecuador","Egypt","ElSalvador","Eritrea","Estonia","Ethiopia","Fiji","Finland","France","Gabon","Gambia","Georgia","Germany","Ghana","Greece","Grenada","Guatemala","Guinea","Guinea-Bissau","Guyana","Haiti","Honduras","Hungary","Iceland","India","Indonesia","Iran","Iraq","Ireland","Israel","Italy","Jamaica","Japan","Jordan","Kazakhstan","Kenya","Kiribati","KoreaNorth","KoreaSouth","Kosovo","Kuwait","Kyrgyzstan","Laos","Latvia","Lebanon","Lesotho","Liberia","Libya","Liechtenstein","Lithuania","Luxembourg","Macedonia","Madagascar","Malawi","Malaysia","Maldives","Mali","Malta","Mauritania","Mauritius","Mexico","Micronesia","Monaco","Mongolia","Montenegro","Morocco","Mozambique","Namibia","Nauru","Nepal","Netherlands","NewZealand","Nicaragua","Niger","Nigeria","Norway","Oman","Pakistan","Palau","Panama","PapuaNewGuinea","Paraguay","Peru","Philippines","Poland","Portugal","Qatar","Romania","Russia","Rwanda","Samoa","SaudiArabia","Senegal","Serbia","Seychelles","SierraLeone","Singapore","Slovakia","Slovenia","Somalia","SouthAfrica","Spain","SriLanka","Sudan","Sudan","South","Suriname","Swaziland","Sweden","Switzerland","Syria","Taiwan","Tajikistan","Tanzania","Thailand","Togo","Tonga","Tunisia","Turkey","Turkmenistan","Tuvalu","Uganda","Ukraine","Emirates","UK","USA","Uruguay","Uzbekistan","Vanuatu","Vatican","Venezuela","Vietnam","Yemen","Zimbabwe"];
let count = Math.floor(Math.random()*countries.length-1);
let random2 = Math.floor(Math.random()*10000);
return `${countries[count]}${random2}`;
}

function getServersArray (num) {
  let array = [];
  for (let i=0; i<num; i++){
    array.push(getRandomServer());
  }
  return array;
}

function getProxyArray () {
  let random = Math.floor(Math.random()*20);
  if (random<2) getProxyArray ();
  let serversArray = getServersArray(random);
  let array = [];
  for (let i=0; i<random-1; i++){
    array.push({from: serversArray[i], to: serversArray[i+1]});
  }
  let endpoint = serversArray[serversArray.length-1];
  let finalArray = array.sort(()=>Math.random()*100); //need to change this sorting, it's bad
  console.log(endpoint, finalArray) //instead this function should return the example
  return finalArray;
}

getProxyArray ()

moraga

Template Literals

Template literals resolve duas coisas:

String com múltiplas linhas
Interpolação de variáveis

Multiplas linhas

// com era
var a = 'ola \
multiplas\
linhas';

// como ficou
const a = `ola
multiplas
linhas`;

Interpolação

Não existia. O jeito era concatenar as variáveis.

// como resolvia
var a = 'ola ' + user + ', bem-vindo!';

// como ficou
const a = `ola ${user}, bem-vindo`;

Exercício:

Converta o código para ES6 usando template literals.

var bg = 'gray';

var css = '' +
  '<style>' +
  'body {' +
  '  background: '+ bg + ';' +
  '  color: black;'
  '}' +
  '</style>';

describe("Solution", function(){
  it("should test for something", function(){
    Test.assertEquals(css.includes('gray'), true, "This is just an example of how you can write your own TDD tests");
  });
});

Freestyle Sparring

Remover itens duplicados

Async / await em Promises

Interando um Generator

Alinhando Generators

For vs forEach vs Map vs Reduce

Criando uma Classe

Estranged Matrix Row

Method shorthand e computed property names

Proxy Decoder

Template Literals

Multiplas linhas

Interpolação

You have not created any collections yet.

Freestyle Sparring

Multiplas linhas

Interpolação

Confirm

Collect: kata

You have not created any collections yet.