主页 / user-287190

solarisedigle's questions

Martin Hope
solarisedigle
Asked: 2022-07-09 22:07:15 +0000 UTC
  • 3

我有一个函数可以根据它的长度和角度画一条线（这不能改变，最终结果取决于它）

这是问题所在：

在此处输入图像描述

我有距离a（0°线）和距离b。使用毕达哥拉斯公式，我得到了虚线的长度。我也知道标记的角度。

最后一点必须在虚线的末端。

在此处输入图像描述

问题是该点逐渐升高然后降低。

如果您将半径设置得更多 - 只有更低

可能是什么问题以及如何解决？

let canv = document.getElementById('canv');
let ctx = canv.getContext('2d');
ctx.fillRect(0, 0, 300, 300);
let parts = 120;
let line_width = 300;
let part_width = line_width/(parts + 1);
let part_angle = (Math.PI/2)/parts;
let start_radius = 150;

// для ориентировки на холсте
ctx.strokeStyle = "white";
ctx.beginPath();
ctx.moveTo(0, 100);  
ctx.lineTo(300, 100);
ctx.moveTo(0, 150);  
ctx.lineTo(300, 150);
ctx.moveTo(0, 200);  
ctx.lineTo(300, 200);
ctx.moveTo(0, 250);  
ctx.lineTo(300, 250);
ctx.stroke();

ctx.strokeStyle = "red";
for(let i = 0; i <= parts; i++){
  let b = 150 - i*part_width;
  let hipotenusa = Math.sqrt(b*b + start_radius*start_radius);
  ctx.beginPath();
  ctx.moveTo(150, 250);  
  //поворачиваю точку с нужной длиной на нужный угол
  ctx.lineTo(
    150 + hipotenusa*Math.sin(i*part_angle + Math.PI*0.75),
    250 + hipotenusa*Math.cos(i*part_angle + Math.PI*0.75));
  ctx.stroke();
}
<canvas width="500" height="500" id="canv"></canvas>

如果您不将线连接到一个点，会发生以下情况（没有极坐标，它可能会有所帮助）

在此处输入图像描述

javascript
Martin Hope
solarisedigle
Asked: 2022-08-06 05:47:00 +0000 UTC
  • 1

我正在为 React.js 上的机器人创建一个管理面板，但我无法将它放在根目录中。如何构建项目以在文件夹中使用？例如https://domain.com/admin

站点本身已启动，但路由器看不到链接。它们是 /login、/users 等。他可能会看到 /admin/login ... 是否有可以解决此问题的配置选项？还是我需要手动输入文件夹的路径？

javascript
Martin Hope
solarisedigle
Asked: 2022-08-03 03:59:28 +0000 UTC
  • 1

我使用 url 字符串中的参数在 useEffect 内的 ajax 请求中传递它。我收到此错误：conditional could make the dependencies of useEffect Hook

