Resolvendo Algoritmos com JavaScript 5 / 5 - O tabuleiro secreto

 

Desafio

O senhor Milli, morador da cidade Petland, é o famoso proprietário da maior fábrica de jogos de tabuleiros do mundo. 

Recentemente, ele teve a ideia de lançar um novo jogo exclusivo de tabuleiro, que ele apelidou de Tabuleiro da Frequência.

O jogo ocorre da seguinte forma. Inicialmente, um tabuleiro com dimensões N × N é dado contendo apenas 0’s. Depois disso, Q operações são propostas, podendo ser de 4 tipos:

  • 1 X R: Atribuir o valor R a todos os números da linha X;

  • 2 X R: Atribuir o valor R a todos os números da coluna X;

  • 3 X: Imprimir o valor mais frequente na linha X;

  • 4 X: Imprimir o valor mais frequente da coluna X.

Milli não é muito bom com computadores, mas é bastante preguiçoso. Sabendo que você é um dos melhores programadores do mundo, ele precisa sua ajuda para resolver este problema.

Entrada

A primeira linha da entrada é composta por dois inteiros N e Q (1 ≤ N, Q ≤ 105), representando, respectivamente, o tamanho do tabuleiro e a quantidade de operações. As próximas Q linhas da entrada vão conter as Q operações. O primeiro inteiro de cada linha vai indicar o tipo da operação. Caso seja 1 ou 2, será seguido por mais dois inteiros X (1 ≤ X ≤ N) e R (0 ≤ R ≤ 50). Caso seja 3 ou 4, será seguido por apenas mais um inteiro X.

Saída

Para cada operação do tipo 3 ou 4, seu programa deve produzir uma linha, contendo o valor da resposta correspondente. Se uma linha ou coluna tiver dois ou mais valores que se repetem o mesmo número de vezes, você deve imprimir o maior deles. Por exemplo, se uma linha tem os valores [5,7,7,2,5,2,1,3], tanto o 2, 5 e 7 se repetem duas vezes, então a resposta será 7, pois é o maior deles.     

 
-------------------------------------------------------------------------------------------------------
let input;
const limit = Math.pow(10, 5);
let T, X, R;
var output = '';

const operation = {
  '1': function fillLine(matrix, line, num) {
    for (let index = 0; index < matrix.length; index++) {
      matrix[line - 1][index] = num;
    }
  },
  '2': function fillColumn(matrix, col, num) {
    for (let index = 0; index < matrix.length; index++) {
      matrix[index][col - 1] = num;
    }
  },
  '3': function showMostFrequentAtLine(matrix, line) {
    const lineValues = matrix[line - 1]

    output += getMostFrequentIn(lineValues) + '\n'
  },
  '4': function showMostFrequentAtColumn(matrix, col) {
    const columnValues = matrix.map(line => line[col - 1])

    output += getMostFrequentIn(columnValues) + '\n'
  }
}

const getMostFrequentIn = (values) => {

  let n = values.length;

  if (n == 0) return null;

  let map = {}, most = values[0], freqCount = 1;

  for (let i = 0; i < n; i++) {
    let el = values[i];

    if (map[el] == null)
      map[el] = 1;
    else
      map[el]++;

    if (map[el] > freqCount) {
      most = el;
      freqCount = map[el];
    }
    else if (map[el] === freqCount) {
      most = Math.max(most, el)
    }
  }
  return most;
}

