int numDecodings(string s) { // Start typing your C/C++ solution below // DO NOT write int main() function if(s.empty()) return 0; int n = s.size(); vector<int> vec(n+1); vec[0] = 1; vec[1] = isSingle(s[0]); for(int i = 2; i <= n; i++) vec[i] = isSingle(s[i-1])*vec[i-1] + isDouble(s[i-2],s[i-1])*vec[i-2]; return vec[n]; }
bool isMatch(const char *s, const char *p) { // Start typing your C/C++ solution below // DO NOT write int main() function while(true) { if (*s=='\0' && *p=='\0') { return true; } if (isSingle(p)) { if (!match_single(s, p)) { return false; } s++; p++; } else { if (isMatch(s, p+2)) { return true; } while(match_single(s, p)){ if (isMatch(s+1, p+2)) { return true; } s++; } return false; } } }
std::pair<CDBTRule::cards_type, int> CDBTRule::getType(const std::vector<int>& cards) { if (isSingle(cards)) return std::make_pair(type_singal, getWeight(cards[0])); else if (isPairs(cards)) return std::make_pair(type_pairs, getWeightNoRedFive(cards[1])); else if (isthree(cards)) return std::make_pair(type_three, getWeightNoRedFive(cards[2])); else if (isBoom(cards)) return std::make_pair(type_boom, getWeightNoRedFive(cards[cards.size() - 1])); else if (isAtom(cards)) return std::make_pair(type_atom, getWeight(cards[cards.size() - 1])); else if (isSister(cards)) { //带A if (getValue(cards[0]) == 0) return std::make_pair(type_sister, getWeightNoRedFive(cards[1])); return std::make_pair(type_sister, getWeightNoRedFive(cards[cards.size() - 1])); } else if (isPlane(cards)) { //带A if (getValue(cards[0]) == 0) return std::make_pair(type_plane, getWeightNoRedFive(cards[2])); return std::make_pair(type_plane, getWeightNoRedFive(cards[cards.size() - 1])); } else if (isThreetwo(cards)){ //AAABB if (getValue(cards[1]) == getValue(cards[2])){ return std::make_pair(type_three, getWeightNoRedFive(cards[2])); } //AABBB return std::make_pair(type_three, getWeightNoRedFive(cards[4])); } return std::make_pair(type_unknow, 0); }
uint32_t FloatRegister::getRegisterDumpOffsetInBytes() { if (isSingle()) return id() * sizeof(float); if (isDouble()) return id() * sizeof(double); MOZ_CRASH(); }
uint32_t VFPRegister::getRegisterDumpOffsetInBytes() { if (isSingle()) return id() * sizeof(float); if (isDouble()) return id() * sizeof(double); MOZ_ASSUME_UNREACHABLE(); }
void UserManagerPlugin::slotMainActionForMenuTriggered() { if(isSingle() && UserManagerMainWindow::isRunning()) { //TODO: Activate the widget qDebug() << "----UserManagerPlugin::slotRun():UserManager Is Running!"; return; } QWidget *parentWidget = qobject_cast<QWidget *> (parent()); HEHUI::User user; HEHUI::LoginBase login(&user, name(), parentWidget); if (!login.isVerified()) { return ; } bool isYDAdmin = false; if(user.getBusinessAddress() == "DG") { isYDAdmin = false; } else if(user.getBusinessAddress() == "YD") { isYDAdmin = true; } UserManagerMainWindow *wgt = new UserManagerMainWindow(isYDAdmin, parentWidget); //connect(userManager, SIGNAL(destroyed(QObject *)), this, SLOT(slotUserManagerWidgetDestoryed(QObject *))); QMdiArea *mdiArea = 0; if(parentWidget) { mdiArea = qobject_cast<QMdiArea *>(parentWidget); } if(mdiArea) { QMdiSubWindow *subWindow = new QMdiSubWindow; subWindow->setWidget(wgt); subWindow->setAttribute(Qt::WA_DeleteOnClose); mdiArea->addSubWindow(subWindow); //connect(this, SIGNAL(signalPluginToBeUnloaded()), subWindow, SLOT(close())); connect(subWindow, SIGNAL(destroyed(QObject *)), this, SLOT(slotWidgetDestoryed(QObject *))); widgetList.append(subWindow); } else {
/** * @brief Token::token * @return */ QString Token::token() const { Q_ASSERT(isSingle()); return m_Data.m_Token; }
/** * @brief ComponentsMaker::makeMethod * @param tokens * @return */ OptionalEntity ComponentsMaker::makeMethod(const Tokens &tokens) { Q_ASSERT(!tokens.isEmpty() && tokens[int(MethodsGroupsNames::ReturnType)]->isMulti() && tokens[int(MethodsGroupsNames::Name)]->isSingle()); Q_ASSERT(checkCommonState()); entity::SharedMethod newMethod = std::make_shared<entity::ClassMethod>(); // Add Lhs auto lhsToken = tokens[int(MethodsGroupsNames::LhsKeywords)]; Q_ASSERT(!lhsToken->isEmpty() && lhsToken->isSingle()); for (auto &&w : lhsToken->token().split(QChar::Space, QString::SkipEmptyParts)) { entity::LhsIdentificator id = utility::methodLhsIdFromString(w); Q_ASSERT(id != entity::LhsIdentificator::None); newMethod->addLhsIdentificator(id); } // Add return type auto returnTypeToken = tokens[int(MethodsGroupsNames::ReturnType)]; Q_ASSERT(returnTypeToken->isMulti() && !returnTypeToken->isEmpty()); auto returnType = makeType(returnTypeToken->tokens()); if (!returnType.errorMessage.isEmpty()) return {returnType.errorMessage, nullptr}; newMethod->setReturnTypeId(returnType.resultEntity->id()); // Add name newMethod->setName(tokens[int(MethodsGroupsNames::Name)]->token()); // Add arguments auto argumentsToken = tokens[int(MethodsGroupsNames::Arguments)]; Q_ASSERT(argumentsToken->isEmpty() || argumentsToken->isMulti()); if (argumentsToken->isMulti()) { auto argumentsTokens = argumentsToken->tokens(); for (auto &&argumentToken : argumentsTokens) { Q_ASSERT(argumentToken->isMulti()); auto argSubTokens = argumentToken->tokens(); Q_ASSERT(argSubTokens.size() == int(Argument::GroupsCount)); Q_ASSERT(argSubTokens[int(Argument::Name)]->isSingle()); auto name = argSubTokens[int(Argument::Name)]->token(); Q_ASSERT(argSubTokens[int(Argument::Type)]->isMulti()); auto type = makeType(argSubTokens[int(Argument::Type)]->tokens()); if (!type.errorMessage.isEmpty()) return {tr("Wrong type of argument: %1. Error: %2.").arg( QString::number(argumentsTokens.indexOf(argumentToken)), type.errorMessage ), nullptr}; Q_ASSERT(type.resultEntity); newMethod->addParameter(name, type.resultEntity->id()); } } // Const auto constArgument = tokens[int(MethodsGroupsNames::Const)]; Q_ASSERT(!constArgument->isEmpty() && constArgument->isSingle()); const QString &token = constArgument->token(); if (!token.isEmpty()) { if (token == "const") newMethod->setConstStatus(true); else return {tr("Wrong const status token: %1.").arg(constArgument->token()), nullptr}; } // Rhs auto rhsArgument = tokens[int(MethodsGroupsNames::RhsKeywords)]; Q_ASSERT(!rhsArgument->isEmpty() && rhsArgument->isSingle()); const QString &rhsToken = rhsArgument->token(); if (!rhsToken.isEmpty()) { entity::RhsIdentificator rhsId = utility::methodRhsIdFromString(rhsToken); if (rhsId != entity::RhsIdentificator::None) newMethod->setRhsIdentificator(rhsId); else return {tr("Wrong rhs keyword: %1").arg(rhsToken), nullptr}; } return {"", newMethod}; }
bool Assign<std::string>::do_assign(std::string& dest, int type, const void* data) { char buf[32]; if (isSpecial(type)) { if (isString(type)) { dest.assign((const char*)data,size(type)); return true; } switch (type) { case Null: dest.clear(); return true; case Enum: snprintf(buf,sizeof(buf),"%d",*(const int*)data); dest = buf; return true; case ID: snprintf(buf,sizeof(buf),"0x%016llx",*(const long long*)data); dest = buf; return true; } } else if (isMatrix(type)) { std::string str; dest = "{"; for (int y=0;y<ny(type);y++) { if (y) dest += ", "; dest += '{'; for (int x=0;x<nx(type);x++) { if (x) dest += ", "; do_assign(str, toSingle(type), data); data = ((const char*)data) + elemSize(type); dest += str; } dest += '}'; } dest += '}'; } else if (isVector(type)) { std::string str; dest = "{"; for (int x=0;x<nx(type);x++) { if (x) dest += ", "; do_assign(str, toSingle(type), data); data = ((const char*)data) + elemSize(type); dest += str; } dest += '}'; } else { if (!isSingle(type)) type = toSingle(type); switch (toSingle(type)) { case Bool: dest = (*(const unsigned char*)data)?"true":"false"; return true; case Byte: snprintf(buf,sizeof(buf),"%u",(unsigned)*(const unsigned char*)data); dest = buf; return true; case Short: snprintf(buf,sizeof(buf),"%d",(int)*(const short*)data); dest = buf; return true; case Int: snprintf(buf,sizeof(buf),"%d",*(const int*)data); dest = buf; return true; case QWord: snprintf(buf,sizeof(buf),"%lld",*(const long long*)data); dest = buf; return true; case Float: snprintf(buf,sizeof(buf),"%f",(double)*(const float*)data); dest = buf; return true; case Double: snprintf(buf,sizeof(buf),"%f",*(const double*)data); dest = buf; return true; case LongDouble: snprintf(buf,sizeof(buf),"%Lf",*(const long double*)data); dest = buf; return true; } } // Failure // In this implementation: only Type::Delete is not supported return false; }