1.股票通用的码分辅助画线工具都有什么?
2.LLVM（MLIR）安装编译
3.Package Manager
4.八数码C++源代码
5.c编程题+有多少个整点oj？

股票通用的辅助画线工具都有什么?

       通达信黄金分割压力和支撑画线主图指标公式,演示在源码下面网址里.

       N1:=;

       N2:=;

       N3:=5;

       AA:=REF(H,N1)=HHV(H,2*N1+1);

       QY:=BACKSET(AA,N1+1);

       CC:=FILTER(QY,N1) AND H=HHV(H,N1+1);

       DDD:=BARSLAST(CC);

       GDTS:=IF(CC,CURRBARSCOUNT,0);

       DINGBU:=IF(DDD,REF(H,DDD),H);{ 顶部}

       DINGBUTS:=IF(DDD,REF(GDTS,DDD),GDTS);

       DINGBU1:=REF(DINGBU,DDD+1);

       GDCS1:=CONST(DINGBUTS);

       DINGBUTS1:=REF(DINGBUTS,DDD+1);

       GDCS2:=CONST(DINGBUTS1);

       DINGBU2:=REF(DINGBU1,DDD+1);

       MM:=IF(CURRBARSCOUNT>GDCS2,0,1);

       { DRAWLINE(CURRBARSCOUNT=GDCS2,H,ISLASTBAR,REF(H,GDCS2-1),1),COLORFF,POINTDOT,LINETHICK2;

       DRAWLINE(CURRBARSCOUNT=GDCS1,H,ISLASTBAR,REF(H,GDCS1-1),1),COLORYELLOW,POINTDOT,LINETHICK2;}

       AA1:=REF(L,N1)=LLV(L,2*N1+1);

       QY1:=BACKSET(AA1,N1+1);

       CC1:=FILTER(QY1,N1) AND L=LLV(L,N1+1);

       DD1:=BARSLAST(CC1);

       DDTS:=IF(CC1,CURRBARSCOUNT,0);

       YDB:=IF(DD1,REF(L,DD1),L);

       DDTS1:=IF(DD1,REF(DDTS,DD1),DDTS);

       DDCS1:=CONST(DDTS1);

       ZDB:=REF(YDB,DD1+1);

       DDTS2:=REF(DDTS1,DD1+1);

       DDCS2:=CONST(DDTS2);

       { DRAWLINE(CURRBARSCOUNT=DDCS2,L,ISLASTBAR,REF(L,DDCS2-1),1),COLORFF,POINTDOT,LINETHICK2;

       DRAWLINE(CURRBARSCOUNT=DDCS1,L,ISLASTBAR,REF(L,DDCS1-1),1),COLORYELLOW,POINTDOT,LINETHICK2;}

       LAA:=REF(H,N2)=HHV(H,2*N2+1);

       LQY:=BACKSET(LAA,N2+1);

       LCC:=FILTER(LQY,N2) AND H=HHV(H,N2+1);

       LDDD:=BARSLAST(LCC);

       LGDTS:=IF(LCC,CURRBARSCOUNT,0);

       LDINGBU:=IF(LDDD,REF(H,LDDD),H);{ 顶部}

       LDINGBUTS:=IF(LDDD,REF(LGDTS,LDDD),LGDTS);

       LDINGBU1:=REF(LDINGBU,LDDD+1);

       LGDCS1:=CONST(LDINGBUTS);

       LDINGBUTS1:=REF(LDINGBUTS,LDDD+1);

       LGDCS2:=CONST(LDINGBUTS1);

       LDINGBU2:=REF(LDINGBU1,LDDD+1);

       LMM:=IF(CURRBARSCOUNT>LGDCS2,0,1);

       { DRAWLINE(CURRBARSCOUNT=LGDCS2,H,ISLASTBAR,REF(H,LGDCS2-1),1),COLORFF,POINTDOT;

       DRAWLINE(CURRBARSCOUNT=LGDCS1,H,ISLASTBAR,REF(H,LGDCS1-1),1),COLORYELLOW,POINTDOT;}

       LAA1:=REF(L,N2)=LLV(L,2*N2+1);

       LQY1:=BACKSET(LAA1,N2+1);

       LCC1:=FILTER(LQY1,N2) AND L=LLV(L,N2+1);

       LDD1:=BARSLAST(LCC1);

       LDDTS:=IF(LCC1,CURRBARSCOUNT,0);

       LYDB:=IF(LDD1,REF(L,LDD1),L);

       LDDTS1:=IF(LDD1,REF(LDDTS,LDD1),LDDTS);

       LDDCS1:=CONST(LDDTS1);

       LZDB:=REF(LYDB,LDD1+1);

       LDDTS2:=REF(LDDTS1,DD1+1);

       LDDCS2:=CONST(LDDTS2);

       DDYL2:=DRAWLINE(CURRBARSCOUNT=LGDCS2,H,CURRBARSCOUNT=LGDCS1,H,1) COLORWHITE;

       DDZC2:=DRAWLINE(CURRBARSCOUNT=LDDCS2,L,CURRBARSCOUNT=LDDCS1,L,1) COLORWHITE;

       ZGSTAR:=(DDYL2+DDZC2)/2;

       ZGEND:=CONST((DDYL2+DDZC2)/2);

       STARDAY:=IF(DDCS2<GDCS2,DDCS2,GDCS2);

       LLAA:=REF(H,N3)=HHV(H,2*N3+1);

       LLQY:=BACKSET(LLAA,N3+1);

       LLCC:=FILTER(LLQY,N3) AND H=HHV(H,N3+1);

       LLDDD:=BARSLAST(LLCC);

       LLGDTS:=IF(LLCC,CURRBARSCOUNT,0);

       LLDINGBU:=IF(LLDDD,REF(H,LLDDD),H);{ 顶部}

       LLDINGBUTS:=IF(LLDDD,REF(LLGDTS,LLDDD),LLGDTS);

       LLDINGBU1:=REF(LLDINGBU,LLDDD+1);

       LLGDCS1:=CONST(LLDINGBUTS);

       LLDINGBUTS1:=REF(LLDINGBUTS,LLDDD+1);

       LLGDCS2:=CONST(LLDINGBUTS1);

       LLDINGBU2:=REF(LLDINGBU1,LLDDD+1);

       LLMM:=IF(CURRBARSCOUNT>LGDCS2,0,1);

       { DRAWLINE(CURRBARSCOUNT=LLGDCS2,H,ISLASTBAR,REF(H,LLGDCS2-1),1),COLORFF,POINTDOT;

       DRAWLINE(CURRBARSCOUNT=LLGDCS1,H,ISLASTBAR,REF(H,LLGDCS1-1),1),COLORYELLOW,POINTDOT;}

       LLAA1:=REF(L,N3)=LLV(L,2*N3+1);

       LLQY1:=BACKSET(LLAA1,N3+1);

       LLCC1:=FILTER(LLQY1,N3) AND L=LLV(L,N3+1);

       LLDD1:=BARSLAST(LCC1);

       LLDDTS:=IF(LLCC1,CURRBARSCOUNT,0);

       LLYDB:=IF(LLDD1,REF(L,LLDD1),L);

       LLDDTS1:=IF(LLDD1,REF(LLDDTS,LLDD1),LDDTS);

       LLDDCS1:=CONST(LLDDTS1);

       LLZDB:=REF(LLYDB,LLDD1+1);

       LLDDTS2:=REF(LLDDTS1,DD1+1);

       LLDDCS2:=CONST(LLDDTS2);

       GDYL3:=DRAWLINE(CURRBARSCOUNT=LLGDCS2,H,CURRBARSCOUNT=LLGDCS1,H,1) COLORYELLOW;

       DDZC3:=DRAWLINE(CURRBARSCOUNT=LLDDCS2,L,CURRBARSCOUNT=LLDDCS1,L,1) COLORYELLOW;

       LZGSTAR:=(GDYL3+DDZC3)/2;

       LZGEND:=CONST((GDYL3+DDZC3)/2);

       LSTARDAY:=IF(LLDDCS2<LLGDCS2,LLDDCS2,LLGDCS2);

       GDYL1:=DRAWLINE(CURRBARSCOUNT=GDCS2,H,CURRBARSCOUNT=GDCS1,H,1) COLORRED;

       DDZC1:=DRAWLINE(CURRBARSCOUNT=DDCS2,L,CURRBARSCOUNT=DDCS1,L,1) COLORRED;

       长线压力:DDZC1+(GDYL1-DDZC1)*0.,COLORRED;

       长线支撑:DDZC1+(GDYL1-DDZC1)*0.,COLORRED;

       中线压力:DDZC2+(DDYL2-DDZC2)*0.,COLORGREEN;

       中线支撑:DDZC2+(DDYL2-DDZC2)*0.,COLORGREEN;

       短线压力:DDZC3+ (GDYL3-DDZC3)*0.,COLORBLUE;

       短线支撑:DDZC3+(GDYL3-DDZC3)*0.,COLORBLUE;

       L中轨:DRAWLINE(CURRBARSCOUNT=LSTARDAY,LZGSTAR,ISLASTBAR,LZGEND,1),COLORYELLOW;

       中轨:DRAWLINE(CURRBARSCOUNT=STARDAY,ZGSTAR,ISLASTBAR,ZGEND,1),COLORWHITE;

       长GDYL:DRAWLINE(CURRBARSCOUNT=GDCS2,H,CURRBARSCOUNT=GDCS1,H,1) COLORRED,POINTDOT;

       长DDZC:DRAWLINE(CURRBARSCOUNT=DDCS2,L,CURRBARSCOUNT=DDCS1,L,1) COLORRED,POINTDOT;

       中DDYL:DRAWLINE(CURRBARSCOUNT=LGDCS2,H,CURRBARSCOUNT=LGDCS1,H,1) COLORWHITE,POINTDOT;

       中DDZC:DRAWLINE(CURRBARSCOUNT=LDDCS2,L,CURRBARSCOUNT=LDDCS1,L,1) COLORWHITE,POINTDOT;

       短GDYL:DRAWLINE(CURRBARSCOUNT=LLGDCS2,H,CURRBARSCOUNT=LLGDCS1,H,1) COLORYELLOW,POINTDOT;

       短DDZC:DRAWLINE(CURRBARSCOUNT=LLDDCS2,L,CURRBARSCOUNT=LLDDCS1,L,1) COLORYELLOW,POINTDOT;

