IvanVergiliev

#include <cstdio>

template<typename First, typename... Rest>
struct Tuple: public Tuple<Rest...> {
  Tuple(First first, Rest... rest): Tuple<Rest...>(rest...), first(first) {}

  First first;
};

template<typename First>

IvanVergiliev

val andPredicates: Array[Column] = parseAndPredicates(...)
val compositePredicate: Column = andPredicates.foldLeft(lit(true))((x, y) => x && y)

IvanVergiliev

f(H) =
  f(H - 1) // for the first transform call
  +
  f(H - 1) // for the second transform call
= 2 * f(H - 1) =
= 2 * 2 * f(H - 2) = ... = 2 ^ (H - 1) * f(1) // unfolding further

IvanVergiliev

import org.apache.spark.sql.Column

def treeFold(
  columns: List[Column],
  initialValue: Column,
  op: (Column, Column) => Column
): Column = {
  if (columns.isEmpty) {
    initialValue
  } else if (columns.length == 1) {

IvanVergiliev

def transformTree(tree: Tree): Option[Tree] = {
  // Notice that there's no `canTranform` - we're using
  // `transform().isDefined` to check for transformability!
  val transformedLeft = if (transform(tree.left).isDefined) {
    transform(tree.left)
  } else None
  
  ...
}

IvanVergiliev

def transformTree(tree: Tree): Option[Tree] = {
  val transformedLeft = if (canTransform(tree.left)) {
    transform(tree.left)
  } else None
  
  val transformedRight = if (canTransform(tree.right)) {
    transform(tree.right)
  } else None
  
  val result = if (transformedLeft.isDefined && transformedRight.isDefined) {

IvanVergiliev

#include <cstdlib>

#include <string>

// All of the below are not really standards-compliant, but good enough
// for experiments.
void* operator new(std::size_t size) {
  printf("Calling new(%zu).\n", size);
  return std::malloc(size);
}

IvanVergiliev

package io.github.ivanvergiliev;

public class NonVolatileFlag {
  private static boolean flag = false;

  public static class FlagChecker implements Runnable {
    public void run() {
      long iter = 0;
      while (flag == false) {
        ++iter;

IvanVergiliev

#include <cstdio>
#include <algorithm>
#include <iterator>
#include <vector>

using namespace std;

struct TestCase {
  int N;
  int K;

IvanVergiliev

#include <cstdio>
#include <map>
#include <set>
#include <vector>

using namespace std;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};