while (true) {
   input = gets()
 
  if (!input || input === '') break;

  let [N, Q] = input.match(/\d+/g);

  N = parseInt(N);
  Q = parseInt(Q);

  if (N < 1 || N > limit || Q < 1 || N > limit) break;

  let matrix = Array.from(Array(parseInt(N)), () => new Array(parseInt(N)).fill(0));

  for (let index = 0; index < Q; index++) {
     let [T, X, R] = gets().split(/[ ]+/g) //para uso na DIO
    X = parseInt(X)
    R = parseInt(R)

    if (/[12]/.test(T)) {
      if (X < 1 || X > N || R < 0 || R > 50) {
        // console.log('Valores de X e/ou N inválidos para operação 1 ou 2. Verifique antes de iniciar o jogo');
        continue;
      }
    }

    if (/[34]/.test(T)) {
      if (X > N || X < 0) {
        // console.log('Valores de X e/ou N inválidos para operação 3 ou 4. Verifique antes de iniciar o jogo');
        continue;
      }
    }

    operation[T](matrix, X, R);
  }
  console.log(output);
}
 

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Resolvendo Algoritmos com JavaScript 4 / 5 - Hash Mágico

 

Desafio

O conceito de hash é transformar uma grande quantidade de dados em uma pequena quantidade de informações. Nesse algoritmo você terá uma entrada com várias linhas, cada uma com uma string. 

O valor de cada caracter é computado como segue:

Valor = (Posição no alfabeto) + (Elemento de entrada) + (Posição do elemento)

As posições iniciam em zero. 'A' tem posição 0 no alfabeto, ‘C' tem posição 2 no alfabeto, ... O cálculo de hash retornado é a soma de todos os caracteres da entrada. Por exemplo, se a entrada for:

CBA

DDD

então cada caractere deverá ser computado como segue:

2 = 2 + 0 + 0 : 'C' no elemento 0 posição 0

2 = 1 + 0 + 1 : 'B' no elemento 0 posição 1

2 = 0 + 0 + 2 : 'A' no elemento 0 posição 2

4 = 3 + 1 + 0 : 'D' no elemento 1 posição 0

5 = 3 + 1 + 1 : 'D' no elemento 1 posição 1

6 = 3 + 1 + 2 : 'D' no elemento 1 posição 2

O cálculo final de hash será 2+2+2+4+5+6 = 21.

Entrada

A entrada contém vários casos de teste. A primeira linha de entrada contém um inteiro N que indica a quantidade de casos de teste. Cada caso de teste inicia com um inteiro L (1 ≤ L ≤ 100) que indica a quantidade de linhas que vem a seguir. Cada uma destas L linhas contém uma string com até 50 letras maiúsculas ('A' - 'Z').

Saída

Para cada caso de teste imprima o valor de hash que é calculado conforme o exemplo apresentado acima.

 
------------------------------------------------------------------------------------------------------------
const regexLine = /[A-Z]/g

 let nCase = parseInt(gets());
let L = 0;
let value;
let lines;

while (nCase > 0) {
  nCase--
  lines = []
  value = 0
   L = parseInt(gets())
 
  if (L < 1 || L > 100) {
    for (let i = 0; i < L; i++) { gets(); }
    continue;
  }

  for (let i = 0; i < L; i++) {
     lines = [...lines, gets()]
    }

  for (const [i, line] of lines.entries()) {
    value += line.match(regexLine).slice(0, 50).reduce((acc, curr, elementPosition, array) => {
      const alphabetPosition = parseInt(curr, 36) - 10;
      const elementInput = i;

      return acc + alphabetPosition + elementInput + elementPosition
    }, 0)
  }

  console.log(value);
  }

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Resolvendo Algoritmos com JavaScript 3 / 5 - Combinação de strings

 

Desafio

Crie um algoritmo que receba dois inputs que sejam strings e combine-as alternando as letras de cada string. 

Deve começar pela primeira letra da primeira string, seguido pela primeira letra da segunda string, em seguida pela segunda letra da primeira string e continuar dessa forma sucessivamente.

As letras restantes da cadeia mais longa devem ser adicionadas ao fim da string resultante e retornada.

Entrada

A entrada contém vários casos de teste. A primeira linha contém um inteiro N que indica a quantidade de casos de teste que vem a seguir. Cada caso de teste é composto por uma linha que contém duas cadeias de caracteres, cada cadeia de caracteres contém entre 1 e 50 caracteres inclusive.

Saída

