核心算法出错

A. 核心算法是什么它对机器人有多重要

机器人的算法大方向可以分为感知算法与控制算法，感知算法一般是环境感知、路径规划，而控制算法一般分为决策算法、运动控制算法。环境感知算法获取环境各种数据，通常指以机器人的视觉所见的图像识别等 。

虽然对于工业机器人来说，要想实现高速下稳定精确的运动轨迹，精密的配件必不可少，如电机，伺服系统，还有非常重要的减速机等等。但是这些都只是硬件的需求，仅仅只有好的硬件，没有相应的核心算法，也就是缺少了控制硬件的大脑，那么工业机器人使用再好的硬件，也只能完成一些精确度要求不高的简单工作，而且还容易出问题。而这就是中国机器人制造商面临的最大问题。

作为工业级产品，衡量机器人优劣主要有两个标准：稳定性和精确性。核心控制器是影响稳定性的关键部件，有着工业机器人“大脑”之称。而软件相当于语言，把“大脑”的想法传递出去。 要讲好这门“语言”，就需要底层核心算法。

好的算法，几千行就能让机器人稳定运行不出故障；差的算法，几万行也达不到人家的水准。不掌握核心算法，生产精度需求不高的产品还勉强可以，但倘若应用到航天航空、军工等高端领域，就只能依赖进口工业机器人了。

对于机器人来说，每一个动作都需要核心控制器、伺服驱动器和伺服电机协同动作，而现在的机器人通常拥用多个服务器，因此多台伺服系统更需要核心算法提前进行计算。只有通过底层算法，国外核心控制器才可以通过伺服系统的电流环直接操作电机，实现高动态多轴非线性条件下的精密控制，同时还能满足极短响应延时的需求。这也是为何如今在中国的机器人市场上，6轴以上的高端机器人几乎被国外的机器人公司垄断。

B. 哪位给介绍一下益盟L2核心算法是什么

你说的是益盟操盘手的Level2数据吧，这个东西我清楚刚刚还研究了一下。早在2006提9月份，上海证劵所Level2数据正式上市，各家的分析型软件都开始研究这套数据，因为通过对Level2数据的拆分，可以让投资者明白在巨额成交量中，哪笔是买入的哪笔是卖出的。有了L2核心算法再也不用单凭成交的多少来判断股票后期的走势了。益明操盘手的L2核心算法也是这个时候对这套数据进行潜心研究，益盟的L2核心算法采用科学的算法和合理的拆分方法，将资金流入流出清楚的展现在投资者面前。这使得益盟除了“选股池、操盘线、干坤图、马力表”四大核心外又多了一大核心功能。
L2核心算法是拆单，它的成败对软件分析的的其他数据和指标有着置关重要的作用，公式都是根据逐单还原的数据产生的，L2的核心算法如果逐单还原错了，那么软件的一系列数据也都不准确。益盟的L2核心算法采用的是最科学的方法，经得起数据的考验，我多次比较过两市权威机构发布的数据，和益盟的数据完全稳合，这说明L2核心算法是信得过的。

C. 关于医疗器械软件的核心算法是什么

根据《医疗器械软件注册技术审查指导原则》

（三）核心算法

依据软件设计规范（SDS）和说明书列明核心算法的名称、类型、用途和临床功能。

核心算法是指实现软件核心功能（软件在预期使用环境完成预期用途所必需的功能）所必需的算法，包括但不限于成像算法、后处理算法和人工智能算法。其中成像算法是指用于获取医学图像或数据的算法，后处理算法是指改变原始医学图像或数据产生新临床信息的算法，人工智能算法是指采用人工智能技术进行医学图像或数据分析的算法。

算法类型包括公认成熟算法和全新算法。其中公认成熟算法是指源自公开文献资料、原理简单明确、上市多年且无不良事件的算法，而全新算法是指源自临床研究、科学研究的新算法。

核心算法详尽程度取决于安全性级别和算法类型。当安全性级别为A级时，公认成熟算法和全新算法均列明算法的名称、类型、用途和临床功能。当安全性级别为B级和C级时，公认成熟算法列明算法的名称、类型、用途和临床功能，全新算法在公认成熟算法基础上提供安全性与有效性的验证资料。

D. java。。。求指点呀~~~

