mmo-dev team

import java.util.UUID;

class Node {
    String id;
    Integer value;
    Node left;
    Node right;

    Node(int depth) {
        this.id = UUID.randomUUID().toString();
        this.value = depth;
       
        if (depth > 0) {
            this.left = new Node(depth - 1);
            this.right = new Node(depth - 1);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Node root = new Node(25);
    }
}

#include <iostream>
#include <memory>
#include <string>

struct Node {
    char id[36];
    int value;
    std::unique_ptr<Node> left;
    std::unique_ptr<Node> right;

    Node(int depth) : value(depth) {
        int8_t dummy[] = "12345678-1234-1234-1234-123456789012";
        std::copy(std::begin(dummy), std::end(dummy), id);

        if (depth > 0) {
            left = std::make_unique<Node>(depth - 1);
            right = std::make_unique<Node>(depth - 1);
        }
    }
};

int main() {
    auto root = std::make_unique<Node>(25);
    return 0;
}

import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;

class Point {
    public Double x;
    public Double y;
    public Double z;
    public Boolean isActive;

    public Point(double x, double y, double z, boolean isActive) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.isActive = isActive;
    }
}

public class Main {
    private static double calculate(Point p, Function<Point, Double> formula) {
        return formula.apply(p);
    }

    public static void main(String[] args) {
        List<Point> points = new LinkedList<>();

        for (int i = 0; i < 1_000_000; i++) {
            points.add(new Point(i * 1.1, i * 1.2, i * 1.3, i % 2 == 0));
        }

        long startTime = System.nanoTime();
       
        Double totalSum = 0.0;

        int index = 0;
        for (Point p : points) {
            Integer stepId = index;
            final double modifier = (stepId % 2 == 0) ? 1.0 : 1.005;

            if (Optional.ofNullable(p.isActive).orElse(false)) {
                totalSum += calculate(p, pt -> (pt.x + pt.y + pt.z) * modifier);
            }
            index++;
        }

        long endTime = System.nanoTime();
        System.out.println("Результат: " + totalSum);
        System.out.println("Время выполнения: " + (endTime - startTime) / 1_000_000.0 + " мс");
    }
}

using System.Diagnostics;
using System.Runtime.InteropServices;

public struct Point
{
    public double X;
    public double Y;
    public double Z;
    public bool IsActive;
}

public static class Program
{
    public static void Main()
    {
        List<Point> points = new List<Point>(1_000_000);

        for (int i = 0; i < 1_000_000; i++)
        {
            points.Add(new Point { X = i * 1.1, Y = i * 1.2, Z = i * 1.3, IsActive = (i % 2 == 0) });
        }

        Stopwatch sw = Stopwatch.StartNew();

        double totalSum = 0.0;
        Span<Point> pointSpan = CollectionsMarshal.AsSpan(points);
        for (int i = 0; i < pointSpan.Length; i++)
        {
            ref readonly Point p = ref pointSpan[i];

            if (p.IsActive)
            {
                double modifier = (i % 2 == 0) ? 1.0 : 1.005;
                totalSum += (p.X + p.Y + p.Z) * modifier;
            }
        }

        sw.Stop();
        Console.WriteLine($"Результат: {totalSum}");
        Console.WriteLine($"Время выполнения в C#: {sw.Elapsed.TotalMilliseconds:F2} мс");
    }
}

#include <iostream>
#include <list>
#include <optional>
#include <chrono>

struct Point {
    double x;
    double y;
    double z;
    std::optional<bool> isActive;
};

template<typename F>
double calculate(const Point& p, F formula) {
    return formula(p);
}

int main() {
    std::list<Point> points;

    for (int i = 0; i < 1000000; ++i) {
        points.push_back({ i * 1.1, i * 1.2, i * 1.3, (i % 2 == 0) });
    }

    auto start = std::chrono::high_resolution_clock::now();
    std::optional<double> total_sum = 0.0;

    int index = 0;
    for (const auto& p : points) {
        int step_id = index;
        double modifier = (step_id % 2 == 0) ? 1.0 : 1.005;

        if (p.isActive.value_or(false)) {
            total_sum.value() += calculate(p, [&](const Point& pt) {
                return (pt.x + pt.y + pt.z) * modifier;
                });
        }
        index++;
    }

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> duration = end - start;

    std::cout << "Результат: " << total_sum.value() << "\n";
    std::cout << "Время выполнения в C++: " << duration.count() << " мс\n";
    return 0;
}

package main

import (
    "container/list"
    "fmt"
    "time"
)

type Point struct {
    X        *float64
    Y        *float64
    Z        *float64
    IsActive *bool
}

func NewPoint(x, y, z float64, isActive bool) *Point {
    return &Point{
        X:        &x,
        Y:        &y,
        Z:        &z,
        IsActive: &isActive,
    }
}

func calculate(p *Point, formula func(*Point) float64) float64 {
    return formula(p)
}

func orElseFalse(b *bool) bool {
    if b == nil {
        return false
    }
    return *b
}

func main() {
    points := list.New()

    for i := 0; i < 1000000; i++ {
        points.PushBack(NewPoint(
            float64(i)*1.1,
            float64(i)*1.2,
            float64(i)*1.3,
            i%2 == 0,
        ))
    }

    startTime := time.Now()

    var totalSum float64 = 0.0

    index := 0
    for e := points.Front(); e != nil; e = e.Next() {
        p := e.Value.(*Point)
        stepId := index
        
        var modifier float64
        if stepId%2 == 0 {
            modifier = 1.0
        } else {
            modifier = 1.005
        }

        if orElseFalse(p.IsActive) {
            totalSum += calculate(p, func(pt *Point) float64 {
                return (*pt.X + *pt.Y + *pt.Z) * modifier
            })
        }
        index++
    }

    endTime := time.Now()
    executionTime := float64(endTime.Sub(startTime).Nanoseconds()) / 1000000.0

    fmt.Printf("Результат: %f\n", totalSum)
    fmt.Printf("Время выполнения: %f мс\n", executionTime)
}

