/*
-------------------------------------------------------------
*/
static void midiCleanUp()
{
lock_guard<SC_Lock> mulo(gPmStreamMutex);
if(gMIDIInitialized) {
for (int i=0; i<gNumMIDIOutPorts; ++i) {
Pm_Abort(gMIDIOutStreams[i]);
Pm_Close(gMIDIOutStreams[i]);
}
for (int i=0; i<gNumMIDIInPorts; ++i) {
Pm_Abort(gMIDIInStreams[i]);
Pm_Close(gMIDIInStreams[i]);
}
gNumMIDIOutPorts = 0;
gNumMIDIInPorts = 0;
}
// set the stream pointers to NULL
memset(gMIDIInStreams,0,kMaxMidiPorts*sizeof(PmStream*));
memset(gMIDIOutStreams,0,kMaxMidiPorts*sizeof(PmStream*));
// delete the objects that map in/out indices to Pm dev indices
gMidiInputIndexToPmDevIndex.clear();
gMidiOutputIndexToPmDevIndex.clear();
gMIDIInitialized = false;
}
inline void initChecks(const vector<vector<char>>& board)
{
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
memset(table, 0, sizeof(table));
for (int i = 0; i != 9; i++)
{
for (int j = 0; j != 9; j++)
{
if (board[i][j] == '.') continue;
set(i, j, board[i][j], true);
}
}
}
b2World::b2World(const b2Vec2& gravity)
{
m_destructionListener = NULL;
m_debugDraw = NULL;
m_bodyList = NULL;
m_jointList = NULL;
m_bodyCount = 0;
m_jointCount = 0;
m_warmStarting = true;
m_continuousPhysics = true;
m_subStepping = false;
m_stepComplete = true;
m_allowSleep = true;
m_gravity = gravity;
m_flags = e_clearForces;
m_inv_dt0 = 0.0f;
m_contactManager.m_allocator = &m_blockAllocator;
memset(&m_profile, 0, sizeof(b2Profile));
}
int game_update()
{
const char* key = keyboard_state();
// clear framebuffer
memset(g_framebuffer.data, 12, g_framebuffer.width*g_framebuffer.height);
if (key[KEY_UP])
y -=2;
if (key[KEY_DOWN])
y += 2;
if (key[KEY_LEFT])
x -= 2;
if (key[KEY_RIGHT])
x += 2;
sprite_blit(&g_sprite, &g_framebuffer, x, y);
// q key is press: exit!
if ( key[KEY_ESCAPE] )
return 1;
else
return 0;
}
int characterReplacement(string s, int k) {
const int DICT_SIZE = 26;
int cnt[DICT_SIZE];
int i, j;
int ls = s.size();
int mi;
int res = 0;
memset(cnt, 0, DICT_SIZE * sizeof(int));
i = 0;
for (j = 0; j < ls; ++j) {
++cnt[s[j] - 'A'];
while (true) {
// Keep shifting forward until satisfied
mi = getMaxIndex(cnt, DICT_SIZE);
if (j - i + 1 - cnt[mi] > k) {
--cnt[s[i++] - 'A'];
} else {
break;
}
}
res = max(res, j - i + 1);
}
return res;
}
void SPFA(int source)
{
memset(visited,false,sizeof(bool)*(P+2));
int close,open;
close=1;
open=1;
q[close]=source;
visited[source]=true;
for (int i=1;i<=P;i++) dist[i]=oo;
dist[source]=0;
while (close<=open)
{
//cout<<close<<"cl"<<open<<"op"<<endl;
int now=q[close%P];
close++;
visited[now]=false;
for (List* i=link[now];i!=0;i=i->next)
{
int next=i->data;
if ((dist[now]!=oo)&&(dist[next]>dist[now]+map[now][next]))
{
dist[next]=dist[now]+map[now][next];
if (!visited[next])
{
//cout<<next<<" "<<now<<endl;
visited[next]=true;
open++;
q[open%P]=next;
}
}
}
}
//for (int i=1;i<=P;i++) cout<<dist[i]<<" ";cout<<endl;
}
//判断牌型是否是飞机带同数量的对子
bool CardCombine::is_Plane_Dui()const
{
/*
* 1.先把原牌组拆成对子部分和非对子部分
* 2.非对子部分是否构成无翅飞机 且 非对子部分的牌数是对子部分的1.5倍
* then 怎样拆成两部分?
* 可以先按点数进行计数排序,结果为uint count[16]
* 然后遍历原牌组origin[],
* 若count[origin[i].getPoint()]==2,则将此牌加入对子部分
* 反之,则将此牌加入非对子部分
*/
unsigned int count[16];
memset(count,0,16*sizeof(unsigned int));
unsigned int N=static_cast<unsigned int>(_list.size());
for(unsigned int i=0;i<N;i++)
count[_list[i].getPoint()]++;
CardCombine c1,c2;
for(unsigned int i=0;i<N;i++){
if(count[_list[i].getPoint()]==2)
c1.add(_list[i]);
else
c2.add(_list[i]);
}
return 2*c2.getList().size()==3*c1.getList().size()&&c2.is_Plane();
}
int longestPalindrome(string s) {
// Lowercase letters only.
const int DICT_SIZE = 256;
int cnt[DICT_SIZE];
bool has_odd = false;
memset(cnt, 0, DICT_SIZE * sizeof(int));
int n = s.size();
int i;
for (i = 0; i < n; ++i) {
++cnt[s[i]];
}
int res = 0;
for (i = 0; i < DICT_SIZE; ++i) {
if (cnt[i] & 1 != 0) {
has_odd = true;
}
res += (cnt[i] >> 1 << 1);
}
if (has_odd) {
++res;
}
return res;
}
void Server::run(int port) {
// bind to port
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(port);
// allow reusing recently closed socket
int reuse = 1;
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
// bind to address
bind(s, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
// start listening for connections
int backlog = 5;
listen(s, backlog);
r = true;
while(r) {
// warte auif eingehende Verbindung
cout << "Waiting for new Connection" << endl;
int cs = accept(s, 0, 0);
if(cs < 0)
cout << "accept encountered error " << cs << endl;
else
onAccept(cs);
}
}
void CreateNeighbours(EERIE_3DOBJ * obj)
{
if (obj->ndata == NULL)
{
obj->ndata = (NEIGHBOURS_DATA *)malloc(sizeof(NEIGHBOURS_DATA) * obj->vertexlist.size());
}
else memset(obj->ndata, 0, sizeof(NEIGHBOURS_DATA)*obj->vertexlist.size());
for (size_t i = 0; i < obj->vertexlist.size(); i++)
{
obj->ndata[i].Nvertex = NULL;
obj->ndata[i].Nfaces = NULL;
obj->ndata[i].nb_Nfaces = 0;
obj->ndata[i].nb_Nvertex = 0;
for (size_t j = 0; j < obj->facelist.size(); j++)
{
if ((obj->facelist[j].vid[0] == i) ||
(obj->facelist[j].vid[1] == i) ||
(obj->facelist[j].vid[2] == i))
{
AddNeighBoringVertex(obj, i, obj->facelist[j].vid[0]);
AddNeighBoringVertex(obj, i, obj->facelist[j].vid[1]);
AddNeighBoringVertex(obj, i, obj->facelist[j].vid[2]);
AddNeighBoringFace(obj, i, j);
}
}
}
}
void initDif()
{
memset(dif,0,sizeof(dif));
for (int i=0;i<line;i++)
for (int j=0;j<id_len;j++)
for (int k=0;k<MAXLINE;k++)
dif[i][j][k]=different(font[SET[j]][k],in[i]);
}
int main()
{
char string1[ 15 ] = "BBBBBBBBBBBBBB";
cout << "string1 = " << string1 << endl;
cout << "string1 after memset = "
<< static_cast< char * >( memset( string1, 'b', 7 ) ) << endl;
return 0;
} // end main
ssize_t Package::send(TCPStream& stream) const {
char buff[getPackageSize()];
memset(buff, 0, sizeof(buff));
writeData(buff);
ssize_t sent = stream.send(buff, getPackageSize());
return sent;
}
void init_ambient_light_module(MblMwMetaWearBoard *board) {
Ltr329Config* new_config = (Ltr329Config*) malloc(sizeof(Ltr329Config));
memset(new_config, 0, sizeof(Ltr329Config));
new_config->als_measurement_rate = MBL_MW_ALS_LTR329_RATE_500MS;
board->module_config.emplace(MBL_MW_MODULE_AMBIENT_LIGHT, new_config);
board->sensor_data_signals[LTR329_ILLUMINANCE_RESPONSE_HEADER]= new MblMwDataSignal(LTR329_ILLUMINANCE_RESPONSE_HEADER,
board, ResponseConvertor::UINT32, 1, 4, 0, 0);
}
void Bytecode::OptimizeFixups()
{
Fixup *f;
int codeLength = GetLength();
// the remap array initially is marked with bytes that
// are to be deleted, then later it becomes the map
// from old index to new one
int *remap = new int[codeLength+1];
memset(remap, 0, (codeLength+1) * sizeof(int));
for(f=fFixups.GetHead(); f; f=f->GetNext()) {
if (ShortenFixup(*f)) {
// mark byte to be deleted
remap[f->fLocation+1] = 1;
// change the opcode
fData[f->fLocation - f->fOpcodeOffset] = f->fShortOpcode;
}
}
// trim the code and compute the remap array
int offset = 0;
for(int i=0; i<codeLength; ++i) {
if (!remap[i]) {
fData[offset] = fData[i];
remap[i] = offset++;
}
else {
remap[i] = offset;
}
}
fData.resize(offset);
// add remap entry for end-of-program
remap[codeLength] = offset;
// adjust the labels
int i;
for(i=0; i<(int)fLabels.size(); ++i) {
fLabels[i] = remap[fLabels[i]];
}
// adjust the fixups
for(f=fFixups.GetHead(); f; f=f->GetNext()) {
f->fLocation = remap[f->fLocation];
}
// adjust source tags
for(i=0; i<(int)fTags.size(); ++i) {
fTags[i].fAddress = remap[fTags[i].fAddress];
}
delete [] remap;
}
int run()
{
for (int k=1;k<=N;k++)
for (int i=1;i<=N;i++)
for (int j=1;j<=N;j++)
m[i][j]=m[i][j]||(m[i][k]&&m[k][j]);
int part=0;
int representative[MAXN+2];
bool visited[MAXN+2];
memset(visited,false,sizeof(visited));
for (int i=1;i<=N;i++)
if (!visited[i])
{
representative[++part]=i;
visited[i]=true;
for (int j=1;j<=N;j++)
if (m[i][j]&&m[j][i])
visited[j]=true;
}
int indegree[MAXN+2];
int outdegree[MAXN+2];
memset(indegree,0,sizeof(indegree));
memset(outdegree,0,sizeof(outdegree));
for (int i=1;i<=part;i++)
for (int j=1;j<=part;j++)
if (i!=j&&m[representative[i]][representative[j]])
{
indegree[j]++;
outdegree[i]++;
}
int inTotal=0,outTotal=0;
for (int i=1;i<=part;i++)
{
if (!indegree[i]) inTotal++;
if (!outdegree[i]) outTotal++;
}
if (part>1) cout<<inTotal<<endl<<(inTotal>outTotal?inTotal:outTotal)<<endl;
else cout<<1<<endl<<0<<endl;
return 0;
}
void mbl_mw_acc_mma8452q_write_acceleration_config(const MblMwMetaWearBoard *board) {
uint8_t command[7]= {MBL_MW_MODULE_ACCELEROMETER, ORDINAL(AccelerometerMma8452qRegister::DATA_CONFIG)};
auto config = (Mma8452qConfig*) board->module_config.at(MBL_MW_MODULE_ACCELEROMETER);
Mma8452qAccBitField bit_field;
memset(&bit_field, 0, sizeof(Mma8452qAccBitField));
bit_field.dr= config->odr;
bit_field.fs= config->accel_fsr;
memcpy(command + 2, &bit_field, sizeof(bit_field));
SEND_COMMAND;
}
string getHint(string secret, string guess) {
const int DICT_SIZE = 10;
int cnt1[DICT_SIZE], cnt2[DICT_SIZE];
int bull = 0;
int cow = 0;
int n = secret.size();
int i;
memset(cnt1, 0, DICT_SIZE * sizeof(int));
memset(cnt2, 0, DICT_SIZE * sizeof(int));
for (i = 0; i < n; ++i) {
++cnt1[secret[i] - '0'];
++cnt2[guess[i] - '0'];
if (secret[i] == guess[i]) {
++bull;
}
}
for (i = 0; i < DICT_SIZE; ++i) {
cow += min(cnt1[i], cnt2[i]);
}
cow -= bull;
return to_string(bull) + "A" + to_string(cow) + "B";
}
void Client::connect(const char *hostname, int port)
{
struct hostent *server;
server = gethostbyname(hostname);
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
memcpy(&serv_addr.sin_addr.s_addr, server->h_addr, server->h_length);
serv_addr.sin_port = htons(port);
// connect
::connect(s, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
}
int create_semaphore(key_t key){
int id, retval;
SEMUN s;
id = semget(key, 1, IPC_CREAT|IPC_EXCL|0777);
if (id < 0) {
return ERR_SEMGET;
}
memset(&s, 0, sizeof(s));
s.val = 1;
retval = semctl(id, 0, SETVAL, s);
if (retval) {
return ERR_SEMCTL;
}
return 0;
}
Application(char* input,char* output)
:cin(input),cout(output)
{
memset(m,false,sizeof(m));
cin>>N;
for (int i=1;i<=N;i++)
{
int t;
for (;;)
{
cin>>t;
if (t) m[i][t]=true;
else break;
}
}
}
int game_init(int argc, char** argv)
{
x = 0;
y = 0;
int width, height;
width = 16;
height = 24;
g_sprite.data = new unsigned char[width*height];
g_sprite.width = width;
g_sprite.height = height;
memset(g_sprite.data, 13, width*height);
g_sprite.data[0] = 255;
g_sprite.data[width-1]= 255;
g_sprite.data[(height-1)*width] = 255;
g_sprite.data[width-1 +(height-1)*width] = 255;
g_framebuffer.width = 320;
g_framebuffer.height = 240;
g_framebuffer.data = (unsigned char*)vga_getFrameBuffer();
/*
int i, flags;
char key;
unsigned char* screen_buf = (unsigned char*)0xA0000;
unsigned int x, y;
vga_setMode(0x0013);
screen_buf[0] = 10;
screen_buf[1] = 10;
// initialze screen buffer
for ( x = 0; x < 320; x++ ) {
for ( y = 0; y < 200; y++) {
screen_buf[y*320 +x] = y%256;
}
} */
return 0;
}
Application() :cin("butter.in"),cout("butter.out"),answer(oo)
{
cin>>N>>P>>C;
cow=new int[N+2];
map=new int*[P+2];
for (int i=1;i<=P;i++)
map[i]=new int[P+2];
link=new List*[P+2];
dist=new int[P+2];
visited=new bool[P+2];
q=new int[P+2];
memset(link,0,sizeof(List*)*(P+2));
for (int i=1;i<=N;i++)
cin>>cow[i];
for (int i=1;i<=C;i++)
{
int a,b,c;
cin>>a>>b>>c;
map[a][b]=c;
map[b][a]=c;
if (link[a]==0)
{
link[a]=new List(b);
}
else
{
List* j;
for (j=link[a];j->next!=0;j=j->next) ;//do nothing
j->insert(b);
}
if (link[b]==0)
{
link[b]=new List(a);
}
else
{
List* j;
for (j=link[b];j->next!=0;j=j->next) ;//do nothing
j->insert(a);
}
}
}
int Ethernet_TCPSocketServer::bind(int port) {
if (init_socket(SOCK_STREAM) < 0)
return -1;
struct sockaddr_in localHost;
memset(&localHost, 0, sizeof(localHost));
localHost.sin_family = AF_INET;
localHost.sin_port = htons(port);
localHost.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(_sock_fd, (const struct sockaddr *) &localHost, sizeof(localHost)) < 0) {
close();
return -1;
}
return 0;
}
string RomanAdder::add(){
string result = "";
char letterOrder[] = {'M', 'D', 'C', 'L', 'X', 'V', 'I' };
int size = 7;
int i, j, index;
bool done;
normalizeAddend( _addend1, _addend1 );
normalizeAddend( _addend2, _addend2 );
// cout << _addend1 << " " << _addend2 << endl;
memset( symbolCounter, 0, sizeof( int ) * LETTERS );
countSymbols( _addend1 );
countSymbols( _addend2 );
simplify( symbolCounter );
index = letterOrder[0] - 'A';
for( j = 0; j < symbolCounter[index]; j++ ){
result += letterOrder[0];
}
for( i = 1; i < size; i++ ){
done = false;
index = letterOrder[i] - 'A';
if( i % 2 == 0 ){
if( symbolCounter[index] == 4 ){
result += letterOrder[i];
result += letterOrder[i - 1];
done = true;
}
}
else if( symbolCounter[index] == 1 && symbolCounter[letterOrder[i + 1] - 'A'] == 4 ){
result += letterOrder[i + 1];
result += letterOrder[i - 1];
done = true;
i++;
}
if( !done ){
for( j = 0; j < symbolCounter[index]; j++ ){
result += letterOrder[i];
}
}
}
return result;
}
//判断牌型是否是四带二
bool CardCombine::is_Four_Two()const
{
/*
* 有四张同点数的牌,其余两张点数和这四张不同,但是那两张点数可以相等也可以不等
* how to judge?
* 首先牌数必须为6,然后按点数进行计数排序,结果为uint count[16]
* 然后遍历count[],若存在count[i]==4,则符合要求
*/
unsigned int N=static_cast<unsigned int>(_list.size());
if(N!=6)
return false;
unsigned int count[16];
memset(count,0,16*sizeof(unsigned int));
for(unsigned int i=0;i<N;i++)
count[_list[i].getPoint()]++;
for(int i=0;i<16;i++){
if(count[i]==4)
return true;
}
return false;
}
void init_barometer_module(MblMwMetaWearBoard *board) {
Bmp280Config* new_config = (Bmp280Config*)malloc(sizeof(Bmp280Config));
memset(new_config, 0, sizeof(Bmp280Config));
new_config->pressure_oversampling = MBL_MW_BARO_BMP280_OVERSAMPLE_STANDARD;
new_config->iir_filter = MBL_MW_BARO_BMP280_IIR_FILTER_OFF;
new_config->standby_time = MBL_MW_BARO_BMP280_STANDBY_TIME_0_5MS;
board->module_config.emplace(MBL_MW_MODULE_BAROMETER, new_config);
MblMwDataSignal *baro_pa_signal= new MblMwDataSignal(BARO_PRESSURE_RESPONSE_HEADER, board,
DataInterpreter::BMP280_PRESSURE, 1, 4, 0, 0);
baro_pa_signal->number_to_firmware = bmp280_to_firmware;
board->sensor_data_signals[BARO_PRESSURE_RESPONSE_HEADER]= baro_pa_signal;
board->responses[BARO_PRESSURE_RESPONSE_HEADER]= response_handler_data_no_id;
MblMwDataSignal *baro_m_signal= new MblMwDataSignal(BARO_ALTITUDE_RESPONSE_HEADER, board,
DataInterpreter::BMP280_ALTITUDE, 1, 4, 1, 0);
baro_m_signal->number_to_firmware = bmp280_to_firmware;
board->sensor_data_signals[BARO_ALTITUDE_RESPONSE_HEADER]= baro_m_signal;
board->responses[BARO_ALTITUDE_RESPONSE_HEADER]= response_handler_data_no_id;
}
bool canConstruct(string ransomNote, string magazine) {
const int DICT_SIZE = 26;
int cnt[DICT_SIZE];
memset(cnt, 0, DICT_SIZE * sizeof(int));
int nr = ransomNote.size();
int i;
for (i = 0; i < nr; ++i) {
--cnt[ransomNote[i] - 'a'];
}
int nm = magazine.size();
for (i = 0; i < nm; ++i) {
++cnt[magazine[i] - 'a'];
}
for (i = 0; i < DICT_SIZE; ++i) {
if (cnt[i] < 0) {
return false;
}
}
return true;
}
void init_gyro_module(MblMwMetaWearBoard *board) {
if (board->module_info.count(MBL_MW_MODULE_GYRO) && board->module_info.at(MBL_MW_MODULE_GYRO).present) {
if (!board->module_config.count(MBL_MW_MODULE_GYRO)) {
GyroBmi160Config *new_config = (GyroBmi160Config*)malloc(sizeof(GyroBmi160Config));
memset(new_config, 0, sizeof(GyroBmi160Config));
new_config->gyr_bwp = 2;
new_config->gyr_odr = MBL_MW_GYRO_BMI160_ODR_100HZ;
new_config->gyr_range = MBL_MW_GYRO_BMI160_FSR_2000DPS;
board->module_config.emplace(MBL_MW_MODULE_GYRO, new_config);
}
MblMwDataSignal* rotation;
if (board->module_events.count(GYRO_ROT_RESPONSE_HEADER)) {
rotation = dynamic_cast<MblMwDataSignal*>(board->module_events[GYRO_ROT_RESPONSE_HEADER]);
} else {
rotation = CREATE_ROT_SIGNAL(DataInterpreter::BMI160_ROTATION, 3, 0);
board->module_events[GYRO_ROT_RESPONSE_HEADER] = rotation;
}
if (!rotation->components.size()) {
rotation->components.push_back(CREATE_ROT_SIGNAL_SINGLE(0));
rotation->components.push_back(CREATE_ROT_SIGNAL_SINGLE(2));
rotation->components.push_back(CREATE_ROT_SIGNAL_SINGLE(4));
}
board->responses[GYRO_ROT_RESPONSE_HEADER]= response_handler_data_no_id;
if (board->module_info.at(MBL_MW_MODULE_GYRO).revision >= PACKED_ROT_REVISION) {
if (!board->module_events.count(GYRO_PACKED_ROT_RESPONSE_HEADER)) {
board->module_events[GYRO_PACKED_ROT_RESPONSE_HEADER]= new MblMwDataSignal(GYRO_PACKED_ROT_RESPONSE_HEADER, board,
DataInterpreter::BMI160_ROTATION, FirmwareConverter::BMI160_ROTATION, 3, 2, 1, 0);
}
board->responses[GYRO_PACKED_ROT_RESPONSE_HEADER]= response_handler_packed_data;
}
}
}
Application(char* input,char* output)
:cin(input),cout(output)
{
cin>>H>>W;
memset(appear,false,sizeof(appear));
appearSet_len=0;
for (int i=1;i<=H;i++)
for (int j=1;j<=W;j++)
{
cin>>pic[i][j];
if (pic[i][j]!='.')
{
if (!appear[pic[i][j]])
appearSet[++appearSet_len]=pic[i][j];
appear[pic[i][j]]=true;
}
box[pic[i][j]].update(i,j);
}
/*
for (int i=1;i<=H;i++)
{
for (int j=1;j<=W;j++)
cout<<pic[i][j];
cout<<endl;
}
for (char* i=SETLIST;*i;i++)
{
if (appear[*i])
cout<<*i<<":"<<box[*i].x1<<","<<box[*i].y1<<" "
<<box[*i].x2<<","<<box[*i].y2<<endl;
//cout<<*i<<":"<<appear[*i]<<endl;
}
for (int i=1;i<=appearSet_len;i++)
cout<<appearSet[i]<<endl;
*/
}