package e.cec.jsj.wzq;
public class NegativeSum {
private int[] intItem;
private String[] MSG = {"请输入9个数字（求和哟，亲）\n","出错啦，亲！","第",
"个:" ,"出现负数和的是:" ,"个！",
"no negative sum" ,"和是：" ,"\n"};
//打印
private void print(String msg){
System.out.print(msg);
}
//核心算法
private int negativeSum(){
int sum = 0;
for(int time = 0;time < 9;time++){
sum = intItem[time] + sum;
if(sum < 0)
return time + 1;
}
print(MSG[7] + sum + MSG[8]);
return -1;
}
//外部调用入口
public void calculate(){
print(MSG[0]);
//从键盘读入9个数字
try{
intItem = new int[9];
java.util.Scanner sc = new java.util.Scanner(System.in);
for(int time = 0;time < 9;time++){
print(MSG[2] + (time + 1) + MSG[3]);
intItem[time] = Integer.parseInt(sc.next());
}
} catch(Exception e){
print(MSG[1]);
e.printStackTrace();
}
//执行算法并判断结果
int result = negativeSum();
if (result == -1){
print(MSG[6]);
} else{
print(MSG[4] + MSG[2] + result + MSG[5]);
}
}
//程序入口
public static void main(String args[]) {
new NegativeSum().calculate();
}

}
看了你的求助才答的哈，我会乱说？ 花了我十多分钟 求采纳

E. 数据结构车厢调度问题核心算法解释

页面总数大于1，即m_PageCount>1，此时前面的m_PageCount-1个页面都是显示完全的，它相当于元素总个数中被12整除的部分。而第m_PageCount个页面此时的情况和页数总数为1的情况类似，我们可以采取和页面总数为1类似的方法来处理。

F. 机器学习常见的错误——核心数据缺乏控制

我们在前面的文章中给大家介绍了很多关于机器学习中常见的错误，当然，这些错误都是需要我们去避免的。在这篇文章中我们继续为大家介绍机器学习中常见的错误，希望大家能够引以为，从而更好地学习机器学习知识。
一般来说，从数据流的角度来看的话，机器学习系统中的数据要经过样本收集、特征生成、模型训练、数据评测等等这样一个流程，在这样一个比较长的流程中，不一定每个环节都是自己可控的，那么在那些不可控的环节，就有可能出现风险，而更可怕的是，由于数据控制在别人手里，如果数据控制出现了问题，那么我们很难清楚实际情况。如果我们以样本收集为例，在大型公司里，这样的工作很可能是由统一负责日志收集的平台部门来做的，而算法团队只要拿来用就可以了。这种做法有好处，也有坏处。好处很明显，就是减轻了算法团队的负担，但是也会带来隐患，就是我们拿到的数据不一定真的是我们要的数据。
大家都知道，正确的数据往往只有一种，但是错误的数据却有很多种错误方法。在样本收集方面，前台发送过来的曝光数据也存在着多种可能性，例如可能是缓存起来的数据，也有可能是用来做SEO的数据等等。这些数据在发送方来看，都是合理的数据，但对于算法模型来看，都不是用户真正看到的数据，而用户真正看到的数据才是我们真正想要的数据。那么作为这份数据的使用方，算法模型很有可能就会受到这种错误数据的影响。而且，最可怕的是，这种错误并不是那种能让程序崩溃的错误能够让我们能在第一时间发现，而是完全隐藏在正常数据中，只有我们犯了错误以后返回来找问题时或许才能发现。
那么大家是否知道这种错误数据出现的原因是什么呢？其实这种错误并不是一定日志收集团队不负责任，关键在于收集日志的团队不使用日志，或者说出数据的人不用数据，那么就很难要求他们来保证数据的质量。这种分离的状态对于模型算法这种高度依赖数据的应用是有风险的，所以最好能够加强这部分数据的控制能力，如果自己不能完全独立来做，那么就要有对应的监控机制，这就需要我们做到有问题能及时发现、及时处理，而不是“拿来主义”。
在这篇文章中我们给大家介绍了机器学习中常见的错误，具体就是对核心数据缺乏控制，相信大家阅读了这篇文章以后已经知道了这种错误导致的后果，希望这篇文章能够更好地帮助大家理解机器学习。

G. 求解释 为什么核心算法 于路程无关

简单的解释是:核心算法不关乎执行算法时的每步的执行长短,在意的是每步的结果.

H. JAVA的一道程序题，新手高分求助……（核心算法已经解决,求输入输出及异常处理）

比如：

import java.io.*;

class C {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("base.in"));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("base.out")), true);

outmost:
for (String line; (line = br.readLine()) != null; ) {
String[] nums = line.split("\\s+");
if (nums.length == 1 && Integer.parseInt(nums[0]) == 0)
break;

for (int rdx0 = 2; rdx0 <= 36; rdx0++)
for (int rdx1 = 2; rdx1 <= 36; rdx1++)
try {
if (Integer.parseInt(nums[0], rdx0) == Integer.parseInt(nums[1], rdx1)) {
out.printf("%s (base %s) = %s (base %s)%n", nums[0], rdx0, nums[1], rdx1);
continue outmost;
}
} catch (NumberFormatException e) { /* 不必做什么 */ }

out.printf("%s is not equal to %s in any base 2..36%n", nums[0], nums[1]);
}
}
}

