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;
}
