int main() { Bracket b; if (b.BracketBalance()) cout << "YES" << endl; else cout << "NO" << endl; }
int main() { std::string text; getline(std::cin, text); // get the input string std::stack <Bracket> opening_brackets_stack; for (int position = 0; position < text.length(); ++position) { char next = text[position]; if (next == '(' || next == '[' || next == '{') { // store the left bracket in the stack Bracket parenStart(next, position); opening_brackets_stack.push(parenStart); } else if (next == ')' || next == ']' || next == '}') { // if right bracket is detected if (opening_brackets_stack.empty()) // if the stack is empty, which means no left bracket is stored { std::cout << (position + 1) << std::endl; // output the position of this right bracket, break loop break; } else { Bracket parenStartOut = opening_brackets_stack.top(); // get the latest left bracket, //remove it from stack opening_brackets_stack.pop(); if(!parenStartOut.Matchc(next)) // check if the latest left bracket is matched with // the current right bracket { std::cout << (position + 1) << std::endl; // if not, output the position of this right bracket, break loop break; } } } if (position == text.length() - 1) // if reach the end of the string { if (!opening_brackets_stack.empty()) // if the stack is not empty, output the position of //left bracket at the end of the stack (the first unmatched one) { Bracket firstUnMatched('(',0); // initialization, initial values don't matter here while(!opening_brackets_stack.empty()) { firstUnMatched = opening_brackets_stack.top(); opening_brackets_stack.pop(); } std::cout << (firstUnMatched.position + 1) << std::endl; } else // if stack has no left bracket, which means all the brackets have been matched { std::cout << "Success" << std::endl; } } } return 0; }
Element* Bracket::drop(const DropData& data) { Element* e = data.element; if (e->type() == Element::Type::BRACKET) { Bracket* b = static_cast<Bracket*>(e); score()->undoChangeBracketType(this, b->bracketType()); delete e; return this; } delete e; return 0; }
int main() { bool isBalanced = true; int errorPos = 0; std::string text; getline(std::cin, text); std::stack <Bracket> opening_brackets_stack; for (int position = 0; position < text.length(); ++position) { char next = text[position]; if (next == '(' || next == '[' || next == '{') { // Process opening bracket, write your code here Bracket b = Bracket(next, position); opening_brackets_stack.push(b); } if (next == ')' || next == ']' || next == '}') { // Process closing bracket, write your code here if( opening_brackets_stack.empty() == false ) { Bracket b = opening_brackets_stack.top(); if ( b.Matchc(next) == false ) { isBalanced = false; errorPos = position; break; } else opening_brackets_stack.pop(); } else { isBalanced = false; errorPos = position; break; } } } if(opening_brackets_stack.empty() == false && isBalanced == true) { isBalanced = false; errorPos = opening_brackets_stack.top().position; } // Printing answer, write your code here if ( isBalanced ) std::cout << "Success" << "\n"; else std::cout << errorPos+1 << "\n"; return 0; }
Element* Bracket::drop(const DropData& data) { Element* e = data.element; if (e->type() == BRACKET) { Bracket* b = static_cast<Bracket*>(e); b->setParent(parent()); b->setTrack(track()); b->setSpan(span()); b->setLevel(level()); score()->undoRemoveElement(this); score()->undoAddElement(b); return b; } delete e; return 0; }
void System::layoutSystem(qreal xo1) { if (_staves.empty()) // ignore vbox return; static const Spatium instrumentNameOffset(1.0); // TODO: make style value int nstaves = _staves.size(); //--------------------------------------------------- // find x position of staves // create brackets //--------------------------------------------------- qreal xoff2 = 0.0; // x offset for instrument name int bracketLevels = 0; for (int idx = 0; idx < nstaves; ++idx) bracketLevels = qMax(bracketLevels, score()->staff(idx)->bracketLevels()); qreal bracketWidth[bracketLevels]; for (int i = 0; i < bracketLevels; ++i) bracketWidth[i] = 0.0; QList<Bracket*> bl; bl.swap(_brackets); for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) { Staff* s = score()->staff(staffIdx); for (int i = 0; i < bracketLevels; ++i) { if (s->bracket(i) == BracketType::NO_BRACKET) continue; int firstStaff = staffIdx; int lastStaff = staffIdx + s->bracketSpan(i) - 1; if (lastStaff >= nstaves) lastStaff = nstaves - 1; for (; firstStaff <= lastStaff; ++firstStaff) { if (score()->staff(firstStaff)->show()) break; } for (; lastStaff >= firstStaff; --lastStaff) { if (score()->staff(lastStaff)->show()) break; } int span = lastStaff - firstStaff + 1; // // do not show bracket if it only spans one // system due to some invisible staves // if ((span > 1) || (s->bracketSpan(i) == span)) { // // this bracket is visible // Bracket* b = 0; int track = staffIdx * VOICES; for (int k = 0; k < bl.size(); ++k) { if (bl[k]->track() == track && bl[k]->level() == i) { b = bl.takeAt(k); break; } } if (b == 0) { b = new Bracket(score()); b->setGenerated(true); b->setTrack(track); b->setLevel(i); } add(b); b->setFirstStaff(firstStaff); b->setLastStaff(lastStaff); b->setBracketType(s->bracket(i)); b->setSpan(s->bracketSpan(i)); bracketWidth[i] = qMax(bracketWidth[i], b->width()); } } if (!s->show()) continue; for (InstrumentName* t : _staves[staffIdx]->instrumentNames) { t->layout(); qreal w = t->width() + point(instrumentNameOffset); if (w > xoff2) xoff2 = w; } } for (Bracket* b : bl) delete b; //--------------------------------------------------- // layout SysStaff and StaffLines //--------------------------------------------------- _leftMargin = xoff2; qreal bd = score()->styleP(StyleIdx::bracketDistance); if ( _brackets.size() > 0) { for (int i = 0; i < bracketLevels; ++i) _leftMargin += bracketWidth[i] + bd; } int nVisible = 0; for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) { SysStaff* s = _staves[staffIdx]; Staff* staff = score()->staff(staffIdx); if (!staff->show() || !s->show()) { s->setbbox(QRectF()); continue; } ++nVisible; qreal staffMag = staff->mag(); qreal h; if (staff->lines() == 1) h = 2; else h = (staff->lines()-1) * staff->lineDistance(); h = h * staffMag * spatium(); s->bbox().setRect(_leftMargin + xo1, 0.0, 0.0, h); } //--------------------------------------------------- // layout brackets //--------------------------------------------------- for (Bracket* b : _brackets) { qreal xo = -xo1; for (const Bracket* b2 : _brackets) { if (b->level() > b2->level() && ((b->firstStaff() >= b2->firstStaff() && b->firstStaff() <= b2->lastStaff()) || (b->lastStaff() >= b2->firstStaff() && b->lastStaff() <= b2->lastStaff()))) xo += b2->width() + bd; } b->rxpos() = _leftMargin - xo - b->width(); } //--------------------------------------------------- // layout instrument names x position //--------------------------------------------------- int idx = 0; for (const Part* p : score()->parts()) { SysStaff* s = staff(idx); if (s->show() && p->show()) { for (InstrumentName* t : s->instrumentNames) { switch (t->textStyle().align() & AlignmentFlags::HMASK) { case int(AlignmentFlags::LEFT): t->rxpos() = 0; break; case int(AlignmentFlags::HCENTER): t->rxpos() = (xoff2 - point(instrumentNameOffset) + xo1) * .5; break; case int(AlignmentFlags::RIGHT): default: t->rxpos() = xoff2 - point(instrumentNameOffset) + xo1; break; } t->rxpos() += t->textStyle().offset(t->spatium()).x(); } } idx += p->nstaves(); } }
Bracket OneDimensionOptimizationTools::bracketMinimum( double a, double b, Function * function, ParameterList parameters) { Bracket bracket; // Copy the parameter to use. bracket.a.x = a; parameters[0].setValue(bracket.a.x); bracket.a.f = function->f(parameters); bracket.b.x = b; parameters[0].setValue(bracket.b.x); bracket.b.f = function->f(parameters); if (bracket.b.f > bracket.a.f) { // Switch roles of first and second point so that we can go downhill // in the direction from a to b. NumTools::swap<double>(bracket.a.x, bracket.b.x); NumTools::swap<double>(bracket.a.f, bracket.b.f); } // First guess for third point: bracket.c.x = bracket.b.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.b.x - bracket.a.x); parameters[0].setValue(bracket.c.x); bracket.c.f = function->f(parameters); // Keep returning here until we bracket: while (bracket.b.f > bracket.c.f) { // Compute xu by parabolic extrapolation from a, b, c. TINY is used to prevent // any possible division by 0. double r = (bracket.b.x - bracket.a.x) * (bracket.b.f - bracket.c.f); double q = (bracket.b.x - bracket.c.x) * (bracket.b.f - bracket.a.f); double xu = bracket.b.x - ((bracket.b.x - bracket.c.x) * q - (bracket.b.x - bracket.a.x) * r) / (2.0 * NumTools::sign(NumTools::max(NumTools::abs(q - r), NumConstants::VERY_TINY()), q - r)); double xulim = (bracket.b.x) + GLIMIT * (bracket.c.x - bracket.b.x); double fu; // We don't go farther than this. // Test various possibilities: if ((bracket.b.x - xu) * (xu - bracket.c.x) > 0.0) { parameters[0].setValue(xu); fu = function->f(parameters); if (fu < bracket.c.f) { bracket.setA(bracket.b.x, bracket.b.f); bracket.setB(xu, fu); return bracket; } else if (fu > bracket.b.f) { bracket.setC(xu, fu); return bracket; } // Parabolic fit was no use. // Use default magnification. xu = bracket.c.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.c.x - bracket.b.x); parameters[0].setValue(xu); fu = function->f(parameters); } else if ((bracket.c.x - xu) * (xu - xulim) > 0.0) { // Parabolic fit is between point 3 and its allowed limit. parameters[0].setValue(xu); fu = function->f(parameters); if (fu < bracket.c.f) { NumTools::shift<double>(bracket.b.x, bracket.c.x, xu, bracket.c.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.c.x - bracket.b.x)); parameters[0].setValue(xu); NumTools::shift<double>(bracket.b.f, bracket.c.f, fu, function->f(parameters)); } } else if ((xu - xulim) * (xulim - bracket.c.x) >= 0.0) { // Limit parabolic xu to maximum allowed value. xu = xulim; parameters[0].setValue(xu); fu = function->f(parameters); } else { // Reject parabolic xu, use default magnification. xu = bracket.c.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.c.x - bracket.b.x); parameters[0].setValue(xu); fu = function->f(parameters); } // Eliminate oldest point and continue. NumTools::shift<double>(bracket.a.x, bracket.b.x, bracket.c.x, xu); NumTools::shift<double>(bracket.a.f, bracket.b.f, bracket.c.f, fu); } return bracket; }
void System::layout2() { if (isVbox()) // ignore vbox return; int nstaves = _staves.size(); qreal _spatium = spatium(); qreal y = 0.0; int lastStaffIdx = 0; // last visible staff int firstStaffIdx = -1; qreal lastStaffDistanceDown = 0.0; for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) { Staff* staff = score()->staff(staffIdx); StyleIdx downDistance; qreal userDist = 0.0; if ((staffIdx + 1) == nstaves) { // // last staff in system // MeasureBase* mb = ml.last(); bool nextMeasureIsVBOX = false; if (mb->next()) { Element::Type type = mb->next()->type(); if (type == Element::Type::VBOX || type == Element::Type::TBOX || type == Element::Type::FBOX) nextMeasureIsVBOX = true; } downDistance = nextMeasureIsVBOX ? StyleIdx::systemFrameDistance : StyleIdx::minSystemDistance; } else if (staff->rstaff() < (staff->part()->staves()->size()-1)) { // // staff is not last staff in a part // downDistance = StyleIdx::akkoladeDistance; userDist = score()->staff(staffIdx + 1)->userDist(); } else { downDistance = StyleIdx::staffDistance; userDist = score()->staff(staffIdx + 1)->userDist(); } SysStaff* s = _staves[staffIdx]; qreal distDown = score()->styleS(downDistance).val() * _spatium + userDist; qreal nominalDistDown = distDown; qreal distUp = 0.0; int n = ml.size(); for (int i = 0; i < n; ++i) { MeasureBase* m = ml.at(i); distDown = qMax(distDown, m->distanceDown(staffIdx)); distUp = qMax(distUp, m->distanceUp(staffIdx)); } s->setDistanceDown(distDown); s->setDistanceUp(distUp); if (!staff->show() || !s->show()) { s->setbbox(QRectF()); // already done in layout() ? continue; } qreal sHeight = staff->height(); qreal dup = staffIdx == 0 ? 0.0 : s->distanceUp(); if (staff->lines() == 1) dup -= _spatium * staff->mag(); s->bbox().setRect(_leftMargin, y + dup, width() - _leftMargin, sHeight); y += dup + sHeight + s->distanceDown(); lastStaffIdx = staffIdx; lastStaffDistanceDown = distDown - nominalDistDown; if (firstStaffIdx == -1) firstStaffIdx = staffIdx; } if (firstStaffIdx == -1) firstStaffIdx = 0; qreal systemHeight = staff(lastStaffIdx)->bbox().bottom(); if (lastStaffIdx < nstaves - 1) systemHeight += lastStaffDistanceDown; setHeight(systemHeight); int n = ml.size(); for (int i = 0; i < n; ++i) { MeasureBase* m = ml.at(i); if (m->type() == Element::Type::MEASURE) { // note that the factor 2 * _spatium must be corrected for when exporting // system distance in MusicXML (issue #24733) m->bbox().setRect(0.0, -_spatium, m->width(), systemHeight + 2 * _spatium); } else if (m->type() == Element::Type::HBOX) { m->bbox().setRect(0.0, 0.0, m->width(), systemHeight); static_cast<HBox*>(m)->layout2(); } } if (_barLine) { _barLine->setTrack(firstStaffIdx * VOICES); _barLine->setSpan(lastStaffIdx - firstStaffIdx + 1); if (score()->staff(0)->lines() == 1) _barLine->setSpanFrom(BARLINE_SPAN_1LINESTAFF_FROM); int spanTo = (score()->staff(lastStaffIdx)->lines() == 1) ? BARLINE_SPAN_1LINESTAFF_TO : (score()->staff(lastStaffIdx)->lines()-1)*2; _barLine->setSpanTo(spanTo); _barLine->layout(); } //--------------------------------------------------- // layout brackets vertical position //--------------------------------------------------- n = _brackets.size(); for (int i = 0; i < n; ++i) { Bracket* b = _brackets.at(i); int staffIdx1 = b->firstStaff(); int staffIdx2 = b->lastStaff(); qreal sy = 0; // assume bracket not visible qreal ey = 0; // if start staff not visible, try next staff while (staffIdx1 <= staffIdx2 && !_staves[staffIdx1]->show()) ++staffIdx1; // if end staff not visible, try prev staff while (staffIdx1 <= staffIdx2 && !_staves[staffIdx2]->show()) --staffIdx2; // the bracket will be shown IF: // it spans at least 2 visible staves (staffIdx1 < staffIdx2) OR // it spans just one visible staff (staffIdx1 == staffIdx2) but it is required to do so // (the second case happens at least when the bracket is initially dropped) bool notHidden = (staffIdx1 < staffIdx2) || (b->span() == 1 && staffIdx1 == staffIdx2); if (notHidden) { // set vert. pos. and height to visible spanned staves sy = _staves[staffIdx1]->bbox().top(); ey = _staves[staffIdx2]->bbox().bottom(); } b->rypos() = sy; b->setHeight(ey - sy); b->layout(); } //--------------------------------------------------- // layout instrument names //--------------------------------------------------- int staffIdx = 0; n = score()->parts().size(); for (Part* p : score()->parts()) { SysStaff* s = staff(staffIdx); SysStaff* s2; int nstaves = p->nstaves(); if (s->show()) { for (InstrumentName* t : s->instrumentNames) { // // override Text->layout() // qreal y1, y2; switch (t->layoutPos()) { default: case 0: // center at part y1 = s->bbox().top(); s2 = staff(staffIdx); for (int i = staffIdx + nstaves - 1; i > 0; --i) { SysStaff* s = staff(i); if (s->show()) { s2 = s; break; } } y2 = s2->bbox().bottom(); break; case 1: // center at first staff y1 = s->bbox().top(); y2 = s->bbox().bottom(); break; // TODO: // sort out invisible staves case 2: // center between first and second staff y1 = s->bbox().top(); y2 = staff(staffIdx + 1)->bbox().bottom(); break; case 3: // center at second staff y1 = staff(staffIdx + 1)->bbox().top(); y2 = staff(staffIdx + 1)->bbox().bottom(); break; case 4: // center between first and second staff y1 = staff(staffIdx + 1)->bbox().top(); y2 = staff(staffIdx + 2)->bbox().bottom(); break; case 5: // center at third staff y1 = staff(staffIdx + 2)->bbox().top(); y2 = staff(staffIdx + 2)->bbox().bottom(); break; } t->rypos() = y1 + (y2 - y1) * .5 + t->textStyle().offset(t->spatium()).y(); } } staffIdx += nstaves; } }