主页 / 问题

全部问题

Martin Hope
mrgervant
Asked: 2024-08-25 00:26:33 +0000 UTC
  • 20

为了纪念即将到来的 9 月 1 日，我将举办一场自我修正写作比赛Hello world。

让我立即保留该任务是在 中创建的，但您可以用任何具有与 Python 类似行为的语言Python编写答案：

  • 通过指定括号内的最后一个字符串将字符串传递到标准控制台输出函数
  • PL允许你运行一个明显写有错误的程序

您需要编写代码，在代码末尾将指示反向HelloWorld 命令（允许添加工作所需的结构 - 例如end括号等）：

# Любой Ваш код
HelloWorld("print")

启动后，Hello world 应用程序的更正文本将显示在控制台中：

print("HelloWorld")

HelloWorld在这种情况下，可以更改“发送用于打印”的文本（部分） - 代码应与以下命令类似地工作：

hello_world("print")  >>>  print("hello_world")

test("print")         >>>  print("test")

输出的文本是用一个词写成的——就像一个函数一样。

在它之后，输出命令用括号和引号表示- 它自己的 PL。无需提供更改的能力("print")（或在另一种语言中类似）。

同样，应用程序不必在显示正确的 HelloWorld 代码文本后运行。

JavaScript 中的示例：

# Любой Ваш код
HelloWorld('console.log')

帕斯卡示例：

program Hello;
begin
  # Любой Ваш код
  HelloWorld('writeln')
end.

胜利标准（平票降序）

  1. 计票时的最高票数
  2. 最少数量的代码字符（所有内容都包括在内 - 包括您的代码和最后一行 HelloWorld）
  3. 最早回复
总结 - 9 月 1 日 21:00 莫斯科时间

根据比赛结果，得票最多的答案是@CrazyElf——通过捕获异常的解决方案NameError。

但答案同样包含有趣和意想不到的解决方案！

感谢大家的参与！特别感谢Python以外语言的解决方案！

所以@extrn想出了Perl中最短的解决方案——61个字符！

我最初的解决方案也是通过拦截异常来发明的，但它有111 个字符NameError长：

import sys;sys.excepthook=lambda*a:print(f'''print("{str(a[1]).split()[1].strip("'")}")''')
HelloWorld("print")
любой-язык
Martin Hope
aepot
Asked: 2022-07-10 05:49:04 +0000 UTC
  • 20

相当简单的任务 - 有 N 个有序请求必须异步执行，同时执行的请求数量有限制，然后从它们中取出它们以及 N 个有序响应。

实际上，当有很多请求时，这可以与网络或数据库一起使用，但您不想为您的计算机、网络或服务器安排灾难。因此，对同时活动的异步任务的数量进行了限制。

正面的解决方案看起来很明显。

public async Task<Tout[]> RunSemaphoreAsync<Tin, Tout>(IEnumerable<Tin> items, Func<Tin, Task<Tout>> func, int degree)
{
    using SemaphoreSlim semaphore = new(degree);
    return await Task.WhenAll(items.Select(async item => {
        await semaphore.WaitAsync();
        try
        {
            return await func(item);
        }
        finally
        {
            semaphore.Release();
        }
    }));
}

使用示例：

让它成为一项接受某事、做某事并回馈某事的工作任务。

public async Task<int> RunJobAsync(int n)
{
    await Task.Yield(); 
    return n + 1;
}

这是一个例子。

IEnumerable<int> numbers = Enumerable.Range(0, 100);
int[] result = await RunSemaphoreAsync(numbers, RunJobAsync, Environment.ProcessorCount * 2);
Console.WriteLine(string.Join(",", result));

一切都像发条一样，快速且按预期工作。

上面的一切都很好，但是有一天，当我再次阅读生产者/消费者模式的各种实现时，我想到了使用工人而不是信号量的想法。其实，为什么不呢。

这是方法。

public async Task<Tout[]> RunWorkersAsync<Tin, Tout>(IEnumerable<Tin> items, Func<Tin, Task<Tout>> func, int degree)
{
    List<Task<Tout>> tasks = new();
    using (var source = items.GetEnumerator())
    {
        Task[] jobs = new Task[degree];
        for (int i = 0; i < degree; i++)
        {
            jobs[i] = ((Func<Task>)(async () =>
            {
                while (true)
                {
                    Task<Tout> task;
                    lock (source)
                    {
                        if (source.MoveNext())
                        {
                            task = func(source.Current);
                            tasks.Add(task);
                        }
                        else
                            break;
                    }
                    await task;
                }
            }))();
        }
        await Task.WhenAll(jobs);
    }
    return tasks.Select(t => t.Result).ToArray();
}

