核心演算法出錯

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);
}