Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

#include <iostream>

int main()
{
    std::cout << "Hello, world!" << std::endl;
    return 0;
}

Compile and run:

g++ main.cpp -o main
./main

This is the smallest C++ program shape: main starts the program, and std::cout prints to the terminal.

Variables

#include <string>

std::string name = "Dan";
int count = 1;
bool active = true;
auto language = "C++";

This shows a few common C++ value types and auto for type inference when the initializer already makes the type obvious.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

Console.WriteLine("Hello, world!");

Run the project:

dotnet run

This prints a line to standard output. In a small C# app, Console.WriteLine is the usual starting point.

Variables

string name = "Dan";
int count = 1;
bool active = true;
var language = "C#";

This shows common C# types plus var, which lets the compiler infer the type from the value on the right.

Methods

static string Greet(string name)
{
    return $"Hello, {name}!";
}

This is a basic C# method: it accepts an argument, builds a string, and returns the result.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

IO.puts("Hello, world!")

Run the script:

elixir main.exs

This prints a line in Elixir using the IO module. It is the normal first example for a script.

Variables

Values are immutable. Rebinding creates a new binding for the name.

name = "Dan"
count = 1
active = true

These bindings hold values for the current expression flow. In Elixir, you work with new bindings instead of mutating old values.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

-module(main).
-export([hello/0]).

hello() ->
    io:format("Hello, world!~n").

Compile and run in the Erlang shell:

c(main).
main:hello().

This defines a tiny Erlang module and a function that prints one line to the shell.

Variables

Variables are single-assignment and start with an uppercase letter.

Name = "Dan",
Count = 1,
Active = true.

These are single-assignment bindings. Once a variable has a value in Erlang, you do not mutate it in place.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

A sample go program is show here.

package main

import "fmt"

func main() {
  message := greetMe("world")
  fmt.Println(message)
}

func greetMe(name string) string {
  return "Hello, " + name + "!"
}

Run the program as below:

$ go run hello.go

This is the normal shape of a tiny Go program: main runs first, and fmt.Println writes output.

Variables

Normal Declaration:

var msg string
msg = "Hello"

Shortcut:

msg := "Hello"

This shows both var and the short := form. The short form is the one you will use most inside functions.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

main :: IO ()
main = putStrLn "Hello, world!"

Run the file:

runhaskell Main.hs

This prints one line from main, which is the usual entry point for a small Haskell program.

Values

Values are immutable. Type annotations are optional, but useful for clarity.

name :: String
name = "Dan"

count :: Int
count = 1

active :: Bool
active = True

These are immutable bindings. You describe what each value is, not how to update it later.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

Compile and run:

javac Main.java
java Main

This is the standard Java entry point: the main method runs first, and System.out.println prints to the console.

Variables

String name = "Dan";
int count = 1;
boolean active = true;

These are a few common Java types. Java keeps types explicit, so the declaration tells you exactly what each value holds.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

(format t "Hello, world!~%")

Run with a Common Lisp implementation such as SBCL:

sbcl --script main.lisp

This prints a line in Common Lisp using format, which is a flexible function for building and writing text.

Variables

(defparameter *name* "Dan")
(defparameter *count* 1)
(defparameter *active* t)

These global parameters hold simple values you can reuse across expressions.

Functions

(defun greet (name)
  (format nil "Hello, ~A!" name))

(greet "world")

This defines a function and then calls it. Lisp keeps the function shape compact, even for small reusable helpers.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

<?php

echo "Hello, world!" . PHP_EOL;

Run the script:

php main.php

This writes one line from a PHP script. PHP_EOL keeps the newline portable across environments.

Variables

Variables start with $. Use strict comparisons when the type matters.

$name = "Dan";
$count = 1;
$active = true;

if ($count === 1) {
    echo $name;
}

This shows normal PHP variables and a strict comparison, which is the safer choice when type differences matter.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

print("Hello, world!")

Run the script:

python main.py

This prints a line in Python with the built-in print function. It is the normal first script example.

Variables

Python variables are dynamically typed and can be annotated when the expected type matters.

name = "Dan"
age: int = 30
is_active = True

Python lets you bind values without declaring a type first. Add annotations when you want the expected shape to be clearer.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

fn main() {
    println!("Hello, world!");
}

Run the program:

cargo run

This is the normal Rust entry point. println! is a macro that writes formatted output to the terminal.

Variables

Variables are immutable by default. Use mut when the value should change.

let language = "Rust";
let mut count = 1;
count += 1;

Rust values are immutable unless you mark them with mut, which makes state changes explicit.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

const message: string = "Hello, world!";
console.log(message);

Run with a TypeScript runtime or compile first:

npx tsx main.ts

This defines a typed string and logs it. It is the basic TypeScript shape for a tiny script.

Types

type User = {
  id: number;
  name: string;
  active: boolean;
};

const user: User = {
  id: 1,
  name: "Dan",
  active: true,
};

This type describes the expected object shape, then the object literal follows that contract.

Advanced

Mon, 01 Jan 0001 00:00:00 +0000

Function Clauses and Guards

Use multiple function heads to make branching explicit. Guards keep each clause narrow and readable.

defmodule AccessLevel do
  def label(%{role: :admin}), do: "full access"
  def label(%{role: :editor, active: true}), do: "edit access"
  def label(%{role: role}) when role in [:viewer, :guest], do: "read only"
  def label(_), do: "no access"
end

This keeps branching close to the function definition, which makes Elixir code easier to scan than one large conditional.

Pipelines

The pipe operator passes the previous result as the first argument to the next function.

Basic Types

Mon, 01 Jan 0001 00:00:00 +0000

Strings

str := "Hello"

Multiline string

str := `Multiline
string`

This shows regular strings and raw multiline strings. Raw strings are handy when you want to keep formatting as written.

Numbers

Typical types

num := 3          // int
num := 3.         // float64
num := 3 + 4i     // complex128
num := byte('a')  // byte (alias for uint8)

Other Types

var u uint = 7        // uint (unsigned)
var p float32 = 22.7  // 32-bit float

Go keeps numeric types explicit. The examples show the common defaults plus a few typed variants when precision or size matters.

Flow Control

Mon, 01 Jan 0001 00:00:00 +0000

Condition

if day == "sunday" || day == "saturday" {
  rest()
} else if day == "monday" && isTired() {
  groan()
} else {
  work()
}