Combine as duas cadeias de caracteres da entrada como mostrado no exemplo abaixo e exiba a cadeia resultante.

 --------------------------------------------------------------------------------------------------
 const nCases = parseInt(gets())
let output;

for (let i = 1; i <= nCases; i++) {
  output = '';
   [strA, strB] = gets().split(' ');
 
  const smallestLength = Math.min(strA.length, strB.length)

  for (let j = 0; j < smallestLength; j++) output += `${strA[j]}${strB[j]}`;

  output += strA.length > strB.length
    ? strA.substring(smallestLength)
    : strB.substring(smallestLength)

  console.log(output);
}

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Resolvendo Algoritmos com JavaScript 2 / 5 - Abreviando posts do blog

 

Desafio

Leonardo é um nômade digital e viaja pelo mundo programando em diferentes cafés das cidades por onde passa. Recentemente, resolveu criar um blog, para compartilhar suas experiências e aprendizados com seus amigos.

Para criação do blog, ele optou por utilizar uma ferramenta pronta, que há um limite de caracteres que se pode escrever por dia, e Leonardo está preocupado que essa limitação, afinal, irá impedir de contar suas melhores experiências. Para contornar esse problema, decidiu usar um sistema de abreviação de palavras em seus posts.

O sistema de abreviações é simples e funciona da seguinte forma: para cada letra, é possível escolher uma palavra que inicia com tal letra e que aparece no post. Uma vez escolhida a palavra, sempre que ela aparecer no post, ela será substituída por sua letra inicial e um ponto, diminuindo assim o número de caracteres impressos na tela.

Por exemplo, na frase: “hoje eu programei em Python”, podemos escolher a palavra “programei” para representar a letra ‘p', e a frase ficará assim: “hoje eu p. em Python”, economizando assim sete caracteres. Uma mesma palavra pode aparecer mais de uma vez no texto, e será abreviada todas as vezes. Note que, se após uma abreviação o número de caracteres não diminuir, ela não deve ser usada, tal como no caso da palavra “eu” acima.

Leonardo precisa que seu post tenha o menor número de caracteres possíveis, e por isso pediu a sua ajuda. Para cada letra, escolha uma palavra, de modo que ao serem aplicadas todas as abreviações, o texto contenha o menor número de caracteres possíveis.

Entrada

Haverá diversos casos de teste. Cada caso de teste é composto de uma linha, contendo uma frase de até 10⁴ caracteres. A frase é composta de palavras e espaços em branco, e cada palavra é composta de letras minúsculas ('a'-'z'), e contém entre 1 e 30 caracteres cada.

O último caso de teste é indicado quando a linha dada conter apenas um “.”, o qual não deverá ser processado.

Saída

Para cada caso de teste, imprima uma linha contendo a frase já com as abreviações escolhidas e aplicadas.

Em seguida, imprima um inteiro N, indicando o número de palavras em que foram escolhidas uma letra para a abreviação no texto. Nas próximas N linhas, imprima o seguinte padrão “C. = P”, onde C é a letra inicial e P é a palavra escolhida para tal letra. As linhas devem ser impressas em ordem crescente da letra inicial.

 
------------------------------------------------------------------------------------------------------------

const regexPattern = /\b[a-z]{1,30}\b/g
const alphabet = 'abcdefghijklmnopqrstuvwxyz'