LLVM（MLIR）安装编译

       本文旨在为有兴趣自行安装和编译 LLVM（利用 MLIR 作为后端输出的主要方式）的读者提供一份详细指南。在实际操作过程中，码分可能会遇到一些理解上的码分偏差，欢迎指正。码分由于目标是码分能在 x 和 RISCV 上运行，所有配置均基于 i7-H 笔记本，码分自动写诗源码运行 Ubuntu . LTS 系统。码分

       以下是码分编译配置的步骤：

       第一步：下载 LLVM 的源码。确保已安装 git，码分若未安装，码分请执行 sudo apt-get install git。码分创建名为 LLVM 的码分文件夹存放 LLVM 源码，并将源码文件夹命名为 llvm-project。码分接着，码分通过 git 下载 LLVM 源码。码分

       第二步：建立用于 LLVM 编译的文件夹。为了区分编译产生的分享棋牌源码文件和源文件，建立名为 build 的文件夹。在教程中，每段代码都以 cd 到主文件夹，然后进入工程文件夹的方式进行，便于理解。

       第三步：进入 build 文件夹，完成编译配置。此过程大致分为如何编译、极地指标源码编译什么、为谁编三个部分。具体参数如下：

       如何编译：指定编译器类型、线程数及目标地址。例如，使用 -DLLVM_PARALLEL_COMPILE_JOBS=### 设置并行编译工作数，使用 -DCMAKE_INSTALL_PREFIX=*** 指定安装路径，使用 -DLLVM_CCACHE_BUILD=### 选择是plotclock源码解否使用 ccache。选择 C 和 C++ 编译器，如 -DCMAKE_C_COMPILER=### 和 -DCMAKE_CXX_COMPILER=###。启用 LLD 作为链接器以提高效率，可通过 -DLLVM_ENABLE_LLD=ON 实现。

       编译什么：设置编译版本类型，如 Debug、Release 等，使用 -DCMAKE_BUILD_TYPE=###。tbt指标源码同时，通过 -DLLVM_ENABLE_PROJECTS=### 配置需要编译的子项目。

       为谁编：指定目标平台，如 x 和 RISCV，使用 -DLLVM_TARGETS_TO_BUILD=###。可选平台包括但不限于：AArch、AMDGPU、ARM、AVR、BPF、Hexagon 等。

       注意：在完成编译配置后，执行编译命令。在遇到可能的问题时，检查错误信息并根据需要调整参数。最后，根据实际需求进行文件路径、编译选项等的调整。

       以上步骤和参数配置将帮助您成功安装和编译 LLVM，满足在 x 和 RISCV 上运行的需求。通过本文提供的指南，希望能为您的项目开发提供便利。如有任何疑问或需要进一步的帮助，请随时提问。