let query = new URLSearchParams(useLocation().search);
let sort = query.get('sort') ? JSON.parse(query.get('sort')) : [];
useEffect(() => {
    $.ajax({
        ...
        data: {jwt: localStorage.getItem('jwt'), sort: sort},
        ...
}, [sort]);

我该如何解决？建议 useMemory，但该钩子反过来会在查询时引起仇恨。据我了解，问题出在线路参数上。

javascript
Martin Hope
solarisedigle
Asked: 2022-05-11 18:50:01 +0000 UTC
  • 1

我正在使用 Rails 6.1.3.1 和 Ruby 3.0.1 控制器中有一行代码：

JSON.parse('{"hello": "goodbye"}')

并给出错误。我不知道这两个论点来自哪里。尝试了各种json，连[]和{}都很简单。

当我离开时，JSON.parse()我得到ArgumentError: wrong number of arguments (given 0, expected 1..2)

问题是什么？

ruby-on-rails
Martin Hope
solarisedigle
Asked: 2022-04-09 18:00:42 +0000 UTC
  • 1

svg中有一个带有单元格的字段。它们之间没有距离，但显示为好像有（移动/调整大小时改变的单元格之间的空间线）。

在此处输入图像描述

如何绕过它？不能制作基板，因为。细胞将具有不同的颜色，基板也将是可见的。

var elem = document.getElementById('svg-canvas');
        var w = elem.offsetWidth;
        var h = elem.offsetHeight;
        var two = new Two({ width: w, height: h}).appendTo(elem);
        var settings = {
            def_padding: 20,
            cell_stroke: 'grey',
            cell_lw: 0,
            scale: 1.5,
        }
        var game = {
            width: 30,
            height: 30,
        }
function gen_cell(){
            return {
                kind: '#000000'
            };
        }
        function gen_field(){
            game.cells = [];
            for (let i = 0; i < game.height; i++) {
                game.cells[i] = [];
                for (let j = 0; j < game.width; j++) {
                    game.cells[i][j] = gen_cell();
                }
            }
        }
        var tmp_classes = [];
        function add_class_after(id, classname, attrs = []){
            tmp_classes.push([id, classname, attrs]);
            return id;
        }
        function reset_classes(){
            for (var i = 0; i < tmp_classes.length; i++) {
                $('#' + tmp_classes[i][0]).addClass(tmp_classes[i][1]);
            }
            tmp_classes = []
        }
        function draw(){
            two.clear();
            let size = Math.min((w - settings.def_padding)/game.width, (h - settings.def_padding)/game.height);
            let padding = {
                x: w - size*game.width,
                y: h - size*game.height,
            }
            for (let i = 0; i < game.cells.length; i++) {
                for (let j = 0; j < game.cells[i].length; j++) {
                    let cell = new Two.Rectangle(
                        j*size + padding.x/2 + size/2,
                        i*size + padding.y/2 + size/2,
                        size,
                        size
                        );
                    cell.stroke = settings.cell_stroke;
                    cell.linewidth = settings.cell_lw;
                    cell.fill = game.cells[i][j].kind;
                    cell.id = add_class_after(i + '-' + j, 'cell');
                    two.add(cell);
                }
            }
            two.update();reset_classes();
        }
        function scale(svg, e){
            let content = svg.find('g');
            let transform = content.attr('transform').split('(')[1].split(')')[0].split(' ').map(x => +x);
            let x = e.originalEvent.offsetX - content.width()/2;
            let y = e.originalEvent.offsetY - content.height()/2;
            let deltaY = e.originalEvent.deltaY;
            let scale_now = deltaY < 0 ? settings.scale : 1/settings.scale; 
            transform[0] *= scale_now;
            transform[3] *= scale_now;
            transform[4] = x - (x - transform[4])*scale_now;
            transform[5] = y - (y - transform[5])*scale_now;
            content.attr('transform', 'matrix(' + transform.join(' ') + ')');
        }
        function initialise(){
            $('#svg-canvas').html('');
            w = elem.offsetWidth;
            h = elem.offsetHeight;
            two = new Two({ width: w, height: h}).appendTo(elem);
            draw();
        }
        function move(svg, x, y){
            let transform = svg.find('g').attr('transform').split('(')[1].split(')')[0].split(' ').map(x => +x);
            transform[4] += x;
            transform[5] += y;
            svg.find('g').attr('transform', 'matrix(' + transform.join(' ') + ')');
        }
        $(document).ready(function(){
            gen_field();
            draw();
            $(window).resize(function(){
                initialise();
            });
            $('#svg-canvas').bind('mousewheel DOMMouseScroll', function(e){
                e.preventDefault();
            });
            $('body').bind('mousewheel DOMMouseScroll', '#svg-canvas svg', function(e){
                if(e.ctrlKey){
                    scale($(this), e);
                }
                else if(e.shiftKey){
                    move($(this), -e.originalEvent.deltaY/5, 0);
                }
                else{
                    move($(this), 0, -e.originalEvent.deltaY/5);
                }
            });
            $('body').on('mousedown', '#svg-canvas svg', function(e){
                if(e.which !== 2) return;
                e.preventDefault();
                $(this).css('cursor', 'move');
                let old_x = e.offsetX;
                let old_y = e.offsetY;
                $(this).mousemove(function(emove){
                    let x = emove.offsetX;
                    let y = emove.offsetY;
                    move($(this), emove.offsetX - old_x, emove.offsetY - old_y);
                    old_x = x;
                    old_y = y;
                });
                $(this).mouseup(function(){
                    $(this).off('mousemove');
                    $(this).css('cursor', 'default');
                });
                $(this).mouseleave(function(){
                    $(this).off('mousemove');
                    $(this).css('cursor', 'default');
                });
            });
        });
.cell:hover{
            opacity: 0.2;
        }
        .color, .condition{
            margin-bottom: 10px;
            border-left: 2px solid rgb(33, 37, 41);
        }
        .rule{
            margin-bottom: 10px;
        }
        #svg-canvas{
            width: 100%;
            height: 80vh;
        }
        #svg-canvas svg{
            background: lightgrey;
            border: 1px solid black;
        }
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/two.js/0.7.1/two.min.js"></script>
<div id="svg-canvas" class="main_field"></div>