和第一个候选人一样漂亮。那么什么更好呢？

我决定测量开销。
我不是编写基准测试的高手，但这什么时候阻止了任何人？:)

class Program
{
    static void Main(string[] args)
    {
        var result = BenchmarkRunner.Run<MyBenchmarks>();
        Console.ReadKey();
    }
}

[MemoryDiagnoser]
public class MyBenchmarks
{
    private readonly List<int> numbers = Enumerable.Range(0, 2000).ToList();
    private readonly int degree = Environment.ProcessorCount * 2;

    [Benchmark]
    public Task SemaphoreTest()
    {
        return RunSemaphoreAsync(numbers, RunJobAsync, degree);
    }

    [Benchmark]
    public Task WorkersTest()
    {
        return RunWorkersAsync(numbers, RunJobAsync, degree);
    }

    public async Task<int> RunJobAsync(int n)
    {
        await Task.Yield(); 
        return n + 1;
    }

    public async Task<Tout[]> RunSemaphoreAsync<Tin, Tout>(IEnumerable<Tin> items, Func<Tin, Task<Tout>> func, int degree)
    {
        using SemaphoreSlim semaphore = new(degree);
        return await Task.WhenAll(items.Select(async item => {
            await semaphore.WaitAsync();
            try
            {
                return await func(item);
            }
            finally
            {
                semaphore.Release();
            }
        }));
    }

    public async Task<Tout[]> RunWorkersAsync<Tin, Tout>(IEnumerable<Tin> items, Func<Tin, Task<Tout>> func, int degree)
    {
        List<Task<Tout>> tasks = new();
        using (var source = items.GetEnumerator())
        {
            Task[] jobs = new Task[degree];
            for (int i = 0; i < degree; i++)
            {
                jobs[i] = ((Func<Task>)(async () =>
                {
                    while (true)
                    {
                        Task<Tout> task;
                        lock (source)
                        {
                            if (source.MoveNext())
                            {
                                task = func(source.Current);
                                tasks.Add(task);
                            }
                            else
                                break;
                        }
                        await task;
                    }
                }))();
            }
            await Task.WhenAll(jobs);
        }
        return tasks.Select(t => t.Result).ToArray();
    }
}

在这里我得到了一个有趣的结果

BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1081 (21H1/May2021Update)
Intel Core i7-4700HQ CPU 2.40GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
.NET SDK=5.0.301
  [Host]     : .NET 5.0.7 (5.0.721.25508), X64 RyuJIT
  DefaultJob : .NET 5.0.7 (5.0.721.25508), X64 RyuJIT
方法 意思是 错误 标准差 0代 第一代 第 2 代 已分配
信号量测试 1,780.2 我们 4.23 我们 3.95 我们 140.6250 41.0156 - 519KB
工人测试 943.2us 18.37 我们 26.92 我们 74.2188 19.5313 - 262KB

眼睛拒绝相信。为什么带有信号量的方法只是像这样合并，或者可能是一个歪曲的测试或歪曲的实现？请考虑。

PS我没有立即在SO上运行，但首先我寻找关于缓慢的投诉SemaphoreSlim......并没有找到它，但我发现了这个：https ://github.com/dotnet/runtime/pull/55262 。换句话说，红绿灯在 .NET 6 中会飞一点。

c#
Martin Hope
xhr
Asked: 2020-03-06 22:52:55 +0000 UTC
  • 20

在所有来源中，算法的复杂性表示为 log N（未指定基数）。这是指以 2 为底的对数。

但是这样的对数有自己的名称lb。此外，这个名称是由ISO 31-11标准化的，使用它可能更合乎逻辑和正确，但由于某种原因这不起作用，为什么？

UPD：我没有任何数学背景，我对对数的了解只是它是指数的倒数。