Package Manager

        PackageInstaller是安卓上默认的应用程序，用它来交互式地安装普通包文件。 PackageInstaller提供了用户界面来管理应用或者包文件。PackageInstaller调用一个叫 InstallAppProgress的activity来获取用户发出的指令。InstallAppProgress会请求Package Manager Service，然后通过indalld来安装包文件。源码提供在/packages/apps/PackageInstaller上。

        这个系统守护程序的首要角色是获取来自Package Manager Service的请求，而该请求是通过Linux套接字/dev/socket/installed获得的。

        Installd使用管理员权限执行一系列的步骤来安装APK。

        Package Manger是一个实际上管理应用程序安装、卸载和升级的API。当我们安装APK文件 时，Package Manager会解析APK包文件和显示确认信息。当我们点击OK按钮后，Package Manger会调用一个叫“InstallPackage”的方法，这个方法有四个参数，也就是uri、installFlags、observer和 installPackagename。Package Manger请求服务。

        Package Manger服务运行在系统服务进程中，而安装守护程序（installd）作为一个本地进程运行着，他们都在系统启动时开始运行。

八数码C++源代码

       #include<cstdio>

       #include<vector>

       #include<queue>

       #include<ctime>

       #define maxhash

       #define hash(x) x%maxhash

       using namespace std;

       typedef unsigned long long ULL;

       vector<ULL>list[maxhash];

       vector<int>dist[maxhash];

       inline int abs(int x)

       {

       return x<0?-x:x;

       }

       int hval[][];

       void fill_hval(int *d)

       {

       for(int i=0;i<=8;i++)//number i

       {

       int pos;

       for(int k=1;k<=9;k++)//i's position

       if(d[k]==i)

       {

       pos=k;

       break;

       }

       for(int j=1;j<=9;j++)

       {

       hval[i][j]=abs((j-1)/3-(pos-1)/3)+abs((j-1)%3-(pos-1)%3);

       }

       }

       }

       int h(ULL d)

       {

       int answer=0;

       for(int i=9;i>=1;i--)

       {

       int x=d%;

       d/=;

       answer+=hval[x][i];

       }

       return answer;

       }

       int ToARR(ULL s,int *d)

       {

       int z=0;

       for(int i=9;i>=1;i--)

       {

       d[i]=s%;

       if(d[i]==0) z=i;

       s/=;

       }

       return z;

       }

       ULL ToULL(int *d)

       {

       ULL ans=0;

       for(int i=1;i<=9;i++)

       ans=ans*+d[i];

       return ans;

       }

       void insert(ULL x,int di)

       {

       ULL hx=hash(x);

       list[hx].push_back(x);

       dist[hx].push_back(di);

       }

       int find(ULL x)

       {

       ULL hx=hash(x);

       int size=list[hx].size();

       for(int i=0;i<size;i++)

       if(x==list[hx][i]) return dist[hx][i];

       return -1;

       }

       inline void swap(int &x,int &y)

       {

       int t=x;

       x=y;

       y=t;

       }

       struct state{

       int step;

       ULL x;

       friend bool operator <(state a,state b)

       {

       return a.step>b.step;

       }

       };

       int cnt=0;

       void AStar(int *from,int *to)

       {

       priority_queue<state>q;

       ULL x=ToULL(from);

       ULL y=ToULL(to);

       fill_hval(to);

       q.push((state){ h(x),x});

       insert(x,0);

       int d[];

       while(!q.empty())

       {

       cnt++;

       state s=q.top();

       ULL i=s.x; q.pop();

       int step=find(i);

       int z=ToARR(i,d);

       //printf("%lld %d %d\n",i,step,z);

       if(i==y) return;

       if(z-3>0)

       {

       swap(d[z],d[z-3]);

       ULL j=ToULL(d);

       swap(d[z],d[z-3]);

       if(find(j)!=-1) goto out1;

       q.push((state){ step+h(j),j});

       insert(j,step+1);

       }

       out1:

       if(z+3<)

       {

       swap(d[z],d[z+3]);

       ULL j=ToULL(d);

       swap(d[z],d[z+3]);

       if(find(j)!=-1) goto out2;

       q.push((state){ step+h(j),j});

       insert(j,step+1);

       }

       out2:

       if(z%3!=0)

       {

       swap(d[z],d[z+1]);

       ULL j=ToULL(d);

       swap(d[z],d[z+1]);

       if(find(j)!=-1) goto out3;

       q.push((state){ step+h(j),j});

       insert(j,step+1);

       }

       out3:

       if(z%3!=1)

       {

       swap(d[z],d[z-1]);

       ULL j=ToULL(d);

       swap(d[z],d[z-1]);

       if(find(j)!=-1) continue;

       q.push((state){ step+h(j),j});

       insert(j,step+1);

       }

       }

       }

       int from[],to[];

       void work()

       {

       for(int i=1;i<=9;i++)

       scanf("%d",&from[i]);

       for(int i=1;i<=9;i++)

       scanf("%d",&to[i]);

       AStar(from,to);

       ULL y=ToULL(to);

       printf("%d ",find(y));

       #ifdef DEBUG

       printf("%d ",clock());

       printf("%d ",cnt);

       #endif

       }

       int main()

       {

       #ifdef DEBUG

       freopen("debug.in","r",stdin);

       freopen("debug.out","w",stdout);

       #endif

       work();

       return 0;

       }

       这是基于曼哈顿距离的估价函数的Astar

