Mk-Etlinger

When wanting to use composition for your components, how do you handle cases where you always need to map items 
for things like Radio Group or Accordion Items?

For example: https://chakra-ui.com/docs/disclosure/accordion


<Accordion>
// How can I encapsulate this without losing composition? Is it even worth it?
// In the case where we need to have other developers use this composition, how do we ensure they use it correctly?
// Using TypeScript btw

Mk-Etlinger

function pairSum(data, target) {
  const pairMatches = {};

  for(let i = 0; i < data.length; i++) {
    const number = data[i];
    const difference = (target - number);
    
    if (pairMatches[number]) { 
      return true; 
    }

Mk-Etlinger

function pairSum(data, target) {
    let sumMatchesTarget;

    data.forEach((currentNumber, index) => {
        if (sumMatchesTarget) { return; }

        const dataFiltered = removeCurrentIndex(data, index);

        sumMatchesTarget = dataFiltered.some(nextNumber => {
            const sum = (currentNumber + nextNumber);

Mk-Etlinger

/*
 * Complete the 'pairSum' function below.
 *
 * The function is expected to return a BOOLEAN.
 * The function accepts following parameters:
 *  1. INTEGER_ARRAY array
 *  2. INTEGER target
 */
function pairSum(array, target) {
    for(let i = 0; i < array.length; i++) {

Mk-Etlinger

Proxy cache passes GET instead of HEAD to upstream... so we have a 403.

This version include these fixes.

• Remove $request_method from $string_to_sign and pass static string "GET" instead
• Remove proxy_buffering directive for allowing the nginx cache

Mk-Etlinger

add_action('init', function(){

  session_set_cookie_params( 0 );

  if(!session_id())
    session_start();
}, 1);

Mk-Etlinger

class ExpressionEvaluator
  def self.parse(string)
    complex_exps = string.scan(/-\s\d+\s\d+/)
    simple_exps = string.gsub(/-\s\d+\s\d+/, '')
    complex_sum(complex_exps) + simple_sum(simple_exps)
  end 

  def self.complex_sum(array)
    array.reduce(0) { |sum, exp| sum + (exp.split[1].to_i - exp.split[2].to_i) }
  end

Mk-Etlinger

class ExpressionEvaluator
  def self.parse(string)
    complex_exps = string.scan(/-\s\d+\s\d+/)
    simple_exps = string.gsub(/-\s\d+\s\d+/, '')
    complex_sum(complex_exps) + simple_sum(simple_exps)
  end 
end

Mk-Etlinger

def self.parse(string)
  sum = 0
  char_array = string.split
  char_array.each_with_index do |char, i|
    sum += char.to_i
    next unless char == '-' && char_array[i + 2]
    if char_array[i + 2].to_i == 0
      char_array[i + 1] = char + char_array[i + 1]
    else
      char_array[i + 2] = char + char_array[i + 2]

Mk-Etlinger

Implement an Expression Evaluator Our goal is to write a program that is capable of evaluating simple mathematical expressions. An example expression could look like:

+ 1 2 This expression can be read as 1 + 2 and evaluates to 3. We've placed the operator (+) first in our syntax to simplify some things down the road. The + indicates that this is an operator expression, and is evaluated by summing the two following tokens, which in this case are both numbers.

The general rules are:

Expressions can be numbers or operator expressions (4 is an expression and so is - 3 1) Numbers evaluate to themselves (4 is 4)