Freestyle Sparring

public class Kata
{
    public static int SameCase(char a, char b)
    {
        if (!char.IsLetter(a) || !char.IsLetter(b))
        {
            return -1;
        }

        return (char.IsUpper(a) == char.IsUpper(b)) ? 1 : 0;
    }
}

import java.math.BigInteger;
import java.util.stream.Collectors;

public class MaxNumber {
    public static BigInteger print(long number) {
        return new BigInteger(Long.toString(number)
                .chars()
                .mapToObj(c -> String.valueOf((char) c))
                .sorted((a, b) -> b.compareTo(a))
                .collect(Collectors.joining()));
    }
}

#include <stdlib.h>
#include <string.h>

char *fanis(const char *input, int value)
{
  char *r = malloc(strlen(input) + 1), *p = r;
  while (*input) *p++ = *input++ + value;
  return *p = '\0', r;
}

interface ListOfBoxes {
  code: string
  bomb?: boolean
  boxes?: ListOfBoxes[]
}

export function findTheBomb (listOfBoxes: ListOfBoxes [], path: string[] = []): string | null {
  if (!listOfBoxes.length) {
    return "No Boxes No Bomb!"
  }
  
  
  for (const box of listOfBoxes) {
      const newPath = [...path, box.code]
      if (box.bomb) {
          return newPath.join(" > ")
      }
      if (box.boxes) {
          const found = findTheBomb(box.boxes, newPath)
          if (found) {
            return found
          }
      }
  }
  
  return null
}

const listBoxes1: ListOfBoxes [] = [
  {
    code: "B1",
    boxes: [
      {
        code: "B1.1"
      },
      {
        code: "B1.2"
      }
    ]
  },
  {
    code: "B2",
    boxes: [
      {
        code: "B2.1",
        boxes: [
          {
            code: "B2.1.1"
          },
          {
            code: "B2.1.2",
            bomb: true
          }
        ]
      },
      {
        code: "B2.2"
      }
    ]
  }
]
const listBoxes2: ListOfBoxes [] = [
  {
    "code": "B1.2",
    "boxes": [
      {
        "code": "B1.2.2",
        "boxes": [
          {
            "code": "B1.2.2.6"
          }
        ]
      },
      {
        "code": "B1.2.7"
      },
      {
        "code": "B1.2.4"
      },
      {
        "code": "B1.2.0"
      },
      {
        "code": "B1.2.9",
        "boxes": [
          {
            "code": "B1.2.9.0",
            "bomb": true,
          }
        ]
      }
    ]
  },
  {
    "code": "B2.8",
    "boxes": [
      {
        "code": "B2.8.0"
      },
      {
        "code": "B2.8.7"
      },
      {
        "code": "B2.8.6"
      },
      {
        "code": "B2.8.3"
      }
    ]
  },
  {
    "code": "B3.6",
    "boxes": [
      {
        "code": "B3.6.5"
      },
      {
        "code": "B3.6.7",
        "boxes": [
          {
            "code": "B3.6.7.9"
          }
        ]
      }
    ]
  }
]
const listBoxes3: ListOfBoxes [] = [
  {
    "code": "B1.6",
    "boxes": [
      {
        "code": "B1.6.9"
      },
      {
        "code": "B1.6.2"
      }
    ]
  },
  {
    "code": "B2.4",
    "boxes": [
      {
        "code": "B2.4.0"
      },
      {
        "code": "B2.4.3",
        "boxes": [
          {
            "code": "B2.4.3.9",
            "bomb": true
          }
        ]
      },
      {
        "code": "B2.4.7"
      }
    ]
  }
]

findTheBomb([])
findTheBomb(listBoxes1);
findTheBomb(listBoxes2);
findTheBomb(listBoxes3);

function rgbToHsv(rgb) {
  const [r, g, b] = rgb.map(value => value / 255);
  const v = Math.max(r, g, b);
  const min = Math.min(r, g, b);
  const delta = v - min;
  const s = v === 0 ? 0 : delta / v;

  let h = 0;
  
  const getRes = (h, s, v) => [Math.round(h), Math.round(s * 100), Math.round(v * 100)];
  
  if (s === 0) return getRes(h, s, v);
  
  if (v === r) {
    h = (g - b) / delta;
  } else if (v === g) {
    h = 2 + (b - r) / delta;
  } else {
    h = 4 + (r - g) / delta;
  }
  h *= 60;
  if (h < 0) h += 360;

  return getRes(h, s, v);
}

#include <string>
#include <string_view>
#include <vector>
#include <numeric>
#include <sstream>

std::string Jointup(const std::vector<std::string> &name , const std::string_view delim = " , ")
{
    if (name.empty()) return "";
    std::stringstream ss;
    ss << name.front();
    std::for_each(std::next(name.cbegin()), name.cend(), [&ss, delim](auto const& s) { ss << delim << s; });
    return ss.str();
}

#include <random>

std::uniform_real_distribution<long double> dis(0.,1.); // Default is double
std::random_device rd;
std::mt19937 gen(rd());

inline long double ppow(const long double& x) {
  return x * x;
}

long double pi_estimate_yours(long long n, int seed=0) {
    gen.seed(seed);
    long long inside = 0;
    for (auto i=0; i!=n; i++) {
      if (ppow(dis(gen))+ppow(dis(gen)) < 1.){
        inside++;
      }
    }
    return (4.*inside)/n; 
}

long double divisor(long double num) {
    return sqrt((2.*sqrt(2.) * static_cast<double>(num)) / (2. - sqrt(2.)));
}

//
// i 
//
long double pi_estimate(long double n, int seed = 0) {
  
    gen.seed(seed); // warnings
    long double div = divisor(n);

    long double R = 1.L;
    long double Rsq = R * R;
    long double A = sqrt(0.5L);
    long double Rbit = 1.L / div;
    std::cout << Rbit << std::endl;
    long double Rnum = div;
    long double Anum = A / Rbit;

    long double inside_accum = Anum * Anum + (Rnum - Anum) * Anum; // regular grid
    


    long double yisq = 0;
    long double subaccum = 0;
    for (long double yi = A; yi < R; yi += Rbit) {
        yisq = yi * yi;
        for (long double xi = A * (R - yi)/(R - A); xi < A; xi += Rbit) {
            if (yisq + xi * xi < Rsq) {
                subaccum++;
            } else break;
        }
    }
    
    inside_accum += 2 * subaccum;
    
    long double pee = inside_accum * 4. / (Rnum * Rnum);


    return (pee);
}