我知道精度并不完美，但是这些间隙的大小总是一样的，如果你缩小得太远，你也会看到：

在此处输入图像描述

javascript
Martin Hope
solarisedigle
Asked: 2022-01-08 04:07:00 +0000 UTC
  • 1

我尝试将西里尔语单词作为命令行参数传递，但在子进程中，阅读时，我得到问号或单词 iconengines。我什至无法想象这意味着什么。这是父代码：

STARTUPINFO sti;
PROCESS_INFORMATION pi;
string strCMD = "child.exe ";
strCMD = strCMD + ui->stop->text().toUtf8().constData() + " " + to_string(ui->morale->value());
wstring CommandLine(strCMD.begin(), strCMD.end());
LPWSTR lpwCmdLine = &CommandLine[0];
ui->statusBar->showMessage(QString::fromStdString(strCMD));
ZeroMemory(&sti, sizeof(STARTUPINFO));
sti.cb = sizeof(STARTUPINFO);
CreateProcess(NULL, lpwCmdLine, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &sti, &pi);

阅读论据：

QString word = QString::fromStdString(argv[1]);
cout << word.toUtf8().constData() << endl;
// и таким способом, тот же результат
cout << argv[1];
c++
Martin Hope
solarisedigle
Asked: 2021-12-19 23:29:10 +0000 UTC
  • -1

有一个多维数组，你需要通过简单的指定路径来简单的找出是否有元素。

例如if($user['temp']['active_apply']['wait']))

但同时，也会出现警告，有时还会出现错误。有没有办法检查所有这些密钥是否有效，没有这个：

array_key_exists ('temp', $user) && array_key_exists ('active_apply', $user['temp']) && array_key_exists ('wait', $user['temp']['active_apply'])

7.1 版

php
Martin Hope
solarisedigle
Asked: 2021-12-18 19:45:24 +0000 UTC
  • 0

有一个功能：

function button($text, $value, $col = 6, $row = 1, $color = "#ffffff", $size = 'large', $type = 'reply'){
    return [
            'Columns' => $col,
            'Rows' => $row,
            'Text' => '<font color="'.$color.'"><b>'.$text.'</b></font>',
            'BgColor' => "#30cecb",
            'TextVAlign' => 'middle',
            'TextHAlign' => 'middle',
            'TextSize' => $size,
            'ActionType' => $type,
            'ActionBody' => $value,
        ];
}

如何在不设置 col 和 row 参数的情况下设置“颜色”参数？调用时：

button('button', 'but|run', NULL, NULL, "#ffffff")

不会使用默认参数，但会将 NULL 传递给它。如何在默认设置的参数之后设置任何参数，但在其之前的参数中，不要更改值？

php
Martin Hope
solarisedigle
Asked: 2021-11-14 01:56:47 +0000 UTC
  • 1

我运行代码：

function bubbleSort(array) {
  let len = array.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < len; i++) {
      if (array[i] > array[i + 1]) {
        let tmp = array[i];
        array[i] = array[i + 1];
        array[i + 1] = tmp;
        swapped = true;
      }
    }
  } while (swapped);
};
let array=[];
for (let index = 0; index < 11000; index++) {
   array[index] = Math.floor(Math.random() * (100000));
   let sign = Math.floor(Math.random() * 2);
   if (sign === 1) array[index] *= -1;
}
let arrayToSort = array.slice();
ell = document.getElementById('p');
ell.innerHTML = "Started";