让我们举一个具体的例子——二分查找。它的复杂性到处都被描述为log N。同时，在我看来， log N仍然意味着 N 以 2 为底的对数，因为 操作数正好是 N 以 2 为底的对数，即 必须提高 2（而不是 10 和不是 100）的幂才能得到 N。因此，老实说，我不理解诸如“因为O(n)表示法中的常数系数无关紧要”或“因为带有大 O 的符号对常数没有反应 - 使用哪个对数无关紧要......”我会很感激一个更详细的答案，不是为数学家写的。“大 O 中的常数无关紧要”的规则是否适用于对数的底？不管它的复杂性是写成以 2 为底还是以 100 为底的对数，它对二分搜索没有任何影响吗？

如果二进制搜索的log N表示以 2 为底的对数，那么为什么不将其写为lb N，因为二进制对数有自己的名称，而不是在不指定底数的情况下编写它？

UPD 2：我理解“O(N) 绝不是比较次数，它是对算法运行时间的估计，最大限度地与实现细节和机器解耦。”

但是这个：“并且由于具有大 O 的记录对常数没有反应 - 使用哪个对数无关紧要......”我不明白。为什么使用哪个对数无关紧要？以下是三个对数的图表 - 二进制、自然和以 0.5 为底：

在此处输入图像描述

让我们采用相同的二分搜索。我们能否将其复杂性替换为从 2 到 10 的对数底？从 2 到 0.5？我不认为我们可以。那些。我们不能在表达式 log N 中替换任意基数，因为依赖性将完全不同 - 这可以在图表中清楚地看到。那。使用哪个对数很重要。还是我错了？

алгоритм
Martin Hope
trydex
Asked: 2020-11-21 04:26:20 +0000 UTC
  • 21

告诉我，如何在贝塞尔曲线的末端画一个箭头？有很多关于如何对直线（1、2、3）执行此操作的示例，但是对于我无法执行的曲线。

有这样的代码，但它像在 gif 上一样工作。

在此处输入图像描述

XML:

<Canvas>
  <Path x:Name="pathMain" Stroke="Blue" StrokeThickness="2"/>
</Canvas>

代码隐藏：

    public PolyLineSegment DrawArrow(Point a, Point b)
    {
        double HeadWidth = 10; // Ширина между ребрами стрелки
        double HeadHeight = 5; // Длина ребер стрелки

        double X1 = a.X;
        double Y1 = a.Y;

        double X2 = b.X;
        double Y2 = b.Y;

        double theta = Math.Atan2(Y1 - Y2, X1 - X2);
        double sint = Math.Sin(theta);
        double cost = Math.Cos(theta);

        Point pt3 = new Point(
            X2 + (HeadWidth * cost - HeadHeight * sint),
            Y2 + (HeadWidth * sint + HeadHeight * cost));

        Point pt4 = new Point(
            X2 + (HeadWidth * cost + HeadHeight * sint),
            Y2 - (HeadHeight * cost - HeadWidth * sint));

        PolyLineSegment arrow = new PolyLineSegment();
        arrow.Points.Add(b);
        arrow.Points.Add(pt3);
        arrow.Points.Add(pt4);
        arrow.Points.Add(b);

        return arrow;
    }

    private void DrawLine(MouseEventArgs e)
    {
        Point endPoint = e.GetPosition(this);

        PathFigure pathFigure = new PathFigure
        {
            StartPoint = new Point(800, 500),
            IsClosed = false
        };

        //Кривая Безье
        Vector vector = endPoint - pathFigure.StartPoint;
        Point point1 = new Point(pathFigure.StartPoint.X + vector.X / 2, pathFigure.StartPoint.Y);
        Point point2 = new Point(pathFigure.StartPoint.X + vector.X / 1.5, pathFigure.StartPoint.Y + vector.Y/ 0.95);
        BezierSegment curve = new BezierSegment(point1, point2, endPoint, true);


        PolyLineSegment arrow  = DrawArrow(pathFigure.StartPoint, endPoint);
        PathGeometry path = new PathGeometry();
        path.Figures.Add(pathFigure);
        pathFigure.Segments.Add(curve);
        pathFigure.Segments.Add(arrow);
        pathMain.Data = path;
    }

如果DrawArrow(point2, endPoint)不是DrawArrow(pathFigure.StartPoint, endPoint);，那么它的工作原理如下： 在此处输入图像描述

c#
上一页
下一页