if _, err := doThing(); err != nil {
  fmt.Println("Uh oh")

This shows the normal if and else if flow in Go, plus the common if err != nil pattern for error handling.

Switch

switch day {
  case "sunday":
    // cases don't "fall through" by default!
    fallthrough

  case "saturday":
    rest()

  default:
    work()
}

Go switch blocks are clean by default because cases do not fall through unless you ask for it explicitly.

File Manipulation

Mon, 01 Jan 0001 00:00:00 +0000

Condition

if day == "sunday" || day == "saturday" {
  rest()
} else if day == "monday" && isTired() {
  groan()
} else {
  work()
}

if _, err := doThing(); err != nil {
  fmt.Println("Uh oh")

Despite the title here, this example is another Go conditional. It shows the same straight-line branching style used in most Go code.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Bash Add

add() {
    echo $(( $1 + $2 ))
}

This just adds the two input numbers with Bash arithmetic and prints the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

C++ Add

int add(int param1, int param2)
{
    return param1 + param2;
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

C# Add

static int Add(int param1, int param2)
{
    return param1 + param2;
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Add

defmodule Add do
  def add(param1, param2), do: param1 + param2
end

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Add

-module(add).
-export([add/2]).

add(Param1, Param2) ->
    Param1 + Param2.

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Go Add

func add(param1, param2 int) int {
	return param1 + param2
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Add

add :: Num a => a -> a -> a
add param1 param2 = param1 + param2

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Java Add

public class Solution {
    public static int add(int param1, int param2) {
        return param1 + param2;
    }
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Add

(defun add (param1 param2)
  (+ param1 param2))

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

PHP Add

function add($param1, $param2) {
    return $param1 + $param2;
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Python Add

def add(param1: int, param2: int) -> int:
    return param1 + param2

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Rust Add

fn add(param1: i64, param2: i64) -> i64 {
    param1 + param2
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Add

function add(param1: number, param2: number): number {
  return param1 + param2;
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Bash Add Border

add_border() {
    local -n _pic="$1"
    local -n _outPic="$2"
    local _width=${#_pic[0]}
    local _border
    _border=$(printf '%*s' "$_width" '' | tr ' ' '*')
    _outPic=("$_border")
    local _line
    for _line in "${_pic[@]}"; do
        _outPic+=("*${_line}*")
    done
    _outPic+=("$_border")
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

C++ Add Border

#include <string>
#include <vector>

std::vector<std::string> addBorder(std::vector<std::string> picture)
{
    picture.insert(picture.begin(), std::string(picture[0].size(), '*'));
    for (auto& row : picture) {
        row = "*" + row + "*";
    }
    picture.push_back(std::string(picture[0].size(), '*'));

    return picture;
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

C# Add Border

static string[] AddBorder(string[] picture)
{
    var rows = new List<string> { new string('*', picture[0].Length) };
    rows.AddRange(picture);

    for (int i = 0; i < rows.Count; i++)
    {
        rows[i] = $"*{rows[i]}*";
    }

    rows.Add(new string('*', rows[0].Length));

    return rows.ToArray();
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Add Border

defmodule AddBorder do
  def add_border(picture) do
    border = String.duplicate("*", String.length(hd(picture)))
    wrapped = Enum.map(picture, fn row -> "*" <> row <> "*" end)

    [border] ++ wrapped ++ [border]
  end
end

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Add Border

-module(add_border).
-export([add_border/1]).

add_border(Picture) ->
    Width = length(hd(Picture)),
    Border = lists:duplicate(Width + 2, $*),
    Bordered = [[$*] ++ Row ++ [$*] || Row <- Picture],
    [Border] ++ Bordered ++ [Border].

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Go Add Border

func addBorder(picture []string) []string {
	border := strings.Repeat("*", len(picture[0]))

	result := make([]string, 0, len(picture)+2)
	result = append(result, border)
	for _, line := range picture {
		result = append(result, "*"+line+"*")
	}
	result = append(result, border)

	return result
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Add Border

addBorder :: [String] -> [String]
addBorder picture = border : map (\row -> "*" ++ row ++ "*") picture ++ [border]
  where
    border = replicate (length (head picture) + 2) '*'

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Java Add Border

public class Solution {
    public static String[] addBorder(String[] picture) {
        int width = picture[0].length() + 2;
        String border = "*".repeat(width);

        String[] result = new String[picture.length + 2];
        result[0] = border;
        for (int i = 0; i < picture.length; i++) {
            result[i + 1] = "*" + picture[i] + "*";
        }
        result[result.length - 1] = border;

        return result;
    }
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Add Border

(defun add-border (picture)
  (let* ((width (length (first picture)))
         (border (make-string width :initial-element #\*))
         (wrapped (mapcar (lambda (row) (format nil "*~A*" row))
                           (cons border picture))))
    (append wrapped (list (make-string (+ width 2) :initial-element #\*)))))

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

PHP Add Border

function addBorder($picture) {
    array_unshift($picture,str_repeat("*",strlen($picture[0])));
    foreach($picture as $k=> $v) {
        $picture[$k] = "*{$v}*";
    }
    $picture[] = str_repeat("*", strlen($picture[0]));
    return $picture;

}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Python Add Border

def add_border(picture: list[str]) -> list[str]:
    width = len(picture[0]) + 2
    border = "*" * width
    return [border] + [f"*{row}*" for row in picture] + [border]

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Rust Add Border

fn add_border(picture: &[String]) -> Vec<String> {
    let width = picture[0].len();
    let border = "*".repeat(width + 2);

    let mut result = Vec::with_capacity(picture.len() + 2);
    result.push(border.clone());
    for row in picture {
        result.push(format!("*{row}*"));
    }
    result.push(border);

    result
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Add Border

function addBorder(picture: string[]): string[] {
  const width = picture[0].length;
  const bordered = picture.map((row) => `*${row}*`);
  const border = "*".repeat(width + 2);
  return [border, ...bordered, border];
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Bash Adjacent Elements Product

adjacent_elements_product() {
    local -n _arr="$1"
    local _max=-9223372036854775808
    local _i _c=${#_arr[@]}
    for ((_i = 0; _i < _c - 1; _i++)); do
        local _p=$(( _arr[_i] * _arr[_i+1] ))
        if (( _p > _max )); then _max=$_p; fi
    done
    echo "$_max"
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

C++ Adjacent Elements Product

#include <algorithm>
#include <limits>
#include <vector>

long long adjacentElementsProduct(const std::vector<int>& inputArray)
{
    long long max = std::numeric_limits<long long>::min();

    for (std::size_t i = 0; i + 1 < inputArray.size(); ++i) {
        long long product = static_cast<long long>(inputArray[i]) * inputArray[i + 1];
        max = std::max(max, product);
    }

    return max;
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

C# Adjacent Elements Product

static long AdjacentElementsProduct(int[] inputArray)
{
    long max = long.MinValue;

    for (int i = 0; i < inputArray.Length - 1; i++)
    {
        max = Math.Max(max, (long)inputArray[i] * inputArray[i + 1]);
    }

    return max;
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Adjacent Elements Product

defmodule AdjacentElementsProduct do
  def adjacent_elements_product(input_array) do
    input_array
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.map(fn [a, b] -> a * b end)
    |> Enum.max()
  end
end

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Adjacent Elements Product

-module(adjacent_elements_product).
-export([adjacent_elements_product/1]).

adjacent_elements_product(InputArray) ->
    Pairs = lists:zip(InputArray, tl(InputArray)),
    lists:max([X * Y || {X, Y} <- Pairs]).

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Go Adjacent Elements Product

func adjacentElementsProduct(inputArray []int) int {
	max := inputArray[0] * inputArray[1]

	for i := 0; i < len(inputArray)-1; i++ {
		if p := inputArray[i] * inputArray[i+1]; p > max {
			max = p
		}
	}

	return max
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Adjacent Elements Product

adjacentElementsProduct :: [Int] -> Int
adjacentElementsProduct inputArray = maximum (zipWith (*) inputArray (tail inputArray))

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Java Adjacent Elements Product

public class Solution {
    public static int adjacentElementsProduct(int[] inputArray) {
        int max = Integer.MIN_VALUE;

        for (int i = 0; i < inputArray.length - 1; i++) {
            max = Math.max(max, inputArray[i] * inputArray[i + 1]);
        }

        return max;
    }
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Adjacent Elements Product

(defun adjacent-elements-product (input-array)
  (let ((vec (coerce input-array 'vector))
        (max-product most-negative-fixnum))
    (dotimes (i (1- (length vec)))
      (setf max-product (max max-product (* (aref vec i) (aref vec (1+ i))))))
    max-product))

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

PHP Adjacent Elements Product

function adjacentElementsProduct($inputArray)
{
    $max = PHP_INT_MIN;

    for ($i = 0, $c = count($inputArray); $i < $c - 1; $i++) {
        $max = max($max, $inputArray[$i] * $inputArray[$i + 1]);
    }

    return $max;

}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Python Adjacent Elements Product

def adjacent_elements_product(input_array: list[int]) -> int:
    return max(
        input_array[i] * input_array[i + 1] for i in range(len(input_array) - 1)
    )

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Rust Adjacent Elements Product

fn adjacent_elements_product(input_array: &[i64]) -> i64 {
    input_array
        .windows(2)
        .map(|w| w[0] * w[1])
        .max()
        .unwrap_or(i64::MIN)
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Adjacent Elements Product

function adjacentElementsProduct(inputArray: number[]): number {
  let max = -Infinity;

  for (let i = 0; i < inputArray.length - 1; i++) {
    max = Math.max(max, inputArray[i] * inputArray[i + 1]);
  }

  return max;
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Bash Almost Magic Square

almost_magic_square() {
    local -n _a="$1"
    local -n _out="$2"
    local -a _rowSum=(0 0 0) _colSum=(0 0 0)
    local -a _m
    local _i _j
    for ((_i = 0; _i < 3; _i++)); do
        for ((_j = 0; _j < 3; _j++)); do
            _m[_i*3+_j]=${_a[_i*3+_j]}
        done
    done
    for ((_i = 0; _i < 3; _i++)); do
        for ((_j = 0; _j < 3; _j++)); do
            _rowSum[_i]=$(( _rowSum[_i] + _m[_i*3+_j] ))
            _colSum[_i]=$(( _colSum[_i] + _m[_j*3+_i] ))
        done
    done
    local _maxSum=0
    for ((_i = 0; _i < 3; _i++)); do
        if (( _rowSum[_i] > _maxSum )); then _maxSum=${_rowSum[_i]}; fi
        if (( _colSum[_i] > _maxSum )); then _maxSum=${_colSum[_i]}; fi
    done
    _i=0; _j=0
    while (( _i < 3 && _j < 3 )); do
        local _diffR=$(( _maxSum - _rowSum[_i] ))
        local _diffC=$(( _maxSum - _colSum[_j] ))
        local _diff=$(( _diffR < _diffC ? _diffR : _diffC ))
        _m[_i*3+_j]=$(( _m[_i*3+_j] + _diff ))
        _rowSum[_i]=$(( _rowSum[_i] + _diff ))
        _colSum[_j]=$(( _colSum[_j] + _diff ))
        if (( _rowSum[_i] == _maxSum )); then ((_i++)); fi
        if (( _colSum[_j] == _maxSum )); then ((_j++)); fi
    done
    _out=("${_m[@]}")
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

C++ Almost Magic Square

#include <algorithm>
#include <array>
#include <vector>

std::vector<int> almostMagicSquare(const std::vector<int>& a)
{
    std::array<std::array<int, 3>, 3> grid{};
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            grid[i][j] = a[i * 3 + j];
        }
    }

    std::array<int, 3> rowSum{};
    std::array<int, 3> colSum{};
    int maxSum = 0;

    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            rowSum[i] += grid[i][j];
            colSum[i] += grid[j][i];
        }
    }

    for (int k = 0; k < 3; ++k) {
        maxSum = std::max(maxSum, rowSum[k]);
        maxSum = std::max(maxSum, colSum[k]);
    }

    for (int i = 0, j = 0; i < 3 && j < 3;) {
        int diff = std::min(maxSum - rowSum[i], maxSum - colSum[j]);
        grid[i][j] += diff;
        rowSum[i] += diff;
        colSum[j] += diff;

        if (rowSum[i] == maxSum) {
            ++i;
        }
        if (colSum[j] == maxSum) {
            ++j;
        }
    }

    std::vector<int> result;
    result.reserve(9);
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            result.push_back(grid[i][j]);
        }
    }

    return result;
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

C# Almost Magic Square

static int[] AlmostMagicSquare(int[] a)
{
    var rowSum = new int[3];
    var colSum = new int[3];
    var maxSum = 0;

    var grid = new int[3][];
    for (int i = 0; i < 3; i++)
    {
        grid[i] = new[] { a[i * 3], a[i * 3 + 1], a[i * 3 + 2] };
    }

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            rowSum[i] += grid[i][j];
            colSum[i] += grid[j][i];
        }
    }

    for (int k = 0; k < 3; k++)
    {
        maxSum = Math.Max(maxSum, rowSum[k]);
        maxSum = Math.Max(maxSum, colSum[k]);
    }

    for (int i = 0, j = 0; i < 3 && j < 3;)
    {
        var diff = Math.Min(maxSum - rowSum[i], maxSum - colSum[j]);
        grid[i][j] += diff;
        rowSum[i] += diff;
        colSum[j] += diff;

        if (rowSum[i] == maxSum)
        {
            i++;
        }
        if (colSum[j] == maxSum)
        {
            j++;
        }
    }

    var result = new int[9];
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            result[i * 3 + j] = grid[i][j];
        }
    }

    return result;
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Almost Magic Square

defmodule AlmostMagicSquare do
  def almost_magic_square(a) do
    rows = Enum.chunk_every(a, 3)
    row_sums = Enum.map(rows, &Enum.sum/1)
    col_sums = for j <- 0..2, do: rows |> Enum.map(&Enum.at(&1, j)) |> Enum.sum()
    max_sum = Enum.max(row_sums ++ col_sums)

    {final_rows, _, _, _, _} = balance(rows, row_sums, col_sums, max_sum, 0, 0)
    List.flatten(final_rows)
  end

  defp balance(rows, row_sums, col_sums, max_sum, i, j) when i < 3 and j < 3 do
    diff = min(max_sum - Enum.at(row_sums, i), max_sum - Enum.at(col_sums, j))

    rows = List.update_at(rows, i, fn row -> List.update_at(row, j, &(&1 + diff)) end)
    row_sums = List.update_at(row_sums, i, &(&1 + diff))
    col_sums = List.update_at(col_sums, j, &(&1 + diff))

    next_i = if Enum.at(row_sums, i) == max_sum, do: i + 1, else: i
    next_j = if Enum.at(col_sums, j) == max_sum, do: j + 1, else: j

    balance(rows, row_sums, col_sums, max_sum, next_i, next_j)
  end

  defp balance(rows, row_sums, col_sums, _max_sum, i, j), do: {rows, row_sums, col_sums, i, j}
end

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Almost Magic Square

-module(almost_magic_square).
-export([almost_magic_square/1]).

almost_magic_square(A) ->
    Rows = chunk3(A),
    RowSums = [lists:sum(R) || R <- Rows],
    ColSums = [lists:sum([lists:nth(C, R) || R <- Rows]) || C <- [1, 2, 3]],
    MaxSum = lists:max(RowSums ++ ColSums),
    FinalRows = balance(0, 0, RowSums, ColSums, Rows, MaxSum),
    lists:append(FinalRows).

chunk3([]) -> [];
chunk3(List) ->
    {Row, Rest} = lists:split(3, List),
    [Row | chunk3(Rest)].

balance(I, J, RowSums, ColSums, Rows, MaxSum) when I < 3, J < 3 ->
    RowSumI = lists:nth(I + 1, RowSums),
    ColSumJ = lists:nth(J + 1, ColSums),
    Diff = min(MaxSum - RowSumI, MaxSum - ColSumJ),
    Rows1 = add_at(Rows, I, J, Diff),
    RowSums1 = add_at_list(RowSums, I, Diff),
    ColSums1 = add_at_list(ColSums, J, Diff),
    NextI = case lists:nth(I + 1, RowSums1) of MaxSum -> I + 1; _ -> I end,
    NextJ = case lists:nth(J + 1, ColSums1) of MaxSum -> J + 1; _ -> J end,
    balance(NextI, NextJ, RowSums1, ColSums1, Rows1, MaxSum);
balance(_, _, _, _, Rows, _) ->
    Rows.

add_at(Rows, I, J, Diff) ->
    [case Idx of
         I -> [case Jdx of J -> V + Diff; _ -> V end
               || {Jdx, V} <- lists:zip(lists:seq(0, length(Row) - 1), Row)];
         _ -> Row
     end || {Idx, Row} <- lists:zip(lists:seq(0, length(Rows) - 1), Rows)].

add_at_list(List, Idx0, Diff) ->
    [case I of Idx0 -> V + Diff; _ -> V end
     || {I, V} <- lists:zip(lists:seq(0, length(List) - 1), List)].

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Go Almost Magic Square

func almostMagicSquare(a []int) []int {
	var grid [3][3]int
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			grid[i][j] = a[i*3+j]
		}
	}

	rowSum := make([]int, 3)
	colSum := make([]int, 3)
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			rowSum[i] += grid[i][j]
			colSum[i] += grid[j][i]
		}
	}

	maxSum := 0
	for k, v := range rowSum {
		maxSum = max(maxSum, v, colSum[k])
	}

	for i, j := 0, 0; i < 3 && j < 3; {
		diff := min(maxSum-rowSum[i], maxSum-colSum[j])
		grid[i][j] += diff
		rowSum[i] += diff
		colSum[j] += diff

		if rowSum[i] == maxSum {
			i++
		}
		if colSum[j] == maxSum {
			j++
		}
	}

	result := make([]int, 0, 9)
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			result = append(result, grid[i][j])
		}
	}

	return result
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Almost Magic Square

almostMagicSquare :: [Int] -> [Int]
almostMagicSquare a = concat (go rows rowSums colSums 0 0)
  where
    chunk3 [] = []
    chunk3 xs = take 3 xs : chunk3 (drop 3 xs)

    updateAt :: Int -> (b -> b) -> [b] -> [b]
    updateAt idx f xs = [if i == idx then f x else x | (i, x) <- zip [0 ..] xs]

    rows    = chunk3 a
    rowSums = map sum rows
    colSums = [sum [rows !! r !! c | r <- [0 .. 2]] | c <- [0 .. 2]]
    maxSum  = maximum (rowSums ++ colSums)

    go grid rs cs i j
      | i >= 3 || j >= 3 = grid
      | otherwise =
          let diff  = min (maxSum - rs !! i) (maxSum - cs !! j)
              grid' = updateAt i (updateAt j (+ diff)) grid
              rs'   = updateAt i (+ diff) rs
              cs'   = updateAt j (+ diff) cs
              i'    = if rs' !! i == maxSum then i + 1 else i
              j'    = if cs' !! j == maxSum then j + 1 else j
          in  go grid' rs' cs' i' j'

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Java Almost Magic Square

public class Solution {
    public static int[] almostMagicSquare(int[] a) {
        int[][] grid = new int[3][3];
        for (int i = 0; i < 9; i++) {
            grid[i / 3][i % 3] = a[i];
        }

        int[] rowSum = new int[3];
        int[] colSum = new int[3];
        int maxSum = 0;

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                rowSum[i] += grid[i][j];
                colSum[i] += grid[j][i];
            }
        }

        for (int k = 0; k < 3; k++) {
            maxSum = Math.max(maxSum, rowSum[k]);
            maxSum = Math.max(maxSum, colSum[k]);
        }

        for (int i = 0, j = 0; i < 3 && j < 3; ) {
            int diff = Math.min(maxSum - rowSum[i], maxSum - colSum[j]);
            grid[i][j] += diff;
            rowSum[i] += diff;
            colSum[j] += diff;

            if (rowSum[i] == maxSum) {
                i++;
            }
            if (colSum[j] == maxSum) {
                j++;
            }
        }

        int[] result = new int[9];
        for (int i = 0; i < 9; i++) {
            result[i] = grid[i / 3][i % 3];
        }

        return result;
    }
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Almost Magic Square

(defun almost-magic-square (a)
  (let ((m (make-array '(3 3)))
        (row-sum (make-array 3 :initial-element 0))
        (col-sum (make-array 3 :initial-element 0))
        (max-sum 0))
    (loop for idx from 0 below 9
          for val in a
          do (setf (aref m (floor idx 3) (mod idx 3)) val))
    (dotimes (i 3)
      (dotimes (j 3)
        (incf (aref row-sum i) (aref m i j))
        (incf (aref col-sum i) (aref m j i))))
    (dotimes (k 3)
      (setf max-sum (max max-sum (aref row-sum k) (aref col-sum k))))
    (let ((i 0) (j 0))
      (loop while (and (< i 3) (< j 3))
            do (let ((diff (min (- max-sum (aref row-sum i))
                                 (- max-sum (aref col-sum j)))))
                 (incf (aref m i j) diff)
                 (incf (aref row-sum i) diff)
                 (incf (aref col-sum j) diff)
                 (when (= (aref row-sum i) max-sum) (incf i))
                 (when (and (< j 3) (= (aref col-sum j) max-sum)) (incf j)))))
    (loop for idx from 0 below 9
          collect (aref m (floor idx 3) (mod idx 3)))))

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

PHP Almost Magic Square

function almostMagicSquare(array $a): array
{
    $rowSum = $colSum = array_fill(0, 3, 0);
    $maxSum = 0;

    $a = array_chunk($a, 3);
    for ($i = 0; $i < 3; $i++) {
        for ($j = 0; $j < 3; $j++) {
            $rowSum[$i] += $a[$i][$j];
            $colSum[$i] += $a[$j][$i];
        }
    }

    foreach ($rowSum as $k => $v) {
        $maxSum = max($maxSum, $v);
        $maxSum = max($maxSum, $colSum[$k]);
    }

    for ($i = 0, $j = 0; $i < 3 && $j < 3;) {
        $diff       = min($maxSum - $rowSum[$i], $maxSum - $colSum[$j]);
        $a[$i][$j]  += $diff;
        $rowSum[$i] += $diff;
        $colSum[$j] += $diff;

        if ($rowSum[$i] === $maxSum) {
            $i++;
        }
        if ($colSum[$j] === $maxSum) {
            $j++;
        }
    }

    return array_merge([], ...$a);

}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Python Almost Magic Square

def almost_magic_square(a: list[int]) -> list[int]:
    grid = [a[i:i + 3] for i in range(0, 9, 3)]
    row_sum = [0, 0, 0]
    col_sum = [0, 0, 0]

    for i in range(3):
        for j in range(3):
            row_sum[i] += grid[i][j]
            col_sum[i] += grid[j][i]

    max_sum = 0
    for k in range(3):
        max_sum = max(max_sum, row_sum[k])
        max_sum = max(max_sum, col_sum[k])

    i = j = 0
    while i < 3 and j < 3:
        diff = min(max_sum - row_sum[i], max_sum - col_sum[j])
        grid[i][j] += diff
        row_sum[i] += diff
        col_sum[j] += diff

        if row_sum[i] == max_sum:
            i += 1
        if col_sum[j] == max_sum:
            j += 1

    return [v for row in grid for v in row]

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Rust Almost Magic Square

fn almost_magic_square(a: &[i64]) -> Vec<i64> {
    let mut grid: Vec<Vec<i64>> = a.chunks(3).map(|c| c.to_vec()).collect();
    let mut row_sum = [0i64; 3];
    let mut col_sum = [0i64; 3];

    for i in 0..3 {
        for j in 0..3 {
            row_sum[i] += grid[i][j];
            col_sum[i] += grid[j][i];
        }
    }

    let mut max_sum = 0;
    for k in 0..3 {
        max_sum = max_sum.max(row_sum[k]);
        max_sum = max_sum.max(col_sum[k]);
    }

    let (mut i, mut j) = (0usize, 0usize);
    while i < 3 && j < 3 {
        let diff = (max_sum - row_sum[i]).min(max_sum - col_sum[j]);
        grid[i][j] += diff;
        row_sum[i] += diff;
        col_sum[j] += diff;

        if row_sum[i] == max_sum {
            i += 1;
        }
        if col_sum[j] == max_sum {
            j += 1;
        }
    }

    grid.into_iter().flatten().collect()
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Almost Magic Square

function almostMagicSquare(a: number[]): number[] {
  const rowSum = [0, 0, 0];
  const colSum = [0, 0, 0];
  let maxSum = 0;

  const grid: number[][] = [a.slice(0, 3), a.slice(3, 6), a.slice(6, 9)];

  for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
      rowSum[i] += grid[i][j];
      colSum[i] += grid[j][i];
    }
  }

  for (let k = 0; k < 3; k++) {
    maxSum = Math.max(maxSum, rowSum[k]);
    maxSum = Math.max(maxSum, colSum[k]);
  }

  for (let i = 0, j = 0; i < 3 && j < 3; ) {
    const diff = Math.min(maxSum - rowSum[i], maxSum - colSum[j]);
    grid[i][j] += diff;
    rowSum[i] += diff;
    colSum[j] += diff;

    if (rowSum[i] === maxSum) {
      i++;
    }
    if (colSum[j] === maxSum) {
      j++;
    }
  }

  return grid.flat();
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Bash Are Equally Strong

are_equally_strong() {
    local _yourLeft=$1 _yourRight=$2 _friendsLeft=$3 _friendsRight=$4
    local _maxYou=$(( _yourRight > _yourLeft ? _yourRight : _yourLeft ))
    local _maxFriend=$(( _friendsLeft > _friendsRight ? _friendsLeft : _friendsRight ))
    local _minYou=$(( _yourLeft < _yourRight ? _yourLeft : _yourRight ))
    local _minFriend=$(( _friendsRight < _friendsLeft ? _friendsRight : _friendsLeft ))
    if (( _maxYou == _maxFriend && _minYou == _minFriend )); then
        echo true
    else
        echo false
    fi
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

C++ Are Equally Strong

#include <algorithm>

bool areEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight)
{
    return std::max(yourRight, yourLeft) == std::max(friendsLeft, friendsRight)
        && std::min(yourLeft, yourRight) == std::min(friendsRight, friendsLeft);
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

C# Are Equally Strong

static bool AreEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight)
{
    return Math.Max(yourRight, yourLeft) == Math.Max(friendsLeft, friendsRight)
           && Math.Min(yourLeft, yourRight) == Math.Min(friendsRight, friendsLeft);
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Are Equally Strong

defmodule AreEquallyStrong do
  def are_equally_strong(your_left, your_right, friends_left, friends_right) do
    max(your_right, your_left) == max(friends_left, friends_right) and
      min(your_left, your_right) == min(friends_right, friends_left)
  end
end

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Are Equally Strong

-module(are_equally_strong).
-export([are_equally_strong/4]).

are_equally_strong(YourLeft, YourRight, FriendsLeft, FriendsRight) ->
    max(YourRight, YourLeft) =:= max(FriendsLeft, FriendsRight) andalso
    min(YourLeft, YourRight) =:= min(FriendsRight, FriendsLeft).

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Go Are Equally Strong

func areEquallyStrong(yourLeft, yourRight, friendsLeft, friendsRight int) bool {
	return max(yourRight, yourLeft) == max(friendsLeft, friendsRight) &&
		min(yourLeft, yourRight) == min(friendsRight, friendsLeft)
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Are Equally Strong

areEquallyStrong :: Int -> Int -> Int -> Int -> Bool
areEquallyStrong yourLeft yourRight friendsLeft friendsRight =
  max yourRight yourLeft == max friendsLeft friendsRight
    && min yourLeft yourRight == min friendsRight friendsLeft

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Java Are Equally Strong

public class Solution {
    public static boolean areEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight) {
        return Math.max(yourLeft, yourRight) == Math.max(friendsLeft, friendsRight)
                && Math.min(yourLeft, yourRight) == Math.min(friendsLeft, friendsRight);
    }
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Are Equally Strong

(defun are-equally-strong (your-left your-right friends-left friends-right)
  (and (= (max your-right your-left) (max friends-left friends-right))
       (= (min your-left your-right) (min friends-right friends-left))))

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

PHP Are Equally Strong

function areEquallyStrong($yourLeft, $yourRight, $friendsLeft, $friendsRight)
{
    return max($yourRight, $yourLeft) === max($friendsLeft, $friendsRight)
           && min($yourLeft, $yourRight) === min($friendsRight, $friendsLeft);

}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Python Are Equally Strong

def are_equally_strong(
    your_left: int, your_right: int, friends_left: int, friends_right: int
) -> bool:
    return max(your_right, your_left) == max(friends_left, friends_right) and min(
        your_left, your_right
    ) == min(friends_right, friends_left)

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Rust Are Equally Strong

fn are_equally_strong(your_left: i64, your_right: i64, friends_left: i64, friends_right: i64) -> bool {
    your_right.max(your_left) == friends_left.max(friends_right)
        && your_left.min(your_right) == friends_right.min(friends_left)
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Are Equally Strong

function areEquallyStrong(
  yourLeft: number,
  yourRight: number,
  friendsLeft: number,
  friendsRight: number
): boolean {
  return (
    Math.max(yourRight, yourLeft) === Math.max(friendsLeft, friendsRight) &&
    Math.min(yourLeft, yourRight) === Math.min(friendsRight, friendsLeft)
  );
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Bash Array Change

array_change() {
    local -n _a="$1"
    local _min=0 _k _c=${#_a[@]}
    for ((_k = 0; _k < _c - 1; _k++)); do
        if (( _a[_k] >= _a[_k+1] )); then
            local _dif=$(( _a[_k] - _a[_k+1] + 1 ))
            _a[_k+1]=$(( _a[_k+1] + _dif ))
            _min=$(( _min + _dif ))
        fi
    done
    echo "$_min"
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

C++ Array Change

#include <vector>

long long arrayChange(std::vector<long long> a)
{
    long long min = 0;
    for (std::size_t k = 0; k + 1 < a.size(); ++k) {
        if (a[k] >= a[k + 1]) {
            long long dif = a[k] - a[k + 1] + 1;
            a[k + 1] += dif;
            min += dif;
        }
    }

    return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

C# Array Change

static long ArrayChange(int[] a)
{
    var arr = new long[a.Length];
    Array.Copy(a, arr, a.Length);
    long min = 0;

    for (int k = 0; k < arr.Length - 1; k++)
    {
        if (arr[k] >= arr[k + 1])
        {
            var dif = arr[k] - arr[k + 1] + 1;
            arr[k + 1] += dif;
            min += dif;
        }
    }

    return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Array Change

defmodule ArrayChange do
  def array_change(a) when length(a) < 2, do: 0

  def array_change(a) do
    {_final, total} =
      Enum.reduce(0..(length(a) - 2), {a, 0}, fn k, {arr, total} ->
        cur = Enum.at(arr, k)
        nxt = Enum.at(arr, k + 1)

        if cur >= nxt do
          diff = cur - nxt + 1
          {List.update_at(arr, k + 1, &(&1 + diff)), total + diff}
        else
          {arr, total}
        end
      end)

    total
  end
end

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Array Change

-module(array_change).
-export([array_change/1]).

array_change([H | T]) ->
    {_, Total} = lists:foldl(fun(X, {Prev, Acc}) ->
        case X =< Prev of
            true ->
                New = Prev + 1,
                {New, Acc + (New - X)};
            false ->
                {X, Acc}
        end
    end, {H, 0}, T),
    Total.

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Go Array Change

func arrayChange(a []int) int {
	moves := 0

	for k := 0; k < len(a)-1; k++ {
		if a[k] >= a[k+1] {
			diff := a[k] - a[k+1] + 1
			a[k+1] += diff
			moves += diff
		}
	}

	return moves
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Array Change

arrayChange :: [Int] -> Int
arrayChange []       = 0
arrayChange (x : xs) = snd (foldl step (x, 0) xs)
  where
    step (prev, total) cur
      | prev >= cur = (prev + 1, total + (prev - cur + 1))
      | otherwise   = (cur, total)

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Java Array Change

public class Solution {
    public static long arrayChange(int[] a) {
        long min = 0;
        long[] arr = new long[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }

        for (int k = 0; k < arr.length - 1; k++) {
            if (arr[k] >= arr[k + 1]) {
                long dif = arr[k] - arr[k + 1] + 1;
                arr[k + 1] += dif;
                min += dif;
            }
        }

        return min;
    }
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Array Change

(defun array-change (a)
  (let ((vec (coerce a 'vector))
        (min 0))
    (dotimes (k (1- (length vec)))
      (when (>= (aref vec k) (aref vec (1+ k)))
        (let ((dif (+ (- (aref vec k) (aref vec (1+ k))) 1)))
          (incf (aref vec (1+ k)) dif)
          (incf min dif))))
    min))

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

PHP Array Change

function arrayChange($a)
{
    $min = 0;
    for ($k = 0, $c = count($a); $k < $c - 1; $k++) {
        if ($a[$k] >= $a[$k + 1]) {
            $dif       = $a[$k] - $a[$k + 1] + 1;
            $a[$k + 1] += $dif;
            $min       += $dif;
        }
    }

    return $min;

}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Python Array Change

def array_change(a: list[int]) -> int:
    moves = 0
    for k in range(len(a) - 1):
        if a[k] >= a[k + 1]:
            diff = a[k] - a[k + 1] + 1
            a[k + 1] += diff
            moves += diff
    return moves

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Rust Array Change

fn array_change(mut a: Vec<i64>) -> i64 {
    let mut min = 0;
    for k in 0..a.len().saturating_sub(1) {
        if a[k] >= a[k + 1] {
            let dif = a[k] - a[k + 1] + 1;
            a[k + 1] += dif;
            min += dif;
        }
    }

    min
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Array Change

function arrayChange(a: number[]): number {
  let min = 0;
  for (let k = 0; k < a.length - 1; k++) {
    if (a[k] >= a[k + 1]) {
      const dif = a[k] - a[k + 1] + 1;
      a[k + 1] += dif;
      min += dif;
    }
  }

  return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Bash Array Maximal Adjacement Difference

array_maximal_adjacent_difference() {
    local -n _a="$1"
    local _dif=0 _i _c=${#_a[@]}
    for ((_i = 1; _i < _c - 1; _i++)); do
        local _d1=$(( _a[_i] - _a[_i-1] )); (( _d1 < 0 )) && _d1=$(( -_d1 ))
        local _d2=$(( _a[_i] - _a[_i+1] )); (( _d2 < 0 )) && _d2=$(( -_d2 ))
        (( _d1 > _dif )) && _dif=$_d1
        (( _d2 > _dif )) && _dif=$_d2
    done
    echo "$_dif"
}

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

C++ Array Maximal Adjacement Difference

#include <algorithm>
#include <cstdlib>
#include <vector>

long long arrayMaximalAdjacentDifference(const std::vector<int>& a)
{
    long long dif = 0;
    for (std::size_t i = 1; i + 1 < a.size(); ++i) {
        long long left = std::llabs(static_cast<long long>(a[i]) - a[i - 1]);
        long long right = std::llabs(static_cast<long long>(a[i]) - a[i + 1]);
        dif = std::max({dif, left, right});
    }

    return dif;
}

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

C# Array Maximal Adjacement Difference

static long ArrayMaximalAdjacentDifference(int[] a)
{
    long dif = 0;

    for (int i = 1; i < a.Length - 1; i++)
    {
        dif = Math.Max(dif, Math.Max(Math.Abs((long)a[i] - a[i - 1]), Math.Abs((long)a[i] - a[i + 1])));
    }

    return dif;
}

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Array Maximal Adjacement Difference

defmodule ArrayMaximalAdjacentDifference do
  def array_maximal_adjacent_difference(a) when length(a) < 3, do: 0

  def array_maximal_adjacent_difference(a) do
    len = length(a)

    1..(len - 2)
    |> Enum.map(fn i ->
      prev = Enum.at(a, i - 1)
      cur = Enum.at(a, i)
      nxt = Enum.at(a, i + 1)
      max(abs(cur - prev), abs(cur - nxt))
    end)
    |> Enum.max()
  end
end

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Array Maximal Adjacement Difference

-module(array_maximal_adjacent_difference).
-export([array_maximal_adjacent_difference/1]).

array_maximal_adjacent_difference(A) when length(A) < 3 ->
    0;
array_maximal_adjacent_difference(A) ->
    Triples = lists:zip3(A, tl(A), tl(tl(A))),
    lists:max([max(abs(Cur - Prev), abs(Cur - Next)) || {Prev, Cur, Next} <- Triples]).

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Go Array Maximal Adjacement Difference

func abs(n int) int {
	if n < 0 {
		return -n
	}

	return n
}

func arrayMaximalAdjacentDifference(a []int) int {
	diff := 0

	for i := 1; i < len(a)-1; i++ {
		diff = max(diff, abs(a[i]-a[i-1]), abs(a[i]-a[i+1]))
	}

	return diff
}

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Array Maximal Adjacement Difference

arrayMaximalAdjacentDifference :: [Int] -> Int
arrayMaximalAdjacentDifference a
  | length a < 3 = 0
  | otherwise    = maximum (zipWith3 middle a (tail a) (drop 2 a))
  where
    middle p c n = max (abs (c - p)) (abs (c - n))

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Java Array Maximal Adjacement Difference

public class Solution {
    public static int arrayMaximalAdjacentDifference(int[] a) {
        int dif = 0;
        for (int i = 1; i < a.length - 1; i++) {
            dif = Math.max(dif, Math.max(Math.abs(a[i] - a[i - 1]), Math.abs(a[i] - a[i + 1])));
        }

        return dif;
    }
}

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Array Maximal Adjacement Difference

(defun array-maximal-adjacent-difference (a)
  (let* ((vec (coerce a 'vector))
         (c (length vec))
         (dif 0))
    (loop for i from 1 below (1- c)
          do (setf dif (max dif
                             (abs (- (aref vec i) (aref vec (1- i))))
                             (abs (- (aref vec i) (aref vec (1+ i)))))))
    dif))

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

PHP Array Maximal Adjacement Difference

function arrayMaximalAdjacentDifference($a)
{
    $dif = 0;
    for ($i = 1, $c = count($a); $i < $c - 1; $i++) {
        $dif = max($dif, abs($a[$i] - $a[$i - 1]), abs($a[$i] - $a[$i + 1]));
    }

    return $dif;

}

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Python Array Maximal Adjacement Difference

def array_maximal_adjacent_difference(a: list[int]) -> int:
    diff = 0
    for i in range(1, len(a) - 1):
        diff = max(diff, abs(a[i] - a[i - 1]), abs(a[i] - a[i + 1]))
    return diff

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Rust Array Maximal Adjacement Difference

fn array_maximal_adjacent_difference(a: &[i64]) -> i64 {
    let mut dif = 0;
    for i in 1..a.len().saturating_sub(1) {
        dif = dif.max((a[i] - a[i - 1]).abs()).max((a[i] - a[i + 1]).abs());
    }

    dif
}

This checks the gap between each pair of neighbors and returns the largest difference.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Array Maximal Adjacement Difference

function arrayMaximalAdjacentDifference(a: number[]): number {
  let dif = 0;
  for (let i = 1; i < a.length - 1; i++) {
    dif = Math.max(dif, Math.abs(a[i] - a[i - 1]), Math.abs(a[i] - a[i + 1]));
  }

  return dif;
}

This checks the gap between each pair of neighbors and returns the largest difference.

Bash Variables

Mon, 01 Jan 0001 00:00:00 +0000

Variable

NAME="John"
echo $NAME
echo "$NAME"
echo "${NAME}

This shows the common ways to read a Bash variable. Quoting is usually the safe default because it keeps spaces and special characters from breaking your output.

Condition

if [[ -z "$string" ]]; then
  echo "String is empty"
elif [[ -n "$string" ]]; then
  echo "String is not empty"
fi

This is the standard Bash string check. -z means the value is empty, and -n means it has content.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Bash Binary Gap

binary_gap() {
    local _n=$1
    local _bin=""
    if (( _n == 0 )); then
        _bin="0"
    else
        local _x=$_n
        while (( _x > 0 )); do
            _bin="$(( _x % 2 ))$_bin"
            _x=$(( _x / 2 ))
        done
    fi
    _bin="${_bin#"${_bin%%[!0]*}"}"
    _bin="${_bin%"${_bin##*[!0]}"}"
    local _gap=0 _len=0
    local -a _zeros
    IFS='1' read -ra _zeros <<< "$_bin"
    local _z
    for _z in "${_zeros[@]}"; do
        _len=${#_z}
        (( _len > _gap )) && _gap=$_len
    done
    echo "$_gap"
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

C++ Binary Gap

#include <algorithm>

int binaryGap(int n)
{
    int gap = 0;
    int run = -1; // -1 means no leading '1' has been seen yet

    while (n > 0) {
        if (n & 1) {
            if (run >= 0) {
                gap = std::max(gap, run);
            }
            run = 0;
        } else if (run >= 0) {
            ++run;
        }
        n >>= 1;
    }

    return gap;
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

C# Binary Gap

static int BinaryGap(int n)
{
    var binary = Convert.ToString(n, 2).Trim('0');
    var gap = 0;

    foreach (var zero in binary.Split('1'))
    {
        gap = Math.Max(gap, zero.Length);
    }

    return gap;
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Binary Gap

defmodule BinaryGap do
  def binary_gap(n) do
    n
    |> Integer.to_string(2)
    |> String.trim("0")
    |> String.split("1")
    |> Enum.map(&String.length/1)
    |> Enum.max()
  end
end

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Binary Gap

-module(binary_gap).
-export([binary_gap/1]).

binary_gap(N) ->
    Bin = integer_to_list(N, 2),
    Trimmed = string:trim(Bin, both, "0"),
    Groups = string:split(Trimmed, "1", all),
    lists:max([length(G) || G <- Groups]).

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Go Binary Gap

func binaryGap(n int) int {
	trimmed := strings.Trim(strconv.FormatInt(int64(n), 2), "0")

	gap := 0
	for _, zeroes := range strings.Split(trimmed, "1") {
		if len(zeroes) > gap {
			gap = len(zeroes)
		}
	}

	return gap
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Binary Gap

import Data.Char (intToDigit)
import Data.List (dropWhileEnd)
import Numeric (showIntAtBase)

binaryGap :: Int -> Int
binaryGap n = maximum (0 : map length (words spaced))
  where
    bin     = showIntAtBase 2 intToDigit n ""
    trimmed = dropWhileEnd (== '0') (dropWhile (== '0') bin)
    spaced  = map (\c -> if c == '1' then ' ' else c) trimmed

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Java Binary Gap

public class Solution {
    public static int binaryGap(int n) {
        String bin = Integer.toBinaryString(n).replaceAll("^0+|0+$", "");
        String[] zeroes = bin.split("1", -1);

        int gap = 0;
        for (String zero : zeroes) {
            gap = Math.max(gap, zero.length());
        }

        return gap;
    }
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Binary Gap

(defun binary-gap (n)
  (let* ((bits (write-to-string n :base 2))
         (trimmed (string-trim "0" bits))
         (groups (split-on-char trimmed #\1))
         (gap 0))
    (dolist (zero groups)
      (setf gap (max gap (length zero))))
    gap))

(defun split-on-char (s ch)
  (loop with start = 0
        for pos = (position ch s :start start)
        collect (subseq s start pos)
        while pos
        do (setf start (1+ pos))))

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

PHP Binary Gap

function binaryGap(int $n): int
{
    $gap    = 0;
    $zeroes = explode('1', trim(decbin($n), '0'));
    foreach ($zeroes as $zero) {
        $len = strlen($zero);
        $gap = $len > $gap ? $len : $gap;
    }

    return $gap;
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Python Binary Gap

def binary_gap(n: int) -> int:
    zeroes = bin(n)[2:].strip("0").split("1")
    return max((len(z) for z in zeroes), default=0)

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Rust Binary Gap

fn binary_gap(n: i64) -> i64 {
    let bits = format!("{n:b}");
    let trimmed = bits.trim_matches('0');

    trimmed
        .split('1')
        .map(|zeroes| zeroes.len() as i64)
        .max()
        .unwrap_or(0)
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Binary Gap

function binaryGap(n: number): number {
  const trimmed = n.toString(2).replace(/^0+|0+$/g, "");
  const zeroes = trimmed.split("1");

  let gap = 0;
  for (const zero of zeroes) {
    gap = Math.max(gap, zero.length);
  }

  return gap;
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Bash Bracket

bracket() {
    local _s=$1
    local -a _stack=()
    local _i _c
    for ((_i = 0; _i < ${#_s}; _i++)); do
        _c=${_s:_i:1}
        case "$_c" in
            ')')
                if (( ${#_stack[@]} == 0 )) || [[ "${_stack[-1]}" != "(" ]]; then
                    echo 0; return
                fi
                unset '_stack[-1]'
                ;;
            ']')
                if (( ${#_stack[@]} == 0 )) || [[ "${_stack[-1]}" != "[" ]]; then
                    echo 0; return
                fi
                unset '_stack[-1]'
                ;;
            '}')
                if (( ${#_stack[@]} == 0 )) || [[ "${_stack[-1]}" != "{" ]]; then
                    echo 0; return
                fi
                unset '_stack[-1]'
                ;;
            *)
                _stack+=("$_c")
                ;;
        esac
    done
    if (( ${#_stack[@]} == 0 )); then echo 1; else echo 0; fi
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

C++ Bracket

#include <string>
#include <vector>

int bracket(const std::string& s)
{
    std::vector<char> stack;

    for (char c : s) {
        switch (c) {
            case ')':
                if (stack.empty() || stack.back() != '(') {
                    return 0;
                }
                stack.pop_back();
                break;
            case ']':
                if (stack.empty() || stack.back() != '[') {
                    return 0;
                }
                stack.pop_back();
                break;
            case '}':
                if (stack.empty() || stack.back() != '{') {
                    return 0;
                }
                stack.pop_back();
                break;
            default:
                stack.push_back(c);
                break;
        }
    }

    return stack.empty() ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

C# Bracket

static int Bracket(string s)
{
    var stack = new Stack<char>();

    foreach (var v in s)
    {
        switch (v)
        {
            case ')':
                if (stack.Count == 0 || stack.Pop() != '(')
                {
                    return 0;
                }
                break;
            case ']':
                if (stack.Count == 0 || stack.Pop() != '[')
                {
                    return 0;
                }
                break;
            case '}':
                if (stack.Count == 0 || stack.Pop() != '{')
                {
                    return 0;
                }
                break;
            default:
                stack.Push(v);
                break;
        }
    }

    return stack.Count == 0 ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Bracket

defmodule Bracket do
  def bracket(s) do
    result =
      s
      |> String.graphemes()
      |> Enum.reduce_while([], fn ch, stack ->
        case ch do
          ")" -> pop_match(stack, "(")
          "]" -> pop_match(stack, "[")
          "}" -> pop_match(stack, "{")
          _ -> {:cont, [ch | stack]}
        end
      end)

    if result == [], do: 1, else: 0
  end

  defp pop_match([], _expected), do: {:halt, :mismatch}

  defp pop_match([top | rest], expected) do
    if top == expected, do: {:cont, rest}, else: {:halt, :mismatch}
  end
end

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Bracket

-module(bracket).
-export([bracket/1]).

bracket(S) ->
    case close_stack(S, []) of
        [] -> 1;
        _  -> 0
    end.

close_stack([], Stack) -> Stack;
close_stack([$( | T], Stack) -> close_stack(T, [$( | Stack]);
close_stack([$[ | T], Stack) -> close_stack(T, [$[ | Stack]);
close_stack([${ | T], Stack) -> close_stack(T, [${ | Stack]);
close_stack([$) | T], [$( | Stack1]) -> close_stack(T, Stack1);
close_stack([$] | T], [$[ | Stack1]) -> close_stack(T, Stack1);
close_stack([$} | T], [${ | Stack1]) -> close_stack(T, Stack1);
close_stack([$) | _], _) -> error;
close_stack([$] | _], _) -> error;
close_stack([$} | _], _) -> error;
close_stack([_ | T], Stack) -> close_stack(T, Stack).

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Go Bracket

func bracket(s string) int {
	pairs := map[byte]byte{')': '(', ']': '[', '}': '{'}
	stack := make([]byte, 0, len(s))

	for i := 0; i < len(s); i++ {
		c := s[i]
		if open, isClose := pairs[c]; isClose {
			if len(stack) == 0 || stack[len(stack)-1] != open {
				return 0
			}
			stack = stack[:len(stack)-1]
		} else {
			stack = append(stack, c)
		}
	}

	if len(stack) == 0 {
		return 1
	}

	return 0
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Bracket

bracket :: String -> Int
bracket s = go s []
  where
    go [] stack = if null stack then 1 else 0
    go (c : cs) stack = case c of
      ')' -> pop '(' cs stack
      ']' -> pop '[' cs stack
      '}' -> pop '{' cs stack
      _   -> go cs (c : stack)

    pop expected cs (top : rest)
      | top == expected = go cs rest
    pop _ _ _ = 0

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Java Bracket

import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {
    public static int bracket(String s) {
        Deque<Character> stack = new ArrayDeque<>();

        for (char v : s.toCharArray()) {
            switch (v) {
                case ')':
                    if (stack.isEmpty() || stack.pop() != '(') {
                        return 0;
                    }
                    break;
                case ']':
                    if (stack.isEmpty() || stack.pop() != '[') {
                        return 0;
                    }
                    break;
                case '}':
                    if (stack.isEmpty() || stack.pop() != '{') {
                        return 0;
                    }
                    break;
                default:
                    stack.push(v);
                    break;
            }
        }

        return stack.isEmpty() ? 1 : 0;
    }
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Bracket

(defun bracket (s)
  (let ((stack '()))
    (loop for v across s
          do (cond
               ((char= v #\))
                (if (or (null stack) (char/= (pop stack) #\())
                    (return-from bracket 0)))
               ((char= v #\])
                (if (or (null stack) (char/= (pop stack) #\[))
                    (return-from bracket 0)))
               ((char= v #\})
                (if (or (null stack) (char/= (pop stack) #\{))
                    (return-from bracket 0)))
               (t (push v stack))))
    (if (null stack) 1 0)))

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

PHP Bracket

function bracket(string $s): int
{
    $stack = [];
    foreach (str_split($s) as $v) {
        switch ($v) {
            case ')':
                if (empty($stack) || array_pop($stack) !== '(') {
                    return 0;
                }
                break;
            case ']':
                if (empty($stack) || array_pop($stack) !== '[') {
                    return 0;
                }
                break;
            case '}':
                if (empty($stack) || array_pop($stack) !== '{') {
                    return 0;
                }
                break;
            default:
                if ( ! empty($v)) {
                    $stack[] = $v;
                }
                break;
        }

    }

    return empty($stack) ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Python Bracket

def bracket(s: str) -> int:
    closers = {")": "(", "]": "[", "}": "{"}
    stack: list[str] = []

    for ch in s:
        if ch in closers:
            if not stack or stack.pop() != closers[ch]:
                return 0
        elif ch:
            stack.append(ch)

    return 1 if not stack else 0

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Rust Bracket

fn bracket(s: &str) -> i64 {
    let mut stack = Vec::new();
    for c in s.chars() {
        match c {
            ')' => {
                if stack.pop() != Some('(') {
                    return 0;
                }
            }
            ']' => {
                if stack.pop() != Some('[') {
                    return 0;
                }
            }
            '}' => {
                if stack.pop() != Some('{') {
                    return 0;
                }
            }
            _ => stack.push(c),
        }
    }

    if stack.is_empty() { 1 } else { 0 }
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Bracket

function bracket(s: string): number {
  const stack: string[] = [];

  for (const v of s) {
    switch (v) {
      case ")":
        if (stack.length === 0 || stack.pop() !== "(") {
          return 0;
        }
        break;
      case "]":
        if (stack.length === 0 || stack.pop() !== "[") {
          return 0;
        }
        break;
      case "}":
        if (stack.length === 0 || stack.pop() !== "{") {
          return 0;
        }
        break;
      default:
        if (v) {
          stack.push(v);
        }
        break;
    }
  }

  return stack.length === 0 ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Bash Century From Year

century_from_year() {
    local _year=$1
    echo $(( (_year + 99) / 100 ))
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

C++ Century From Year

#include <cmath>

int centuryFromYear(int year)
{
    return static_cast<int>(std::ceil(year / 100.0));
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

C# Century From Year

static int CenturyFromYear(int year)
{
    return (int)Math.Ceiling(year / 100.0);
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Century From Year

defmodule CenturyFromYear do
  def century_from_year(year), do: ceil(year / 100)
end

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Century From Year

-module(century_from_year).
-export([century_from_year/1]).

century_from_year(Year) ->
    (Year + 99) div 100.

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Go Century From Year

func centuryFromYear(year int) int {
	return int(math.Ceil(float64(year) / 100))
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Century From Year

centuryFromYear :: Int -> Int
centuryFromYear year = ceiling (fromIntegral year / 100 :: Double)

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Java Century From Year

public class Solution {
    public static int centuryFromYear(int year) {
        return (int) Math.ceil(year / 100.0);
    }
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Century From Year

(defun century-from-year (year)
  (ceiling year 100))

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

PHP Century From Year

function centuryFromYear($year) {
    return ceil($year / 100);
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Python Century From Year

import math


def century_from_year(year: int) -> int:
    return math.ceil(year / 100)

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Rust Century From Year

fn century_from_year(year: i64) -> i64 {
    (year as f64 / 100.0).ceil() as i64
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Century From Year

function centuryFromYear(year: number): number {
  return Math.ceil(year / 100);
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Bash Check Palindrome

check_palindrome() {
    local _s=$1
    local _rev=""
    local _i
    for ((_i = ${#_s} - 1; _i >= 0; _i--)); do
        _rev="${_rev}${_s:_i:1}"
    done
    if [[ "$_rev" == "$_s" ]]; then echo true; else echo false; fi
}

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

C++ Check Palindrome

#include <string>

bool checkPalindrome(const std::string& inputString)
{
    return std::string(inputString.rbegin(), inputString.rend()) == inputString;
}

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

C# Check Palindrome

static bool CheckPalindrome(string inputString)
{
    var reversed = new string(inputString.Reverse().ToArray());

    return reversed == inputString;
}

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Check Palindrome

defmodule CheckPalindrome do
  def check_palindrome(input_string), do: String.reverse(input_string) == input_string
end

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Check Palindrome

-module(check_palindrome).
-export([check_palindrome/1]).

check_palindrome(InputString) ->
    lists:reverse(InputString) =:= InputString.

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Go Check Palindrome

func checkPalindrome(inputString string) bool {
	for i, j := 0, len(inputString)-1; i < j; i, j = i+1, j-1 {
		if inputString[i] != inputString[j] {
			return false
		}
	}

	return true
}

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Check Palindrome

checkPalindrome :: String -> Bool
checkPalindrome inputString = reverse inputString == inputString

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Java Check Palindrome

public class Solution {
    public static boolean checkPalindrome(String inputString) {
        return new StringBuilder(inputString).reverse().toString().equals(inputString);
    }
}

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Check Palindrome

(defun check-palindrome (input-string)
  (string= (reverse input-string) input-string))

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

PHP Check Palindrome

function checkPalindrome($inputString)
{
    return strrev($inputString) === $inputString;
}

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Python Check Palindrome

def check_palindrome(input_string: str) -> bool:
    return input_string[::-1] == input_string

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Rust Check Palindrome

fn check_palindrome(input_string: &str) -> bool {
    input_string.chars().rev().collect::<String>() == input_string
}

This compares the string with its reverse. If they match, it is a palindrome.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Check Palindrome

function checkPalindrome(inputString: string): boolean {
  return inputString.split("").reverse().join("") === inputString;
}

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Bash Chocolates By Numbers

gcd() {
    local _n=$1 _m=$2
    if (( _n % _m == 0 )); then
        echo "$_m"
        return
    fi
    gcd "$_m" $(( _n % _m ))
}

chocolates_by_numbers() {
    local _n=$1 _m=$2
    local _g
    _g=$(gcd "$_n" "$_m")
    echo $(( (_n * _m / _g) / _m ))
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

C++ Chocolates By Numbers

long long chocolatesGcd(long long n, long long m)
{
    if (n % m == 0) {
        return m;
    }

    return chocolatesGcd(m, n % m);
}

long long chocolatesByNumbers(long long n, long long m)
{
    long long g = chocolatesGcd(n, m);

    return ((n * m) / g) / m;
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

C# Chocolates By Numbers

static long ChocolatesByNumbers(long n, long m)
{
    long Gcd(long x, long y) => x % y == 0 ? y : Gcd(y, x % y);

    return (n * m) / Gcd(n, m) / m;
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Chocolates By Numbers

defmodule ChocolatesByNumbers do
  def chocolates_by_numbers(n, m) do
    g = gcd(n, m)
    n * m |> div(g) |> div(m)
  end

  defp gcd(n, m) when rem(n, m) == 0, do: m
  defp gcd(n, m), do: gcd(m, rem(n, m))
end

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Chocolates By Numbers

-module(chocolates_by_numbers).
-export([chocolates_by_numbers/2]).

chocolates_by_numbers(N, M) ->
    G = gcd(N, M),
    (N * M) div G div M.

gcd(N, M) when N rem M =:= 0 -> M;
gcd(N, M) -> gcd(M, N rem M).

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Go Chocolates By Numbers

func chocolatesByNumbers(n, m int) int {
	var gcd func(n, m int) int
	gcd = func(n, m int) int {
		if n%m == 0 {
			return m
		}

		return gcd(m, n%m)
	}

	return n / gcd(n, m)
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Chocolates By Numbers

chocolatesByNumbers :: Int -> Int -> Int
chocolatesByNumbers n m = (n * m) `div` gcd n m `div` m

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Java Chocolates By Numbers

public class Solution {
    public static int chocolatesByNumbers(int n, int m) {
        long gcd = gcd(n, m);
        long result = ((long) n * m / gcd) / m;

        return (int) result;
    }

    private static long gcd(long n, long m) {
        if (n % m == 0) {
            return m;
        }

        return gcd(m, n % m);
    }
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Chocolates By Numbers

(defun choc-gcd (n m)
  (if (zerop (mod n m))
      m
      (choc-gcd m (mod n m))))

(defun chocolates-by-numbers (n m)
  (/ (/ (* n m) (choc-gcd n m)) m))

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

PHP Chocolates By Numbers

function chocolatesByNumbers(int $n, int $m): int
{
    $gcd = static function (int $n, int $m) use (&$gcd) {
        if ($n % $m === 0) {
            return $m;
        }

        return $gcd($m, $n % $m);
    };

    return (($n * $m) / $gcd($n, $m)) / $m;
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Python Chocolates By Numbers

from math import gcd


def chocolates_by_numbers(n: int, m: int) -> int:
    return (n * m) // gcd(n, m) // m

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Rust Chocolates By Numbers

fn gcd(n: i64, m: i64) -> i64 {
    if n % m == 0 { m } else { gcd(m, n % m) }
}

fn chocolates_by_numbers(n: i64, m: i64) -> i64 {
    (n * m) / gcd(n, m) / m
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Chocolates By Numbers

function chocolatesByNumbers(n: number, m: number): number {
  const gcd = (x: number, y: number): number => (x % y === 0 ? y : gcd(y, x % y));

  return (n * m) / gcd(n, m) / m;
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Bash Common Prime Divisors

gcd() {
    local _n=$1 _m=$2
    if (( _n % _m == 0 )); then
        echo "$_m"
        return
    fi
    gcd "$_m" $(( _n % _m ))
}

remove_common_prime_divisors() {
    local _n=$1 _m=$2 _d
    while (( _n != 1 )); do
        _d=$(gcd "$_n" "$_m")
        if (( _d == 1 )); then
            break
        fi
        _n=$(( _n / _d ))
    done
    echo "$_n"
}

common_prime_divisors() {
    local -n _arrA="$1"
    local -n _arrB="$2"
    local _counter=0 _i _x _y _d _rx _ry
    for _i in "${!_arrA[@]}"; do
        _x=${_arrA[$_i]}
        _y=${_arrB[$_i]}
        _d=$(gcd "$_x" "$_y")
        _rx=$(remove_common_prime_divisors "$_x" "$_d")
        if (( _rx != 1 )); then
            continue
        fi
        _ry=$(remove_common_prime_divisors "$_y" "$_d")
        if (( _ry == 1 )); then
            ((_counter++))
        fi
    done
    echo "$_counter"
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

C++ Common Prime Divisors

#include <cstddef>
#include <vector>

long long commonPrimeDivisorsGcd(long long n, long long m)
{
    if (n % m == 0) {
        return m;
    }

    return commonPrimeDivisorsGcd(m, n % m);
}

long long removeCommonPrimeDivisors(long long n, long long m)
{
    while (n != 1) {
        long long d = commonPrimeDivisorsGcd(n, m);
        if (d == 1) {
            break;
        }
        n /= d;
    }

    return n;
}

int commonPrimeDivisors(const std::vector<int>& a, const std::vector<int>& b)
{
    int counter = 0;

    for (std::size_t i = 0; i < a.size(); ++i) {
        long long x = a[i];
        long long y = b[i];
        long long d = commonPrimeDivisorsGcd(x, y);

        x = removeCommonPrimeDivisors(x, d);
        if (x != 1) {
            continue;
        }

        y = removeCommonPrimeDivisors(y, d);
        if (y == 1) {
            ++counter;
        }
    }

    return counter;
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

C# Common Prime Divisors

static int CommonPrimeDivisors(int[] a, int[] b)
{
    long Gcd(long n, long m) => n % m == 0 ? m : Gcd(m, n % m);

    long RemoveCommonPrimeDivisors(long n, long m)
    {
        while (n != 1)
        {
            var d = Gcd(n, m);
            if (d == 1)
            {
                break;
            }
            n /= d;
        }

        return n;
    }

    var counter = 0;
    for (int i = 0; i < a.Length; i++)
    {
        long x = a[i];
        long y = b[i];
        var d = Gcd(x, y);

        x = RemoveCommonPrimeDivisors(x, d);
        if (x != 1)
        {
            continue;
        }

        y = RemoveCommonPrimeDivisors(y, d);
        if (y == 1)
        {
            counter++;
        }
    }

    return counter;
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Common Prime Divisors

defmodule CommonPrimeDivisors do
  def common_prime_divisors(a, b) do
    a
    |> Enum.zip(b)
    |> Enum.count(fn {x, y} ->
      d = gcd(x, y)
      remove_common(x, d) == 1 and remove_common(y, d) == 1
    end)
  end

  defp gcd(n, m) when rem(n, m) == 0, do: m
  defp gcd(n, m), do: gcd(m, rem(n, m))

  defp remove_common(1, _m), do: 1

  defp remove_common(n, m) do
    d = gcd(n, m)
    if d == 1, do: n, else: remove_common(div(n, d), m)
  end
end

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Common Prime Divisors

-module(common_prime_divisors).
-export([common_prime_divisors/2]).

common_prime_divisors(A, B) ->
    length([ok || {X, Y} <- lists:zip(A, B), has_same_prime_divisors(X, Y)]).

has_same_prime_divisors(X, Y) ->
    D = gcd(X, Y),
    case remove_common(X, D) of
        1 -> remove_common(Y, D) =:= 1;
        _ -> false
    end.

remove_common(1, _) -> 1;
remove_common(N, M) ->
    case gcd(N, M) of
        1 -> N;
        D -> remove_common(N div D, M)
    end.

gcd(N, M) when N rem M =:= 0 -> M;
gcd(N, M) -> gcd(M, N rem M).

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Go Common Prime Divisors

func commonPrimeDivisors(a, b []int) int {
	var gcd func(n, m int) int
	gcd = func(n, m int) int {
		if n%m == 0 {
			return m
		}

		return gcd(m, n%m)
	}

	removeCommonPrimeDivisors := func(n, m int) int {
		for n != 1 {
			d := gcd(n, m)
			if d == 1 {
				break
			}
			n /= d
		}

		return n
	}

	counter := 0
	for i := range a {
		x, y := a[i], b[i]
		d := gcd(x, y)

		x = removeCommonPrimeDivisors(x, d)
		if x != 1 {
			continue
		}

		y = removeCommonPrimeDivisors(y, d)
		if y == 1 {
			counter++
		}
	}

	return counter
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Common Prime Divisors

commonPrimeDivisors :: [Int] -> [Int] -> Int
commonPrimeDivisors as bs = length (filter matches (zip as bs))
  where
    matches (x, y) =
      let d = gcd x y
      in strip x d == 1 && strip y d == 1

    strip n m
      | n == 1    = 1
      | d == 1    = n
      | otherwise = strip (n `div` d) m
      where
        d = gcd n m

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Java Common Prime Divisors

public class Solution {
    public static int commonPrimeDivisors(int[] a, int[] b) {
        int counter = 0;

        for (int i = 0; i < a.length; i++) {
            int x = a[i];
            int y = b[i];
            int d = gcd(x, y);

            x = removeCommonPrimeDivisors(x, d);
            if (x != 1) {
                continue;
            }

            y = removeCommonPrimeDivisors(y, d);
            if (y == 1) {
                counter++;
            }
        }

        return counter;
    }

    private static int gcd(int n, int m) {
        if (n % m == 0) {
            return m;
        }

        return gcd(m, n % m);
    }

    private static int removeCommonPrimeDivisors(int n, int m) {
        while (n != 1) {
            int d = gcd(n, m);
            if (d == 1) {
                break;
            }
            n /= d;
        }

        return n;
    }
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Common Prime Divisors

(defun cpd-gcd (n m)
  (if (zerop (mod n m))
      m
      (cpd-gcd m (mod n m))))

(defun remove-common-prime-divisors (n m)
  (loop while (/= n 1)
        do (let ((d (cpd-gcd n m)))
             (when (= d 1)
               (return-from remove-common-prime-divisors n))
             (setf n (/ n d))))
  n)

(defun common-prime-divisors (a b)
  (let ((counter 0))
    (loop for x in a
          for y in b
          do (let* ((d (cpd-gcd x y))
                     (rx (remove-common-prime-divisors x d)))
               (when (= rx 1)
                 (let ((ry (remove-common-prime-divisors y d)))
                   (when (= ry 1)
                     (incf counter))))))
    counter))

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

PHP Common Prime Divisors

function commonPrimeDivisors(array $a, array $b): int
{
    $gcd = static function (int $n, int $m) use (&$gcd) {
        if ($n % $m === 0) {
            return $m;
        }

        return $gcd($m, $n % $m);
    };

    $removeCommonPrimeDivisors = static function (int $n, int $m) use ($gcd) {
        while ($n !== 1) {
            $d = $gcd($n, $m);
            if ($d === 1) {
                break;
            }
            $n /= $d;
        }

        return $n;
    };

    $counter = 0;
    for ($i = 0, $count = count($a); $i < $count; $i++) {
        $x = $a[$i];
        $y = $b[$i];
        $d = $gcd($x, $y);

        $x = $removeCommonPrimeDivisors($x, $d);
        if ($x !== 1) {
            continue;
        }

        $y = $removeCommonPrimeDivisors($y, $d);
        if ($y === 1) {
            $counter++;
        }
    }

    return $counter;
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Python Common Prime Divisors

from math import gcd


def common_prime_divisors(a: list[int], b: list[int]) -> int:
    def remove_common_prime_divisors(n: int, m: int) -> int:
        while n != 1:
            d = gcd(n, m)
            if d == 1:
                break
            n //= d
        return n

    counter = 0
    for x, y in zip(a, b):
        d = gcd(x, y)

        x = remove_common_prime_divisors(x, d)
        if x != 1:
            continue

        y = remove_common_prime_divisors(y, d)
        if y == 1:
            counter += 1

    return counter

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Rust Common Prime Divisors

fn gcd(n: i64, m: i64) -> i64 {
    if n % m == 0 { m } else { gcd(m, n % m) }
}

fn remove_common_prime_divisors(mut n: i64, m: i64) -> i64 {
    while n != 1 {
        let d = gcd(n, m);
        if d == 1 {
            break;
        }
        n /= d;
    }

    n
}

fn common_prime_divisors(a: &[i64], b: &[i64]) -> i64 {
    let mut counter = 0;
    for i in 0..a.len() {
        let x = a[i];
        let y = b[i];
        let d = gcd(x, y);

        let x = remove_common_prime_divisors(x, d);
        if x != 1 {
            continue;
        }

        let y = remove_common_prime_divisors(y, d);
        if y == 1 {
            counter += 1;
        }
    }

    counter
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Common Prime Divisors

function commonPrimeDivisors(a: number[], b: number[]): number {
  const gcd = (n: number, m: number): number => (n % m === 0 ? m : gcd(m, n % m));

  const removeCommonPrimeDivisors = (n: number, m: number): number => {
    while (n !== 1) {
      const d = gcd(n, m);
      if (d === 1) {
        break;
      }
      n /= d;
    }

    return n;
  };

  let counter = 0;
  for (let i = 0; i < a.length; i++) {
    let x = a[i];
    let y = b[i];
    const d = gcd(x, y);

    x = removeCommonPrimeDivisors(x, d);
    if (x !== 1) {
      continue;
    }

    y = removeCommonPrimeDivisors(y, d);
    if (y === 1) {
      counter++;
    }
  }

  return counter;
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Div

count_div() {
    local _a=$1 _b=$2 _k=$3
    local _firstDiv
    if (( _a % _k == 0 )); then _firstDiv=$_a; else _firstDiv=$(( _a + (_k - _a % _k) )); fi
    local _lastDiv=$(( _b - _b % _k ))
    echo $(( (_lastDiv - _firstDiv) / _k + 1 ))
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Div

long long countDiv(long long a, long long b, long long k)
{
    long long firstDiv = a % k == 0 ? a : a + (k - a % k);
    long long lastDiv = b - b % k;

    return (lastDiv - firstDiv) / k + 1;
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Div

static long CountDiv(long a, long b, long k)
{
    var firstDiv = a % k == 0 ? a : a + (k - a % k);
    var lastDiv = b - b % k;

    return (lastDiv - firstDiv) / k + 1;
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Div

defmodule CountDiv do
  def count_div(a, b, k) do
    first_div = if rem(a, k) == 0, do: a, else: a + (k - rem(a, k))
    last_div = b - rem(b, k)

    div(last_div - first_div, k) + 1
  end
end

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Div

-module(count_div).
-export([count_div/3]).

count_div(A, B, K) ->
    FirstDiv = case A rem K of
        0 -> A;
        R -> A + (K - R)
    end,
    LastDiv = B - (B rem K),
    (LastDiv - FirstDiv) div K + 1.

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Div

func countDiv(a, b, k int) int {
	firstDiv := a
	if a%k != 0 {
		firstDiv = a + (k - a%k)
	}
	lastDiv := b - b%k

	return (lastDiv-firstDiv)/k + 1
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Count Div

countDiv :: Int -> Int -> Int -> Int
countDiv a b k = (lastDiv - firstDiv) `div` k + 1
  where
    firstDiv = if a `mod` k == 0 then a else a + (k - a `mod` k)
    lastDiv  = b - b `mod` k

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Div

public class Solution {
    public static int countDiv(int a, int b, int k) {
        int firstDiv = a % k == 0 ? a : a + (k - a % k);
        int lastDiv = b - b % k;

        return (lastDiv - firstDiv) / k + 1;
    }
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Count Div

(defun count-div (a b k)
  (let* ((first-div (if (zerop (mod a k)) a (+ a (- k (mod a k)))))
         (last-div (- b (mod b k))))
    (1+ (/ (- last-div first-div) k))))

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

PHP Count Div

function countDiv(int $a, int $b, int $k): int
{
    $firstDiv = $a % $k === 0 ? $a : $a + ($k - $a % $k);
    $lastDiv  = $b - $b % $k;

    return ($lastDiv - $firstDiv) / $k + 1;
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Div

def count_div(a: int, b: int, k: int) -> int:
    first_div = a if a % k == 0 else a + (k - a % k)
    last_div = b - b % k

    return (last_div - first_div) // k + 1

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Div

fn count_div(a: i64, b: i64, k: i64) -> i64 {
    let first_div = if a % k == 0 { a } else { a + (k - a % k) };
    let last_div = b - b % k;

    (last_div - first_div) / k + 1
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Count Div

function countDiv(a: number, b: number, k: number): number {
  const firstDiv = a % k === 0 ? a : a + (k - (a % k));
  const lastDiv = b - (b % k);

  return (lastDiv - firstDiv) / k + 1;
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Factors

count_factors() {
    local _n=$1
    local _count=0 _i=1
    while (( _i * _i < _n )); do
        if (( _n % _i == 0 )); then
            _count=$(( _count + 2 ))
        fi
        ((_i++))
    done
    if (( _i * _i == _n )); then
        ((_count++))
    fi
    echo "$_count"
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Factors

long long countFactors(long long n)
{
    long long count = 0;
    long long i = 1;

    while (i * i < n) {
        if (n % i == 0) {
            count += 2;
        }
        ++i;
    }
    if (i * i == n) {
        ++count;
    }

    return count;
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Factors

static int CountFactors(long n)
{
    var count = 0;
    long i = 1;

    while (i * i < n)
    {
        if (n % i == 0)
        {
            count += 2;
        }
        i++;
    }
    if (i * i == n)
    {
        count++;
    }

    return count;
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Factors

defmodule CountFactors do
  def count_factors(n), do: loop(1, 0, n)

  defp loop(i, count, n) when i * i < n do
    count = if rem(n, i) == 0, do: count + 2, else: count
    loop(i + 1, count, n)
  end

  defp loop(i, count, n) do
    if i * i == n, do: count + 1, else: count
  end
end

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Factors

-module(count_factors).
-export([count_factors/1]).

count_factors(N) ->
    count_factors(N, 1, 0).

count_factors(N, I, Count) when I * I < N ->
    NewCount = case N rem I =:= 0 of
        true -> Count + 2;
        false -> Count
    end,
    count_factors(N, I + 1, NewCount);
count_factors(N, I, Count) when I * I =:= N ->
    Count + 1;
count_factors(_, _, Count) ->
    Count.

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Factors

func countFactors(n int) int {
	count := 0
	i := 1
	for i*i < n {
		if n%i == 0 {
			count += 2
		}
		i++
	}
	if i*i == n {
		count++
	}

	return count
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Count Factors

countFactors :: Int -> Int
countFactors n = finalize (loop 1 0)
  where
    loop i count
      | i * i < n = loop (i + 1) (if n `mod` i == 0 then count + 2 else count)
      | otherwise = (i, count)

    finalize (i, count) = if i * i == n then count + 1 else count

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Factors

public class Solution {
    public static int countFactors(int n) {
        int count = 0;
        long i = 1;

        while (i * i < n) {
            if (n % i == 0) {
                count += 2;
            }
            i++;
        }
        if (i * i == n) {
            ++count;
        }

        return count;
    }
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Count Factors

(defun count-factors (n)
  (let ((count 0)
        (i 1))
    (loop while (< (* i i) n)
          do (progn
               (when (zerop (mod n i))
                 (incf count 2))
               (incf i)))
    (when (= (* i i) n)
      (incf count))
    count))

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

PHP Count Factors

function countFactors(int $n): int
{
    $count = 0;
    $i     = 1;
    while ($i * $i < $n) {
        if ($n % $i === 0) {
            $count += 2;
        }
        $i++;
    }
    if ($i * $i === $n) {
        ++$count;
    }

    return $count;
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Factors

def count_factors(n: int) -> int:
    count = 0
    i = 1
    while i * i < n:
        if n % i == 0:
            count += 2
        i += 1
    if i * i == n:
        count += 1

    return count

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Factors

fn count_factors(n: i64) -> i64 {
    let mut count = 0;
    let mut i = 1i64;
    while i * i < n {
        if n % i == 0 {
            count += 2;
        }
        i += 1;
    }
    if i * i == n {
        count += 1;
    }

    count
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Count Factors

function countFactors(n: number): number {
  let count = 0;
  let i = 1;
  while (i * i < n) {
    if (n % i === 0) {
      count += 2;
    }
    i++;
  }
  if (i * i === n) {
    ++count;
  }

  return count;
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Non Divisible

count_non_divisible() {
    local -n _a="$1"
    local -n _out="$2"
    local _size=${#_a[@]}
    local _maxv=${_a[0]} _v
    for _v in "${_a[@]}"; do (( _v > _maxv )) && _maxv=$_v; done
    local -a _occ
    for ((_v = 0; _v <= _maxv; _v++)); do _occ[_v]=0; done
    for _v in "${_a[@]}"; do _occ[_v]=$(( _occ[_v] + 1 )); done
    _out=()
    local _k
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        local _count=0 _i=1
        while (( _i * _i <= _v )); do
            if (( _v % _i == 0 )); then
                _count=$(( _count + _occ[_i] ))
                if (( _v / _i != _i )); then
                    _count=$(( _count + _occ[_v/_i] ))
                fi
            fi
            ((_i++))
        done
        _out[_k]=$(( _size - _count ))
    done
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Non Divisible

#include <algorithm>
#include <vector>

std::vector<int> countNonDivisible(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());
    std::vector<int> nondivisor(size, 0);

    int maxVal = *std::max_element(a.begin(), a.end());
    std::vector<int> occurrences(maxVal + 1, 0);

    for (int v : a) {
        ++occurrences[v];
    }

    for (int k = 0; k < size; ++k) {
        int v = a[k];
        int count = 0;
        long long i = 1;
        while (i * i <= v) {
            if (v % i == 0) {
                count += occurrences[i];
                if (v / i != i) {
                    count += occurrences[v / i];
                }
            }
            ++i;
        }
        nondivisor[k] = size - count;
    }

    return nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Non Divisible

static int[] CountNonDivisible(int[] a)
{
    var size = a.Length;
    var nondivisor = new int[size];
    var occurrences = new int[a.Max() + 1];

    foreach (var v in a)
    {
        occurrences[v]++;
    }

    for (int k = 0; k < size; k++)
    {
        var v = a[k];
        var count = 0;
        var i = 1;
        while (i * i <= v)
        {
            if (v % i == 0)
            {
                count += occurrences[i];
                if (v / i != i)
                {
                    count += occurrences[v / i];
                }
            }
            i++;
        }
        nondivisor[k] = size - count;
    }

    return nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Non Divisible

defmodule CountNonDivisible do
  def count_non_divisible(a) do
    size = length(a)
    occurrences = Enum.frequencies(a)

    Enum.map(a, fn v -> size - divisor_occurrences(1, v, occurrences, 0) end)
  end

  defp divisor_occurrences(i, v, _occurrences, count) when i * i > v, do: count

  defp divisor_occurrences(i, v, occurrences, count) do
    count =
      if rem(v, i) == 0 do
        count = count + Map.get(occurrences, i, 0)

        if div(v, i) != i do
          count + Map.get(occurrences, div(v, i), 0)
        else
          count
        end
      else
        count
      end

    divisor_occurrences(i + 1, v, occurrences, count)
  end
end

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Non Divisible

-module(count_non_divisible).
-export([count_non_divisible/1]).

count_non_divisible(A) ->
    Size = length(A),
    Occ = lists:foldl(fun(V, Map) ->
        maps:update_with(V, fun(C) -> C + 1 end, 1, Map)
    end, #{}, A),
    [Size - count_divisors(V, Occ) || V <- A].

count_divisors(V, Occ) ->
    count_divisors(V, Occ, 1, 0).

count_divisors(V, _Occ, I, Count) when I * I > V ->
    Count;
count_divisors(V, Occ, I, Count) ->
    case V rem I of
        0 ->
            Base = Count + maps:get(I, Occ, 0),
            Total = case V div I =:= I of
                true -> Base;
                false -> Base + maps:get(V div I, Occ, 0)
            end,
            count_divisors(V, Occ, I + 1, Total);
        _ ->
            count_divisors(V, Occ, I + 1, Count)
    end.

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Non Divisible

func countNonDivisible(a []int) []int {
	size := len(a)
	nonDivisors := make([]int, size)

	maxVal := a[0]
	for _, v := range a {
		if v > maxVal {
			maxVal = v
		}
	}

	occurrences := make([]int, maxVal+1)
	for _, v := range a {
		occurrences[v]++
	}

	for k, v := range a {
		count := 0
		for i := 1; i*i <= v; i++ {
			if v%i == 0 {
				count += occurrences[i]
				if v/i != i {
					count += occurrences[v/i]
				}
			}
		}
		nonDivisors[k] = size - count
	}

	return nonDivisors
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Count Non Divisible

import qualified Data.Map.Strict as Map

countNonDivisible :: [Int] -> [Int]
countNonDivisible a = map (\v -> size - divisorCount v) a
  where
    size = length a
    occ  = Map.fromListWith (+) [(v, 1 :: Int) | v <- a]
    occCount v = Map.findWithDefault 0 v occ

    divisorCount v =
      sum
        [ occCount i + (if v `div` i /= i then occCount (v `div` i) else 0)
        | i <- takeWhile (\i -> i * i <= v) [1 ..]
        , v `mod` i == 0
        ]

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Non Divisible

import java.util.Arrays;

public class Solution {
    public static int[] countNonDivisible(int[] a) {
        int size = a.length;
        int[] nondivisor = new int[size];
        int maxValue = Arrays.stream(a).max().orElse(0);
        int[] occurrences = new int[maxValue + 1];

        for (int v : a) {
            occurrences[v]++;
        }

        for (int k = 0; k < size; k++) {
            int v = a[k];
            int count = 0;
            long i = 1;
            while (i * i <= v) {
                if (v % i == 0) {
                    count += occurrences[(int) i];
                    if (v / i != i) {
                        count += occurrences[(int) (v / i)];
                    }
                }
                i++;
            }
            nondivisor[k] = size - count;
        }

        return nondivisor;
    }
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Count Non Divisible

(defun count-non-divisible (a)
  (let* ((vec (coerce a 'vector))
         (size (length vec))
         (occurrences (make-array (1+ (reduce #'max vec)) :initial-element 0)))
    (loop for v across vec do (incf (aref occurrences v)))
    (loop for v across vec
          collect (let ((count 0) (i 1))
                    (loop while (<= (* i i) v)
                          do (progn
                               (when (zerop (mod v i))
                                 (incf count (aref occurrences i))
                                 (unless (= (/ v i) i)
                                   (incf count (aref occurrences (/ v i)))))
                               (incf i)))
                    (- size count)))))

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

PHP Count Non Divisible

function countNonDivisible(array $a): array
{
    $size       = count($a);
    $nondivisor = array_fill(0, $size, 0);
    $occurences = array_fill(0, max($a) + 1, 0);

    foreach ($a as $v) {
        $occurences[$v]++;
    }

    foreach ($a as $k => $v) {
        $count = 0;
        $i     = 1;
        while ($i * $i <= $v) {
            if ($v % $i === 0) {
                $count += $occurences[$i];
                if ($v / $i !== $i) {
                    $count += $occurences[$v / $i];
                }
            }
            $i++;
        }
        $nondivisor[$k] = $size - $count;
    }

    return $nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Non Divisible

def count_non_divisible(a: list[int]) -> list[int]:
    size = len(a)
    occurrences = [0] * (max(a) + 1)
    for v in a:
        occurrences[v] += 1

    nondivisor = [0] * size
    for k, v in enumerate(a):
        count = 0
        i = 1
        while i * i <= v:
            if v % i == 0:
                count += occurrences[i]
                if v // i != i:
                    count += occurrences[v // i]
            i += 1
        nondivisor[k] = size - count

    return nondivisor

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Non Divisible

fn count_non_divisible(a: &[i64]) -> Vec<i64> {
    let size = a.len();
    let max_val = *a.iter().max().unwrap() as usize;
    let mut occurrences = vec![0i64; max_val + 1];

    for &v in a {
        occurrences[v as usize] += 1;
    }

    let mut nondivisor = vec![0i64; size];
    for (k, &v) in a.iter().enumerate() {
        let mut count = 0;
        let mut i = 1i64;
        while i * i <= v {
            if v % i == 0 {
                count += occurrences[i as usize];
                if v / i != i {
                    count += occurrences[(v / i) as usize];
                }
            }
            i += 1;
        }
        nondivisor[k] = size as i64 - count;
    }

    nondivisor
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Count Non Divisible

function countNonDivisible(a: number[]): number[] {
  const size = a.length;
  const nondivisor: number[] = new Array(size).fill(0);
  const occurences: number[] = new Array(Math.max(...a) + 1).fill(0);

  for (const v of a) {
    occurences[v]++;
  }

  for (let k = 0; k < size; k++) {
    const v = a[k];
    let count = 0;
    let i = 1;
    while (i * i <= v) {
      if (v % i === 0) {
        count += occurences[i];
        if (v / i !== i) {
          count += occurences[v / i];
        }
      }
      i++;
    }
    nondivisor[k] = size - count;
  }

  return nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Semi Primes

count_semi_primes() {
    local _n=$1
    local -n _pArr="$2"
    local -n _qArr="$3"
    local -n _outArr="$4"
    local -a _is_prime _semi _cum
    local _i _k _idx
    for ((_i = 0; _i <= _n; _i++)); do _is_prime[_i]=1; _semi[_i]=0; done
    for ((_i = 2; _i * _i <= _n; _i++)); do
        if (( _is_prime[_i] )); then
            for ((_k = _i * _i; _k <= _n; _k += _i)); do
                _is_prime[_k]=0
            done
        fi
    done
    for ((_k = 2; _k * _k <= _n; _k++)); do
        if (( _is_prime[_k] )); then
            for ((_i = 2; _i * _k <= _n; _i++)); do
                if (( _is_prime[_i] )); then
                    _semi[_k * _i]=1
                fi
            done
        fi
    done
    _cum[0]=${_semi[0]}
    for ((_i = 1; _i <= _n; _i++)); do
        _cum[_i]=$(( _cum[_i-1] + _semi[_i] ))
    done
    _outArr=()
    for _idx in "${!_pArr[@]}"; do
        local _lo=${_pArr[$_idx]}
        local _hi=${_qArr[$_idx]}
        _outArr[_idx]=$(( _cum[_hi] - _cum[_lo-1] ))
    done
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Semi Primes

#include <cstddef>
#include <vector>

std::vector<int> countSemiPrimes(int n, const std::vector<int>& p, const std::vector<int>& q)
{
    std::vector<bool> primes(n + 1, true);
    std::vector<int> semiPrimes(n + 1, 0);
    std::vector<int> semiPrimeCounts(p.size(), 0);

    for (int i = 2; i * i <= n; ++i) {
        if (primes[i]) {
            for (int k = i * i; k <= n; k += i) {
                primes[k] = false;
            }
        }
    }

    for (int k = 2; k * k <= n; ++k) {
        if (primes[k]) {
            for (int i = 2; i * k <= n; ++i) {
                if (primes[i]) {
                    semiPrimes[k * i] = 1;
                }
            }
        }
    }

    for (int i = 1; i <= n; ++i) {
        semiPrimes[i] += semiPrimes[i - 1];
    }

    for (std::size_t k = 0; k < p.size(); ++k) {
        semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
    }

    return semiPrimeCounts;
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Semi Primes

static int[] CountSemiPrimes(int n, int[] p, int[] q)
{
    var primes = new bool[n + 1];
    Array.Fill(primes, true);
    var semiPrimes = new int[n + 1];

    for (int i = 2; i * i <= n; i++)
    {
        if (primes[i])
        {
            for (int k = i * i; k <= n; k += i)
            {
                primes[k] = false;
            }
        }
    }

    for (int k = 2; k * k <= n; k++)
    {
        if (primes[k])
        {
            for (int i = 2; i * k <= n; i++)
            {
                if (primes[i])
                {
                    semiPrimes[k * i] = 1;
                }
            }
        }
    }

    for (int i = 1; i <= n; i++)
    {
        semiPrimes[i] += semiPrimes[i - 1];
    }

    var semiPrimeCounts = new int[p.Length];
    for (int k = 0; k < p.Length; k++)
    {
        semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
    }

    return semiPrimeCounts;
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Semi Primes

defmodule CountSemiPrimes do
  def count_semi_primes(n, p, q) do
    primes = sieve(n)
    semi_flags = semi_prime_flags(n, primes)
    prefix = prefix_sums(semi_flags, n)

    p
    |> Enum.zip(q)
    |> Enum.map(fn {pi, qi} -> Map.get(prefix, qi) - Map.get(prefix, pi - 1, 0) end)
  end

  defp sieve(n) do
    initial = for i <- 0..n, into: %{}, do: {i, i >= 2}
    limit = :math.sqrt(n) |> trunc()

    Enum.reduce(2..limit//1, initial, fn i, primes ->
      if Map.get(primes, i) do
        Enum.reduce(i * i..n//i, primes, fn k, acc -> Map.put(acc, k, false) end)
      else
        primes
      end
    end)
  end

  defp semi_prime_flags(n, primes) do
    initial = for i <- 0..n, into: %{}, do: {i, 0}
    limit = :math.sqrt(n) |> trunc()

    Enum.reduce(2..limit//1, initial, fn k, flags ->
      if Map.get(primes, k) do
        mark_multiples(k, 2, n, primes, flags)
      else
        flags
      end
    end)
  end

  defp mark_multiples(k, i, n, _primes, flags) when i * k > n, do: flags

  defp mark_multiples(k, i, n, primes, flags) do
    flags = if Map.get(primes, i), do: Map.put(flags, k * i, 1), else: flags
    mark_multiples(k, i + 1, n, primes, flags)
  end

  defp prefix_sums(flags, n) do
    {result, _last} =
      Enum.reduce(1..n//1, {%{0 => Map.get(flags, 0, 0)}, Map.get(flags, 0, 0)}, fn i,
                                                                                      {acc, prev} ->
        cur = prev + Map.get(flags, i, 0)
        {Map.put(acc, i, cur), cur}
      end)

    result
  end
end

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Count Semi Primes

-module(count_semi_primes).
-export([count_semi_primes/3]).

count_semi_primes(N, P, Q) ->
    IsPrime = sieve(N),
    Flags = mark_semiprimes(N, IsPrime),
    Prefix = prefix_cumulative(N, Flags),
    [array:get(Qi, Prefix) - array:get(Pi - 1, Prefix) || {Pi, Qi} <- lists:zip(P, Q)].

sieve(N) ->
    Arr0 = array:new(N + 1, {default, true}),
    Arr1 = array:set(0, false, Arr0),
    Arr2 = case N >= 1 of
        true -> array:set(1, false, Arr1);
        false -> Arr1
    end,
    sieve(2, N, Arr2).

sieve(I, N, Arr) when I * I > N ->
    Arr;
sieve(I, N, Arr) ->
    Arr1 = case array:get(I, Arr) of
        true -> mark_multiples(I * I, I, N, Arr);
        false -> Arr
    end,
    sieve(I + 1, N, Arr1).

mark_multiples(K, _Step, N, Arr) when K > N ->
    Arr;
mark_multiples(K, Step, N, Arr) ->
    mark_multiples(K + Step, Step, N, array:set(K, false, Arr)).

mark_semiprimes(N, IsPrime) ->
    Flags0 = array:new(N + 1, {default, 0}),
    mark_k(2, N, IsPrime, Flags0).

mark_k(K, N, _IsPrime, Flags) when K * K > N ->
    Flags;
mark_k(K, N, IsPrime, Flags) ->
    Flags1 = case array:get(K, IsPrime) of
        true -> mark_i(2, K, N, IsPrime, Flags);
        false -> Flags
    end,
    mark_k(K + 1, N, IsPrime, Flags1).

mark_i(I, K, N, _IsPrime, Flags) when I * K > N ->
    Flags;
mark_i(I, K, N, IsPrime, Flags) ->
    Flags1 = case array:get(I, IsPrime) of
        true -> array:set(K * I, 1, Flags);
        false -> Flags
    end,
    mark_i(I + 1, K, N, IsPrime, Flags1).

prefix_cumulative(N, Flags) ->
    {_, Prefix} = lists:foldl(fun(I, {Prev, Acc}) ->
        Cur = Prev + array:get(I, Flags),
        {Cur, array:set(I, Cur, Acc)}
    end, {0, Flags}, lists:seq(1, N)),
    Prefix.

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Semi Primes

func countSemiPrimes(n int, p, q []int) []int {
	primes := make([]bool, n+1)
	for i := range primes {
		primes[i] = true
	}
	semiPrimes := make([]int, n+1)
	result := make([]int, len(p))

	for i := 2; i*i <= n; i++ {
		if primes[i] {
			for k := i * i; k <= n; k += i {
				primes[k] = false
			}
		}
	}

	for k := 2; k*k <= n; k++ {
		if primes[k] {
			for i := 2; i*k <= n; i++ {
				if primes[i] {
					semiPrimes[k*i] = 1
				}
			}
		}
	}

	for i := 1; i <= n; i++ {
		semiPrimes[i] += semiPrimes[i-1]
	}

	for k := range p {
		result[k] = semiPrimes[q[k]] - semiPrimes[p[k]-1]
	}

	return result
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Count Semi Primes

import Control.Monad (forM_, when)
import Control.Monad.ST (runST)
import Data.Array (Array, listArray, (!))
import Data.Array.ST (newArray, readArray, runSTUArray, writeArray)
import Data.Array.Unboxed (UArray)

isPrimeArr :: Int -> UArray Int Bool
isPrimeArr n = runSTUArray $ do
  arr <- newArray (0, n) True
  forM_ [2 .. floor (sqrt (fromIntegral n :: Double))] $ \i -> do
    p <- readArray arr i
    when p $ forM_ [i * i, i * i + i .. n] $ \k -> writeArray arr k False
  return arr

semiPrimeArr :: Int -> UArray Int Bool -> UArray Int Bool
semiPrimeArr n primes = runSTUArray $ do
  arr <- newArray (0, n) False
  forM_ [k | k <- [2 .. floor (sqrt (fromIntegral n :: Double))], primes ! k] $ \k ->
    forM_ (takeWhile (\i -> i * k <= n) [2 ..]) $ \i ->
      when (primes ! i) $ writeArray arr (k * i) True
  return arr

prefixCounts :: Int -> UArray Int Bool -> Array Int Int
prefixCounts n semi =
  listArray (0, n) (scanl1 (+) (0 : [if semi ! i then 1 else 0 | i <- [1 .. n]]))

countSemiPrimes :: Int -> [Int] -> [Int] -> [Int]
countSemiPrimes n p q = [prefix ! qi - prefix ! (pi' - 1) | (pi', qi) <- zip p q]
  where
    primes = isPrimeArr n
    semi   = semiPrimeArr n primes
    prefix = prefixCounts n semi

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Semi Primes

import java.util.Arrays;

public class Solution {
    public static int[] countSemiPrimes(int n, int[] p, int[] q) {
        boolean[] primes = new boolean[n + 1];
        Arrays.fill(primes, true);
        int[] semiPrimes = new int[n + 1];
        int[] semiPrimeCounts = new int[p.length];

        for (int i = 2; (long) i * i <= n; i++) {
            if (primes[i]) {
                for (int k = i * i; k <= n; k += i) {
                    primes[k] = false;
                }
            }
        }

        for (int k = 2; (long) k * k <= n; k++) {
            if (primes[k]) {
                for (int i = 2; i * k <= n; i++) {
                    if (primes[i]) {
                        semiPrimes[k * i] = 1;
                    }
                }
            }
        }

        for (int i = 1; i <= n; i++) {
            semiPrimes[i] += semiPrimes[i - 1];
        }

        for (int k = 0; k < p.length; k++) {
            semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
        }

        return semiPrimeCounts;
    }
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Count Semi Primes

(defun count-semi-primes (n p q)
  (let ((primes (make-array (1+ n) :initial-element t))
        (semi-primes (make-array (1+ n) :initial-element 0)))
    (loop for i from 2 while (<= (* i i) n)
          do (when (aref primes i)
               (loop for k from (* i i) to n by i
                     do (setf (aref primes k) nil))))
    (loop for k from 2 while (<= (* k k) n)
          do (when (aref primes k)
               (loop for i from 2 while (<= (* i k) n)
                     do (when (aref primes i)
                          (setf (aref semi-primes (* k i)) 1)))))
    (loop for i from 1 to n
          do (incf (aref semi-primes i) (aref semi-primes (1- i))))
    (loop for v in p
          for qi in q
          collect (- (aref semi-primes qi) (aref semi-primes (1- v))))))

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

PHP Count Semi Primes

function countSemiPrimes(int $n, array $p, array $q): array
{
    $primes          = array_fill(0, $n + 1, true);
    $semiPrimes      = array_fill(0, $n + 1, 0);
    $semiPrimeCounts = array_fill(0, count($p), 0);

    for ($i = 2; $i * $i <= $n; $i++) {
        if ($primes[$i]) {
            for ($k = $i * $i; $k <= $n; $k += $i) {
                $primes[$k] = false;
            }
        }
    }

    for ($k = 2; $k * $k <= $n; $k++) {
        if ($primes[$k]) {
            for ($i = 2; $i * $k <= $n; $i++) {
                if ($primes[$i]) {
                    $semiPrimes[$k * $i] = 1;
                }
            }
        }
    }

    for ($i = 1; $i <= $n; $i++) {
        $semiPrimes[$i] += $semiPrimes[$i - 1];
    }

    foreach ($p as $k => $v) {
        $semiPrimeCounts[$k] = $semiPrimes[$q[$k]] - $semiPrimes[$v - 1];

    }

    return $semiPrimeCounts;


}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Semi Primes

def count_semi_primes(n: int, p: list[int], q: list[int]) -> list[int]:
    primes = [True] * (n + 1)
    semi_primes = [0] * (n + 1)

    i = 2
    while i * i <= n:
        if primes[i]:
            for k in range(i * i, n + 1, i):
                primes[k] = False
        i += 1

    k = 2
    while k * k <= n:
        if primes[k]:
            i = 2
            while i * k <= n:
                if primes[i]:
                    semi_primes[k * i] = 1
                i += 1
        k += 1

    for i in range(1, n + 1):
        semi_primes[i] += semi_primes[i - 1]

    return [semi_primes[q[idx]] - semi_primes[p[idx] - 1] for idx in range(len(p))]

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Semi Primes

fn count_semi_primes(n: usize, p: &[usize], q: &[usize]) -> Vec<i64> {
    let mut is_prime = vec![true; n + 1];
    let mut semi_primes = vec![0i64; n + 1];

    let mut i = 2;
    while i * i <= n {
        if is_prime[i] {
            let mut k = i * i;
            while k <= n {
                is_prime[k] = false;
                k += i;
            }
        }
        i += 1;
    }

    let mut k = 2;
    while k * k <= n {
        if is_prime[k] {
            let mut i = 2;
            while i * k <= n {
                if is_prime[i] {
                    semi_primes[k * i] = 1;
                }
                i += 1;
            }
        }
        k += 1;
    }

    for i in 1..=n {
        semi_primes[i] += semi_primes[i - 1];
    }

    p.iter()
        .zip(q.iter())
        .map(|(&pi, &qi)| semi_primes[qi] - semi_primes[pi - 1])
        .collect()
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Count Semi Primes

function countSemiPrimes(n: number, p: number[], q: number[]): number[] {
  const primes: boolean[] = new Array(n + 1).fill(true);
  const semiPrimes: number[] = new Array(n + 1).fill(0);
  const semiPrimeCounts: number[] = new Array(p.length).fill(0);

  for (let i = 2; i * i <= n; i++) {
    if (primes[i]) {
      for (let k = i * i; k <= n; k += i) {
        primes[k] = false;
      }
    }
  }

  for (let k = 2; k * k <= n; k++) {
    if (primes[k]) {
      for (let i = 2; i * k <= n; i++) {
        if (primes[i]) {
          semiPrimes[k * i] = 1;
        }
      }
    }
  }

  for (let i = 1; i <= n; i++) {
    semiPrimes[i] += semiPrimes[i - 1];
  }

  for (let k = 0; k < p.length; k++) {
    semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
  }

  return semiPrimeCounts;
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Bash Cyclic Rotation

cyclic_rotation() {
    local -n _a="$1"
    local -n _out="$2"
    local _k=$3
    local _size=${#_a[@]}
    if (( _size == 0 )); then
        _out=()
        return
    fi
    _k=$(( _k % _size ))
    _out=()
    local _i
    for ((_i = 0; _i < _size; _i++)); do
        _out[(_i + _k) % _size]=${_a[_i]}
    done
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

C++ Cyclic Rotation

#include <vector>

std::vector<int> cyclicRotation(std::vector<int> a, int k)
{
    if (!a.empty()) {
        for (int i = 0; i < k; ++i) {
            int back = a.back();
            a.pop_back();
            a.insert(a.begin(), back);
        }
    }

    return a;
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

C# Cyclic Rotation

static int[] CyclicRotation(int[] a, int k)
{
    if (a.Length == 0)
    {
        return a;
    }

    var list = new List<int>(a);
    for (int i = 0; i < k; i++)
    {
        var last = list[^1];
        list.RemoveAt(list.Count - 1);
        list.Insert(0, last);
    }

    return list.ToArray();
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Cyclic Rotation

defmodule CyclicRotation do
  def cyclic_rotation([], _k), do: []

  def cyclic_rotation(a, k) do
    size = length(a)
    shift = rem(k, size)
    {front, back} = Enum.split(a, size - shift)

    back ++ front
  end
end

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Cyclic Rotation

-module(cyclic_rotation).
-export([cyclic_rotation/2]).

cyclic_rotation([], _K) ->
    [];
cyclic_rotation(A, K) ->
    N = length(A),
    Shift = K rem N,
    {Front, Back} = lists:split(N - Shift, A),
    Back ++ Front.

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Go Cyclic Rotation

func cyclicRotation(a []int, k int) []int {
	size := len(a)
	if size == 0 || k <= 0 {
		return a
	}

	k %= size
	result := make([]int, size)
	for i, v := range a {
		result[(i+k)%size] = v
	}

	return result
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Cyclic Rotation

cyclicRotation :: [Int] -> Int -> [Int]
cyclicRotation [] _ = []
cyclicRotation a k  = back ++ front
  where
    n             = length a
    r             = k `mod` n
    (front, back) = splitAt (n - r) a

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Java Cyclic Rotation

public class Solution {
    public static int[] cyclicRotation(int[] a, int k) {
        if (a.length > 0) {
            for (int i = 0; i < k; i++) {
                int last = a[a.length - 1];
                System.arraycopy(a, 0, a, 1, a.length - 1);
                a[0] = last;
            }
        }

        return a;
    }
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Cyclic Rotation

(defun cyclic-rotation (a k)
  (if (null a)
      a
      (let ((result (copy-list a)))
        (dotimes (i k)
          (let ((last (car (last result))))
            (setf result (cons last (butlast result)))))
        result)))

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

PHP Cyclic Rotation

function cyclicRotation(array $a, int $k): array
{
    if ( ! empty($a)) {
        for ($i = 0; $i < $k; $i++) {
            array_unshift($a, array_pop($a));
        }
    }

    return $a;
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Python Cyclic Rotation

from collections import deque


def cyclic_rotation(a: list[int], k: int) -> list[int]:
    if not a:
        return a

    d = deque(a)
    d.rotate(k)
    return list(d)

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Rust Cyclic Rotation

fn cyclic_rotation(mut a: Vec<i64>, k: i64) -> Vec<i64> {
    let len = a.len();
    if len > 0 && k > 0 {
        let k = (k as usize) % len;
        a.rotate_right(k);
    }

    a
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Cyclic Rotation

function cyclicRotation(a: number[], k: number): number[] {
  const result = [...a];

  if (result.length > 0) {
    for (let i = 0; i < k; i++) {
      const popped = result.pop() as number;
      result.unshift(popped);
    }
  }

  return result;
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Bash Distinct

distinct() {
    local -n _a="$1"
    local -A _seen
    local _v
    for _v in "${_a[@]}"; do _seen[$_v]=1; done
    echo "${#_seen[@]}"
}

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

C++ Distinct

#include <unordered_set>
#include <vector>

int distinct(const std::vector<int>& a)
{
    std::unordered_set<int> unique(a.begin(), a.end());

    return static_cast<int>(unique.size());
}

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

C# Distinct

static int Distinct(int[] a)
{
    return new HashSet<int>(a).Count;
}

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Distinct

defmodule Distinct do
  def distinct(a), do: a |> Enum.uniq() |> length()
end

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Distinct

-module(distinct).
-export([distinct/1]).

distinct(A) ->
    length(lists:usort(A)).

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Go Distinct

func distinct(a []int) int {
	seen := make(map[int]struct{}, len(a))
	for _, v := range a {
		seen[v] = struct{}{}
	}

	return len(seen)
}

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Distinct

import qualified Data.Set as Set

distinct :: [Int] -> Int
distinct a = Set.size (Set.fromList a)

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Java Distinct

import java.util.Arrays;

public class Solution {
    public static int distinct(int[] a) {
        return (int) Arrays.stream(a).distinct().count();
    }
}

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Distinct

(defun distinct (a)
  (length (remove-duplicates a :test #'equal)))

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

PHP Distinct

function distinct(array $a): int
{
    return count(array_flip($a));
}

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Python Distinct

def distinct(a: list[int]) -> int:
    return len(set(a))

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Rust Distinct

use std::collections::HashSet;

fn distinct(a: &[i64]) -> i64 {
    let set: HashSet<_> = a.iter().collect();
    set.len() as i64
}

This counts unique values by tracking what has already been seen.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Distinct

function distinct(a: number[]): number {
  return new Set(a).size;
}

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Bash Dominator

dominator() {
    local -n _a="$1"
    local _size=0 _value=0 _count=0 _index=0
    local _k _v
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        if (( _size == 0 )); then
            ((_size++))
            _value=$_v
            _index=$_k
        elif (( _value != _v )); then
            ((_size--))
        else
            ((_size++))
        fi
    done
    local _candidate
    if (( _size > 0 )); then _candidate=$_value; else _candidate=-1; fi
    _count=0
    for _v in "${_a[@]}"; do
        if (( _v == _candidate )); then ((_count++)); fi
    done
    if (( _count <= ${#_a[@]} / 2 )); then
        _index=-1
    fi
    echo "$_index"
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

C++ Dominator

#include <cstddef>
#include <vector>

int dominator(const std::vector<int>& a)
{
    int size = 0;
    int value = 0;
    int index = 0;

    for (std::size_t k = 0; k < a.size(); ++k) {
        int v = a[k];
        if (size == 0) {
            ++size;
            value = v;
            index = static_cast<int>(k);
        } else if (value != v) {
            --size;
        } else {
            ++size;
        }
    }

    int candidate = size > 0 ? value : -1;
    int count = 0;
    for (int v : a) {
        if (v == candidate) {
            ++count;
        }
    }
    if (count <= static_cast<int>(a.size()) / 2) {
        index = -1;
    }

    return index;
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

C# Dominator

static int Dominator(int[] a)
{
    var size = 0;
    var value = 0;
    var index = 0;

    for (int k = 0; k < a.Length; k++)
    {
        var v = a[k];
        if (size == 0)
        {
            size++;
            value = v;
            index = k;
        }
        else if (value != v)
        {
            size--;
        }
        else
        {
            size++;
        }
    }

    var candidate = size > 0 ? value : -1;
    var count = 0;
    foreach (var v in a)
    {
        if (v == candidate)
        {
            count++;
        }
    }

    if (count <= a.Length / 2.0)
    {
        index = -1;
    }

    return index;
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Dominator

defmodule Dominator do
  def dominator(a) do
    {size, value, index} =
      a
      |> Enum.with_index()
      |> Enum.reduce({0, nil, nil}, fn {v, k}, {size, value, index} ->
        cond do
          size == 0 -> {1, v, k}
          value != v -> {size - 1, value, index}
          true -> {size + 1, value, index}
        end
      end)

    candidate = if size > 0, do: value, else: -1
    count = Enum.count(a, &(&1 == candidate))

    if count > div(length(a), 2), do: index, else: -1
  end
end

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Dominator

-module(dominator).
-export([dominator/1]).

dominator(A) ->
    Indexed = lists:zip(lists:seq(0, length(A) - 1), A),
    {FinalSize, FinalValue, FinalIndex} = lists:foldl(fun({K, V}, {Size, Value, Index}) ->
        case Size of
            0 -> {1, V, K};
            _ ->
                case Value =:= V of
                    true -> {Size + 1, Value, Index};
                    false -> {Size - 1, Value, Index}
                end
        end
    end, {0, undefined, 0}, Indexed),
    Candidate = case FinalSize > 0 of
        true -> FinalValue;
        false -> -1
    end,
    Count = length([X || X <- A, X =:= Candidate]),
    case Count > length(A) / 2 of
        true -> FinalIndex;
        false -> -1
    end.

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Go Dominator

func dominator(a []int) int {
	size, value, index := 0, 0, 0
	for k, v := range a {
		switch {
		case size == 0:
			size++
			value = v
			index = k
		case value != v:
			size--
		default:
			size++
		}
	}

	candidate := -1
	if size > 0 {
		candidate = value
	}

	count := 0
	for _, v := range a {
		if v == candidate {
			count++
		}
	}
	if count <= len(a)/2 {
		index = -1
	}

	return index
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Dominator

dominator :: [Int] -> Int
dominator a
  | count > length a `div` 2 = index
  | otherwise                = -1
  where
    (size, value, index) = foldl step (0, 0, 0) (zip [0 ..] a)
    step (sz, val, idx) (k, v)
      | sz == 0   = (1, v, k)
      | val /= v  = (sz - 1, val, idx)
      | otherwise = (sz + 1, val, idx)

    candidate = if size > 0 then value else -1
    count     = length (filter (== candidate) a)

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Java Dominator

public class Solution {
    public static int dominator(int[] a) {
        int size = 0;
        int value = 0;
        int index = 0;

        for (int k = 0; k < a.length; k++) {
            int v = a[k];
            if (size == 0) {
                size++;
                value = v;
                index = k;
            } else if (value != v) {
                size--;
            } else {
                size++;
            }
        }
        int candidate = size > 0 ? value : -1;

        int count = 0;
        for (int v : a) {
            if (v == candidate) {
                count++;
            }
        }
        if (count <= a.length / 2.0) {
            index = -1;
        }

        return index;
    }
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Dominator

(defun dominator (a)
  (let ((vec (coerce a 'vector))
        (size 0) (value 0) (index 0))
    (loop for k from 0 below (length vec)
          for v = (aref vec k)
          do (cond
               ((zerop size) (incf size) (setf value v) (setf index k))
               ((/= value v) (decf size))
               (t (incf size))))
    (let ((candidate (if (> size 0) value -1))
          (count 0))
      (loop for v across vec do (when (= v candidate) (incf count)))
      (when (<= count (/ (length vec) 2))
        (setf index -1))
      index)))

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

PHP Dominator

function dominator(array $a): int
{
    $size  = $value = $count = 0;
    $index = 0;
    foreach ($a as $k => $v) {
        if ($size === 0) {
            $size++;
            $value = $v;
            $index = $k;
        } elseif ($value !== $v) {
            $size--;
        } else {
            $size++;
        }
    }
    $candidate = $size > 0 ? $value : -1;

    foreach ($a as $v) {
        if ($v === $candidate) {
            $count++;
        }
    }
    if ($count <= count($a) / 2) {
        $index = -1;
    }

    return $index;
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Python Dominator

def dominator(a: list[int]) -> int:
    size = value = index = 0
    for k, v in enumerate(a):
        if size == 0:
            size += 1
            value = v
            index = k
        elif value != v:
            size -= 1
        else:
            size += 1
    candidate = value if size > 0 else -1

    count = sum(1 for v in a if v == candidate)
    if count <= len(a) / 2:
        index = -1

    return index

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Rust Dominator

fn dominator(a: &[i64]) -> i64 {
    let mut size = 0i64;
    let mut value = 0;
    let mut index: i64 = 0;

    for (k, &v) in a.iter().enumerate() {
        if size == 0 {
            size += 1;
            value = v;
            index = k as i64;
        } else if value != v {
            size -= 1;
        } else {
            size += 1;
        }
    }

    let candidate = if size > 0 { value } else { -1 };

    let count = a.iter().filter(|&&v| v == candidate).count() as i64;
    if count <= a.len() as i64 / 2 {
        index = -1;
    }

    index
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Dominator

function dominator(a: number[]): number {
  let size = 0;
  let value = 0;
  let index = 0;

  a.forEach((v, k) => {
    if (size === 0) {
      size++;
      value = v;
      index = k;
    } else if (value !== v) {
      size--;
    } else {
      size++;
    }
  });

  const candidate = size > 0 ? value : -1;

  let count = 0;
  for (const v of a) {
    if (v === candidate) {
      count++;
    }
  }

  if (count <= a.length / 2) {
    index = -1;
  }

  return index;
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Bash Equi Leader

equi_leader() {
    local -n _a="$1"
    local _leaderSize=0 _value=0 _leaderCount=0
    local _k _v
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        if (( _leaderSize == 0 )); then
            ((_leaderSize++))
            _value=$_v
        elif (( _value != _v )); then
            ((_leaderSize--))
        else
            ((_leaderSize++))
        fi
    done
    local _candidate
    if (( _leaderSize > 0 )); then _candidate=$_value; else _candidate=-1; fi
    _leaderCount=0
    for _v in "${_a[@]}"; do
        if (( _v == _candidate )); then ((_leaderCount++)); fi
    done
    local _leader=-1
    local _count=${#_a[@]}
    if (( 2 * _leaderCount > _count )); then
        _leader=$_candidate
    fi
    local _lLeaderCount=0 _equiLeaders=0
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        local _leftHalf=$(( (_k + 1) / 2 ))
        local _rightHalf=$(( (_count - _k - 1) / 2 ))
        if (( _v == _leader )); then
            ((_lLeaderCount++))
        fi
        local _rLeaderCount=$(( _leaderCount - _lLeaderCount ))
        if (( _lLeaderCount > _leftHalf && _rLeaderCount > _rightHalf )); then
            ((_equiLeaders++))
        fi
    done
    echo "$_equiLeaders"
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

C++ Equi Leader

#include <vector>

int equiLeader(const std::vector<int>& a)
{
    int leaderSize = 0;
    int value = 0;
    for (int v : a) {
        if (leaderSize == 0) {
            ++leaderSize;
            value = v;
        } else if (value != v) {
            --leaderSize;
        } else {
            ++leaderSize;
        }
    }
    int candidate = leaderSize > 0 ? value : -1;

    int leaderCount = 0;
    for (int v : a) {
        if (v == candidate) {
            ++leaderCount;
        }
    }

    int count = static_cast<int>(a.size());
    int leader = -1;
    if (leaderCount > count / 2) {
        leader = candidate;
    }

    int lLeaderCount = 0;
    int equiLeaders = 0;

    for (int k = 0; k < count; ++k) {
        int v = a[k];
        int leftHalf = (k + 1) / 2;
        int rightHalf = (count - k - 1) / 2;
        if (v == leader) {
            ++lLeaderCount;
        }

        int rLeaderCount = leaderCount - lLeaderCount;
        if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
            ++equiLeaders;
        }
    }

    return equiLeaders;
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

C# Equi Leader

static int EquiLeader(int[] a)
{
    var leaderSize = 0;
    var value = 0;

    foreach (var v in a)
    {
        if (leaderSize == 0)
        {
            leaderSize++;
            value = v;
        }
        else if (value != v)
        {
            leaderSize--;
        }
        else
        {
            leaderSize++;
        }
    }

    var candidate = leaderSize > 0 ? value : -1;
    var leaderCount = 0;
    foreach (var v in a)
    {
        if (v == candidate)
        {
            leaderCount++;
        }
    }

    var leader = -1;
    if (leaderCount > a.Length / 2.0)
    {
        leader = candidate;
    }

    var count = a.Length;
    var lLeaderCount = 0;
    var equiLeaders = 0;

    for (int k = 0; k < count; k++)
    {
        var v = a[k];
        var leftHalf = (k + 1) / 2;
        var rightHalf = (count - k - 1) / 2;
        if (v == leader)
        {
            lLeaderCount++;
        }

        var rLeaderCount = leaderCount - lLeaderCount;
        if (lLeaderCount > leftHalf && rLeaderCount > rightHalf)
        {
            equiLeaders++;
        }
    }

    return equiLeaders;
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Equi Leader

defmodule EquiLeader do
  def equi_leader(a) do
    {leader_size, value} =
      Enum.reduce(a, {0, nil}, fn v, {size, value} ->
        cond do
          size == 0 -> {1, v}
          value != v -> {size - 1, value}
          true -> {size + 1, value}
        end
      end)

    count = length(a)
    candidate = if leader_size > 0, do: value, else: -1
    leader_count = Enum.count(a, &(&1 == candidate))
    leader = if leader_count > div(count, 2), do: candidate, else: -1

    {equi_leaders, _l_leader_count} =
      a
      |> Enum.with_index()
      |> Enum.reduce({0, 0}, fn {v, k}, {equi_leaders, l_leader_count} ->
        left_half = div(k + 1, 2)
        right_half = div(count - k - 1, 2)
        l_leader_count = if v == leader, do: l_leader_count + 1, else: l_leader_count
        r_leader_count = leader_count - l_leader_count

        equi_leaders =
          if l_leader_count > left_half and r_leader_count > right_half do
            equi_leaders + 1
          else
            equi_leaders
          end

        {equi_leaders, l_leader_count}
      end)

    equi_leaders
  end
end

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Equi Leader

-module(equi_leader).
-export([equi_leader/1]).

equi_leader(A) ->
    N = length(A),
    {LeaderSize, LeaderValue} = leader_scan(A),
    Candidate = case LeaderSize > 0 of
        true -> LeaderValue;
        false -> -1
    end,
    LeaderCount = length([X || X <- A, X =:= Candidate]),
    Leader = case LeaderCount > N / 2 of
        true -> Candidate;
        false -> -1
    end,
    {_, Count} = lists:foldl(fun({K, V}, {LCount, Equi}) ->
        LCount1 = case V =:= Leader of
            true -> LCount + 1;
            false -> LCount
        end,
        LeftHalf = (K + 1) div 2,
        RightHalf = (N - K - 1) div 2,
        RCount = LeaderCount - LCount1,
        Equi1 = case LCount1 > LeftHalf andalso RCount > RightHalf of
            true -> Equi + 1;
            false -> Equi
        end,
        {LCount1, Equi1}
    end, {0, 0}, lists:zip(lists:seq(0, N - 1), A)),
    Count.

leader_scan(A) ->
    lists:foldl(fun(V, {Size, Value}) ->
        case Size of
            0 -> {1, V};
            _ ->
                case Value =:= V of
                    true -> {Size + 1, Value};
                    false -> {Size - 1, Value}
                end
        end
    end, {0, undefined}, A).

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Go Equi Leader

func equiLeader(a []int) int {
	leaderSize, value := 0, 0
	for _, v := range a {
		switch {
		case leaderSize == 0:
			leaderSize++
			value = v
		case value != v:
			leaderSize--
		default:
			leaderSize++
		}
	}

	candidate := -1
	if leaderSize > 0 {
		candidate = value
	}

	leaderCount := 0
	for _, v := range a {
		if v == candidate {
			leaderCount++
		}
	}

	leader := -1
	if leaderCount > len(a)/2 {
		leader = candidate
	}

	count := len(a)
	lLeaderCount, equiLeaders := 0, 0
	for k, v := range a {
		leftHalf := (k + 1) / 2
		rightHalf := (count - k - 1) / 2
		if v == leader {
			lLeaderCount++
		}

		rLeaderCount := leaderCount - lLeaderCount
		if lLeaderCount > leftHalf && rLeaderCount > rightHalf {
			equiLeaders++
		}
	}

	return equiLeaders
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Equi Leader

equiLeader :: [Int] -> Int
equiLeader a = length (filter isEqui (zip3 [0 ..] a prefixLeaderCounts))
  where
    n = length a

    (size, value) = foldl step (0, 0) a
    step (sz, val) v
      | sz == 0   = (1, v)
      | val /= v  = (sz - 1, val)
      | otherwise = (sz + 1, val)

    candidate   = if size > 0 then value else -1
    leaderCount = length (filter (== candidate) a)
    leader      = if leaderCount > n `div` 2 then candidate else -1

    prefixLeaderCounts = scanl1 (+) [if v == leader then 1 else 0 | v <- a]

    isEqui (k, _, lLeaderCount) =
      let leftHalf     = (k + 1) `div` 2
          rightHalf     = (n - k - 1) `div` 2
          rLeaderCount = leaderCount - lLeaderCount
      in  lLeaderCount > leftHalf && rLeaderCount > rightHalf

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Java Equi Leader

public class Solution {
    public static int equiLeader(int[] a) {
        int leaderSize = 0;
        int value = 0;

        for (int v : a) {
            if (leaderSize == 0) {
                leaderSize++;
                value = v;
            } else if (value != v) {
                leaderSize--;
            } else {
                leaderSize++;
            }
        }
        int candidate = leaderSize > 0 ? value : -1;

        int leaderCount = 0;
        for (int v : a) {
            if (v == candidate) {
                leaderCount++;
            }
        }
        int leader = -1;
        if (leaderCount > a.length / 2.0) {
            leader = candidate;
        }

        int count = a.length;
        int lLeaderCount = 0;
        int equiLeaders = 0;

        for (int k = 0; k < count; k++) {
            int v = a[k];
            int leftHalf = (k + 1) / 2;
            int rightHalf = (count - k - 1) / 2;
            if (v == leader) {
                lLeaderCount++;
            }

            int rLeaderCount = leaderCount - lLeaderCount;
            if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
                equiLeaders++;
            }
        }

        return equiLeaders;
    }
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Equi Leader

(defun equi-leader (a)
  (let ((vec (coerce a 'vector))
        (leader-size 0) (value 0))
    (loop for v across vec
          do (cond
               ((zerop leader-size) (incf leader-size) (setf value v))
               ((/= value v) (decf leader-size))
               (t (incf leader-size))))
    (let* ((candidate (if (> leader-size 0) value -1))
           (leader-count 0))
      (loop for v across vec do (when (= v candidate) (incf leader-count)))
      (let ((leader (if (> leader-count (/ (length vec) 2)) candidate -1))
            (count (length vec))
            (l-leader-count 0)
            (equi-leaders 0))
        (loop for k from 0 below count
              for v = (aref vec k)
              do (let ((left-half (floor (1+ k) 2))
                       (right-half (floor (- count k 1) 2)))
                   (when (= v leader) (incf l-leader-count))
                   (let ((r-leader-count (- leader-count l-leader-count)))
                     (when (and (> l-leader-count left-half)
                                (> r-leader-count right-half))
                       (incf equi-leaders)))))
        equi-leaders))))

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

PHP Equi Leader

function equiLeader(array $a): int
{
    $leaderSize = $value = $leaderCount = 0;
    foreach ($a as $k => $v) {
        if ($leaderSize === 0) {
            $leaderSize++;
            $value = $v;
        } elseif ($value !== $v) {
            $leaderSize--;
        } else {
            $leaderSize++;
        }
    }
    $candidate = $leaderSize > 0 ? $value : -1;

    foreach ($a as $v) {
        if ($v === $candidate) {
            $leaderCount++;
        }
    }
    $leader = -1;
    if ($leaderCount > count($a) / 2) {
        $leader = $candidate;
    }

    $count        = count($a);
    $lLeaderCount = $equiLeaders = 0;

    foreach ($a as $k => $v) {
        $leftHalf  = (int)(($k + 1) / 2);
        $rightHalf = (int)(($count - $k - 1) / 2);
        if ($v === $leader) {
            $lLeaderCount++;
        }

        $rLeaderCount = $leaderCount - $lLeaderCount;
        if ($lLeaderCount > $leftHalf && $rLeaderCount > $rightHalf) {
            $equiLeaders++;
        }

    }

    return $equiLeaders;
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Python Equi Leader

def equi_leader(a: list[int]) -> int:
    leader_size = value = 0
    for v in a:
        if leader_size == 0:
            leader_size += 1
            value = v
        elif value != v:
            leader_size -= 1
        else:
            leader_size += 1
    candidate = value if leader_size > 0 else -1

    count = len(a)
    leader_count = sum(1 for v in a if v == candidate)
    leader = candidate if leader_count > count / 2 else -1

    l_leader_count = 0
    equi_leaders = 0
    for k, v in enumerate(a):
        left_half = (k + 1) // 2
        right_half = (count - k - 1) // 2
        if v == leader:
            l_leader_count += 1

        r_leader_count = leader_count - l_leader_count
        if l_leader_count > left_half and r_leader_count > right_half:
            equi_leaders += 1

    return equi_leaders

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Rust Equi Leader

fn equi_leader(a: &[i64]) -> i64 {
    let mut leader_size = 0i64;
    let mut value = 0;
    for &v in a {
        if leader_size == 0 {
            leader_size += 1;
            value = v;
        } else if value != v {
            leader_size -= 1;
        } else {
            leader_size += 1;
        }
    }
    let candidate = if leader_size > 0 { value } else { -1 };

    let leader_count = a.iter().filter(|&&v| v == candidate).count() as i64;
    let leader = if leader_count > a.len() as i64 / 2 { candidate } else { -1 };

    let count = a.len() as i64;
    let mut l_leader_count = 0i64;
    let mut equi_leaders = 0i64;

    for (k, &v) in a.iter().enumerate() {
        let k = k as i64;
        let left_half = (k + 1) / 2;
        let right_half = (count - k - 1) / 2;
        if v == leader {
            l_leader_count += 1;
        }

        let r_leader_count = leader_count - l_leader_count;
        if l_leader_count > left_half && r_leader_count > right_half {
            equi_leaders += 1;
        }
    }

    equi_leaders
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Equi Leader

function equiLeader(a: number[]): number {
  let leaderSize = 0;
  let value = 0;

  for (const v of a) {
    if (leaderSize === 0) {
      leaderSize++;
      value = v;
    } else if (value !== v) {
      leaderSize--;
    } else {
      leaderSize++;
    }
  }

  const candidate = leaderSize > 0 ? value : -1;

  let leaderCount = 0;
  for (const v of a) {
    if (v === candidate) {
      leaderCount++;
    }
  }

  let leader = -1;
  if (leaderCount > a.length / 2) {
    leader = candidate;
  }

  const count = a.length;
  let lLeaderCount = 0;
  let equiLeaders = 0;

  for (let k = 0; k < count; k++) {
    const v = a[k];
    const leftHalf = Math.trunc((k + 1) / 2);
    const rightHalf = Math.trunc((count - k - 1) / 2);
    if (v === leader) {
      lLeaderCount++;
    }

    const rLeaderCount = leaderCount - lLeaderCount;
    if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
      equiLeaders++;
    }
  }

  return equiLeaders;
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Bash Fib Frog

fib_frog() {
    local -n _arr="$1"
    local _size=${#_arr[@]}
    local -a _fib=(0 1)
    local _i=1
    while (( _fib[_i] <= _size )); do
        ((_i++))
        _fib[_i]=$(( _fib[_i-1] + _fib[_i-2] ))
    done
    local -a _q_idx=(-1) _q_jmp=(0)
    local _head=0
    local -a _steps
    for ((_i = 0; _i < _size; _i++)); do _steps[_i]=0; done
    while (( _head < ${#_q_idx[@]} )); do
        local _cidx=${_q_idx[_head]} _cjmp=${_q_jmp[_head]}
        ((_head++))
        local _fidx
        for ((_fidx = ${#_fib[@]} - 1; _fidx >= 2; _fidx--)); do
            local _idx=$(( _cidx + _fib[_fidx] ))
            if (( _idx == _size )); then
                echo $(( _cjmp + 1 ))
                return
            fi
            if (( _idx > _size )) || (( ${_steps[_idx]:-0} )) || (( _arr[_idx] == 0 )); then
                continue
            fi
            if (( _arr[_idx] == 1 )); then
                _steps[_idx]=1
                _q_idx+=("$_idx")
                _q_jmp+=($(( _cjmp + 1 )))
            fi
        done
    done
    echo -1
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

C++ Fib Frog

#include <queue>
#include <vector>

int fibFrog(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());

    std::vector<int> fib{0, 1};
    for (int i = 1; fib[i] <= size;) {
        ++i;
        fib.push_back(fib[i - 1] + fib[i - 2]);
    }

    struct Path {
        int idx;
        int jmp;
    };

    std::queue<Path> paths;
    paths.push({-1, 0});

    std::vector<bool> steps(size, false);

    while (!paths.empty()) {
        Path path = paths.front();
        paths.pop();

        for (int i = static_cast<int>(fib.size()) - 1; i >= 2; --i) {
            int idx = path.idx + fib[i];
            if (idx == size) {
                return path.jmp + 1;
            }
            if (idx > size || steps[idx] || a[idx] == 0) {
                continue;
            }
            if (a[idx] == 1) {
                steps[idx] = true;
                paths.push({idx, path.jmp + 1});
            }
        }
    }

    return -1;
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

C# Fib Frog

static int FibFrog(int[] a)
{
    var size = a.Length;

    var fib = new List<int> { 0, 1 };
    for (int i = 1; fib[i] <= size;)
    {
        i++;
        fib.Add(fib[i - 1] + fib[i - 2]);
    }

    var queue = new Queue<(int Idx, int Jmp)>();
    queue.Enqueue((-1, 0));

    var visited = new bool[size];

    while (queue.Count > 0)
    {
        var (idx0, jmp) = queue.Dequeue();
        for (int i = fib.Count - 1; i >= 2; i--)
        {
            var idx = idx0 + fib[i];
            if (idx == size)
            {
                return jmp + 1;
            }
            if (idx > size || visited[idx] || a[idx] == 0)
            {
                continue;
            }
            if (a[idx] == 1)
            {
                visited[idx] = true;
                queue.Enqueue((idx, jmp + 1));
            }
        }
    }

    return -1;
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Fib Frog

defmodule FibFrog do
  def fib_frog(a) do
    size = length(a)
    jumps = size |> build_fib([1, 0]) |> Enum.reverse()
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)

    bfs([{-1, 0}], MapSet.new(), jumps, a_map, size)
  end

  defp build_fib(size, [last | _] = acc) when last > size do
    acc |> Enum.reverse() |> Enum.drop(2)
  end

  defp build_fib(size, [a, b | _] = acc), do: build_fib(size, [a + b | acc])

  defp bfs([], _visited, _jumps, _a_map, _size), do: -1

  defp bfs([{idx, jmp} | rest], visited, jumps, a_map, size) do
    case try_jumps(jumps, idx, jmp, size, a_map, visited) do
      {:found, result} -> result
      {:continue, new_paths, visited} -> bfs(rest ++ new_paths, visited, jumps, a_map, size)
    end
  end

  defp try_jumps(jumps, idx, jmp, size, a_map, visited) do
    Enum.reduce_while(jumps, {:continue, [], visited}, fn f, {:continue, paths, visited} ->
      next_idx = idx + f

      cond do
        next_idx == size ->
          {:halt, {:found, jmp + 1}}

        next_idx > size or MapSet.member?(visited, next_idx) or Map.get(a_map, next_idx) == 0 ->
          {:cont, {:continue, paths, visited}}

        true ->
          {:cont, {:continue, paths ++ [{next_idx, jmp + 1}], MapSet.put(visited, next_idx)}}
      end
    end)
  end
end

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Fib Frog

-module(fib_frog).
-export([fib_frog/1]).

fib_frog(A) ->
    Size = length(A),
    Arr = array:from_list(A),
    Fibs = gen_fibs(Size),
    bfs([-1], sets:from_list([-1]), Fibs, Size, Arr, 0).

gen_fibs(Size) ->
    gen_fibs(0, 1, Size, []).

gen_fibs(_A, B, Size, Acc) when B > Size ->
    lists:reverse(Acc);
gen_fibs(A, B, Size, Acc) ->
    gen_fibs(B, A + B, Size, [B | Acc]).

bfs(Frontier, Visited, Fibs, Size, Arr, Level) ->
    Hit = lists:any(fun(Idx) ->
        lists:any(fun(F) -> Idx + F =:= Size end, Fibs)
    end, Frontier),
    case Hit of
        true -> Level + 1;
        false ->
            NextCandidates = lists:usort([Idx + F || Idx <- Frontier, F <- Fibs,
                                            Idx + F >= 0, Idx + F < Size,
                                            array:get(Idx + F, Arr) =:= 1,
                                            not sets:is_element(Idx + F, Visited)]),
            case NextCandidates of
                [] -> -1;
                _ ->
                    Visited1 = sets:union(Visited, sets:from_list(NextCandidates)),
                    bfs(NextCandidates, Visited1, Fibs, Size, Arr, Level + 1)
            end
    end.

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Go Fib Frog

func fibFrog(a []int) int {
	size := len(a)

	fib := []int{0, 1}
	for i := 1; fib[i] <= size; {
		i++
		fib = append(fib, fib[i-1]+fib[i-2])
	}

	type path struct {
		idx int
		jmp int
	}
	paths := []path{{idx: -1, jmp: 0}}
	steps := make([]bool, size)

	for len(paths) > 0 {
		cur := paths[0]
		paths = paths[1:]

		for i := len(fib) - 1; i >= 2; i-- {
			idx := cur.idx + fib[i]
			if idx == size {
				return cur.jmp + 1
			}
			if idx > size || steps[idx] || a[idx] == 0 {
				continue
			}
			if a[idx] == 1 {
				steps[idx] = true
				paths = append(paths, path{idx: idx, jmp: cur.jmp + 1})
			}
		}
	}

	return -1
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Fib Frog

import Data.Array (Array, listArray, (!))
import qualified Data.Sequence as Seq
import Data.Sequence (Seq, ViewL (..), viewl, (|>))
import qualified Data.Set as Set

fibFrog :: [Int] -> Int
fibFrog a = go (Seq.singleton (-1, 0)) (Set.singleton (-1))
  where
    n = length a
    leaves = listArray (0, n - 1) a :: Array Int Int

    -- distinct Fibonacci jump lengths, up to the first one exceeding n
    jumps = takeWhile (<= n) fibJumps
      where
        fibJumps = 1 : 2 : zipWith (+) fibJumps (tail fibJumps)

    go :: Seq (Int, Int) -> Set.Set Int -> Int
    go queue visited = case viewl queue of
      EmptyL -> -1
      (pos, steps) :< rest
        | any (\j -> pos + j == n) jumps -> steps + 1
        | otherwise ->
            let (queue', visited') = foldl (enqueue pos steps) (rest, visited) jumps
            in  go queue' visited'

    enqueue pos steps (q, visited) j
      | idx >= 0 && idx < n && leaves ! idx == 1 && not (Set.member idx visited) =
          (q |> (idx, steps + 1), Set.insert idx visited)
      | otherwise = (q, visited)
      where
        idx = pos + j

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Java Fib Frog

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

public class Solution {
    public static int fibFrog(int[] a) {
        int size = a.length;

        List<Integer> fib = new ArrayList<>(List.of(0, 1));
        for (int i = 1; fib.get(i) <= size; ) {
            i++;
            fib.add(fib.get(i - 1) + fib.get(i - 2));
        }

        Deque<int[]> paths = new ArrayDeque<>();
        paths.add(new int[]{-1, 0}); // {idx, jmp}

        boolean[] steps = new boolean[size];

        while (!paths.isEmpty()) {
            int[] path = paths.poll();
            int curIdx = path[0];
            int jmp = path[1];

            for (int i = fib.size() - 1; i >= 2; i--) {
                int idx = curIdx + fib.get(i);
                if (idx == size) {
                    return jmp + 1;
                }
                if (idx > size || steps[idx] || a[idx] == 0) {
                    continue;
                }
                if (a[idx] == 1) {
                    steps[idx] = true;
                    paths.add(new int[]{idx, jmp + 1});
                }
            }
        }

        return -1;
    }
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Fib Frog

(defun fib-frog (a)
  (let* ((vec (coerce a 'vector))
         (size (length vec))
         (fib (make-array 2 :initial-contents '(0 1) :adjustable t :fill-pointer 2)))
    (let ((i 1))
      (loop while (<= (aref fib i) size)
            do (progn
                 (incf i)
                 (vector-push-extend (+ (aref fib (1- i)) (aref fib (- i 2))) fib))))
    (let ((paths (list (list :idx -1 :jmp 0)))
          (steps (make-array size :initial-element nil)))
      (loop while paths
            do (let ((path (pop paths)))
                 (loop for i from (1- (length fib)) downto 2
                       do (let ((idx (+ (getf path :idx) (aref fib i))))
                            (cond
                              ((= idx size) (return-from fib-frog (1+ (getf path :jmp))))
                              ((or (> idx size)
                                   (aref steps idx)
                                   (zerop (aref vec idx)))
                               nil)
                              ((= (aref vec idx) 1)
                               (setf (aref steps idx) t)
                               (setf paths (append paths (list (list :idx idx :jmp (1+ (getf path :jmp))))))))))))
      -1)))

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

PHP Fib Frog

function fibFrog(array $a): int
{
    $size = count($a);

    $fib = [0, 1];
    for ($i = 1; $fib[$i] <= $size;) {
        $i++;
        $fib[$i] = $fib[$i - 1] + $fib[$i - 2];
    }

    $paths = [
        [
            'idx' => -1,
            'jmp' => 0
        ]
    ];

    $steps = array_fill(0, $size, false);

    while (count($paths) > 0) {
        $path = array_shift($paths);
        for ($i = count($fib) - 1; $i >= 2; $i--) {
            $idx = $path['idx'] + $fib[$i];
            if ($idx === $size) {
                return $path['jmp'] + 1;
            }
            if ($idx > $size
                || $steps[$idx]
                || $a[$idx] === 0
            ) {
                continue;
            }
            if ($a[$idx] === 1) {
                $steps[$idx] = true;
                $paths[]     = [
                    'idx' => $idx,
                    'jmp' => $path['jmp'] + 1
                ];
            }
        }
    }

    return -1;
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Python Fib Frog

from collections import deque


def fib_frog(a: list[int]) -> int:
    size = len(a)

    fib = [0, 1]
    i = 1
    while fib[i] <= size:
        i += 1
        fib.append(fib[i - 1] + fib[i - 2])

    queue = deque([(-1, 0)])
    visited = [False] * size

    while queue:
        idx, jumps = queue.popleft()
        for f in range(len(fib) - 1, 1, -1):
            new_idx = idx + fib[f]
            if new_idx == size:
                return jumps + 1
            if new_idx > size or visited[new_idx] or a[new_idx] == 0:
                continue
            if a[new_idx] == 1:
                visited[new_idx] = True
                queue.append((new_idx, jumps + 1))

    return -1

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Rust Fib Frog

use std::collections::VecDeque;

fn fib_frog(a: &[i64]) -> i64 {
    let size = a.len() as i64;

    let mut fib = vec![0i64, 1];
    let mut i = 1;
    while fib[i] <= size {
        i += 1;
        fib.push(fib[i - 1] + fib[i - 2]);
    }

    let mut paths: VecDeque<(i64, i64)> = VecDeque::new();
    paths.push_back((-1, 0));

    let mut steps = vec![false; size as usize];

    while let Some((idx, jmp)) = paths.pop_front() {
        for f in (2..fib.len()).rev() {
            let next_idx = idx + fib[f];
            if next_idx == size {
                return jmp + 1;
            }
            if next_idx > size || steps[next_idx as usize] || a[next_idx as usize] == 0 {
                continue;
            }
            if a[next_idx as usize] == 1 {
                steps[next_idx as usize] = true;
                paths.push_back((next_idx, jmp + 1));
            }
        }
    }

    -1
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Fib Frog

function fibFrog(a: number[]): number {
  const size = a.length;

  const fib: number[] = [0, 1];
  for (let i = 1; fib[i] <= size; ) {
    i++;
    fib[i] = fib[i - 1] + fib[i - 2];
  }

  type Path = { idx: number; jmp: number };
  const paths: Path[] = [{ idx: -1, jmp: 0 }];
  const steps: boolean[] = new Array(size).fill(false);

  while (paths.length > 0) {
    const path = paths.shift() as Path;
    for (let i = fib.length - 1; i >= 2; i--) {
      const idx = path.idx + fib[i];
      if (idx === size) {
        return path.jmp + 1;
      }
      if (idx > size || steps[idx] || a[idx] === 0) {
        continue;
      }
      if (a[idx] === 1) {
        steps[idx] = true;
        paths.push({ idx, jmp: path.jmp + 1 });
      }
    }
  }

  return -1;
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Bash Fish

fish() {
    local -n _a="$1"
    local -n _b="$2"
    local _size=${#_a[@]}
    local _dead=0
    local -a _stack=()
    local _i
    for ((_i = 0; _i < _size; _i++)); do
        if (( _b[_i] == 1 )); then
            _stack+=("${_a[_i]}")
        elif (( ${#_stack[@]} > 0 )); then
            while (( ${#_stack[@]} > 0 )); do
                ((_dead++))
                local _top=${_stack[-1]}
                if (( _a[_i] > _top )); then
                    unset '_stack[-1]'
                    _stack=("${_stack[@]}")
                else
                    break
                fi
            done
        fi
    done
    echo $(( _size - _dead ))
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

C++ Fish

#include <vector>

int fish(const std::vector<int>& a, const std::vector<int>& b)
{
    int size = static_cast<int>(a.size());
    int dead = 0;
    std::vector<int> downstream;

    for (int i = 0; i < size; ++i) {
        if (b[i] == 1) {
            downstream.push_back(a[i]);
        } else if (!downstream.empty()) {
            while (!downstream.empty()) {
                ++dead;
                if (a[i] > downstream.back()) {
                    downstream.pop_back();
                } else {
                    break;
                }
            }
        }
    }

    return size - dead;
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

C# Fish

static int Fish(int[] a, int[] b)
{
    var size = a.Length;
    var dead = 0;
    var fish = new Stack<int>();

    for (int i = 0; i < size; i++)
    {
        if (b[i] == 1)
        {
            fish.Push(a[i]);
        }
        else
        {
            while (fish.Count > 0)
            {
                dead++;
                if (a[i] > fish.Peek())
                {
                    fish.Pop();
                }
                else
                {
                    break;
                }
            }
        }
    }

    return size - dead;
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Fish

defmodule Fish do
  def fish(a, b) do
    size = length(a)

    {_stack, dead} =
      a
      |> Enum.zip(b)
      |> Enum.reduce({[], 0}, fn {size_i, dir_i}, {stack, dead} ->
        if dir_i == 1 do
          {[size_i | stack], dead}
        else
          fight(size_i, stack, dead)
        end
      end)

    size - dead
  end

  defp fight(_size_i, [], dead), do: {[], dead}

  defp fight(size_i, [top | rest] = stack, dead) do
    if size_i > top do
      fight(size_i, rest, dead + 1)
    else
      {stack, dead + 1}
    end
  end
end

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Fish

-module(fish).
-export([fish/2]).

fish(A, B) ->
    Pairs = lists:zip(A, B),
    {_, Dead} = lists:foldl(fun({Ai, Bi}, {Stack, D}) ->
        case Bi of
            1 -> {[Ai | Stack], D};
            _ -> fight(Ai, Stack, D)
        end
    end, {[], 0}, Pairs),
    length(A) - Dead.

fight(_Ai, [], Dead) ->
    {[], Dead};
fight(Ai, [Top | Rest], Dead) ->
    Dead1 = Dead + 1,
    case Ai > Top of
        true -> fight(Ai, Rest, Dead1);
        false -> {[Top | Rest], Dead1}
    end.

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Go Fish

func fish(a, b []int) int {
	size := len(a)
	dead := 0
	downstream := make([]int, 0, size)

	for i := 0; i < size; i++ {
		if b[i] == 1 {
			downstream = append(downstream, a[i])
		} else {
			for len(downstream) > 0 {
				dead++
				if a[i] > downstream[len(downstream)-1] {
					downstream = downstream[:len(downstream)-1]
				} else {
					break
				}
			}
		}
	}

	return size - dead
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Fish

fish :: [Int] -> [Int] -> Int
fish a b = size - dead
  where
    size      = length a
    (dead, _) = foldl step (0, []) (zip a b)

    step (d, stack) (ai, bi)
      | bi == 1   = (d, ai : stack)
      | otherwise = fight ai stack d

    fight _  []             d = (d, [])
    fight ai (top : tops) d
      | ai > top  = fight ai tops (d + 1)
      | otherwise = (d + 1, top : tops)

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Java Fish

import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {
    public static int fish(int[] a, int[] b) {
        int size = a.length;
        int dead = 0;
        Deque<Integer> fish = new ArrayDeque<>();

        for (int i = 0; i < size; i++) {
            if (b[i] == 1) {
                fish.push(a[i]);
            } else if (!fish.isEmpty()) {
                while (!fish.isEmpty()) {
                    dead++;
                    if (a[i] > fish.peek()) {
                        fish.pop();
                    } else {
                        break;
                    }
                }
            }
        }

        return size - dead;
    }
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Fish

(defun fish (a b)
  (let* ((veca (coerce a 'vector))
         (vecb (coerce b 'vector))
         (size (length veca))
         (dead 0)
         (stack '()))
    (dotimes (i size)
      (if (= (aref vecb i) 1)
          (push (aref veca i) stack)
          (when stack
            (loop while stack
                  do (progn
                       (incf dead)
                       (if (> (aref veca i) (first stack))
                           (pop stack)
                           (return)))))))
    (- size dead)))

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

PHP Fish

function fish(array $a, array $b): int
{
    $size  = count($a);
    $dead = 0;
    $fish  = [];
    for ($i = 0; $i < $size; $i++) {
        if ($b[$i] === 1) {
            $fish[] = $a[$i];
        } elseif (isset($fish[0])) {
            while (isset($fish[0])) {
                $dead++;
                if ($a[$i] > end($fish)) {
                    array_pop($fish);
                } else {
                    break;
                }
            }
        }
    }

    return $size - $dead;
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Python Fish

def fish(a: list[int], b: list[int]) -> int:
    size = len(a)
    dead = 0
    downstream: list[int] = []

    for i in range(size):
        if b[i] == 1:
            downstream.append(a[i])
        else:
            while downstream:
                dead += 1
                if a[i] > downstream[-1]:
                    downstream.pop()
                else:
                    break

    return size - dead

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Rust Fish

fn fish(a: &[i64], b: &[i64]) -> i64 {
    let size = a.len();
    let mut dead = 0i64;
    let mut fish: Vec<i64> = Vec::new();

    for i in 0..size {
        if b[i] == 1 {
            fish.push(a[i]);
        } else if !fish.is_empty() {
            while let Some(&last) = fish.last() {
                dead += 1;
                if a[i] > last {
                    fish.pop();
                } else {
                    break;
                }
            }
        }
    }

    size as i64 - dead
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Fish

function fish(a: number[], b: number[]): number {
  const size = a.length;
  let dead = 0;
  const downstream: number[] = [];

  for (let i = 0; i < size; i++) {
    if (b[i] === 1) {
      downstream.push(a[i]);
    } else if (downstream.length > 0) {
      while (downstream.length > 0) {
        dead++;
        if (a[i] > downstream[downstream.length - 1]) {
          downstream.pop();
        } else {
          break;
        }
      }
    }
  }

  return size - dead;
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Bash Flags

flags() {
    local -n _a="$1"
    local _size=${#_a[@]}
    local -a _peak _nxt
    _peak[0]=0
    local _i
    for ((_i = 1; _i < _size; _i++)); do
        local _right=0
        (( _i + 1 < _size )) && _right=${_a[_i+1]}
        if (( _a[_i-1] < _a[_i] && _a[_i] > _right )); then _peak[_i]=1; else _peak[_i]=0; fi
    done
    _nxt[_size-1]=-1
    for ((_i = _size - 2; _i >= 0; _i--)); do
        if (( _peak[_i] )); then _nxt[_i]=$_i; else _nxt[_i]=${_nxt[_i+1]}; fi
    done
    _i=1
    local _result=0
    while (( _i * (_i - 1) <= _size )); do
        local _pos=0 _num=0
        while (( _pos < _size && _num < _i )); do
            _pos=${_nxt[_pos]}
            if (( _pos == -1 )); then break; fi
            ((_num++))
            _pos=$(( _pos + _i ))
        done
        ((_i++))
        (( _num > _result )) && _result=$_num
    done
    echo "$_result"
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

C++ Flags

#include <algorithm>
#include <vector>

int flags(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());
    if (size == 0) {
        return 0;
    }

    std::vector<bool> peaks(size, false);
    for (int i = 1; i < size; ++i) {
        int nextVal = (i + 1 < size) ? a[i + 1] : 0;
        peaks[i] = a[i - 1] < a[i] && a[i] > nextVal;
    }

    std::vector<int> next(size);
    next[size - 1] = -1;
    for (int i = size - 2; i >= 0; --i) {
        next[i] = peaks[i] ? i : next[i + 1];
    }

    int i = 1;
    int result = 0;
    while (i * (i - 1) <= size) {
        int pos = 0;
        int num = 0;
        while (pos < size && num < i) {
            pos = next[pos];
            if (pos == -1) {
                break;
            }
            ++num;
            pos += i;
        }
        ++i;
        result = std::max(result, num);
    }

    return result;
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

C# Flags

static int Flags(int[] a)
{
    var size = a.Length;
    if (size == 0)
    {
        return 0;
    }

    var peaks = new bool[size];
    var next = new int[size];

    for (int i = 1; i < size; i++)
    {
        var right = i + 1 < size ? a[i + 1] : 0;
        peaks[i] = a[i - 1] < a[i] && a[i] > right;
    }

    next[size - 1] = -1;
    for (int i = size - 2; i >= 0; i--)
    {
        next[i] = peaks[i] ? i : next[i + 1];
    }

    var result = 0;
    for (int i = 1; i * (i - 1) <= size; i++)
    {
        var pos = 0;
        var num = 0;
        while (pos < size && num < i)
        {
            pos = next[pos];
            if (pos == -1)
            {
                break;
            }
            num++;
            pos += i;
        }
        result = Math.Max(result, num);
    }

    return result;
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Flags

defmodule Flags do
  def flags(a) do
    size = length(a)
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)

    peaks =
      for i <- 1..(size - 1), into: %{} do
        prev = Map.get(a_map, i - 1)
        cur = Map.get(a_map, i)
        nxt = Map.get(a_map, i + 1, 0)
        {i, prev < cur and cur > nxt}
      end

    next_map = build_next(size, peaks)

    search(1, size, next_map, 0)
  end

  defp build_next(size, peaks) do
    Enum.reduce((size - 2)..0//-1, %{size - 1 => -1}, fn i, next_map ->
      value = if Map.get(peaks, i, false), do: i, else: Map.get(next_map, i + 1)
      Map.put(next_map, i, value)
    end)
  end

  defp search(i, size, next_map, result) when i * (i - 1) <= size do
    num = walk(0, i, 0, size, next_map)
    search(i + 1, size, next_map, max(result, num))
  end

  defp search(_i, _size, _next_map, result), do: result

  defp walk(pos, step, num, size, next_map) when pos < size and num < step do
    next_pos = Map.get(next_map, pos)

    if next_pos == -1 do
      num
    else
      walk(next_pos + step, step, num + 1, size, next_map)
    end
  end

  defp walk(_pos, _step, num, _size, _next_map), do: num
end

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Flags

-module(flags).
-export([flags/1]).

flags(A) ->
    Size = length(A),
    Arr = array:from_list(A),
    Peaks = compute_peaks(Arr, Size),
    Next = compute_next(Peaks, Size),
    max_flags(1, Size, Next, 0).

compute_peaks(_Arr, Size) when Size =< 1 ->
    array:new(max(Size, 1), {default, false});
compute_peaks(Arr, Size) ->
    Peaks0 = array:new(Size, {default, false}),
    lists:foldl(fun(I, Acc) ->
        Ai = array:get(I, Arr),
        Prev = array:get(I - 1, Arr),
        Next = case I + 1 < Size of
            true -> array:get(I + 1, Arr);
            false -> 0
        end,
        IsPeak = Prev < Ai andalso Ai > Next,
        array:set(I, IsPeak, Acc)
    end, Peaks0, lists:seq(1, Size - 1)).

compute_next(_Peaks, Size) when Size =:= 0 ->
    array:new(0);
compute_next(Peaks, Size) ->
    NextArr0 = array:set(Size - 1, -1, array:new(Size)),
    lists:foldl(fun(I, Acc) ->
        Val = case array:get(I, Peaks) of
            true -> I;
            false -> array:get(I + 1, Acc)
        end,
        array:set(I, Val, Acc)
    end, NextArr0, lists:seq(Size - 2, 0, -1)).

max_flags(I, Size, _Next, Result) when I * (I - 1) > Size ->
    Result;
max_flags(I, Size, Next, Result) ->
    Num = count_flags(0, 0, I, Size, Next),
    max_flags(I + 1, Size, Next, max(Result, Num)).

count_flags(Pos, Num, I, Size, _Next) when Pos >= Size orelse Num >= I ->
    Num;
count_flags(Pos, Num, I, Size, Next) ->
    case array:get(Pos, Next) of
        -1 -> Num;
        NextPos -> count_flags(NextPos + I, Num + 1, I, Size, Next)
    end.

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Go Flags

func flags(a []int) int {
	size := len(a)

	peaks := make([]bool, size)
	for i := 1; i < size; i++ {
		nextVal := 0
		if i+1 < size {
			nextVal = a[i+1]
		}
		peaks[i] = a[i-1] < a[i] && a[i] > nextVal
	}

	next := make([]int, size)
	next[size-1] = -1
	for i := size - 2; i >= 0; i-- {
		if peaks[i] {
			next[i] = i
		} else {
			next[i] = next[i+1]
		}
	}

	result := 0
	for i := 1; i*(i-1) <= size; i++ {
		pos, num := 0, 0
		for pos < size && num < i {
			pos = next[pos]
			if pos == -1 {
				break
			}
			num++
			pos += i
		}
		if num > result {
			result = num
		}
	}

	return result
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Flags

import Data.Array (Array, listArray, (!))

flags :: [Int] -> Int
flags a = result
  where
    n   = length a
    arr = listArray (0, n - 1) a :: Array Int Int
    at i
      | i >= 0 && i < n = arr ! i
      | otherwise       = 0

    isPeak i = i > 0 && i < n && arr ! (i - 1) < arr ! i && arr ! i > at (i + 1)

    nextArr :: Array Int Int
    nextArr = listArray (0, n - 1) [compute i | i <- [0 .. n - 1]]
      where
        compute i
          | i == n - 1 = if isPeak i then i else -1
          | isPeak i   = i
          | otherwise  = nextArr ! (i + 1)

    result = go 1 0
    go i best
      | i * (i - 1) > n = best
      | otherwise       = go (i + 1) (max best (countFlags i))

    countFlags i = walk 0 0
      where
        walk pos num
          | not (pos < n && num < i) = num
          | nextArr ! pos == -1      = num
          | otherwise                = walk (nextArr ! pos + i) (num + 1)

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Java Flags

public class Solution {
    public static int flags(int[] a) {
        int size = a.length;
        boolean[] peaks = new boolean[size];

        for (int i = 1; i < size; i++) {
            int next = (i + 1 < size) ? a[i + 1] : 0;
            peaks[i] = a[i - 1] < a[i] && a[i] > next;
        }

        int[] next = new int[size];
        next[size - 1] = -1;
        for (int i = size - 2; i >= 0; i--) {
            next[i] = peaks[i] ? i : next[i + 1];
        }

        int i = 1;
        int result = 0;
        while (i * (i - 1) <= size) {
            int pos = 0;
            int num = 0;
            while (pos < size && num < i) {
                pos = next[pos];
                if (pos == -1) {
                    break;
                }
                ++num;
                pos += i;
            }
            i++;
            result = Math.max(result, num);
        }

        return result;
    }
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Flags

(defun flags (a)
  (let* ((vec (coerce a 'vector))
         (size (length vec))
         (peaks (make-array size :initial-element nil))
         (next (make-array size :initial-element -1)))
    (loop for i from 1 below size
          do (setf (aref peaks i)
                   (and (< (aref vec (1- i)) (aref vec i))
                        (> (aref vec i) (if (< (1+ i) size) (aref vec (1+ i)) 0)))))
    (setf (aref next (1- size)) -1)
    (loop for i from (- size 2) downto 0
          do (setf (aref next i) (if (aref peaks i) i (aref next (1+ i)))))
    (let ((i 1) (result 0))
      (loop while (<= (* i (1- i)) size)
            do (let ((pos 0) (num 0))
                 (loop while (and (< pos size) (< num i))
                       do (progn
                            (setf pos (aref next pos))
                            (when (= pos -1) (return))
                            (incf num)
                            (incf pos i)))
                 (incf i)
                 (setf result (max result num))))
      result)))

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

PHP Flags

function flags(array $a)
{

    $size  = count($a);
    $peaks = [false];
    $next  = [];
    for ($i = 1; $i < $size; $i++) {
        $peaks[$i] = $a[$i - 1] < $a[$i] && $a[$i] > ($a[$i + 1] ?? 0);
    }

    $next[$size - 1] = -1;
    for ($i = $size - 2; $i >= 0; $i--) {
        $next[$i] = $peaks[$i] ? $i : $next[$i + 1];
    }
    $i      = 1;
    $result = 0;
    while ($i * ($i - 1) <= $size) {
        $pos = 0;
        $num = 0;
        while ($pos < $size && $num < $i) {
            $pos = $next[$pos];
            if ($pos === -1) {
                break;
            }
            ++$num;
            $pos += $i;
        }
        $i++;
        $result = max($result, $num);
    }

    return $result;
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Python Flags

def flags(a: list[int]) -> int:
    size = len(a)
    if size == 0:
        return 0

    peaks = [False] * size
    for i in range(1, size):
        next_val = a[i + 1] if i + 1 < size else 0
        peaks[i] = a[i - 1] < a[i] and a[i] > next_val

    next_peak = [0] * size
    next_peak[size - 1] = -1
    for i in range(size - 2, -1, -1):
        next_peak[i] = i if peaks[i] else next_peak[i + 1]

    i = 1
    result = 0
    while i * (i - 1) <= size:
        pos = 0
        num = 0
        while pos < size and num < i:
            pos = next_peak[pos]
            if pos == -1:
                break
            num += 1
            pos += i
        i += 1
        result = max(result, num)

    return result

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Rust Flags

fn flags(a: &[i64]) -> i64 {
    let size = a.len();
    let mut peaks = vec![false; size];
    for i in 1..size {
        let next = a.get(i + 1).copied().unwrap_or(0);
        peaks[i] = a[i - 1] < a[i] && a[i] > next;
    }

    let mut next_peak = vec![-1i64; size];
    if size > 0 {
        next_peak[size - 1] = -1;
        for i in (0..size - 1).rev() {
            next_peak[i] = if peaks[i] { i as i64 } else { next_peak[i + 1] };
        }
    }

    let mut i = 1i64;
    let mut result = 0i64;
    while i * (i - 1) <= size as i64 {
        let mut pos = 0i64;
        let mut num = 0i64;
        while pos < size as i64 && num < i {
            pos = next_peak[pos as usize];
            if pos == -1 {
                break;
            }
            num += 1;
            pos += i;
        }
        i += 1;
        result = result.max(num);
    }

    result
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Flags

function flags(a: number[]): number {
  const size = a.length;
  const peaks: boolean[] = [false];
  const next: number[] = [];

  for (let i = 1; i < size; i++) {
    peaks[i] = a[i - 1] < a[i] && a[i] > (a[i + 1] ?? 0);
  }

  next[size - 1] = -1;
  for (let i = size - 2; i >= 0; i--) {
    next[i] = peaks[i] ? i : next[i + 1];
  }

  let i = 1;
  let result = 0;
  while (i * (i - 1) <= size) {
    let pos = 0;
    let num = 0;
    while (pos < size && num < i) {
      pos = next[pos];
      if (pos === -1) {
        break;
      }
      ++num;
      pos += i;
    }
    i++;
    result = Math.max(result, num);
  }

  return result;
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Bash Frog Jmp

frog_jmp() {
    local _x=$1 _y=$2 _d=$3
    echo $(( (_y - _x + _d - 1) / _d ))
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

C++ Frog Jmp

#include <cmath>

long long frogJmp(long long x, long long y, long long d)
{
    return static_cast<long long>(std::ceil(static_cast<double>(y - x) / d));
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

C# Frog Jmp

static long FrogJmp(long x, long y, long d)
{
    return (long)Math.Ceiling((double)(y - x) / d);
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Frog Jmp

defmodule FrogJmp do
  def frog_jmp(x, y, d), do: ceil((y - x) / d)
end

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Frog Jmp

-module(frog_jmp).
-export([frog_jmp/3]).

frog_jmp(X, Y, D) ->
    (Y - X + D - 1) div D.

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Go Frog Jmp

func frogJmp(x, y, d int) int {
	return int(math.Ceil(float64(y-x) / float64(d)))
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Frog Jmp

frogJmp :: Int -> Int -> Int -> Int
frogJmp x y d = ceiling (fromIntegral (y - x) / fromIntegral d :: Double)

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Java Frog Jmp

public class Solution {
    public static long frogJmp(int x, int y, int d) {
        return (long) Math.ceil(((double) y - x) / d);
    }
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Frog Jmp

(defun frog-jmp (x y d)
  (ceiling (- y x) d))

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

PHP Frog Jmp

function frogJmp(int $x, int $y, int $d): int
{
    return ceil(($y - $x) / $d);
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Python Frog Jmp

import math


def frog_jmp(x: int, y: int, d: int) -> int:
    return math.ceil((y - x) / d)

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Rust Frog Jmp

fn frog_jmp(x: i64, y: i64, d: i64) -> i64 {
    let dist = y - x;
    (dist + d - 1) / d
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Frog Jmp

function frogJmp(x: number, y: number, d: number): number {
  return Math.ceil((y - x) / d);
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Bash Frog River One

frog_river_one() {
    local _x=$1
    local -n _a="$2"
    local -A _existing
    local _k _v
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        if [[ -z "${_existing[$_v]:-}" ]] && (( _v <= _x )); then
            _existing[$_v]=1
            if (( ${#_existing[@]} == _x )); then
                echo "$_k"
                return
            fi
        fi
    done
    echo -1
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

C++ Frog River One

#include <cstddef>
#include <vector>

int frogRiverOne(int x, const std::vector<int>& a)
{
    std::vector<bool> existing(x + 1, false);
    int count = 0;

    for (std::size_t k = 0; k < a.size(); ++k) {
        int i = a[k];
        if (i <= x && !existing[i]) {
            existing[i] = true;
            ++count;
            if (count == x) {
                return static_cast<int>(k);
            }
        }
    }

    return -1;
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

C# Frog River One

static int FrogRiverOne(int x, int[] a)
{
    var existing = new HashSet<int>();

    for (int k = 0; k < a.Length; k++)
    {
        var i = a[k];
        if (i <= x && existing.Add(i) && existing.Count == x)
        {
            return k;
        }
    }

    return -1;
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Frog River One

defmodule FrogRiverOne do
  def frog_river_one(x, a) do
    a
    |> Enum.with_index()
    |> Enum.reduce_while(MapSet.new(), fn {leaf, k}, seen ->
      seen =
        if leaf <= x and not MapSet.member?(seen, leaf) do
          MapSet.put(seen, leaf)
        else
          seen
        end

      if MapSet.size(seen) == x, do: {:halt, k}, else: {:cont, seen}
    end)
    |> case do
      k when is_integer(k) -> k
      _ -> -1
    end
  end
end

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Frog River One

-module(frog_river_one).
-export([frog_river_one/2]).

frog_river_one(X, A) ->
    frog_river_one(X, A, 0, sets:new()).

frog_river_one(_X, [], _K, _Seen) ->
    -1;
frog_river_one(X, [H | T], K, Seen) ->
    case H =< X andalso not sets:is_element(H, Seen) of
        true ->
            Seen1 = sets:add_element(H, Seen),
            case sets:size(Seen1) =:= X of
                true -> K;
                false -> frog_river_one(X, T, K + 1, Seen1)
            end;
        false ->
            frog_river_one(X, T, K + 1, Seen)
    end.

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Go Frog River One

func frogRiverOne(x int, a []int) int {
	existing := make(map[int]bool)

	for k, v := range a {
		if v <= x && !existing[v] {
			existing[v] = true
			if len(existing) == x {
				return k
			}
		}
	}

	return -1
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Frog River One

import qualified Data.Set as Set

frogRiverOne :: Int -> [Int] -> Int
frogRiverOne x a = go (zip [0 ..] a) Set.empty
  where
    go [] _ = -1
    go ((k, i) : rest) seen
      | i <= x && not (Set.member i seen) =
          let seen' = Set.insert i seen
          in  if Set.size seen' == x then k else go rest seen'
      | otherwise = go rest seen

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Java Frog River One

public class Solution {
    public static int frogRiverOne(int x, int[] a) {
        boolean[] existing = new boolean[x + 1];
        int count = 0;

        for (int k = 0; k < a.length; k++) {
            int i = a[k];
            if (i <= x && !existing[i]) {
                existing[i] = true;
                count++;
                if (count == x) {
                    return k;
                }
            }
        }

        return -1;
    }
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Frog River One

(defun frog-river-one (x a)
  (let ((existing (make-hash-table)))
    (loop for k from 0
          for i in a
          do (when (and (not (gethash i existing)) (<= i x))
               (setf (gethash i existing) i)
               (when (= (hash-table-count existing) x)
                 (return-from frog-river-one k))))
    -1))

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

PHP Frog River One

function frogRiverOne(int $x, array $a): int
{
    $existing = [];
    foreach ($a as $k => $i) {
        if ( ! isset($existing[$i]) && $i <= $x) {
            $existing[$i] = $i;
            if (count($existing) === $x) {
                return $k;
            }
        }
    }

    return -1;
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Python Frog River One

def frog_river_one(x: int, a: list[int]) -> int:
    existing: set[int] = set()
    for k, i in enumerate(a):
        if i not in existing and i <= x:
            existing.add(i)
            if len(existing) == x:
                return k

    return -1

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Rust Frog River One

use std::collections::HashSet;

fn frog_river_one(x: i64, a: &[i64]) -> i64 {
    let mut existing: HashSet<i64> = HashSet::new();
    for (k, &i) in a.iter().enumerate() {
        if i <= x && existing.insert(i) && existing.len() as i64 == x {
            return k as i64;
        }
    }

    -1
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Frog River One

function frogRiverOne(x: number, a: number[]): number {
  const existing = new Set<number>();

  for (let k = 0; k < a.length; k++) {
    const i = a[k];
    if (!existing.has(i) && i <= x) {
      existing.add(i);
      if (existing.size === x) {
        return k;
      }
    }
  }

  return -1;
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Bash Genomic Range Query

genomic_range_query() {
    local _s=$1
    local -n _p="$2"
    local -n _q="$3"
    local -n _out="$4"
    _out=()
    local _k _idx
    for _idx in "${!_p[@]}"; do
        local _pi=${_p[$_idx]} _qi=${_q[$_idx]}
        local _len=$(( _qi - _pi + 1 ))
        local _sub=${_s:_pi:_len}
        if [[ "$_sub" == *A* ]]; then
            _out[_idx]=1
        elif [[ "$_sub" == *C* ]]; then
            _out[_idx]=2
        elif [[ "$_sub" == *G* ]]; then
            _out[_idx]=3
        else
            _out[_idx]=4
        fi
    done
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

C++ Genomic Range Query

#include <cstddef>
#include <string>
#include <vector>

std::vector<int> genomicRangeQuery(const std::string& s, const std::vector<int>& p, const std::vector<int>& q)
{
    std::vector<int> r;
    r.reserve(p.size());

    for (std::size_t k = 0; k < p.size(); ++k) {
        int pi = p[k];
        int qi = q[k] - pi + 1;
        std::string subStr = s.substr(pi, qi);

        if (subStr.find('A') != std::string::npos) {
            r.push_back(1);
        } else if (subStr.find('C') != std::string::npos) {
            r.push_back(2);
        } else if (subStr.find('G') != std::string::npos) {
            r.push_back(3);
        } else {
            r.push_back(4);
        }
    }

    return r;
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

C# Genomic Range Query

static int[] GenomicRangeQuery(string s, int[] p, int[] q)
{
    var r = new int[p.Length];

    for (int k = 0; k < p.Length; k++)
    {
        var pi = p[k];
        var length = q[k] - pi + 1;
        var subStr = s.Substring(pi, length);

        if (subStr.Contains('A'))
        {
            r[k] = 1;
        }
        else if (subStr.Contains('C'))
        {
            r[k] = 2;
        }
        else if (subStr.Contains('G'))
        {
            r[k] = 3;
        }
        else
        {
            r[k] = 4;
        }
    }

    return r;
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Genomic Range Query

defmodule GenomicRangeQuery do
  def genomic_range_query(s, p, q) do
    p
    |> Enum.zip(q)
    |> Enum.map(fn {pi, qi} ->
      substr = String.slice(s, pi, qi - pi + 1)

      cond do
        String.contains?(substr, "A") -> 1
        String.contains?(substr, "C") -> 2
        String.contains?(substr, "G") -> 3
        true -> 4
      end
    end)
  end
end

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Genomic Range Query

-module(genomic_range_query).
-export([genomic_range_query/3]).

genomic_range_query(S, P, Q) ->
    [classify(string:slice(S, Pi, Qi - Pi + 1)) || {Pi, Qi} <- lists:zip(P, Q)].

classify(Sub) ->
    case lists:member($A, Sub) of
        true -> 1;
        false ->
            case lists:member($C, Sub) of
                true -> 2;
                false ->
                    case lists:member($G, Sub) of
                        true -> 3;
                        false -> 4
                    end
            end
    end.

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Go Genomic Range Query

func genomicRangeQuery(s string, p, q []int) []int {
	result := make([]int, len(p))

	for k, pi := range p {
		sub := s[pi : q[k]+1]
		switch {
		case strings.Contains(sub, "A"):
			result[k] = 1
		case strings.Contains(sub, "C"):
			result[k] = 2
		case strings.Contains(sub, "G"):
			result[k] = 3
		default:
			result[k] = 4
		}
	}

	return result
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Genomic Range Query

genomicRangeQuery :: String -> [Int] -> [Int] -> [Int]
genomicRangeQuery s p q = [classify (substr pi' qi) | (pi', qi) <- zip p q]
  where
    substr pi' qi = take (qi - pi' + 1) (drop pi' s)
    classify sub
      | 'A' `elem` sub = 1
      | 'C' `elem` sub = 2
      | 'G' `elem` sub = 3
      | otherwise      = 4

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Java Genomic Range Query

public class Solution {
    public static int[] genomicRangeQuery(String s, int[] p, int[] q) {
        int[] r = new int[p.length];

        for (int k = 0; k < p.length; k++) {
            int pi = p[k];
            int qi = q[k] - pi + 1;
            String subStr = s.substring(pi, pi + qi);

            if (subStr.contains("A")) {
                r[k] = 1;
            } else if (subStr.contains("C")) {
                r[k] = 2;
            } else if (subStr.contains("G")) {
                r[k] = 3;
            } else {
                r[k] = 4;
            }
        }

        return r;
    }
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Genomic Range Query

(defun genomic-range-query (s p q)
  (loop for pi in p
        for qi in q
        collect (let ((sub (subseq s pi (1+ qi))))
                  (cond
                    ((find #\A sub) 1)
                    ((find #\C sub) 2)
                    ((find #\G sub) 3)
                    (t 4)))))

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

PHP Genomic Range Query

function genomicRangeQuery(string $s, array $p, array $q): array
{
    $r = [];
    foreach ($p as $k => $pi) {
        $qi     = $q[$k] - $pi + 1;
        $subStr = substr($s, $pi, $qi);
        if (str_contains($subStr, 'A')) {
            $r[] = 1;
        } elseif (str_contains($subStr, 'C')) {
            $r[] = 2;
        } elseif (str_contains($subStr, 'G')) {
            $r[] = 3;
        } else {
            $r[] = 4;
        }
    }

    return $r;
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Python Genomic Range Query

def genomic_range_query(s: str, p: list[int], q: list[int]) -> list[int]:
    result = []
    for pi, qi in zip(p, q):
        sub = s[pi:qi + 1]
        if "A" in sub:
            result.append(1)
        elif "C" in sub:
            result.append(2)
        elif "G" in sub:
            result.append(3)
        else:
            result.append(4)

    return result

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Rust Genomic Range Query

fn genomic_range_query(s: &str, p: &[usize], q: &[usize]) -> Vec<i64> {
    let chars: Vec<char> = s.chars().collect();
    p.iter()
        .zip(q.iter())
        .map(|(&pi, &qi)| {
            let sub = &chars[pi..=qi];
            if sub.contains(&'A') {
                1
            } else if sub.contains(&'C') {
                2
            } else if sub.contains(&'G') {
                3
            } else {
                4
            }
        })
        .collect()
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Genomic Range Query

function genomicRangeQuery(s: string, p: number[], q: number[]): number[] {
  const r: number[] = [];

  for (let k = 0; k < p.length; k++) {
    const subStr = s.slice(p[k], q[k] + 1);
    if (subStr.includes("A")) {
      r.push(1);
    } else if (subStr.includes("C")) {
      r.push(2);
    } else if (subStr.includes("G")) {
      r.push(3);
    } else {
      r.push(4);
    }
  }

  return r;
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Bash Is Ipv 4 Adress

is_ipv4_address() {
    local _s=$1
    local -a _parts
    IFS='.' read -ra _parts <<< "$_s"
    if (( ${#_parts[@]} != 4 )); then echo false; return; fi
    local _v
    for _v in "${_parts[@]}"; do
        if [[ -z "$_v" ]] || ! [[ "$_v" =~ ^[0-9]+$ ]]; then
            echo false; return
        fi
        if (( ${#_v} > 1 && ${_v:0:1} == 0 )); then
            echo false; return
        fi
        if (( _v > 255 )); then
            echo false; return
        fi
    done
    echo true
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

C++ Is Ipv 4 Adress

#include <algorithm>
#include <cctype>
#include <string>
#include <vector>

bool isIPv4Address(const std::string& inputString)
{
    std::vector<std::string> parts;
    std::string cur;
    for (char c : inputString) {
        if (c == '.') {
            parts.push_back(cur);
            cur.clear();
        } else {
            cur += c;
        }
    }
    parts.push_back(cur);

    for (const auto& v : parts) {
        if (v.empty() || !std::all_of(v.begin(), v.end(), [](unsigned char c) { return std::isdigit(c); })) {
            return false;
        }
        if (v.size() > 1 && v[0] == '0') {
            return false; // rejects leading zeros, mirrors $v !== (string)(int)$v
        }
        if (std::stol(v) > 255) {
            return false;
        }
    }

    return parts.size() == 4;
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

C# Is Ipv 4 Adress

static bool IsIPv4Address(string inputString)
{
    var parts = inputString.Split('.');

    foreach (var v in parts)
    {
        if (!long.TryParse(v, out var n) || n > 255 || v == "" || v != n.ToString())
        {
            return false;
        }
    }

    return parts.Length == 4;
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Is Ipv 4 Adress

defmodule IsIpv4Address do
  def is_ipv4_address(input_string) do
    parts = String.split(input_string, ".")

    length(parts) == 4 and Enum.all?(parts, &valid_octet?/1)
  end

  defp valid_octet?(v) do
    case Integer.parse(v) do
      {n, ""} -> n >= 0 and n <= 255 and Integer.to_string(n) == v
      _ -> false
    end
  end
end

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Is Ipv 4 Adress

-module(is_ipv4_address).
-export([is_ipv4_address/1]).

is_ipv4_address(InputString) ->
    Parts = string:split(InputString, ".", all),
    length(Parts) =:= 4 andalso lists:all(fun valid_octet/1, Parts).

valid_octet(V) ->
    case string:to_integer(V) of
        {Int, ""} when Int >= 0, Int =< 255 ->
            integer_to_list(Int) =:= V;
        _ ->
            false
    end.

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Go Is Ipv 4 Adress

func isIPv4Address(inputString string) bool {
	parts := strings.Split(inputString, ".")
	if len(parts) != 4 {
		return false
	}

	for _, part := range parts {
		n, err := strconv.Atoi(part)
		if err != nil || n > 255 || strconv.Itoa(n) != part {
			return false
		}
	}

	return true
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Is Ipv 4 Adress

isIPv4Address :: String -> Bool
isIPv4Address s = length parts == 4 && all valid parts
  where
    parts = splitOn '.' s

    splitOn c str = foldr step [""] str
      where
        step ch acc@(cur : rest)
          | ch == c   = "" : acc
          | otherwise = (ch : cur) : rest

    valid p =
      not (null p)
        && all (`elem` ['0' .. '9']) p
        && case reads p :: [(Int, String)] of
             [(n, "")] -> n <= 255 && show n == p
             _         -> False

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Java Is Ipv 4 Adress

public class Solution {
    public static boolean isIPv4Address(String inputString) {
        String[] a = inputString.split("\\.", -1);

        for (String v : a) {
            if (v.isEmpty() || v.length() > 3 || !v.matches("\\d+")) {
                return false;
            }
            int num = Integer.parseInt(v);
            if (num > 255 || !String.valueOf(num).equals(v)) {
                return false;
            }
        }

        return a.length == 4;
    }
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Is Ipv 4 Adress

(defun split-on-char (s ch)
  (loop with start = 0
        for pos = (position ch s :start start)
        collect (subseq s start pos)
        while pos
        do (setf start (1+ pos))))

(defun is-ipv4-address (input-string)
  (let ((parts (split-on-char input-string #\.)))
    (and (= (length parts) 4)
         (every (lambda (v)
                  (and (> (length v) 0)
                       (every #'digit-char-p v)
                       (<= (parse-integer v) 255)
                       (string= v (write-to-string (parse-integer v)))))
                parts))))

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

PHP Is Ipv 4 Adress

function isIPv4Address($inputString)
{
    $a = explode('.', $inputString);
    foreach ($a as $k => $v) {
        if ( ! is_numeric($v) || $v > 255 || $v === '' || $v !== (string)(int)$v) {
            return false;
        }
    }

    return count($a) === 4;
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Python Is Ipv 4 Adress

def is_ipv4_address(input_string: str) -> bool:
    parts = input_string.split(".")
    if len(parts) != 4:
        return False

    for v in parts:
        try:
            n = int(v)
        except ValueError:
            return False
        if n > 255 or v == "" or v != str(n):
            return False

    return True

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Rust Is Ipv 4 Adress

fn is_ipv_4_adress(input_string: &str) -> bool {
    let parts: Vec<&str> = input_string.split('.').collect();
    if parts.len() != 4 {
        return false;
    }

    for part in &parts {
        match part.parse::<i64>() {
            Ok(n) => {
                if n > 255 || part.to_string() != n.to_string() {
                    return false;
                }
            }
            Err(_) => return false,
        }
    }

    true
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Is Ipv 4 Adress

function isIPv4Address(inputString: string): boolean {
  const parts = inputString.split(".");

  for (const v of parts) {
    const n = Number(v);
    if (v === "" || Number.isNaN(n) || n > 255 || v !== String(Math.trunc(n))) {
      return false;
    }
  }

  return parts.length === 4;
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Bash Ladder

ladder() {
    local -n _aArr="$1"
    local -n _bArr="$2"
    local -n _outArr="$3"
    local _size=${#_aArr[@]}
    local _maxB
    _maxB=$(printf '%s\n' "${_bArr[@]}" | sort -n | tail -1)
    local _mod=$(( (1 << _maxB) - 1 ))
    local _limitA
    _limitA=$(printf '%s\n' "${_aArr[@]}" | sort -n | tail -1)
    local -a _fib=(0 1)
    local _i
    for ((_i = 2; _i < _limitA + 2; _i++)); do
        _fib[_i]=$(( (_fib[_i-1] + _fib[_i-2]) & _mod ))
    done
    _outArr=()
    for ((_i = 0; _i < _size; _i++)); do
        _outArr[_i]=$(( _fib[_aArr[_i]+1] & ((1 << _bArr[_i]) - 1) ))
    done
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

C++ Ladder

#include <algorithm>
#include <vector>

std::vector<int> ladder(const std::vector<int>& a, const std::vector<int>& b)
{
    std::size_t size = a.size();
    std::vector<int> r(size, 0);

    int maxB = *std::max_element(b.begin(), b.end());
    long long mod = (1LL << maxB) - 1;

    int maxA = *std::max_element(a.begin(), a.end());
    std::vector<long long> fib(maxA + 2, 0);
    fib[1] = 1;
    for (int i = 2; i < maxA + 2; ++i) {
        fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
    }

    for (std::size_t i = 0; i < size; ++i) {
        r[i] = static_cast<int>(fib[a[i] + 1] & ((1LL << b[i]) - 1));
    }

    return r;
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

C# Ladder

static int[] Ladder(int[] a, int[] b)
{
    var size = a.Length;
    var r = new int[size];
    var mod = (1 << b.Max()) - 1;

    var limit = a.Max();
    var fib = new int[limit + 2];
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i < limit + 2; i++)
    {
        fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
    }

    for (int i = 0; i < size; i++)
    {
        r[i] = fib[a[i] + 1] & ((1 << b[i]) - 1);
    }

    return r;
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Ladder

defmodule Ladder do
  import Bitwise

  def ladder(a, b) do
    mod = (1 <<< Enum.max(b)) - 1
    limit = Enum.max(a)
    fib = build_fib(limit, mod)

    a
    |> Enum.zip(b)
    |> Enum.map(fn {ai, bi} -> Map.get(fib, ai + 1) &&& (1 <<< bi) - 1 end)
  end

  defp build_fib(limit, mod) do
    Enum.reduce(2..(limit + 1)//1, %{0 => 0, 1 => 1}, fn i, fib ->
      value = (Map.get(fib, i - 1) + Map.get(fib, i - 2)) &&& mod
      Map.put(fib, i, value)
    end)
  end
end

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Ladder

-module(ladder).
-export([ladder/2]).

%% Erlang integers are arbitrary precision, so unlike the PHP version we
%% don't need to mask the running Fibonacci total against max(B) on every
%% step to dodge overflow; masking once at the end with each B(i) is enough.
ladder(A, B) ->
    MaxA = lists:max(A),
    Fib = build_fib(MaxA),
    [array:get(Ai + 1, Fib) band ((1 bsl Bi) - 1) || {Ai, Bi} <- lists:zip(A, B)].

build_fib(Limit) ->
    Arr0 = array:set(1, 1, array:set(0, 0, array:new(Limit + 2))),
    build_fib(2, Limit + 1, Arr0).

build_fib(I, Limit, Arr) when I > Limit ->
    Arr;
build_fib(I, Limit, Arr) ->
    V = array:get(I - 1, Arr) + array:get(I - 2, Arr),
    build_fib(I + 1, Limit, array:set(I, V, Arr)).

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Go Ladder

func ladder(a, b []int) []int {
	size := len(a)
	result := make([]int, size)

	maxB := b[0]
	for _, v := range b {
		if v > maxB {
			maxB = v
		}
	}
	mod := (1 << maxB) - 1

	maxA := a[0]
	for _, v := range a {
		if v > maxA {
			maxA = v
		}
	}

	fib := make([]int, maxA+2)
	fib[0], fib[1] = 0, 1
	for i := 2; i < maxA+2; i++ {
		fib[i] = (fib[i-1] + fib[i-2]) & mod
	}

	for i := 0; i < size; i++ {
		result[i] = fib[a[i]+1] & ((1 << b[i]) - 1)
	}

	return result
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Ladder

import Data.Array (Array, listArray, (!))
import Data.Bits (shiftL, (.&.))

ladder :: [Int] -> [Int] -> [Int]
ladder a b = [fibArr ! (ai + 1) .&. ((1 `shiftL` bi) - 1) | (ai, bi) <- zip a b]
  where
    maxA       = maximum a
    globalMask = (1 `shiftL` maximum b) - 1
    fibs       = 0 : 1 : zipWith (\x y -> (x + y) .&. globalMask) fibs (tail fibs)
    fibArr     = listArray (0, maxA + 1) (take (maxA + 2) fibs) :: Array Int Int

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Java Ladder

import java.util.Arrays;

public class Solution {
    public static int[] ladder(int[] a, int[] b) {
        int size = a.length;
        int[] r = new int[size];
        int maxB = Arrays.stream(b).max().orElse(0);
        int mod = (1 << maxB) - 1;

        int maxA = Arrays.stream(a).max().orElse(0);
        int[] fib = new int[maxA + 2];
        fib[0] = 0;
        fib[1] = 1;
        for (int i = 2; i < maxA + 2; i++) {
            fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
        }

        for (int i = 0; i < size; i++) {
            r[i] = fib[a[i] + 1] & ((1 << b[i]) - 1);
        }

        return r;
    }
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Ladder

(defun ladder (a b)
  (let* ((veca (coerce a 'vector))
         (vecb (coerce b 'vector))
         (size (length veca))
         (modulus (1- (ash 1 (reduce #'max vecb))))
         (limit (reduce #'max veca))
         (fib (make-array (+ limit 2) :initial-element 0)))
    (setf (aref fib 1) 1)
    (loop for i from 2 below (+ limit 2)
          do (setf (aref fib i) (logand (+ (aref fib (1- i)) (aref fib (- i 2))) modulus)))
    (loop for i from 0 below size
          collect (logand (aref fib (1+ (aref veca i))) (1- (ash 1 (aref vecb i)))))))

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

PHP Ladder

function ladder(array $a, array $b): array
{
    $size     = count($a);
    $r        = array_fill(0, $size, 0);
    $mod = (1 << max($b)) - 1;

    $fib = [0, 1];
    for ($i = 2, $limit = max($a); $i < $limit + 2; $i++) {
        $fib[$i] = ($fib[$i - 1] + $fib[$i - 2]) & $mod;
    }

    for ($i = 0; $i < $size; $i++) {
        $r[$i] = $fib[$a[$i] + 1] & ((1 << $b[$i]) - 1);
    }

    return $r;
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Python Ladder

def ladder(a: list[int], b: list[int]) -> list[int]:
    size = len(a)
    mod = (1 << max(b)) - 1

    fib = [0, 1]
    for i in range(2, max(a) + 2):
        fib.append((fib[i - 1] + fib[i - 2]) & mod)

    result = [0] * size
    for i in range(size):
        result[i] = fib[a[i] + 1] & ((1 << b[i]) - 1)

    return result

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Rust Ladder

fn ladder(a: &[i64], b: &[i64]) -> Vec<i64> {
    let size = a.len();
    let mut r = vec![0i64; size];

    let max_b = *b.iter().max().unwrap();
    let mod_mask = (1i64 << max_b) - 1;

    let max_a = *a.iter().max().unwrap();
    let mut fib = vec![0i64, 1];
    for i in 2..(max_a as usize + 2) {
        fib.push((fib[i - 1] + fib[i - 2]) & mod_mask);
    }

    for i in 0..size {
        r[i] = fib[(a[i] + 1) as usize] & ((1i64 << b[i]) - 1);
    }

    r
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Ladder

function ladder(a: number[], b: number[]): number[] {
  const size = a.length;
  const r: number[] = new Array(size).fill(0);
  const mod = (1 << Math.max(...b)) - 1;

  const fib: number[] = [0, 1];
  const limit = Math.max(...a);
  for (let i = 2; i < limit + 2; i++) {
    fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
  }

  for (let i = 0; i < size; i++) {
    r[i] = fib[a[i] + 1] & ((1 << b[i]) - 1);
  }

  return r;
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Bash Largest String

largest_string() {
    local _s=$1
    local -a _c
    local _i _len=${#_s}
    for ((_i = 0; _i < _len; _i++)); do _c[_i]=${_s:_i:1}; done
    local _cur=""
    for ((_i = _len - 1; _i >= 0; _i--)); do
        _cur="${_c[_i]}${_cur}"
        if (( ${#_cur} == 3 )); then
            if [[ "$_cur" == "abb" ]]; then
                _c[_i]="b"; _c[_i+1]="a"; _c[_i+2]="a"
                if [[ -n "${_c[_i+4]:-}" && "${_c[_i+4]}" == "b" ]]; then
                    _i=$(( _i + 4 + 1 ))
                elif [[ -n "${_c[_i+3]:-}" && "${_c[_i+3]}" == "b" ]]; then
                    _i=$(( _i + 3 + 1 ))
                elif [[ "${_c[_i+2]}" == "b" ]]; then
                    _i=$(( _i + 2 + 1 ))
                fi
            fi
            if [[ "${_c[_i+1]}" == "b" ]]; then
                _i=$(( _i + 1 + 1 ))
            else
                ((_i++))
            fi
            _cur=""
        fi
    done
    local _out=""
    for ((_i = 0; _i < _len; _i++)); do _out="${_out}${_c[_i]}"; done
    echo "$_out"
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

C++ Largest String

#include <string>

std::string largestString(std::string s)
{
    int len = static_cast<int>(s.size());
    std::string cur;

    for (int i = len - 1; i >= 0; --i) {
        cur = s[i] + cur;

        if (cur.size() == 3) {
            if (cur == "abb") {
                s[i] = 'b';
                s[i + 1] = 'a';
                s[i + 2] = 'a';
                if (i + 4 < len && s[i + 4] == 'b') {
                    i += 4 + 1;
                } else if (i + 3 < len && s[i + 3] == 'b') {
                    i += 3 + 1;
                } else if (s[i + 2] == 'b') {
                    i += 2 + 1;
                }
            }
            if (i + 1 < len && s[i + 1] == 'b') {
                i += 1 + 1;
            } else {
                ++i;
            }
            cur.clear();
        }
    }

    return s;
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

C# Largest String

static string LargestString(string s)
{
    var chars = s.ToCharArray();
    var len = chars.Length;
    var cur = "";

    for (int i = len - 1; i >= 0; i--)
    {
        cur = chars[i] + cur;

        if (cur.Length == 3)
        {
            if (cur == "abb")
            {
                chars[i] = 'b';
                chars[i + 1] = 'a';
                chars[i + 2] = 'a';

                if (i + 4 < len && chars[i + 4] == 'b')
                {
                    i += 4 + 1;
                }
                else if (i + 3 < len && chars[i + 3] == 'b')
                {
                    i += 3 + 1;
                }
                else if (chars[i + 2] == 'b')
                {
                    i += 2 + 1;
                }
            }

            if (chars[i + 1] == 'b')
            {
                i += 1 + 1;
            }
            else
            {
                i++;
            }
            cur = "";
        }
    }

    return new string(chars);
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Largest String

defmodule LargestString do
  def largest_string(s) do
    s
    |> String.to_charlist()
    |> Enum.chunk_by(&(&1 in ~c"ab"))
    |> Enum.map(&sort_segment/1)
    |> List.flatten()
    |> List.to_string()
  end

  defp sort_segment([c | _] = segment) when c in ~c"ab" do
    Enum.sort(segment, :desc)
  end

  defp sort_segment(segment), do: segment
end

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Largest String

-module(largest_string).
-export([largest_string/1]).

largest_string(S) ->
    Len = length(S),
    Arr0 = array:from_list(S),
    ArrFinal = process(Len - 1, Arr0, Len),
    array:to_list(ArrFinal).

%% Fewer than 3 characters remain before the current position, so no more
%% "abb" windows can be completed.
process(P, Arr, _Len) when P < 2 ->
    Arr;
process(P, Arr, Len) ->
    I = P - 2,
    {Arr1, I2} = handle_triple(I, Arr, Len),
    process(I2 - 1, Arr1, Len).

handle_triple(I, Arr, Len) ->
    Window = [array:get(I, Arr), array:get(I + 1, Arr), array:get(I + 2, Arr)],
    case Window of
        "abb" ->
            Arr1 = array:set(I, $b, array:set(I + 1, $a, array:set(I + 2, $a, Arr))),
            I1 = advance_on_b(I, Arr1, Len),
            final_adjust(I1, Arr1, Len);
        _ ->
            final_adjust(I, Arr, Len)
    end.

advance_on_b(I, Arr, Len) ->
    case I + 4 < Len andalso array:get(I + 4, Arr) =:= $b of
        true -> I + 4 + 1;
        false ->
            case I + 3 < Len andalso array:get(I + 3, Arr) =:= $b of
                true -> I + 3 + 1;
                false -> I
            end
    end.

final_adjust(I, Arr, Len) ->
    case I + 1 < Len andalso array:get(I + 1, Arr) =:= $b of
        true -> {Arr, I + 2};
        false -> {Arr, I + 1}
    end.

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Go Largest String

func largestString(s string) string {
	b := []byte(s)
	length := len(b)
	cur := ""

	for i := length - 1; i >= 0; i-- {
		cur = string(b[i]) + cur

		if len(cur) == 3 {
			if cur == "abb" {
				b[i] = 'b'
				b[i+1] = 'a'
				b[i+2] = 'a'
				if i+4 < length && b[i+4] == 'b' {
					i += 4 + 1
				} else if i+3 < length && b[i+3] == 'b' {
					i += 3 + 1
				} else if b[i+2] == 'b' {
					i += 2 + 1
				}
			}
			if b[i+1] == 'b' {
				i += 1 + 1
			} else {
				i++
			}
			cur = ""
		}
	}

	return string(b)
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Largest String

import Data.Array (Array, bounds, elems, listArray, (!), (//))

largestString :: String -> String
largestString s0 = elems (go (len - 1) arr0 "")
  where
    len  = length s0
    arr0 = listArray (0, len - 1) s0 :: Array Int Char

    safeAt arr idx
      | idx >= 0 && idx <= snd (bounds arr) = Just (arr ! idx)
      | otherwise                           = Nothing

    go i arr cur
      | i < 0 = arr
      | otherwise =
          let cur1 = (arr ! i) : cur
          in  if length cur1 == 3
                then
                  let (arr1, i1) = handleTriplet i arr cur1
                      i2         = adjustEnd i1 arr1
                  in  go (i2 - 1) arr1 ""
                else go (i - 1) arr cur1

    handleTriplet i arr cur
      | cur == "abb" =
          let arr' = arr // [(i, 'b'), (i + 1, 'a'), (i + 2, 'a')]
          in  (arr', skipIndex i arr')
      | otherwise = (arr, i)

    skipIndex i arr
      | safeAt arr (i + 4) == Just 'b' = i + 4 + 1
      | safeAt arr (i + 3) == Just 'b' = i + 3 + 1
      | arr ! (i + 2) == 'b'           = i + 2 + 1
      | otherwise                      = i

    adjustEnd i arr
      | safeAt arr (i + 1) == Just 'b' = i + 1 + 1
      | otherwise                      = i + 1

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Java Largest String

public class Solution {
    public static String largestString(String s) {
        char[] chars = s.toCharArray();
        int len = chars.length;
        StringBuilder cur = new StringBuilder();

        for (int i = len - 1; i >= 0; i--) {
            cur.insert(0, chars[i]);

            if (cur.length() == 3) {
                if (cur.toString().equals("abb")) {
                    chars[i] = 'b';
                    chars[i + 1] = 'a';
                    chars[i + 2] = 'a';
                    if (i + 4 < len && chars[i + 4] == 'b') {
                        i += 4 + 1;
                    } else if (i + 3 < len && chars[i + 3] == 'b') {
                        i += 3 + 1;
                    } else if (chars[i + 2] == 'b') {
                        i += 2 + 1;
                    }
                }
                if (chars[i + 1] == 'b') {
                    i += 1 + 1;
                } else {
                    ++i;
                }
                cur.setLength(0);
            }
        }

        return new String(chars);
    }
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Largest String

(defun largest-string (s)
  (let* ((str (copy-seq s))
         (len (length str))
         (cur "")
         (i (1- len)))
    (loop while (>= i 0)
          do (progn
               (setf cur (concatenate 'string (string (char str i)) cur))
               (when (= (length cur) 3)
                 (when (string= cur "abb")
                   (setf (char str i) #\b)
                   (setf (char str (+ i 1)) #\a)
                   (setf (char str (+ i 2)) #\a)
                   (cond
                     ((and (< (+ i 4) len) (char= (char str (+ i 4)) #\b))
                      (incf i (+ 4 1)))
                     ((and (< (+ i 3) len) (char= (char str (+ i 3)) #\b))
                      (incf i (+ 3 1)))
                     ((char= (char str (+ i 2)) #\b)
                      (incf i (+ 2 1)))))
                 (if (char= (char str (+ i 1)) #\b)
                     (incf i (+ 1 1))
                     (incf i))
                 (setf cur ""))
               (decf i)))
    str))

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

PHP Largest String

function largestString(string $s): string
{
    $len = strlen($s);
    $cur = '';

    for ($i = $len - 1; $i >= 0; $i--) {
        $cur = $s[$i] . $cur;

        if (strlen($cur) === 3) {
            if ($cur === 'abb') {
                $s[$i]     = 'b';
                $s[$i + 1] = 'a';
                $s[$i + 2] = 'a';
                if (isset($s[$i + 4]) && $s[$i + 4] === 'b') {
                    $i += 4 + 1;
                } elseif (isset($s[$i + 3]) && $s[$i + 3] === 'b') {
                    $i += 3 + 1;
                } elseif ($s[$i + 2] === 'b') {
                    $i += 2 + 1;
                }
            }
            if ($s[$i + 1] === 'b') {
                $i += 1 + 1;
            } else {
                ++$i;
            }
            $cur = '';
        }
    }

    return $s;
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Python Largest String

def largest_string(s: str) -> str:
    chars = list(s)
    length = len(chars)

    # instead of raising; this helper preserves that read behavior so the
    # lookahead checks below can't index past the end of the list.
    def char_at(idx: int) -> str:
        return chars[idx] if 0 <= idx < length else ""

    cur = ""
    i = length - 1
    while i >= 0:
        cur = char_at(i) + cur

        if len(cur) == 3:
            if cur == "abb":
                chars[i] = "b"
                chars[i + 1] = "a"
                chars[i + 2] = "a"
                if char_at(i + 4) == "b":
                    i += 4 + 1
                elif char_at(i + 3) == "b":
                    i += 3 + 1
                elif chars[i + 2] == "b":
                    i += 2 + 1
            if char_at(i + 1) == "b":
                i += 1 + 1
            else:
                i += 1
            cur = ""
        i -= 1

    return "".join(chars)

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Rust Largest String

fn largest_string(s: &str) -> String {
    let mut bytes: Vec<u8> = s.bytes().collect();
    let len = bytes.len() as i64;
    let mut cur: Vec<u8> = Vec::new();

    let mut i = len - 1;
    while i >= 0 {
        cur.insert(0, bytes[i as usize]);

        if cur.len() == 3 {
            if cur == b"abb" {
                bytes[i as usize] = b'b';
                bytes[i as usize + 1] = b'a';
                bytes[i as usize + 2] = b'a';

                if bytes.get(i as usize + 4) == Some(&b'b') {
                    i += 4 + 1;
                } else if bytes.get(i as usize + 3) == Some(&b'b') {
                    i += 3 + 1;
                } else if bytes.get(i as usize + 2) == Some(&b'b') {
                    i += 2 + 1;
                }
            }
            if bytes.get(i as usize + 1) == Some(&b'b') {
                i += 1 + 1;
            } else {
                i += 1;
            }
            cur.clear();
        }

        i -= 1;
    }

    String::from_utf8(bytes).unwrap()
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Largest String

function largestString(s: string): string {
  const chars = s.split("");
  let cur = "";
  let i = chars.length - 1;

  while (i >= 0) {
    cur = chars[i] + cur;

    if (cur.length === 3) {
      if (cur === "abb") {
        chars[i] = "b";
        chars[i + 1] = "a";
        chars[i + 2] = "a";

        if (chars[i + 4] !== undefined && chars[i + 4] === "b") {
          i += 4 + 1;
        } else if (chars[i + 3] !== undefined && chars[i + 3] === "b") {
          i += 3 + 1;
        } else if (chars[i + 2] === "b") {
          i += 2 + 1;
        }
      }
      if (chars[i + 1] === "b") {
        i += 1 + 1;
      } else {
        i += 1;
      }
      cur = "";
    }

    i--;
  }

  return chars.join("");
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Counters

max_counters() {
    local _n=$1
    local -n _a="$2"
    local -n _out="$3"
    local -a _counters
    local _i
    for ((_i = 0; _i < _n; _i++)); do _counters[_i]=0; done
    local _maxCounter=0 _lastUpdate=0
    local _condition=$(( _n + 1 ))
    local _v
    for _v in "${_a[@]}"; do
        if (( _v <= _n )); then
            local _index=$(( _v - 1 ))
            if (( _counters[_index] < _lastUpdate )); then
                _counters[_index]=$_lastUpdate
            fi
            (( _counters[_index]++ ))
            (( _counters[_index] > _maxCounter )) && _maxCounter=${_counters[_index]}
        fi
        if (( _v == _condition )); then
            _lastUpdate=$_maxCounter
        fi
    done
    for _i in "${!_counters[@]}"; do
        if (( _counters[_i] < _lastUpdate )); then
            _counters[_i]=$_lastUpdate
        fi
    done
    _out=("${_counters[@]}")
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Counters

#include <algorithm>
#include <vector>

std::vector<int> maxCounters(int n, const std::vector<int>& a)
{
    std::vector<int> counters(n, 0);
    int maxCounter = 0;
    int lastUpdate = 0;
    int condition = n + 1;

    for (int v : a) {
        if (v <= n) {
            int index = v - 1;
            if (counters[index] < lastUpdate) {
                counters[index] = lastUpdate;
            }
            ++counters[index];
            maxCounter = std::max(maxCounter, counters[index]);
        }
        if (v == condition) {
            lastUpdate = maxCounter;
        }
    }

    for (int& c : counters) {
        if (c < lastUpdate) {
            c = lastUpdate;
        }
    }

    return counters;
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Counters

static int[] MaxCounters(int n, int[] a)
{
    var counters = new int[n];
    var maxCounter = 0;
    var lastUpdate = 0;
    var condition = n + 1;

    foreach (var v in a)
    {
        if (v <= n)
        {
            var index = v - 1;
            if (counters[index] < lastUpdate)
            {
                counters[index] = lastUpdate;
            }
            counters[index]++;
            maxCounter = Math.Max(counters[index], maxCounter);
        }
        if (v == condition)
        {
            lastUpdate = maxCounter;
        }
    }

    // apply all max operations to avoid O(M*N) complexity
    for (int k = 0; k < counters.Length; k++)
    {
        if (counters[k] < lastUpdate)
        {
            counters[k] = lastUpdate;
        }
    }

    return counters;
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Counters

defmodule MaxCounters do
  def max_counters(n, a) do
    condition = n + 1

    {counters, _max_counter, last_update} =
      Enum.reduce(a, {%{}, 0, 0}, fn v, {counters, max_counter, last_update} ->
        cond do
          v <= n ->
            index = v - 1
            updated = max(Map.get(counters, index, 0), last_update) + 1
            {Map.put(counters, index, updated), max(max_counter, updated), last_update}

          v == condition ->
            {counters, max_counter, max_counter}

          true ->
            {counters, max_counter, last_update}
        end
      end)

    0..(n - 1)
    |> Enum.map(fn i -> max(Map.get(counters, i, 0), last_update) end)
  end
end

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Counters

-module(max_counters).
-export([max_counters/2]).

max_counters(N, A) ->
    Condition = N + 1,
    {CountersMap, _MaxCounter, LastUpdate} = lists:foldl(fun(V, {Map, MaxC, Last}) ->
        case V of
            Condition ->
                {Map, MaxC, MaxC};
            _ when V =< N ->
                Index = V - 1,
                NewVal = max(maps:get(Index, Map, 0), Last) + 1,
                {maps:put(Index, NewVal, Map), max(MaxC, NewVal), Last};
            _ ->
                {Map, MaxC, Last}
        end
    end, {#{}, 0, 0}, A),
    [max(maps:get(I, CountersMap, 0), LastUpdate) || I <- lists:seq(0, N - 1)].

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Counters

func maxCounters(n int, a []int) []int {
	counters := make([]int, n)
	maxCounter := 0
	lastUpdate := 0
	condition := n + 1

	for _, v := range a {
		if v <= n {
			index := v - 1
			if counters[index] < lastUpdate {
				counters[index] = lastUpdate // should already be maxed
			}
			counters[index]++
			if counters[index] > maxCounter {
				maxCounter = counters[index]
			}
		}
		if v == condition {
			lastUpdate = maxCounter
		}
	}

	// apply all max operations to avoid O(M*N) complexity
	for k, v := range counters {
		if v < lastUpdate {
			counters[k] = lastUpdate
		}
	}

	return counters
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Max Counters

import Control.Monad (forM_, when)
import Control.Monad.ST (ST, runST)
import Data.Array.ST (STArray, getElems, newArray, readArray, writeArray)
import Data.STRef (newSTRef, readSTRef, writeSTRef)

maxCounters :: Int -> [Int] -> [Int]
maxCounters n a = runST $ do
  counters <- newArray (0, n - 1) 0 :: ST s (STArray s Int Int)
  maxRef   <- newSTRef 0
  lastRef  <- newSTRef 0
  forM_ a $ \v ->
    if v <= n
      then do
        let idx = v - 1
        lastUpdate <- readSTRef lastRef
        cur        <- readArray counters idx
        let cur' = max cur lastUpdate + 1
        writeArray counters idx cur'
        maxC <- readSTRef maxRef
        when (cur' > maxC) (writeSTRef maxRef cur')
      else
        when (v == n + 1) (readSTRef maxRef >>= writeSTRef lastRef)
  lastUpdate <- readSTRef lastRef
  finalCounters <- getElems counters
  return (map (max lastUpdate) finalCounters)

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Counters

public class Solution {
    public static int[] maxCounters(int n, int[] a) {
        int[] counters = new int[n];
        int maxCounter = 0;
        int lastUpdate = 0;
        int condition = n + 1;

        for (int v : a) {
            if (v <= n) {
                int index = v - 1;
                if (counters[index] < lastUpdate) {
                    counters[index] = lastUpdate;
                }
                counters[index]++;
                maxCounter = Math.max(counters[index], maxCounter);
            }
            if (v == condition) {
                lastUpdate = maxCounter;
            }
        }

        for (int k = 0; k < counters.length; k++) {
            if (counters[k] < lastUpdate) {
                counters[k] = lastUpdate;
            }
        }

        return counters;
    }
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Max Counters

(defun max-counters (n a)
  (let ((counters (make-array n :initial-element 0))
        (max-counter 0)
        (last-update 0)
        (condition (1+ n)))
    (dolist (v a)
      (when (<= v n)
        (let ((index (1- v)))
          (when (< (aref counters index) last-update)
            (setf (aref counters index) last-update))
          (incf (aref counters index))
          (setf max-counter (max max-counter (aref counters index)))))
      (when (= v condition)
        (setf last-update max-counter)))
    (dotimes (k n)
      (when (< (aref counters k) last-update)
        (setf (aref counters k) last-update)))
    (coerce counters 'list)))

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

PHP Max Counters

function maxCounters(int $n, array $a): array
{
    $counters   = array_fill(0, $n, 0);
    $maxCounter = 0;
    $lastUpdate = 0;
    $condition  = $n + 1;

    foreach ($a as $v) {
        if ($v <= $n) {
            $index = $v - 1;
            if ($counters[$index] < $lastUpdate) {
                $counters[$index] = $lastUpdate; // should already be maxed
            }
            $counters[$index]++;
            $maxCounter = $counters[$index] > $maxCounter ? $counters[$index] : $maxCounter;
        }
        if ($v === $condition) {
            $lastUpdate = $maxCounter;
        }
    }

    // apply all max operations to avoid O(M*N) complexity
    foreach ($counters as $k => $v) {
        if ($v < $lastUpdate) {
            $counters[$k] = $lastUpdate;
        }
    }

    return $counters;
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Counters

def max_counters(n: int, a: list[int]) -> list[int]:
    counters = [0] * n
    max_counter = 0
    last_update = 0
    condition = n + 1

    for v in a:
        if v <= n:
            index = v - 1
            if counters[index] < last_update:
                counters[index] = last_update
            counters[index] += 1
            max_counter = max(counters[index], max_counter)
        if v == condition:
            last_update = max_counter

    for k, v in enumerate(counters):
        if v < last_update:
            counters[k] = last_update

    return counters

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Counters

fn max_counters(n: i64, a: &[i64]) -> Vec<i64> {
    let mut counters = vec![0i64; n as usize];
    let mut max_counter = 0i64;
    let mut last_update = 0i64;
    let condition = n + 1;

    for &v in a {
        if v <= n {
            let index = (v - 1) as usize;
            if counters[index] < last_update {
                counters[index] = last_update;
            }
            counters[index] += 1;
            max_counter = max_counter.max(counters[index]);
        }
        if v == condition {
            last_update = max_counter;
        }
    }

    for c in counters.iter_mut() {
        if *c < last_update {
            *c = last_update;
        }
    }

    counters
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Counters

function maxCounters(n: number, a: number[]): number[] {
  const counters: number[] = new Array(n).fill(0);
  let maxCounter = 0;
  let lastUpdate = 0;
  const condition = n + 1;

  for (const v of a) {
    if (v <= n) {
      const index = v - 1;
      if (counters[index] < lastUpdate) {
        counters[index] = lastUpdate;
      }
      counters[index]++;
      maxCounter = counters[index] > maxCounter ? counters[index] : maxCounter;
    }
    if (v === condition) {
      lastUpdate = maxCounter;
    }
  }

  return counters.map((v) => (v < lastUpdate ? lastUpdate : v));
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Double Slice Sum

max_double_slice_sum() {
    local -n _arr="$1"
    local _size=${#_arr[@]}
    if (( _size < 3 )); then
        echo 0
        return
    fi
    local -a _p1 _p2
    _p1[1]=0
    _p2[_size-2]=0
    local _i
    for ((_i = 2; _i < _size - 1; _i++)); do
        local _left=$(( _p1[_i-1] + _arr[_i-1] ))
        (( _left < 0 )) && _left=0
        _p1[_i]=$_left
        local _right=$(( _p2[_size-_i] + _arr[_size-_i] ))
        (( _right < 0 )) && _right=0
        _p2[_size-_i-1]=$_right
    done
    local _sum=$(( _p1[1] + _p2[1] ))
    for ((_i = 1; _i < _size - 1; _i++)); do
        local _cand=$(( _p1[_i] + _p2[_i] ))
        if (( _cand > _sum )); then _sum=$_cand; fi
    done
    echo "$_sum"
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Double Slice Sum

#include <algorithm>
#include <vector>

long long maxDoubleSliceSum(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());
    if (size < 3) {
        return 0;
    }

    std::vector<long long> p1(size, 0);
    std::vector<long long> p2(size, 0);

    for (int i = 2; i < size - 1; ++i) {
        p1[i] = std::max<long long>(0, p1[i - 1] + a[i - 1]);
        p2[size - i - 1] = std::max<long long>(0, p2[size - i] + a[size - i]);
    }

    long long sum = p1[1] + p2[1];
    for (int i = 1; i < size - 1; ++i) {
        sum = std::max(sum, p1[i] + p2[i]);
    }

    return sum;
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Double Slice Sum

static long MaxDoubleSliceSum(int[] a)
{
    var size = a.Length;
    if (size < 3)
    {
        return 0;
    }

    var p1 = new long[size];
    var p2 = new long[size];
    p1[1] = 0;
    p2[size - 2] = 0;

    for (int i = 2; i < size - 1; i++)
    {
        p1[i] = Math.Max(0, p1[i - 1] + a[i - 1]);
        p2[size - i - 1] = Math.Max(0, p2[size - i] + a[size - i]);
    }

    var sum = p1[1] + p2[1];
    for (int i = 1; i < size - 1; i++)
    {
        sum = Math.Max(sum, p1[i] + p2[i]);
    }

    return sum;
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Double Slice Sum

defmodule MaxDoubleSliceSum do
  def max_double_slice_sum(a) when length(a) < 3, do: 0

  def max_double_slice_sum(a) do
    size = length(a)
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)

    p1 = build_p1(size, a_map)
    p2 = build_p2(size, a_map)

    1..(size - 2)
    |> Enum.map(fn i -> Map.get(p1, i) + Map.get(p2, i) end)
    |> Enum.max()
  end

  defp build_p1(size, a_map) do
    Enum.reduce(2..(size - 2)//1, %{1 => 0}, fn i, p1 ->
      value = max(0, Map.get(p1, i - 1) + Map.get(a_map, i - 1))
      Map.put(p1, i, value)
    end)
  end

  defp build_p2(size, a_map) do
    Enum.reduce(2..(size - 2)//1, %{size - 2 => 0}, fn i, p2 ->
      key = size - i - 1
      value = max(0, Map.get(p2, size - i) + Map.get(a_map, size - i))
      Map.put(p2, key, value)
    end)
  end
end

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Double Slice Sum

-module(max_double_slice_sum).
-export([max_double_slice_sum/1]).

max_double_slice_sum(A) ->
    Size = length(A),
    case Size < 3 of
        true -> 0;
        false ->
            Arr = array:from_list(A),
            P1 = build_p1(Arr, Size),
            P2 = build_p2(Arr, Size),
            lists:max([array:get(I, P1) + array:get(I, P2) || I <- lists:seq(1, Size - 2)])
    end.

build_p1(Arr, Size) ->
    P0 = array:set(1, 0, array:new(Size)),
    lists:foldl(fun(I, Acc) ->
        V = max(0, array:get(I - 1, Acc) + array:get(I - 1, Arr)),
        array:set(I, V, Acc)
    end, P0, lists:seq(2, Size - 2)).

build_p2(Arr, Size) ->
    P0 = array:set(Size - 2, 0, array:new(Size)),
    lists:foldl(fun(J, Acc) ->
        V = max(0, array:get(J + 1, Acc) + array:get(J + 1, Arr)),
        array:set(J, V, Acc)
    end, P0, lists:seq(Size - 3, 1, -1)).

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Double Slice Sum

func maxDoubleSliceSum(a []int) int {
	size := len(a)
	if size < 3 {
		return 0
	}

	p1 := make([]int, size)
	p2 := make([]int, size)
	p1[1] = 0
	p2[size-2] = 0

	for i := 2; i < size-1; i++ {
		if v := p1[i-1] + a[i-1]; v > 0 {
			p1[i] = v
		}
		if v := p2[size-i] + a[size-i]; v > 0 {
			p2[size-i-1] = v
		}
	}

	sum := p1[1] + p2[1]
	for i := 1; i < size-1; i++ {
		if s := p1[i] + p2[i]; s > sum {
			sum = s
		}
	}

	return sum
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Max Double Slice Sum

import Data.Array (Array, array, listArray, (!))

maxDoubleSliceSum :: [Int] -> Int
maxDoubleSliceSum a
  | n < 3     = 0
  | otherwise = maximum [p1 ! i + p2 ! i | i <- [1 .. n - 2]]
  where
    n   = length a
    arr = listArray (0, n - 1) a :: Array Int Int

    -- p1 ! i = best sum of a slice ending just before index i, growing left to right
    p1list = scanl (\acc i -> max 0 (acc + arr ! (i - 1))) 0 [2 .. n - 2]
    p1     = listArray (1, n - 2) p1list :: Array Int Int

    -- p2 ! i = best sum of a slice starting just after index i, growing right to left
    p2list = scanl (\acc k -> max 0 (acc + arr ! (k + 1))) 0 [n - 3, n - 4 .. 1]
    p2     = array (1, n - 2) (zip [n - 2, n - 3 .. 1] p2list) :: Array Int Int

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Double Slice Sum

public class Solution {
    public static int maxDoubleSliceSum(int[] a) {
        int size = a.length;
        if (size < 3) {
            return 0;
        }

        int[] p1 = new int[size];
        int[] p2 = new int[size];
        p1[1] = 0;
        p2[size - 2] = 0;

        for (int i = 2; i < size - 1; i++) {
            p1[i] = Math.max(0, p1[i - 1] + a[i - 1]);
            p2[size - i - 1] = Math.max(0, p2[size - i] + a[size - i]);
        }

        int sum = p1[1] + p2[1];
        for (int i = 1; i < size - 1; i++) {
            sum = Math.max(sum, p1[i] + p2[i]);
        }

        return sum;
    }
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Max Double Slice Sum

(defun max-double-slice-sum (a)
  (let* ((vec (coerce a 'vector))
         (size (length vec)))
    (if (< size 3)
        0
        (let ((p1 (make-array size :initial-element 0))
              (p2 (make-array size :initial-element 0)))
          (setf (aref p1 1) 0)
          (setf (aref p2 (- size 2)) 0)
          (loop for i from 2 below (1- size)
                do (progn
                     (setf (aref p1 i) (max 0 (+ (aref p1 (1- i)) (aref vec (1- i)))))
                     (setf (aref p2 (- size i 1)) (max 0 (+ (aref p2 (- size i)) (aref vec (- size i)))))))
          (let ((sum (+ (aref p1 1) (aref p2 1))))
            (loop for i from 1 below (1- size)
                  do (setf sum (max sum (+ (aref p1 i) (aref p2 i)))))
            sum)))))

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

PHP Max Double Slice Sum

function maxDoubleSliceSum(array $a): int
{
    $size = count($a);
    if ($size < 3) {
        return 0;
    }

    $p1[1]         = 0;
    $p2[$size - 2] = 0;

    for ($i = 2; $i < ($size - 1); $i++) {
        $p1[$i]             = max(0, $p1[$i - 1] + $a[$i - 1]);
        $p2[$size - $i - 1] = max(0, $p2[$size - $i] + $a[$size - $i]);
    }

    $sum = $p1[1] + $p2[1];
    for ($i = 1; $i < ($size - 1); $i++) {
        $sum = max($sum, $p1[$i] + $p2[$i]);
    }

    return $sum;
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Double Slice Sum

def max_double_slice_sum(a: list[int]) -> int:
    size = len(a)
    if size < 3:
        return 0

    p1 = {1: 0}
    p2 = {size - 2: 0}

    for i in range(2, size - 1):
        p1[i] = max(0, p1[i - 1] + a[i - 1])
        p2[size - i - 1] = max(0, p2[size - i] + a[size - i])

    total = p1[1] + p2[1]
    for i in range(1, size - 1):
        total = max(total, p1[i] + p2[i])

    return total

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Double Slice Sum

fn max_double_slice_sum(a: &[i64]) -> i64 {
    let size = a.len();
    if size < 3 {
        return 0;
    }

    let mut p1 = vec![0i64; size];
    let mut p2 = vec![0i64; size];

    for i in 2..size - 1 {
        p1[i] = 0.max(p1[i - 1] + a[i - 1]);
        p2[size - i - 1] = 0.max(p2[size - i] + a[size - i]);
    }

    let mut sum = p1[1] + p2[1];
    for i in 1..size - 1 {
        sum = sum.max(p1[i] + p2[i]);
    }

    sum
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Double Slice Sum

function maxDoubleSliceSum(a: number[]): number {
  const size = a.length;
  if (size < 3) {
    return 0;
  }

  const p1: number[] = new Array(size).fill(0);
  const p2: number[] = new Array(size).fill(0);
  p1[1] = 0;
  p2[size - 2] = 0;

  for (let i = 2; i < size - 1; i++) {
    p1[i] = Math.max(0, p1[i - 1] + a[i - 1]);
    p2[size - i - 1] = Math.max(0, p2[size - i] + a[size - i]);
  }

  let sum = p1[1] + p2[1];
  for (let i = 1; i < size - 1; i++) {
    sum = Math.max(sum, p1[i] + p2[i]);
  }

  return sum;
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Product Of Three

max_product_of_three() {
    local -n _a="$1"
    local -a _sorted=($(printf '%s\n' "${_a[@]}" | sort -n))
    local _c=${#_sorted[@]}
    local _p1=$(( _sorted[_c-1] * _sorted[_c-2] * _sorted[_c-3] ))
    local _p2=$(( _sorted[0] * _sorted[1] * _sorted[_c-1] ))
    if (( _p1 > _p2 )); then echo "$_p1"; else echo "$_p2"; fi
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Product Of Three

#include <algorithm>
#include <vector>

long long maxProductOfThree(std::vector<int> a)
{
    std::sort(a.begin(), a.end());
    int c = static_cast<int>(a.size());

    long long topThree = static_cast<long long>(a[c - 1]) * a[c - 2] * a[c - 3];
    long long twoLowestAndTop = static_cast<long long>(a[0]) * a[1] * a[c - 1];

    return std::max(topThree, twoLowestAndTop);
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Product Of Three

static long MaxProductOfThree(int[] a)
{
    var sorted = (int[])a.Clone();
    Array.Sort(sorted);
    var c = sorted.Length;

    return Math.Max(
        (long)sorted[c - 1] * sorted[c - 2] * sorted[c - 3],
        (long)sorted[0] * sorted[1] * sorted[c - 1]
    );
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Product Of Three

defmodule MaxProductOfThree do
  def max_product_of_three(a) do
    sorted = Enum.sort(a)
    c = length(sorted)

    max(
      Enum.at(sorted, c - 1) * Enum.at(sorted, c - 2) * Enum.at(sorted, c - 3),
      Enum.at(sorted, 0) * Enum.at(sorted, 1) * Enum.at(sorted, c - 1)
    )
  end
end

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Product Of Three

-module(max_product_of_three).
-export([max_product_of_three/1]).

max_product_of_three(A) ->
    Sorted = lists:sort(A),
    N = length(Sorted),
    Top3 = lists:nth(N, Sorted) * lists:nth(N - 1, Sorted) * lists:nth(N - 2, Sorted),
    TwoLowOneHigh = lists:nth(1, Sorted) * lists:nth(2, Sorted) * lists:nth(N, Sorted),
    max(Top3, TwoLowOneHigh).

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Product Of Three

func maxProductOfThree(a []int) int {
	sorted := append([]int(nil), a...)
	sort.Ints(sorted)
	c := len(sorted)

	return max(sorted[c-1]*sorted[c-2]*sorted[c-3], sorted[0]*sorted[1]*sorted[c-1])
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Max Product Of Three

import Data.List (sort)

maxProductOfThree :: [Int] -> Int
maxProductOfThree a =
  max (s !! (n - 1) * s !! (n - 2) * s !! (n - 3)) (s !! 0 * s !! 1 * s !! (n - 1))
  where
    s = sort a
    n = length s

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Product Of Three

import java.util.Arrays;

public class Solution {
    public static long maxProductOfThree(int[] a) {
        int[] sorted = a.clone();
        Arrays.sort(sorted);
        int c = sorted.length;

        long p1 = (long) sorted[c - 1] * sorted[c - 2] * sorted[c - 3];
        long p2 = (long) sorted[0] * sorted[1] * sorted[c - 1];

        return Math.max(p1, p2);
    }
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Max Product Of Three

(defun max-product-of-three (a)
  (let* ((sorted (sort (copy-list a) #'<))
         (vec (coerce sorted 'vector))
         (c (length vec)))
    (max (* (aref vec (- c 1)) (aref vec (- c 2)) (aref vec (- c 3)))
         (* (aref vec 0) (aref vec 1) (aref vec (- c 1))))))

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

PHP Max Product Of Three

function maxProductOfThree(array $a): int
{
    sort($a);
    $c = count($a);

    return max($a[$c - 1] * $a[$c - 2] * $a[$c - 3], $a[0] * $a[1] * $a[$c - 1]);
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Product Of Three

def max_product_of_three(a: list[int]) -> int:
    a = sorted(a)
    c = len(a)

    return max(a[c - 1] * a[c - 2] * a[c - 3], a[0] * a[1] * a[c - 1])

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Product Of Three

fn max_product_of_three(mut a: Vec<i64>) -> i64 {
    a.sort();
    let c = a.len();

    (a[c - 1] * a[c - 2] * a[c - 3]).max(a[0] * a[1] * a[c - 1])
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Product Of Three

function maxProductOfThree(a: number[]): number {
  const sorted = [...a].sort((x, y) => x - y);
  const c = sorted.length;

  return Math.max(
    sorted[c - 1] * sorted[c - 2] * sorted[c - 3],
    sorted[0] * sorted[1] * sorted[c - 1]
  );
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Profit

max_profit() {
    local -n _a="$1"
    local _price=${_a[0]} _profit=0 _v
    for _v in "${_a[@]}"; do
        (( _v < _price )) && _price=$_v
        local _cur=$(( _v - _price ))
        (( _cur > _profit )) && _profit=$_cur
    done
    echo "$_profit"
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Profit

#include <algorithm>
#include <vector>

long long maxProfit(const std::vector<int>& a)
{
    long long price = a[0];
    long long profit = 0;

    for (int v : a) {
        price = std::min(price, static_cast<long long>(v));
        profit = std::max(profit, v - price);
    }

    return profit;
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Profit

static int MaxProfit(int[] a)
{
    var price = a[0];
    var profit = 0;

    foreach (var v in a)
    {
        price = Math.Min(price, v);
        profit = Math.Max(profit, v - price);
    }

    return profit;
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Profit

defmodule MaxProfit do
  def max_profit([first | _] = a) do
    {_min_price, profit} =
      Enum.reduce(a, {first, 0}, fn v, {min_price, profit} ->
        min_price = min(min_price, v)
        {min_price, max(profit, v - min_price)}
      end)

    profit
  end
end

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Profit

-module(max_profit).
-export([max_profit/1]).

max_profit([H | T]) ->
    {_, Profit} = lists:foldl(fun(V, {MinPrice, MaxProfit}) ->
        MinPrice1 = min(MinPrice, V),
        {MinPrice1, max(MaxProfit, V - MinPrice1)}
    end, {H, 0}, T),
    Profit.

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Profit

func maxProfit(a []int) int {
	price := a[0]
	profit := 0

	for _, v := range a {
		if v < price {
			price = v
		}
		if v-price > profit {
			profit = v - price
		}
	}

	return profit
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Max Profit

maxProfit :: [Int] -> Int
maxProfit a = snd (foldl step (head a, 0) a)
  where
    step (price, profit) v =
      let price' = min price v
      in  (price', max profit (v - price'))

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Profit

public class Solution {
    public static int maxProfit(int[] a) {
        int price = a[0];
        int profit = 0;

        for (int v : a) {
            price = Math.min(price, v);
            profit = Math.max(profit, v - price);
        }

        return profit;
    }
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Max Profit

(defun max-profit (a)
  (let ((price (first a))
        (profit 0))
    (dolist (v a)
      (setf price (min price v))
      (setf profit (max profit (- v price))))
    profit))

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

PHP Max Profit

function maxProfit(array $a): int
{
    $price = $a[0];
    $profit   = 0;
    foreach ($a as $v) {
        $price = min($price, $v);
        $profit   = max($profit, $v - $price);
    }

    return $profit;

}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Profit

def max_profit(a: list[int]) -> int:
    price = a[0]
    profit = 0
    for v in a:
        price = min(price, v)
        profit = max(profit, v - price)

    return profit

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Profit

fn max_profit(a: &[i64]) -> i64 {
    let mut price = a[0];
    let mut profit = 0i64;
    for &v in a {
        price = price.min(v);
        profit = profit.max(v - price);
    }

    profit
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Profit

function maxProfit(a: number[]): number {
  let price = a[0];
  let profit = 0;

  for (const v of a) {
    price = Math.min(price, v);
    profit = Math.max(profit, v - price);
  }

  return profit;
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Slice Sum

max_slice_sum() {
    local -n _arr="$1"
    local _tmp=-9223372036854775808 _max=-9223372036854775808
    local _v
    for _v in "${_arr[@]}"; do
        if (( _tmp + _v > _v )); then _tmp=$(( _tmp + _v )); else _tmp=$_v; fi
        if (( _tmp > _max )); then _max=$_tmp; fi
    done
    echo "$_max"
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Slice Sum

#include <algorithm>
#include <limits>
#include <vector>

long long maxSliceSum(const std::vector<int>& a)
{
    long long tmp = std::numeric_limits<long long>::min();
    long long max = std::numeric_limits<long long>::min();

    for (int v : a) {
        tmp = std::max(tmp + v, static_cast<long long>(v));
        max = std::max(max, tmp);
    }

    return max;
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Slice Sum

static long MaxSliceSum(int[] a)
{
    long tmp = long.MinValue;
    long max = long.MinValue;

    foreach (var v in a)
    {
        tmp = Math.Max(tmp + v, v);
        max = Math.Max(max, tmp);
    }

    return max;
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Slice Sum

defmodule MaxSliceSum do
  def max_slice_sum([first | rest]) do
    {_tmp, max} =
      Enum.reduce(rest, {first, first}, fn v, {tmp, max} ->
        tmp = max(tmp + v, v)
        {tmp, max(max, tmp)}
      end)

    max
  end
end

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Max Slice Sum

-module(max_slice_sum).
-export([max_slice_sum/1]).

max_slice_sum([H | T]) ->
    {_, Max} = lists:foldl(fun(V, {Tmp, MaxV}) ->
        Tmp1 = max(Tmp + V, V),
        {Tmp1, max(MaxV, Tmp1)}
    end, {H, H}, T),
    Max.

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Slice Sum

func maxSliceSum(a []int) int {
	tmp, best := math.MinInt, math.MinInt

	for _, v := range a {
		if tmp+v > v {
			tmp += v
		} else {
			tmp = v
		}
		if tmp > best {
			best = tmp
		}
	}

	return best
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Max Slice Sum

maxSliceSum :: [Int] -> Int
maxSliceSum a = snd (foldl step (minBound, minBound) a)
  where
    step (tmp, best) v =
      let tmp' = max (tmp + v) v
      in  (tmp', max best tmp')

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Slice Sum

public class Solution {
    public static int maxSliceSum(int[] a) {
        long tmp = Long.MIN_VALUE;
        long max = Long.MIN_VALUE;

        for (int v : a) {
            tmp = Math.max(tmp + v, v);
            max = Math.max(max, tmp);
        }

        return (int) max;
    }
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Max Slice Sum

(defun max-slice-sum (a)
  (let ((tmp most-negative-fixnum)
        (max most-negative-fixnum))
    (dolist (v a)
      (setf tmp (max (+ tmp v) v))
      (setf max (max max tmp)))
    max))

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

PHP Max Slice Sum

function maxSliceSum(array $a): int
{
    $tmp = $max = PHP_INT_MIN;

    foreach ($a as $v) {
        $tmp = max($tmp + $v, $v);
        $max = max($max, $tmp);
    }

    return $max;
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Slice Sum

def max_slice_sum(a: list[int]) -> int:
    tmp = max_sum = float("-inf")
    for v in a:
        tmp = max(tmp + v, v)
        max_sum = max(max_sum, tmp)

    return int(max_sum)

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Slice Sum

fn max_slice_sum(a: &[i64]) -> i64 {
    let mut tmp = a[0];
    let mut max = a[0];

    for &v in &a[1..] {
        tmp = (tmp + v).max(v);
        max = max.max(tmp);
    }

    max
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Slice Sum

function maxSliceSum(a: number[]): number {
  let tmp = -Infinity;
  let max = -Infinity;

  for (const v of a) {
    tmp = Math.max(tmp + v, v);
    max = Math.max(max, tmp);
  }

  return max;
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Bash Min Avg Two Slice

min_avg_two_slice() {
    local -n _a="$1"
    local _idx=0
    local _min
    _min=$(echo "scale=10; (${_a[0]} + ${_a[1]}) / 2" | bc)
    local _count=${#_a[@]} _i
    for ((_i = 0; _i < _count - 1; _i++)); do
        local _cur
        _cur=$(echo "scale=10; (${_a[_i]} + ${_a[_i+1]}) / 2" | bc)
        if (( _i + 2 < _count )); then
            local _three
            _three=$(echo "scale=10; (${_a[_i]} + ${_a[_i+1]} + ${_a[_i+2]}) / 3" | bc)
            if (( $(echo "$_three < $_cur" | bc -l) )); then
                _cur=$_three
            fi
        fi
        if (( $(echo "$_cur < $_min" | bc -l) )); then
            _min=$_cur
            _idx=$_i
        fi
    done
    echo "$_idx"
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

C++ Min Avg Two Slice

#include <algorithm>
#include <vector>

int minAvgTwoSlice(const std::vector<int>& a)
{
    int idx = 0;
    double min = (a[0] + a[1]) / 2.0;

    for (std::size_t i = 0; i + 1 < a.size(); ++i) {
        double cur = (a[i] + a[i + 1]) / 2.0;
        if (i + 2 < a.size()) {
            double three = (a[i] + a[i + 1] + a[i + 2]) / 3.0;
            cur = std::min(cur, three);
        }
        if (cur < min) {
            min = cur;
            idx = static_cast<int>(i);
        }
    }

    return idx;
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

C# Min Avg Two Slice

static int MinAvgTwoSlice(int[] a)
{
    var idx = 0;
    double min = (a[0] + a[1]) / 2.0;

    for (int i = 0; i < a.Length - 1; i++)
    {
        double cur = (a[i] + a[i + 1]) / 2.0;
        if (i + 2 < a.Length)
        {
            double three = (a[i] + a[i + 1] + a[i + 2]) / 3.0;
            cur = cur < three ? cur : three;
        }
        if (cur < min)
        {
            min = cur;
            idx = i;
        }
    }

    return idx;
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Min Avg Two Slice

defmodule MinAvgTwoSlice do
  def min_avg_two_slice(a) do
    size = length(a)
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)
    initial_avg = (Map.get(a_map, 0) + Map.get(a_map, 1)) / 2

    {idx, _min_avg} =
      Enum.reduce(0..(size - 2), {0, initial_avg}, fn i, {idx, min_avg} ->
        two = (Map.get(a_map, i) + Map.get(a_map, i + 1)) / 2

        cur =
          if Map.has_key?(a_map, i + 2) do
            three = (Map.get(a_map, i) + Map.get(a_map, i + 1) + Map.get(a_map, i + 2)) / 3
            min(two, three)
          else
            two
          end

        if cur < min_avg, do: {i, cur}, else: {idx, min_avg}
      end)

    idx
  end
end

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Erlang Min Avg Two Slice

-module(min_avg_two_slice).
-export([min_avg_two_slice/1]).

min_avg_two_slice(A) ->
    N = length(A),
    Arr = array:from_list(A),
    Init = (array:get(0, Arr) + array:get(1, Arr)) / 2,
    {_, Idx} = lists:foldl(fun(I, {MinV, IdxAcc}) ->
        Two = (array:get(I, Arr) + array:get(I + 1, Arr)) / 2,
        Cur = case I + 2 < N of
            true ->
                Three = (array:get(I, Arr) + array:get(I + 1, Arr) + array:get(I + 2, Arr)) / 3,
                min(Two, Three);
            false ->
                Two
        end,
        case Cur < MinV of
            true -> {Cur, I};
            false -> {MinV, IdxAcc}
        end
    end, {Init, 0}, lists:seq(0, N - 2)),
    Idx.

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Go Min Avg Two Slice

func minAvgTwoSlice(a []int) int {
	idx := 0
	min := float64(a[0]+a[1]) / 2

	for i := 0; i < len(a)-1; i++ {
		cur := float64(a[i]+a[i+1]) / 2
		if i+2 < len(a) {
			three := float64(a[i]+a[i+1]+a[i+2]) / 3
			if three < cur {
				cur = three
			}
		}
		if cur < min {
			min = cur
			idx = i
		}
	}

	return idx
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Haskell Min Avg Two Slice

import Data.Array (Array, listArray, (!))

minAvgTwoSlice :: [Int] -> Int
minAvgTwoSlice a = fst (foldl step (0, avg2 0) [0 .. n - 2])
  where
    n   = length a
    arr = listArray (0, n - 1) a :: Array Int Int

    avg2 i = fromIntegral (arr ! i + arr ! (i + 1)) / 2 :: Double
    avg3 i = fromIntegral (arr ! i + arr ! (i + 1) + arr ! (i + 2)) / 3 :: Double

    candidate i
      | i + 2 <= n - 1 = min (avg2 i) (avg3 i)
      | otherwise      = avg2 i

    step (bestIdx, bestVal) i =
      let cur = candidate i
      in  if cur < bestVal then (i, cur) else (bestIdx, bestVal)

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Java Min Avg Two Slice

public class Solution {
    public static int minAvgTwoSlice(int[] a) {
        int idx = 0;
        double min = (a[0] + a[1]) / 2.0;

        for (int i = 0; i < a.length - 1; i++) {
            double cur = (a[i] + a[i + 1]) / 2.0;
            if (i + 2 < a.length) {
                double three = (a[i] + a[i + 1] + a[i + 2]) / 3.0;
                cur = Math.min(cur, three);
            }
            if (cur < min) {
                min = cur;
                idx = i;
            }
        }

        return idx;
    }
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Lisp Min Avg Two Slice

(defun min-avg-two-slice (a)
  (let* ((vec (coerce a 'vector))
         (count (length vec))
         (idx 0)
         (min (/ (+ (aref vec 0) (aref vec 1)) 2.0)))
    (loop for i from 0 below (1- count)
          do (let ((cur (/ (+ (aref vec i) (aref vec (1+ i))) 2.0)))
               (when (< (+ i 2) count)
                 (let ((three (/ (+ (aref vec i) (aref vec (1+ i)) (aref vec (+ i 2))) 3.0)))
                   (setf cur (min cur three))))
               (when (< cur min)
                 (setf min cur)
                 (setf idx i))))
    idx))

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

PHP Min Avg Two Slice

function minAvgTwoSlice(array $a): int
{
    $idx    = 0;
    $min = ($a[0] + $a[1]) / 2;
    for ($i = 0, $count = count($a); $i < $count - 1; $i++) {
        $cur = ($a[$i] + $a[$i + 1]) / 2;
        if (isset($a[$i + 2])) {
            $three = ($a[$i] + $a[$i + 1] + $a[$i + 2]) / 3;
            $cur  = $cur < $three ? $cur : $three;
        }
        if ($cur < $min) {
            $min = $cur;
            $idx    = $i;
        }
    }

    return $idx;
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Python Min Avg Two Slice

def min_avg_two_slice(a: list[int]) -> int:
    idx = 0
    min_avg = (a[0] + a[1]) / 2
    for i in range(len(a) - 1):
        cur = (a[i] + a[i + 1]) / 2
        if i + 2 < len(a):
            three = (a[i] + a[i + 1] + a[i + 2]) / 3
            cur = min(cur, three)
        if cur < min_avg:
            min_avg = cur
            idx = i

    return idx

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Rust Min Avg Two Slice

fn min_avg_two_slice(a: &[i64]) -> i64 {
    let mut idx = 0i64;
    let mut min = (a[0] + a[1]) as f64 / 2.0;

    for i in 0..a.len() - 1 {
        let mut cur = (a[i] + a[i + 1]) as f64 / 2.0;
        if i + 2 < a.len() {
            let three = (a[i] + a[i + 1] + a[i + 2]) as f64 / 3.0;
            cur = cur.min(three);
        }
        if cur < min {
            min = cur;
            idx = i as i64;
        }
    }

    idx
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.