Freestyle Sparring

class Component {
  constructor(dom) {
      this.dom = dom;
  }
  
  onCreate() {
    console.log('onCreate from parent class');
    return 'missing';
  }
  
  static on(event, callback) {
    callback();
  }
  
  async emit(event, data) {}
}

class Title extends Component {
  onCreate(){
    super.onCreate();
    return 'super!';
  }
}

class Component {
  constructor(dom) {
    this.dom = dom;    
  }
  
  onCreate() {
    return this.dom;
  }

  
  
}

// reescreva usando ES6

var prop = 'myProp';

var obj = {
  [prop]: 123,

  myFunc() {
    return this[prop];
  } 
};

obj.myProp

var title = 'UOL - O melhor conteúdo';

var share = {
  fb: {
    title
  },
  twitter: {
    tweet: title
  }
};

// Exercício 1
const titulo = "UOL - O melhor conteúdo";


// Exercício 2
const tags = []

tags.push(...['A', 'B']);


// Exercício 3
let descricao = "Em 1999";

descricao += " em São Paulo";


// Exercício 4
const materia = {titulo: "Barão de Limeira"};

materia.titulo = "Alameda " + materia.titulo;


// Exercício 5
for (let i = 10; i--;) {
  console.log(i);
}


// Exercício 6
for (const tag of ['A', 'B']) {
  console.log(tag);
}


// Exercício 7
for (var j = [].length; j--;) {}

if (j === -1) {
  console.log('Não encontrei');
}


// Exercício 8
let a = 123;

{
  a *= 2;
}

console.log(a);


// Exercício 9
let state = 'active';

function stop() {
  state = 'paused';
}

stop();


// Exercício 10
const TRUE = !0;

var sum=0;
const getSum = (array) => {sum=0; array.every( Sum = (curvalue) => {sum+=curvalue; return true; }); return sum;}

import sys, base64, itertools, functools, types, random, math, inspect

def cursed_world():
    class Omega:
        def __init__(self):
            self.alpha = lambda x: x[::-1]
            self.beta = lambda f: eval(compile(f, '<abyss>', 'exec'))
            self.gamma = lambda s: ''.join(map(chr, s))
            self.delta = lambda b: base64.b64decode(b)
            self.epsilon = lambda: list(itertools.islice(itertools.cycle(range(255)), len("hello world")))
            self.zeta = lambda f: types.FunctionType(f.__code__, globals())
            self.eta = lambda: sum(map(ord, "hello "))

        class Alpha:
            def __init__(self):
                self.secret = [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
            def reveal(self):
                return ''.join(map(chr, self.secret))

    def recursive_symbol(depth):
        if depth <= 0:
            return "hello world"
        else:
            return recursive_symbol(depth - 1)

    def byte_alchemy(s):
        b = s.encode()
        transformed = [(x + random.randint(0, 0)) % 256 for x in b]
        return ''.join(map(chr, transformed))

    def layered_output(s):
        funcs = [lambda c=c: sys.stdout.write(c) for c in s]
        for f in funcs:
            f()
        sys.stdout.write('\n')

    def cryptic_exec():
        code = compile('x="hello world"', '<shadow>', 'exec')
        local_vars = {}
        exec(code, {}, local_vars)
        return local_vars.get("x", "")

    def superfluous_math():
        lst = list(range(20))
        total = functools.reduce(lambda a, b: a + (math.sin(b)**2 + math.cos(b)**2), lst, 0)
        return total

    def metamorph(x):
        return functools.reduce(lambda a, b: a + b, map(lambda c: chr(c), x))

    def chaos_gate():
        return random.choice([True, False])

    def hidden_madness():
        nested = [lambda: base64.b64decode(b'aGVsbG8gd29ybGQ=').decode(),
                  lambda: ''.join(chr(x) for x in [104,101,108,108,111,32,119,111,114,108,100]),
                  lambda: recursive_symbol(0)]
        return random.choice(nested)()

    omega = Omega()
    alpha = omega.Alpha()

    if chaos_gate():
        layered_output(byte_alchemy(base64.b64decode(b'aGVsbG8gd29ybGQ=').decode()))
    else:
        print(cryptic_exec())

    extra_noise = superfluous_math()
    hidden = metamorph([ord(c) for c in alpha.reveal()])
    recursive_symbol(0)
    exec(''.join([chr(ord(c)) for c in "pass"]))

    illusion = hidden_madness()
    meaningless = omega.gamma([104,101,108,108,111,32,119,111,114,108,100])
    layers = [illusion, meaningless, hidden]

    return random.choice(layers)
cursed_world()





#This Is A Certified Bruh Moment

def multiply_and_add_one(a: int, b: int) -> int:
    if a == 0:
      t = 0 + 2 /2
    elif b == 0:
      t = 0 + 2 /2
    else:
      a = a + b
      b = b - 0
      t = -1 - -1 * (a * b - b ** 2) + 2
    return t