我被困在解决以下面试实践问题:
我必须写一个函数:
int triangle(int[] A);
给定零索引数组A由N整数组成,1如果存在三重(P,Q,R)则返回0 < P < Q < R < N.
A[P] + A[Q] > A[R],
A[Q] + A[R] > A[P],
A[R] + A[P] > A[Q].
0如果不存在这样的三元组,则该函数应该返回.假设0 < N < 100,000.假设数组的每个元素都是范围内的整数[-1,000,000..1,000,000].
例如,给定的数组就是A这样
A[0]=10, A[1]=2, A[2]=5, A[3]=1, A[4]=8, A[5]=20
函数应该返回1,因为三元组(0, 2, 4)满足所有必需条件.
对于A这样的阵列
A[0]=10, A[1]=50, A[2]=5, A[3]=1
该函数应该返回0.
如果我做一个三重循环,这将非常非常慢(复杂性:) O(n^3).我想也许可以用来存储数组的额外副本并对其进行排序,并使用二进制搜索特定的数字.但我不知道如何解决这个问题.
有任何想法吗？
如果我想在我的C++代码中使用以下连接,那么声明我的头文件的最佳方法是什么,这样我就不会得到'include nested too deep error'？
在我的边缘类中,我有一些需要返回Node对象的函数.对于Edge类,我有需要返回Node对象的函数.但是编译器不允许我有这个嵌套循环的东西.
Node.h
#ifndef _NODE_h__
#define __NODE_h__
#include "Edge.h"
public:
Node();
~Node();
void setName(string);
string getName();
void addEdge(Edge*);
vector<Edge* > getEdges() { return _edges; };
};
#endif
Edge.h
#ifndef _EDGE_h__
#define __EDGE_h__
#include "Node.h"
class Edge
{
public:
Edge();
Edge(bool);
~Edge();
bool hasBeenSeen() { return _seen; };
void reset() { _seen = false; }; // resets seen param to false
Node* getSource() { return _source; };
Node* getTarget() { return _target; };
void setSource(Node* …我正在尝试计算矩阵(任何大小)的行列式,用于自编码/面试练习.我的第一次尝试是使用递归,这导致我进行以下实现:
import java.util.Scanner.*;
public class Determinant {
double A[][];
double m[][];
int N;
int start;
int last;
public Determinant (double A[][], int N, int start, int last){
this.A = A;
this.N = N;
this.start = start;
this.last = last;
}
public double[][] generateSubArray (double A[][], int N, int j1){
m = new double[N-1][];
for (int k=0; k<(N-1); k++)
m[k] = new double[N-1];
for (int i=1; i<N; i++){
int j2=0;
for (int j=0; j<N; j++){
if(j == j1)
continue;
m[i-1][j2] = …我按照libjpeg示例文件中的示例代码,但是我无法读取图像数据.
我有以下结构,我创建了这个结构的一个实例.
struct ImageData {
unsigned char *pixels;
long width;
long height;
};
ImageData *imageData;
下面是我的read_JPEG_file函数:
int read_JPEG_file (char * filename)
{
struct jpeg_decompress_struct cinfo;
struct my_error_mgr jerr;
/* More stuff */
FILE * infile; /* source file */
JSAMPARRAY buffer; /* Output row buffer */
int row_stride; /* physical row width in output buffer */
if ((infile = fopen(filename, "rb")) == NULL) {
fprintf(stderr, "can't open %s\n", filename);
return 0;
}
/* Step 1: allocate and initialize JPEG decompression …我正在尝试在GPU上实现矩阵向量乘法(使用CUDA).
在我的C++代码(CPU)中,我将矩阵加载为密集矩阵,然后使用CUDA执行矩阵向量乘法.我也使用共享内存来提高性能.
下面是我加载矩阵的C++函数:
int readMatrix( char* filename, float* &matrix, unsigned int *dim = NULL, int majority = ROW_MAJOR )
{
unsigned int w, h, x, y, num_entries;
float val;
std::ifstream file( filename );
if ( file )
{
file >> h >> w >> num_entries;
cout << w << " " << h << " " << num_entries << "\n";
assert( w == h || w == 1 || h == 1 );
if( dim != NULL ) *dim …假设我有以下User结构:
struct User {
string userId;
UserType userType; // UserType is just an enumeration
string hostName;
string ipAddress;
//and more other attributes will be added here
};
我需要存储一组用户记录(大约10 ^ 5个用户,也可以扩展得更高).如果我将它存储为unordered_set或unordered_map,它的性能会更好吗？Unordered_set在技术上与HashSet相同,unordered_map与HashMap相同,对吧？使用常规集(有序)不是一个选项,因为当元素数量增加时插入和删除将变得非常慢.
unordered_set <User> userRecords;
要么
unordered_map <string, User> userRecords; // string is the user ID.
我需要它在插入,删除和通过其userId访问特定用户对象方面非常快.
关于如何always在Verilog模块中编写块,我有一个简单的问题.
如果我的Verilog模块中有以下输入:
input [31:0] PCplus4 ; // Value of PC + 4
input [31:0] A; // Value A, i.e. RSbus (Use Forwarded Value)
input [31:0] B; // Value B, i.e. RTbus (Use Forwarded Value)
input [31:0] IMM; // Extended Immediate Value
input [25:0] TARGET; // Target Address for Jumps
input [3:0] BR; // Branch Selector Input
如果我使用,有什么不同
always @ (*)
代替
always @ (PCplus4 or A or B or IMM or TARGET or BR)
这种always @ (*) …
我正在尝试测量 2 个模拟应用程序（用 C++ 编写）之间的 IO 数据传输率（带宽）。我创建了一个非常简单的 perfclient 和 perfserver 程序，只是为了在实际应用程序中实现这种计算方法之前验证我计算网络带宽的方法是否正确。因此，在这种情况下，我需要以编程方式执行此操作（不使用 Iperf）。
我尝试在各个域（本地主机、连接到以太网的计算机以及连接到无线连接的计算机）上运行我的 perfclient 和 perfserver 程序。然而，我总是得到这些不同主机上相似的带宽，大约 1900 Mbps（使用 1472 字节的数据大小进行测试）。这是一个合理的结果，还是我可以获得更好、更准确的带宽？
我应该使用1472（这是以太网MTU，不包括标头）作为每个send()和recv()的最大数据大小，为什么/为什么不呢？我还尝试使用不同的数据大小，这是我获得的平均带宽（使用以太网连接进行测试），这对我来说没有意义，因为数字超过了 1Gbps，达到了 28 Gbps 左右。
SIZE BANDWIDTH
1KB 1396 Mbps
2KB 2689 Mbps
4KB 5044 Mbps
8KB 9146 Mbps
16KB 16815 Mbps
32KB 22486 Mbps
64KB 28560 Mbps
这是我当前的方法：
我做了一个基本的乒乓时尚循环，其中客户端不断向服务器程序发送数据流字节。服务器将读取这些数据，并将数据反映（发送）回客户端程序。然后客户端将读取这些反射数据（2 路传输）。上述操作重复1000次，然后我将时间除以1000以获得平均延迟时间。接下来，我将平均延迟时间除以 2，得到 1 路传输时间。带宽可以计算如下：
bandwidth = total bytes sent / average 1-way transmission time
我的做法有什么问题吗？我怎样才能确保我的结果没有偏见？一旦我做到了这一点，我将需要在我的原始应用程序（不是这个简单的测试应用程序）中测试这种方法，并且我想将此性能测试结果放入科学论文中。
编辑： 我已经解决了这个问题。查看我在下面发布的答案。
我想知道是否有一种简单的方法来查询(编程)GPU OpenGL限制以获得以下功能:
- 最大2D纹理大小
- 最大3D纹理大小
- 最大顶点着色器属性
数 - 最大变化浮点数
- 纹理数图像单元(在顶点着色器和片段着色器中)
- 最大绘制缓冲区数
在编写GPU研究项目之前,我需要提前知道这些数字.
解决这个问题的最佳方法是什么？N元素阵列A的平衡点是索引i,使得较低索引上的所有元素具有值<= A [i],并且较高索引上的所有元素具有高于或等于A [i]的值.
例如,给定:
A [0] = 4 A [1] = 2 A [2] = 7 A [3] = 11 A [4] = 9
一个正确的解决方案是:2.A [2]以下的所有元素都小于A [2],A [2]之后的所有元素都大于A [2].在我看来,一个解决方案是O(nsquare)解决方案.有没有更好的解决方案？