int main() {
eoPop<Dummy> pop;
eoSecondsElapsedContinue<Dummy> cnt(1);
time_t start_time = time(0);
while (cnt(pop)) {}
time_t end_time = time(0);
int diff = end_time = start_time;
if (diff < 1) return 1;
return 0;
}
/**
* @param licensePlate: a string
* @param words: List[str]
* @return: return a string
*/
vector<int> cntChars(const string& s) {
vector<int> cnt(26, 0);
for(auto x: s) {
if(x >= 'a' && x <= 'z')
cnt[x-'a']++;
else if(x >= 'A' && x <= 'Z')
cnt[x-'A']++;
}
return cnt;
}
bool canPermutePalindrome(string s) {
vector<int> cnt(256, 0);
for(int i = 0; i < s.length(); ++i)
cnt[s[i]]++;
int odd_cnt = 0;
for(int i = 0; i < 256; ++i)
if(cnt[i] % 2 != 0 && ++odd_cnt > 1)
return false;
return true;
}
void SkyNet::verify_peer_cert(QByteArray peer_id, QString cert_pem, bool *verified)
{
// ViewCertDialog vcd;
// vcd.SetCert(cert_pem);
// vcd.exec();
Contacts cnt(config_dbname, Accounts::GetCurrentAccount().id);
QString stored_cert;
if (!cnt.Exists(peer_id) && cnt.isOK())
{
cnt.Add(peer_id, Contacts::temporary);
}
if ((stored_cert = cnt.GetContactCert(peer_id)).isEmpty())
{
cnt.SetContactCert(peer_id, cert_pem);
QString name = OpenSSLTool::NameFromCertString(cert_pem);
cnt.SetContactName(peer_id, name);
emit ContactsUpdated();
}
else
{//compare certificates
QString strip_pem[4] = {
"-----BEGIN CERTIFICATE-----",
"-----END CERTIFICATE-----",
"-----BEGIN X509 CERTIFICATE-----",
"-----END X509 CERTIFICATE-----"
};
QString stripped_stored_cert = stored_cert;
QString stripped_received_cert = cert_pem;
for (int i = 0; i < 4; i++)
{
stripped_stored_cert.replace(strip_pem[i], "");
stripped_received_cert.replace(strip_pem[i], "");
}
QByteArray stored_DER, received_DER;
stored_DER = QByteArray::fromBase64(stripped_stored_cert.toAscii().constData());
received_DER = QByteArray::fromBase64(stripped_received_cert.toAscii().constData());
if (stored_DER.size() != received_DER.size() ||
memcmp(stored_DER.constData(), received_DER.constData(), stored_DER.size()) != 0)
{//put scary message here
*verified = false;
emit CertificateForged(peer_id, cert_pem, stored_cert);
}
}
}
SpecificData::~SpecificData(){
if(pcc->release()) delete pcc;
idbgx(Debug::specific, "destroy all cached buffers");
for(int i(0); i < Capacity; ++i){
vdbgx(Debug::specific, i<<" cp = "<<cps[i].cp<<" sz = "<<cps[i].sz<<" specific_id = "<<Specific::sizeToIndex((1<<i)));
BufferNode *pbn(cps[i].pnode);
BufferNode *pnbn;
uint32 cnt(0);
while(pbn){
pnbn = pbn->pnext;
delete []reinterpret_cast<char*>(pbn);
++cnt;
pbn = pnbn;
}
if(cnt != cps[i].sz || cnt != cps[i].cp){
THROW_EXCEPTION_EX("Memory leak specific buffers ", i);
}
}
idbgx(Debug::specific, "destroy all cached objects");
Locker<Mutex> lock(Thread::gmutex());
for(ObjCachePointVecT::iterator it(ops.begin()); it != ops.end(); ++it){
vdbgx(Debug::specific, "it->cp = "<<it->cp);
BufferNode *pbn(it->pnode);
BufferNode *pnbn;
uint32 cnt(0);
while(pbn){
pnbn = pbn->pnext;
void **pv = reinterpret_cast<void**>(pbn);
*pv = pbn;
++cnt;
(*cv[it - ops.begin()])(voidPointer(pbn));
pbn = pnbn;
}
if(cnt != it->sz || cnt != it->cp){
THROW_EXCEPTION_EX("Memory leak specific objects ", (int)(it - ops.begin()));
}
}
}
int firstUniqChar(string s) {
vector<int> cnt(26, 0);
int size = s.size();
for (int i = 0; i < size; i++) {
cnt[s[i] - 'a']++;
}
for (int i = 0; i < size; i++) {
if (cnt[s[i] - 'a'] == 1) return i;
}
return -1;
}
int numSquares(int n) {
if(n<=0) return 0;
vector<int> cnt(n+1,INT_MAX);
cnt[0]=0;
for(int i=1;i<=n;i++)
{
for(int j=1;j*j<=i;j++)
cnt[i]=min(cnt[i],cnt[i-j*j]+1);
}
return cnt.back();
}
void cnt(int v) {
if (was[v])return;
was[v] = 1;
for (int i = 0; i < SIGMA; i++) {
int q = st[v].go[i];
if (q == -1)continue;
cnt(q);
d[v] += d[q] + 1;
dp[v] += d[q] + dp[q] + 1;
}
}
vector<vector<int> > subsetsWithDup(const vector<int> &S) {
// write your code here
vector<int> cnt(S.begin(), S.end());
sort(cnt.begin(), cnt.end());
vector<vector<int> > vec;
vector<int> res;
vec.push_back(res);
//if (cnt.size() == 0) return vec;
solve(vec, cnt, res, 0);
return vec;
}
vector<int> majorityElement(vector<int>& nums) {
vector<int> ans;
vector<int> value(2, 0), cnt(2, 0);
for (int &x : nums) {
calculate(value, cnt, x);
}
if (isMajority(nums, value[0]))
ans.push_back(value[0]);
if (value[0] != value[1] && isMajority(nums, value[1]))
ans.push_back(value[1]);
return ans;
}
unsigned int cnt(string &s, string &t, int ind1, int ind2){
if (arr[ind1][ind2] || visit[ind1][ind2])
return arr[ind1][ind2];
visit[ind1][ind2] = true;
if (ind2 == len2)
return arr[ind1][ind2] = 1;
if (ind1 == len1){
return arr[ind1][ind2] = 0;
}
if (s[ind1] == t[ind2]){
arr[ind1+1][ind2+1] = cnt(s,t,ind1+1,ind2+1);
arr[ind1+1][ind2] = cnt(s,t,ind1+1, ind2);
return arr[ind1][ind2] = arr[ind1+1][ind2+1] + arr[ind1+1][ind2];
}
else{
arr[ind1+1][ind2] = cnt(s,t,ind1+1, ind2);
return arr[ind1][ind2] = arr[ind1+1][ind2];
}
}
void operator()(const state_type& x, state_type& dxdt, const double& t)
{
for (state_type::iterator i(dxdt.begin()); i != dxdt.end(); ++i)
{
*i = 0.0;
}
// XXX
for (reaction_container_type::const_iterator
i(reactions_.begin()); i != reactions_.end(); i++)
{
// Prepare state_array of reactants and products that contain amounts of each reactants.
Ratelaw::state_container_type reactants_states(i->reactants.size());
Ratelaw::state_container_type products_states(i->products.size());
Ratelaw::state_container_type::size_type cnt(0);
for (index_container_type::const_iterator
j((*i).reactants.begin()); j != (*i).reactants.end(); ++j, cnt++)
{
reactants_states[cnt] = x[*j];
}
cnt = 0;
for (index_container_type::const_iterator
j((*i).products.begin()); j != (*i).products.end(); ++j, cnt++)
{
products_states[cnt] = x[*j];
}
double flux;
// Get pointer of Ratelaw object and call it.
if (i->ratelaw.expired() || i->ratelaw.lock()->is_available() == false)
{
boost::scoped_ptr<Ratelaw> temporary_ratelaw_obj(new RatelawMassAction(i->k));
flux = temporary_ratelaw_obj->deriv_func(reactants_states, products_states, volume_);
}
else
{
boost::shared_ptr<Ratelaw> ratelaw = (*i).ratelaw.lock();
flux = (*ratelaw).deriv_func(reactants_states, products_states, volume_);
}
// Merge each reaction's flux into whole dxdt
for (index_container_type::const_iterator
j((*i).reactants.begin()); j != (*i).reactants.end(); ++j)
{
dxdt[*j] -= flux;
}
for (index_container_type::const_iterator
j((*i).products.begin()); j != (*i).products.end(); ++j)
{
dxdt[*j] += flux;
}
}
}
string frequencySort(string s)
{
int n = s.size();
vector<string> sorted(n+1, "");
vector<int> cnt(CHAR_MAX, 0);
for (char c : s) ++cnt[c];
for (int i = 0; i < CHAR_MAX; ++i)
sorted[cnt[i]] += string(cnt[i], i);
string ret;
for (string& e : sorted) ret = e + ret;
return ret;
}
void sortColors2(vector<int> &colors, int k) {
// write your code here
vector<int> cnt(k + 1, 0);
for(int i = 0; i < colors.size(); ++i){
++cnt[colors[i]];
}
for (int i = 1, index = 0; i <= k; i++)
for (int j = 0; j < cnt[i]; j++)
colors[index++] = i;
}
int main()
{
unit_test::timeout();
thread_pool TP;
atomic_int<unsigned> cnt(0);
for(unsigned x=0; x<32; ++x){
TP.enqueue(boost::bind(&inc, boost::ref(cnt)));
}
TP.join();
if(cnt != 32){
LOG; ++fail;
}
return fail;
}
//-------------------------------------------------------------------------------------------------
void MessageBase::print_group(const unsigned short fnum, ostream& os, int depth) const
{
const GroupBase *grpbase(find_group(fnum));
if (!grpbase)
throw InvalidRepeatingGroup(fnum);
const string dspacer((depth + 1) * 3, ' ');
size_t cnt(1);
for (GroupElement::const_iterator itr(grpbase->_msgs.begin()); itr != grpbase->_msgs.end(); ++itr, ++cnt)
{
os << dspacer << (*itr)->_msgType << " (Repeating group " << cnt << '/' << grpbase->_msgs.size() << ')' << endl;
(*itr)->print(os, depth + 1);
}
}
void set_context(bool gzip=false)
{
std::map<std::string,std::string> env;
env["HTTP_HOST"]="www.example.com";
env["SCRIPT_NAME"]="/foo";
env["PATH_INFO"]="/bar";
env["REQUEST_METHOD"]="GET";
if(gzip)
env["HTTP_ACCEPT_ENCODING"]="gzip, deflate";
booster::shared_ptr<dummy_api> api(new dummy_api(srv_,env,output_));
booster::shared_ptr<cppcms::http::context> cnt(new cppcms::http::context(api));
assign_context(cnt);
output_.clear();
}
string frequencySort(string s) {
vector<int> cnt(128);
for(auto c: s) cnt[c]++;
vector<pair<int, int>> arr;
for(int i = 0; i < 128; i++) {
if(cnt[i])
arr.push_back({cnt[i], i});
}
sort(arr.begin(), arr.end(), [](const auto& lhs, const auto& rhs) { return lhs.first > rhs.first; });
string ans;
for(auto& pr: arr) {
ans.append(pr.first, pr.second);
}
return ans;
}
int main(void)
{
static char buf[2][1024];
struct buf seq;
if (dna_seq3(&seq))
#pragma omp sections
{
frq(&seq, buf[0]);
cnt(&seq, buf[1]);
}
#pragma omp barrier
for (int i = 0; i < 2; i++)
fputs(buf[i], stdout);
return 0;
}
bool isAnagram(string s, string t) {
if (s.length() != t.length()) return false;
vector<int> cnt(256, 0);
for (int i = 0; i < s.length(); i++){
cnt[s[i]]++;
cnt[t[i]]--;
}
for (int i = 0; i < cnt.size(); i++){
if (cnt[i]) return false;
}
return true;
}
void Solution::sortColors(vector<int> &A) {
// Do not write main() function.
// Do not read input, instead use the arguments to the function.
// Do not print the output, instead return values as specified
// Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
vector<int> cnt(3);
for (auto a: A) {
cnt[a]++;
}
int idx = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < cnt[i]; j++) {
A[idx++] = i;
}
}
}
kjm::_tstring calc_md5(const kjm::_tstring& fname, bool verbose) {
bool first = false;
kjm::_tstring result;
FILE* fp = _tfopen(fname.c_str(), (g_binaryMode ? _T("rb") : _T("r")));
if (fp) {
MD5 md5;
unsigned char buffer[1024];
int len;
__int64 rlen = 0;
__int64 flen = _filelengthi64(_fileno(fp));
kjm::tickCounter cnt(flen);
while (len = fread(buffer, sizeof(char), countof(buffer), fp)) {
cnt.m_count += len;
if (cnt.lap(1000)) {
if (verbose && cnt.elapseSec() > 3) {
if (first == false) {
_tprintf(_T("計算中 << %s >>\n"), kjm::path::findFileName(fname).c_str());
first = true;
}
_tprintf(_T(" %lld/%lld %d%% 後 %d 秒 \r"),
cnt.m_count, cnt.m_totalCount, cnt.progress(), cnt.estimateRemainingTime()/1000);
}
}
md5.update(buffer, len);
}
if (verbose && cnt.elapseSec() > 3) {
_tprintf(_T(" %lld/%lld %d%% \n"),
cnt.m_count, cnt.m_totalCount, cnt.progress());
}
md5.finalize();
fclose(fp);
#if defined(UNICODE)
result = kjm::util::toUnicode(md5.hex_digest());
#else
result = md5.hex_digest();
#endif
} else {
_tprintf(_T("md5sum: %s: %s\n"), fname.c_str(), _tcserror(errno));
}
return result;
}
void FreeSpaceWidget::updateToolTip()
{
if (isValid())
{
QString value;
QString header = i18n("Camera Media");
if (d->mode == FreeSpaceWidget::AlbumLibrary)
{
header = i18n("Album Library");
}
DToolTipStyleSheet cnt(ApplicationSettings::instance()->getToolTipsFont());
QString tip = cnt.tipHeader;
tip += cnt.headBeg + header + cnt.headEnd;
if (d->dSizeKb > 0)
{
tip += cnt.cellBeg + i18nc("@info Storage", "Capacity:") + cnt.cellMid;
tip += KIO::convertSizeFromKiB(d->kBSize) + cnt.cellEnd;
tip += cnt.cellBeg + i18nc("@info Storage", "Available:") + cnt.cellMid;
tip += KIO::convertSizeFromKiB(d->kBAvail) + cnt.cellEnd;
tip += cnt.cellBeg + i18nc("@info Storage", "Require:") + cnt.cellMid;
tip += KIO::convertSizeFromKiB(d->dSizeKb) + cnt.cellEnd;
}
else
{
tip += cnt.cellBeg + i18nc("@info Storage", "Capacity:") + cnt.cellMid;
tip += KIO::convertSizeFromKiB(d->kBSize) + cnt.cellEnd;
tip += cnt.cellBeg + i18nc("@info Storage", "Available:") + cnt.cellMid;
tip += KIO::convertSizeFromKiB(d->kBAvail) + cnt.cellEnd;
}
tip += cnt.tipFooter;
d->toolTip->setToolTip(tip);
}
else
{
d->toolTip->setToolTip(QString());
}
}
void FORTE_FB_FT_TN64::alg_REQ(void){
if((cnt() == length()-1)){
cnt() = 0;
}
else{
cnt() = cnt()+1;
};
OUT() = X()[cnt()];
X()[cnt()] = IN();
last() = tx();
}
static
UIntType ProblemT_WD(const UIntType below, unsigned index, bool debug)
{
if (debug)
{
std::string func("MultiplesDe3Et5_");
func += ('0'+(char)index);
func += (", ");
std::stringstream ss;
ss << below;
func += ss.str();
DbgCnt cnt(func.c_str());
return ProblemT_W(below, index);
}
else
return ProblemT_W(below, index);
}
void avgNbrPos(Mesh& m, std::vector<Vec3> & nbrPos)
{
std::vector<int>cnt(m.v.size());
for(size_t ii=0;ii<m.t.size();ii++){
Vec3 sum;
for(int jj=0;jj<3;jj++){
sum += m.v[m.t[ii][jj]];
}
for(int jj=0;jj<3;jj++){
nbrPos[m.t[ii][jj]] += (sum-m.v[m.t[ii][jj]]);
cnt[m.t[ii][jj]]+=2;
}
}
std::vector<Vec3> v0 = m.v;
for(size_t ii=0;ii<m.v.size();ii++){
nbrPos[ii]/=cnt[ii];
}
}
int main(){
ll n,k; scanf("%lld %lld", &n, &k);
ll cur(0), cycle(0), cnt(1);
k = (k < n - k) ? k : (n - k);
for(int p = 0; p < n; p++){
cur += k;
cnt += cycle + 1 + (cur > n);
if(cur > n){cycle += 2; cur %= n;}
printf("%lld ", cnt);
}
puts("");
return 0;
}
void CPlPerformanceAPI::UpdateContactsTestL(const TInt aStartPos, const TInt aEndPos)
{
CContactItem* tempCntItem = NULL;
for (int ii = aStartPos; ii < aEndPos; ++ii)//size; ++ii)
{
// Modify the data in a contact from the db
tempCntItem = iCntTestImpl.OpenLC(iIdBuffer->Get(ii), *iMatchAll);
TCnt cnt(tempCntItem);
cnt[KUidContactFieldGivenName] = nsPlPerformance::KName;
cnt[KUidContactFieldPhoneNumber] & KWork & KVoice = nsPlPerformance::KNumber;
cnt[KUidContactFieldPhoneNumber] & KWork & KVoice & KCell += nsPlPerformance::KNumber;
cnt[KUidContactFieldEMail] & KWork = nsPlPerformance::KEmail;
cnt[KUidContactFieldAddress] & KHome = nsPlPerformance::KHomeAdd;
iCntTestImpl.UpdateL(*tempCntItem);
CleanupStack::PopAndDestroy(tempCntItem);
}
}
void S()
{
if(!(strcmp("CONSTANT",token) && strcmp("FLT_TYP",token) && strcmp("BOOL_TYP",token) && strcmp("INT_TYP",token) && strcmp("STR_TYP",token)))
D();
else if(!strcmp("ID",token))
A();
else if(!strcmp("IF_",token))
cnd();
else if(!strcmp("LOOP_THIS",token))
cnt();
else if(!(strcmp("INPT_DATA",token) && strcmp("PRNT_DATA",token)))
io();
else if(!strcmp("B_START",token))
{
consume();
SL();
if(!strcmp("B_END",token))
consume();
else
error("Expecting } symbol");
}
else if(!strcmp("STMNT_END",token))
consume();
else
{
int once = 1;
iLnLast = iLn;
error("Unknown statement");
while(strcmp("STMNT_END",token))
{
if(once)
{
printf("\n\t");
once = 0;
}
printf(" %s",lexeme);
consume();
if(atEnd)
break;
}
consume();
printf(";");
}
}
size_t get_min_diff(const image& img1, const image& img2) {
if(img1.nc() < img2.nc()) return get_min_diff(img2, img1);
size_t score = INFTY;
for (int i = -H_TOL; i<= H_TOL; i+=STEP_SIZE)
for(int j= -V_TOL; j<= V_TOL; j+= STEP_SIZE) {
image copy;
dlib::assign_image(copy, img1);
dlib::rectangle r1 = dlib::get_rect(img1);
dlib::rectangle r2 = dlib::get_rect(img2);
dlib::rectangle crop1 = dlib::intersect(r1, dlib::translate_rect(r2, i, j));
dlib::rectangle crop2 = dlib::translate_rect(crop1, -i, -j);
auto sub1 = dlib::sub_image(copy, crop1);
auto sub2 = dlib::sub_image(img2, crop2);
xor_copy(sub1, sub2);
size_t res = cnt(copy);
score = std::min(score, res);
}
return score;
}