while (true) {
  let newSentence = ''
   const input = gets() //para uso na DIO
 
  if (!input || input === '.') break;

  if (input.length > Math.pow(10, 4)) continue;

  const sentence = input.trim().match(regexPattern)
  const uniqueWords = Array.from(new Set(sentence));

  const words = uniqueWords.map(word => {
    const repeatations = sentence.join(' ').match(new RegExp(`\\b${word}\\b`, 'g')).length;
    const trim = word.length - 2
    const save = trim * repeatations
    const abbreviation = `${word[0]}.`
    const legend = `${abbreviation} = ${word}`
    const regexp = new RegExp(`\\b${word}\\b`, 'g')
    return { word, repeatations, trim, save, abbreviation, legend, regexp }
  }).filter(word => word.save > 0)

  const abbreviations = alphabet.split('').map(letter => {
    candidates = words.filter(word => word.word.match(new RegExp(`\\b${letter}\\w{2,}\\b`, 'g')))

    if (!candidates || candidates === null) return { save: 0 }

    return candidates.reduce((acc, curr) => {
      return curr.save >= acc.save
        ? curr
        : acc

    }, { save: 0 });

  }).filter(el => el.save > 0)

  newSentence = input
  for (const abbr of abbreviations) {
    newSentence = newSentence.replace(abbr.regexp, abbr.abbreviation)
  }

  //Output
  console.log(newSentence);
  console.log(abbreviations.length);
  abbreviations.sort().map(({ legend }) => console.log(legend))
}

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Resolvendo Algoritmos com JavaScript 1 / 5 - Coração das cartas

Desafio

Marcos decidiu abandonar o bar da faculdade onde jogava truco para dedicar-se ao mundo da programação. Para que isso fosse mais fácil, decidiu criar um novo jogo de cartas. 

O coração das cartas, como Marcos apelidou o jogo, é individual e jogado com três pilhas, inicialmente com o mesmo número de cartas. Cada carta tem um valor numérico inteiro de 0 até 9. O jogador pode, a qualquer momento ver o valor de qualquer carta, mas só pode jogar com as cartas que estão no topo das pilhas. Em cada rodada, o jogador pode remover qualquer combinação de cartas que estejam no topo da pilha (pode escolher 1, 2 ou até 3 cartas) cuja soma dos valores seja múltiplo de 3. O jogo é ganho quando todas as cartas forem removidas das pilhas. Se alguma carta não puder ser removida, perde-se o jogo.

Entrada

A entrada é composta por várias instâncias Cada instância é iniciada por um inteiro N (0 ≤ N ≤ 100), que identifica o número de cartas em cada pilha. A entrada termina quando N = 0. Cada uma das N linhas seguintes contém três inteiros A, B e C, que descrevem os valores numéricos das cartas em um nível da pilha (0 ≤ A, B, C ≤  9). As pilhas são descritas do topo até o fundo.

Saída

Para cada instância, imprima uma linha contendo o número 1 se o jogador pode ganhar a instância do jogo ou o número 0 se o jogo for impossível.

 
-------------------------------------------------------------------------------------------------------------------------


let m, cards;
let n = 1;

while (true) {
   n = parseInt(gets());
 

  if (n <= 0) break;

  m = new Map();
  cards = Array.from(new Array(3)).map(v => new Array(n));

  for (let i = 0; i < n; i++) {
     [cards[0][i], cards[1][i], cards[2][i]] = gets().match(new RegExp(/\d+/, 'g')).map(v => parseInt(v));
   
  }

  console.log(canWinWith(0, 0, 0) ? 1 : 0);

 
}

function canWinWith(a, b, c) {
  let s = '';

  s = s.concat(a + '0');
  s = s.concat(b + '0');
  s = s.concat(c + '0');

  if (a === b && b === c && c === n) {
    m.set(s, 1);
    return true;
  }

  let x = m.get(s);

  if (x > 0) {
    return x === 1 ? true : false;
  }

  if (a < n && cards[0][a] % 3 === 0 && canWinWith(a + 1, b, c)) {
    m.set(s, 1);
    return true;
  }

  if (b < n && cards[1][b] % 3 === 0 && canWinWith(a, b + 1, c)) {
    m.set(s, 1);
    return true;
  }

  if (c < n && cards[2][c] % 3 === 0 && canWinWith(a, b, c + 1)) {
    m.set(s, 1);
    return true;
  }

  if (a < n && b < n && (cards[0][a] + cards[1][b]) % 3 == 0 && canWinWith(a + 1, b + 1, c)) {
    m[s] = 1;
    return true;
  }

  if (a < n && c < n && (cards[0][a] + cards[2][c]) % 3 == 0 && canWinWith(a + 1, b, c + 1)) {
    m.set(s, 1);
    return true;
  }
  if (b < n && c < n && (cards[1][b] + cards[2][c]) % 3 == 0 && canWinWith(a, b + 1, c + 1)) {
    m.set(s, 1);
    return true;
  }

  if (a < n && b < n && c < n && (cards[0][a] + cards[1][b] + cards[2][c]) % 3 == 0 && canWinWith(a + 1, b + 1, c + 1)) {
    m.set(s, 1);
    return true;
  }

  m.set(s, 2);
  return false;
}

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Resolvendo Desafios Intermediários em JavaScript * 3 / 3 - Tomadas

 