c编程题+有多少个整点oj？

       分清况讨论：

       当线段为水平或竖直时，两端点整数之间的整数个数即为所求；

       当线段为斜线时，其斜率|k|=|(y2-y1)/(x2-x1)|=|dy/dx|

       dy和dx同除以它们的最大公约数，可将k化为既约分数的形式|k|=|a|/|b|

       那么线段上整点的x坐标一定满足|x-x1|能被|b|整除

       所以问题转化为x1~x2上有多少个整数能被|b|整除

       最后注意坐标的数据范围，为防止溢出都使用长整型long long

       C代码和运行结果如下：

       输出符合样例，望采纳~

       附源码：

#include <stdio.h>

typedef long long ll;

ll abs(ll x) { // 返回绝对值

    return x < 0 ? -x : x;

}

ll gcd(ll a, ll b) { // 辗转相除法求最大公约数

    return b ? gcd(b, a % b) : a;

}

int main() {

    int T;

    ll x1, y1, x2, y2, dx, dy, k;

    scanf("%d", &T);

    while (T--) {

        scanf("%lld%lld%lld%lld", &x1, &y1, &x2, &y2);

        if (x1 == x2) { // 位于同一竖直线上

            printf("%lld\n", abs(y2 - y1) + 1);

        }

        else if (y1 == y2) { // 位于同一水平线上

            printf("%lld\n", abs(x2 - x1) + 1);

        }

        else {

            dx = abs(x2 - x1);

            dy = abs(y2 - y1);

            k = gcd(dx, dy);

            k = dx / k; // 整点的x坐标一定满足|x-x1|能被k整除

            printf("%lld\n", dx / k + 1);

        }

    }

    return 0;

}