setTimeout(bubbleSort(array), 3000);

ell = document.getElementById('p');
ell.innerHTML = "Finished";
  
<p id="p"></p>

但是只有在执行了冒泡排序功能后文本才会发生变化（首先启动，然后立即完成）

为什么文本在函数之前没有改变？大约需要几秒钟。试图推入 setTimeout，但没有结果。我了解该语言的功能，但我不知道如何修复它。

javascript
Martin Hope
solarisedigle
Asked: 2021-11-10 22:06:00 +0000 UTC
  • 0

我正在实现一种快速排序算法，但它仅在元素少于 +-3000 个时才有效。如果有更多元素 - 这个错误就会消失。有一个返回条件，一切正常。问题是什么以及如何解决？这是代码：

function getRandomIntInclusive(min, max) {
    tf = 0;
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
function getBaseLog(x, y) {
    return Math.log(y) / Math.log(x);
}
function check_sort(array){
    var flag = true;
    for (var i = 0; i < array.length - 1; i++) {
        if (array[i] > array[i + 1]) {
            flag = false;
        }
    }
    return flag;
}
function default_sort(array){
    var flag = true;
    while(flag){
        flag = false;
        for (var i = 0; i < array.length - 1; i++) {
            if (array[i] > array[i + 1]) {
                flag = true;
                var tmp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = tmp;
            }
        }
    }
    return array;
}
function bubblesort(array){
    var flag = true;
    var k = 0;
    var array_length = array.length;
    var steps = Math.floor(array_length/100);
    const time_start= new Date().getTime();
    while(flag){
        flag = false;
        for (var i = 0; i < array.length - 1; i++) {
            if (array[i] > array[i + 1]) {
                flag = true;
                var tmp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = tmp;
            }
        }
        k++;
    }
    const time_end = new Date().getTime();
    var ms = time_end - time_start;
    console.log("Bubblesort - " + check_sort(array));
    return ms;
}
function selection(array){
    const time_start= new Date().getTime();
    var fixed = 0;
    var array_length = array.length;
    var steps = Math.floor(array_length/100);
    while (fixed < array.length - 1){
        var exchange = fixed;
        for (var i = fixed + 1; i < array.length; i++) {
            if(array[exchange] > array[i]){
                exchange = i; 
            }
        }
        if(exchange != fixed){
            var temp = array[fixed];
            array[fixed] = array[exchange];
            array[exchange] = temp;
        }
        fixed++;
    }
    const time_end = new Date().getTime();
    var ms = time_end - time_start;
    console.log("Selection - " + check_sort(array));
    return ms;
}
function shell(array){
    var step = array.length;
    const time_start= new Date().getTime();
    var array_length = array.length;
    var k = 0;
    while (step > 1){
        k++;
        step = Math.floor(step/2);
        for (var i = 0; i < step; i++) {
            var tmpray = [];
            for(var p = i; p <= array.length - 1; p += step){
                tmpray.push(array[p]);
            }
            tmpray = default_sort(tmpray);
            var j = 0;
            for(var p = i; p <= array.length - 1; p += step){
                array[p] = tmpray[j];
            j++;
            }
        }
    }
    const time_end = new Date().getTime();
    var ms = time_end - time_start;
    console.log("Shell - " + check_sort(array));
    return ms;
}
var mrg_steps;
var mrg_max;
var mrg_k;
function merge_recursive(array){
    mrg_k += 1;
    if(array.length > 1){
        var array_1 = array.slice(0, Math.floor((array.length)/2));
        var array_2 = array.slice(Math.floor((array.length)/2), array.length);
        array = default_sort(merge_recursive(array_1).concat(merge_recursive(array_2)));
    }
    return array;
}
function merge(array){
    mrg_max = array.length*2;
    mrg_steps = Math.floor(mrg_max/100);
    mrg_k = 1;
    const time_start= new Date().getTime();
    if(array.length > 1){
        var array_1 = array.slice(0, Math.floor((array.length)/2));
        var array_2 = array.slice(Math.floor((array.length)/2), array.length);
        array = default_sort(merge_recursive(array_1).concat(merge_recursive(array_2)));
    }
    const time_end = new Date().getTime();
    var ms = time_end - time_start;
    console.log("Merge - " + check_sort(array));
    return ms;
}
var k = 0;
function quicksort_recursive(start, end, array){
    k++;
    var i = start + 1;
    var j = end;
    var fixed = start;
    while(1){
        while(array[fixed] > array[i] && i < end){
            i++;
        }
        while(array[j] >= array[fixed] && j > start){
            j--;
        }
        if(i < j){
            var tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
        else {
            var tmp = array[j];
            array[j] = array[fixed];
            array[fixed] = tmp;
            break;
        }
    }
    if(j > start) quicksort_recursive(start, j, array);
    if(i < end) quicksort_recursive(i, end, array);
    return;
}
function quicksort(array){
    const time_start= new Date().getTime();
    var start = 0;
    var end = array.length - 1;
    var i = start + 1;
    var j = end;
    var fixed = start;
    while(1){
        while(array[fixed] > array[i] && i < end){
            i++;
        }
        while(array[j] >= array[fixed] && j > start){
            j--;
        }
        if(i < j){
            var tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
        else {
            var tmp = array[j];
            array[j] = array[fixed];
            array[fixed] = tmp;
            break;
        }
    }

    if(j > start) quicksort_recursive(start, j, array);
    if(i < end) quicksort_recursive(i, end, array);

    const time_end = new Date().getTime();
    var ms = time_end - time_start;
    console.log("Quick - " + check_sort(array));
    return ms;
}
var array = [];
for (var i = 0; i < 9000; i++) {
    array.push(getRandomIntInclusive(-200000, 200000));
}
console.log(bubblesort(array));
console.log(selection(array));
console.log(shell(array));
console.log(merge(array));
console.log(quicksort(array));

javascript
Martin Hope
solarisedigle
Asked: 2021-11-08 02:06:07 +0000 UTC
  • 1

该站点有一个常规页面，对其进行长时间计算（20 秒 - 5 分钟。） 30 秒后，浏览器中会出现一条消息，表明页面已冻结。当然，您可以单击“继续”按钮，但最好完全删除“冻结”，因为。该脚本仍然计算执行时间。是否有可能以某种方式启用后台模式，发送脚本在浏览器 api 中正常工作的信息？

javascript
Martin Hope
solarisedigle
Asked: 2021-11-07 23:58:28 +0000 UTC
  • 0

我正在js中实现计数排序算法。简而言之，算法：我们有一个数字数组（int / float），我们计算相同元素的数量，然后以正确的顺序简单地输出它们。示例：数组 - 5, 2, 4, 1, 7, 3, 2, 3, 5, 9, -2, 0, 5, 2 计算：

-2: 1
 0: 1
 1: 1
 2: 3
 3: 2
 4: 1
 5: 3
 7: 1
 9: 1

和输出：-2、0、1、2、2、2、3、3、4、5、5、5、7、9

问题是在 js 中没有带键的数组这样的东西。但是有对象。

作为参数的名称，我使用需要排序的值\u200b\u200b。但是我遇到了一个问题，js非常奇怪地保留了对象参数的顺序：首先是正数从小到大，然后是负数，但是从大到小。这是一个例子：

0: 1
1: 1
2: 2
3: 1
4: 1
5: 1
-2: 1
-3: 3
-4: 1
-5: 3

我怀疑js只是将它们排序为字符串。

我知道可以使用可以从对象排序的键值元素创建一个数组数组，但这是一种额外的排序，会显着影响结果。请告诉我，是否可以默认以某种方式指定参数通常是排序的，或者是否可以以不同的方式输出它们。谢谢

更新：正数以正确的顺序显示，负数以与它们创建时相同的顺序显示。我从浏览器控制台拿了一个例子，他们在里面排序，但没有显示真正的顺序。

javascript
Martin Hope
solarisedigle
Asked: 2020-05-10 19:44:24 +0000 UTC
  • 1

我编写了一个程序，它创建了一个 n 次多项式，并通过迭代系数和度数来计算 f(x) 来绘制它。

为了检查，我设置了正弦点，将多项式的次数设置为 6（它不需要第 7 个，太大的数字）我得到了一个相当漂亮的图形，其轮廓类似于正弦曲线（图 1） 我的日程表 它会看起来程序运行正常，但是通过将生成的多项式输入到任何其他在线编辑器中，我得到了完全不同的结果（图 2） 别人的图表 这根本不像一个接近正弦曲线的图形。多项式是对的，我和其他同学在网上查过（图纯属兴趣）

图表上选定点的颜色对应于表中字段的颜色。

该图绘制完美，我已经使用了很长时间，并在其他几十个功能上进行了测试。我发现这样的点：

function func(x0){
    var y= 0;
    for (var i = 0; i < coef.length; i++) {
        y += coef[i]*Math.pow(x0, i);
    }
    return y;
}

我将解释：我将它通过之前找到的所有系数，乘以 x 到迭代次数的幂（在这种情况下从 0 到 6）并添加到 y，将 y 返回到图中。

问题：悖论在哪里，我做错了什么/或者我不明白什么。

！！如果我还是画错了！！- 为什么会出现一个非常近似的图，然后为什么多项式应该构建一个近似于给定表的函数，甚至不接近？

感谢大家。在数学方面，我远不是一个优秀的学生，如果有愚蠢的错误请见谅）我只是对这个话题感兴趣。

javascript
Martin Hope
solarisedigle
Asked: 2020-03-17 19:39:20 +0000 UTC
  • 0

我明白这是题外话。但我不知道还能问哪里。

学习团结，C#

决定开始创作一款“为了改进”的游戏。在游戏中，您可以赚钱、购买升级以赚取更多的钱来购买更多升级并进入新的关卡。

我看到类似的游戏在大致相同的平衡下工作，每个级别都越来越难。但是我无法弄清楚游戏是通过什么原理/公式变得更加复杂并变慢的。

也许有一个合适的论坛，您可以在其中询问文章是否好或您自己的经验 - 我将非常感谢您提供的信息！

unity3d
Martin Hope
solarisedigle
Asked: 2020-03-15 03:28:58 +0000 UTC
  • 0

我有一个绑定到主相机的主游戏类，它存储我必须从其他脚本读取/编辑的变量。

如何实施？我是 Unity 和 OOP 的新手，我在 Internet 上找不到答案。

例子：

文件 1：

public class Game : MonoBehaviour
{
    ArrayList antibodies = new ArrayList();  
    // другой код
}

第二个文件：

public class Skin : MonoBehaviour
{
    void OnTriggerEnter2D(Collider2D other){
        if(other.gameObject.tag == "antibody "){
            (тут как-то достать antibodies).Remove(other);
        }
    }
}
c#
Martin Hope
solarisedigle
Asked: 2020-02-26 18:25:55 +0000 UTC
  • 0

我尝试了来自互联网的所有代码，不同的方法，输入了文件的完整/相对路径，但是代码没有进一步打开文件，它没有检查文件是否打开。有什么问题？

#include <fstream>
#include <iostream>

int main()
{
  using namespace std;
  ifstream inf("students.txt");
  while ( inf )
    {
        string val = "";
        inf >> val;
        cout << val;
    }
}
c++
Martin Hope
solarisedigle
Asked: 2020-01-23 22:18:00 +0000 UTC
  • 0

我有一个基于请求响应的电报机器人。

但是由于以后用户会更多，所以我们需要创建一个队列。它与优先级有什么关系，因为有些消息需要立即回复，有些消息可以等待 5-10 秒。

这样做也是为了不超过 30 个请求/秒的限制。

下一个问题是脚本执行时间。通信中断 30 秒，而 cron 只能每分钟触发一次。

如果您进行重定向 - 对下一个 cron 和当前 cron 的请求可以重叠（禁止）或暂停 5-6 秒，这也不好 - 很多损失。

问题：是否有可能以某种方式用新的 cron 停止旧的 cron？或者也许有一个为此类任务设计的普通库？

php