I. C语言（哈瑟夫问题）

核心算法错了，我在注释中写出来了，把你不对的地方注释掉了。

intmain()
{
structstu
{
intdata;
structstu*next;
}person[13],*head,*p;

//方便阅读，把你的k放到了下边
inti,n;

for(i=0;i<13;i++)
{
person[i].data=i+1;
if(i==0)
head=&person[i];
else
person[i-1].next=&person[i];
}
person[i-1].next=head;

//你此处的报数删除算法完全不对。
//(1)p指向结构体，怎么能++呢？
//(2)你的next域完全没用到，根本不是链表的思维，还是数组的思维
/*for(p=head,n=0;n!=12;p++)
{
if(p->data!=0)
k++;
if(k==3)
{
p->data=0;
n++;
k=0;
}

}*/


//正确的报数删结点算法
intk;
structstu*prior=NULL;
for(p=head;p!=prior;p=p->next)
{
k=2;
while(k--)
{
prior=p;
p=p->next;
}
prior->next=p->next;
}

//你的循环查找输出也不对，最后就剩下一个结点，直接输出就行了
/*for(i=0,p=head;i<13;p++,i++)
while(p->data!=0)
printf("最后留在圈子中的人原来的序号为：%d
",person[i].data);*/

printf("最后留在圈子中的人原来的序号为：%d
",p->data);
system("pause");
return0;
}

上面的程序可以直接编译运行了，最后的结果是13.

但你根本就没理解链表，你的这个程序完全把数组和链表都弄混了，你写的是数组模拟的静态链表，却没有用next指针做事情，如果像你这种思路来写，根本就没必要用链表了，直接用一个整数数组就能完成题目的要求。比如我给你写的下面这个程序，同样能达到目的，比你那个简单多了。

intmain(intargc,char*argv[])
{
intq[13]={0};//标志数组
intindex;//数组下标
intdeleted;//已删除结点数
inti;

//从q[0]开始报数
index=0;

//删除12个结点，循环12遍
for(deleted=0;deleted<12;deleted++)
{
//报数到3
for(i=0;i<2;i++)
{
while(q[(++index)%13]);
continue;
}

//删除报3的点，并查找下一个未删除的结点
q[index%13]=1;
while(q[(++index)%13]);
}

//遍历数组，查找剩下的最后一个元素的下标
for(i=0;i<13;i++)
if(!q[i])
break;
printf("最后剩下的人原来的序号：%d
",i+1);
system("pause");
return0;
}

你如果真的要用链表来写，就用动态链表，malloc 13个结点，最后free 12 个结点，剩一个输出，输出后把最后一个free掉；要么还不如干脆别用，像我那样直接用数组，不然你那个程序弄个next指针不伦不类，纯粹耽误工夫。

动态链表实现如下：

structstu
{
intdata;
structstu*next;
};
intmain()
{
inti,n;
structstu*head,*p,*tail;

//动态建立循环链表
for(i=0;i<13;i++)
{
p=(structstu*)malloc(sizeof(structstu));
p->data=i+1;
p->next=NULL;
if(i==0)
{
head=p;
tail=p;
}
else
{
tail->next=p;
tail=tail->next;
}

}
tail->next=head;

//报数删结点
intk;
structstu*prior=NULL,*temp;
for(p=head;p!=prior;)
{
k=2;
while(k--)
{
prior=p;
p=p->next;
}
prior->next=p->next;
temp=p;
p=p->next;
free(temp);
}

//输出并释放最后一个结点
printf("最后留在圈子中的人原来的序号为：%d
",p->data);
free(p);
system("pause");
return0;
}

J. 帮我看看下面的代码哪错了 有一个地方有问题

你的程序中，p1，p2指向的地址是常量，它们不能被修改，这有问题
主要的问题是，你在使用的时候，竟然取p1，p2的地址，这就导致错误不可预期了
p1，p2的内容，也就是它们的值，是一个地址；它们作为变量，也有他们自己的地址
不知道你能否理解？

对的应该这样写：

#include<stdio.h>

int main(void)
{
char p1[80];char p2[80];
printf("input p1\n");
scanf("%s",p1);
printf("p1=%s\n",p1);
printf("input p2\n");
scanf("%s",p2);
printf("p2=%s\n",p2);
printf("p1=%s\n",p1);
}