Finalmente, o time da Universidade conseguiu a classificação para a Final Nacional da Maratona de Programação da SBC. Os três membros do time e o técnico estão ansiosos para bem representar a Universidade, e além de treinar muito, preparam com todos os detalhes a sua viagem a São Paulo, onde será realizada a Final Nacional.

Eles planejam levar na viagem todos os seus vários equipamentos eletrônicos: celular, tablet, notebook, ponto de acesso wifi, câmeras, etc, e sabem que necessitarão de várias tomadas de energia para conectar todos esses equipamentos. Eles foram informados de que ficarão os quatro no mesmo quarto de hotel, mas já foram alertados de que em cada quarto há apenas uma tomada de energia disponível.

Precavidos, os três membros do time e o técnico compraram cada um uma régua de tomadas, permitindo assim ligar vários aparelhos na única tomada do quarto de hotel; eles também podem ligar uma régua em outra para aumentar ainda mais o número de tomadas disponíveis. No entanto, como as réguas têm muitas tomadas, eles pediram para você escrever um programa que, dado o número de tomadas em cada régua, determine o número máximo de aparelhos que podem ser conectados à energia num mesmo instante.

Entrada

A entrada consiste de uma linha com quatro números inteiros T1, T2, T3, T4, indicando o número de tomadas de cada uma das quatro réguas (2 ≤ Ti ≤ 6).

Saída

Seu programa deve produzir uma única linha contendo um único número inteiro, indicando o número máximo de aparelhos que podem ser conectados à energia num mesmo instante.

--------------------------------------------------------------------------------------------------------------------

let lines = gets().split("\n");
let t = 5;
let todas = 0;
let line = lines.shift().split(' ');
for(let i = 1; i < t; i++){
  todas = todas + parseInt(line.slice(-i));
}
todas = todas - 3;

console.log(todas);
 

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Resolvendo Desafios Intermediários em JavaScript * 2 / 3 - Guilherme e Suas Pipas

 

Guilherme adora brincar com pipas, pipas de várias cores, formas e tamanhos. Ele tem percebido que para as pipas possuírem maior estabilidade, e dessa forma voarem mais alto, elas devem possuir um barbante bem esticado ligando todos os pares de pontas não vizinhas.

Apesar de ser uma criança bastante criativa e astuta, Guilherme não sabe como determinar a quantidade de barbantes que ele terá que utilizar para tornar uma pipa de n lados, estável. Você pode ajudá-lo?.

Entrada

A entrada será composta por uma única linha, que contém um inteiro 3 ≤ n ≤ 105, representando o número de lados da pipa.

Saída

Imprima um número inteiro, que será a quantidade de barbantes que Guilherme terá que utilizar para tornar a pipa de n lados estável.

 
-----------------------------------------------------------------------------------------------------------------------
let lines = gets().split("\n");

let N = parseInt(lines.shift());
let resposta = ((N - 3)* N ) / 2  ;              
print(resposta);

faço trabalhos avulsos de programação em php , javascript , html , VBA-EXCEL e EXCEL formulas avançadas . pode entrar em contato no whatsapp 83988596239. nós combinaremos os valores de acordo com a demanda.

Programando com JS 2 / 5 - Resto 2

  Desafio Leia um valor inteiro N . Apresente todos os números entre 1 e 10000 que divididos por N dão resto igual a 2. Entrada A ...