using System.Collections;
using System.Diagnostics;
using System.Runtime.CompilerServices;

public class Point
{
    public double? x;
    public double? y;
    public double? z;
    public bool? isActive;

    public void Reset(double x, double y, double z, bool isActive)
    {
        this.x = x;
        this.y = y;
        this.z = z;
        this.isActive = isActive;
    }
}

public class LinkedListNode
{
    public Point Item;
    public LinkedListNode Next;
}

public struct CustomEnumerator : IEnumerator<Point>
{
    private LinkedListNode _current;
    private bool _started;

    public CustomEnumerator(LinkedListNode head)
    {
        _current = head;
        _started = false;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool MoveNext()
    {
        if (!_started)
        {
            _started = true;
            return _current != null;
        }

        if (_current != null)
        {
            _current = _current.Next;
        }
        return _current != null;
    }

    public Point Current => _current != null ? _current.Item : null;

    object IEnumerator.Current => Current;
    public void Reset() => throw new NotSupportedException();
    public void Dispose() { }
}

public class VirtualLinkedList : IReadOnlyCollection<Point>
{
    private LinkedListNode _head;
    private LinkedListNode _tail;
    public int Count { get; private set; } = 0;

    private readonly LinkedListNode[] _nodePool = new LinkedListNode[1_000_000];
    private readonly Point[] _pointPool = new Point[1_000_000];

    public VirtualLinkedList()
    {
        for (int i = 0; i < 1_000_000; i++)
        {
            _nodePool[i] = new LinkedListNode();
            _pointPool[i] = new Point();
        }
    }

    public void AddLast(double x, double y, double z, bool isActive)
    {
        Point p = _pointPool[Count];
        p.Reset(x, y, z, isActive);

        LinkedListNode newNode = _nodePool[Count];
        newNode.Item = p;
        newNode.Next = null;

        if (_head == null)
        {
            _head = newNode;
        }
        else
        {
            _tail.Next = newNode;
        }
        _tail = newNode;
        Count++;
    }

    public CustomEnumerator GetEnumerator() => new CustomEnumerator(_head);
    IEnumerator<Point> IEnumerable<Point>.GetEnumerator() => new CustomEnumerator(_head);
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

public readonly struct CalculationContext
{
    public readonly double Modifier;
    public CalculationContext(double modifier) => Modifier = modifier;
}

public static class Program
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static double Calculate(Point p, in CalculationContext ctx, Func<Point, CalculationContext, double> formula)
    {
        return formula(p, ctx);
    }

    public static void Main()
    {
        VirtualLinkedList points = new VirtualLinkedList();
        for (int i = 0; i < 1_000_000; i++)
        {
            points.AddLast(i * 1.1, i * 1.2, i * 1.3, i % 2 == 0);
        }

        Stopwatch sw = Stopwatch.StartNew();

        double? totalSum = 0.0;
        double localSum = 0.0;

        int index = 0;
        Func<Point, CalculationContext, double> formula = (pt, ctx) => (pt.x.Value + pt.y.Value + pt.z.Value) * ctx.Modifier;

        foreach (Point p in points)
        {
            int? stepId = index;
            double modifier = (stepId % 2 == 0) ? 1.0 : 1.005;

            if (p.isActive.GetValueOrDefault(false))
            {
                var context = new CalculationContext(modifier);
                localSum += Calculate(p, in context, formula);
            }
            index++;
        }

        totalSum = localSum;
        sw.Stop();

        Console.WriteLine($"Результат: {totalSum}");
        Console.WriteLine($"Время выполнения в C#: {sw.Elapsed.TotalMilliseconds:F2} мс");
    }
}

import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.LongAdder;

public class Main {
    static final int N = 10_000_000;
    static final ScopedValue<RequestContext> CONTEXT = ScopedValue.newInstance();

    record RequestContext(UUID requestId, UUID token) {}

    static class Client {
        int query(UUID id) {
            var context = CONTEXT.get();
            if (!context.requestId().equals(id) || context.token() == null) {
                throw new SecurityException();
            }
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5001));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return Math.floorMod(id.hashCode(), 11);
        }
    }

    public static void main(String[] args) {
        var ids = new UUID[N];
        var contexts = new RequestContext[N];
        for (int i = 0; i < N; i++) {
            ids[i] = UUID.randomUUID();
            contexts[i] = new RequestContext(ids[i], UUID.randomUUID());
        }

        var client = new Client();
        var sum = new LongAdder();
        long start = System.nanoTime();

        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < N; i++) {
                var id = ids[i];
                var context = contexts[i];
                executor.submit(() -> ScopedValue.where(CONTEXT, context)
                        .run(() -> sum.add(client.query(id))));
            }
        }

        System.out.println(sum.sum());
        System.out.printf("%.3f s%n", (System.nanoTime() - start) / 1e9);
    }
}

java --version
openjdk 26.0.1 2026-04-21
OpenJDK Runtime Environment Temurin-26.0.1+8 (build 26.0.1+8)
OpenJDK 64-Bit Server VM Temurin-26.0.1+8 (build 26.0.1+8, mixed mode, sharing)

java .\Main.java
50012355
32,628 s