C++ order函数代码示例

void rubiks_cube(QStringList list, QString color)
{
    QString rubiks_cube = "empty,yellow,empty,"+color+",empty,empty";
    QStringList yellow_wall;

    foreach (const QString &str, list)
    {
        if (str.contains("yellow") && str.count('\n') == 2)
        {
            yellow_wall += str;
        }
    }

    yellow_wall = order(yellow_wall, "yellow");

    QString help;
    help = yellow_wall.at(0);
    rubiks_cube.replace(rubiks_cube.indexOf("empty"), QString::fromStdString("empty").count(), help.section('\n', 1, 1));
    rubiks_cube.replace(rubiks_cube.indexOf("empty"), QString::fromStdString("empty").count(), help.section('\n', 2, 2));

    for(int i = 1; i < yellow_wall.count(); i++)
    {
        if(!yellow_wall.at(i).contains(help.section('\n', 1, 1)) && !yellow_wall.at(i).contains(help.section('\n', 2, 2)))
        {
            help = yellow_wall.at(i);
            rubiks_cube.replace(rubiks_cube.indexOf("empty"), QString::fromStdString("empty").count(),help.section('\n', 2, 2));
            rubiks_cube.replace(rubiks_cube.indexOf("empty"), QString::fromStdString("empty").count(),help.section('\n', 1, 1));
        }
    }

    QStringList color_short;
    for(int i = 0; i <= rubiks_cube.count(','); i++)
    {
        help = rubiks_cube.section(',', i, i);
        help.remove(1, help.count()-1);
        help = help.toUpper();
        color_short << help;
    }

    print_rubiks_cube(color_short);
}

void Foam::hierarchGeomDecomp::setDecompOrder()
{
    word order(geomDecomDict_.lookup("order"));

    if (order.size() != 3)
    {
        FatalIOErrorIn
        (
            "hierarchGeomDecomp::hierarchGeomDecomp"
            "(const dictionary& decompositionDict)",
            decompositionDict_
        )   << "number of characters in order (" << order << ") != 3"
            << exit(FatalIOError);
    }

    for (label i = 0; i < 3; i++)
    {
        if (order[i] == 'x')
        {
            decompOrder_[i] = 0;
        }
        else if (order[i] == 'y')
        {
            decompOrder_[i] = 1;
        }
        else if (order[i] == 'z')
        {
            decompOrder_[i] = 2;
        }
        else
        {
            FatalIOErrorIn
            (
                "hierarchGeomDecomp::hierarchGeomDecomp"
                "(const dictionary& decompositionDict)",
                decompositionDict_
            )   << "Illegal decomposition order " << order << endl
                << "It should only contain x, y or z" << exit(FatalError);
        }
    }
}

    void solve(string s, size_t pos, size_t depth, set<string> &res) {
        bool neg;
        
        auto o = order(s, neg);
        if (o == 0) {
            if(neg == false)
                res.insert(s);
            return;
        }
        if (depth == 0)
            return;

        //cout << "s=" << s << " pos=" << pos << " depth=" << depth << endl;
        for (int i = pos; i < s.size(); i++) {
            if (s[i] == '(') {
                string tmp = s;
                tmp.erase(i, 1);
                solve(tmp, i, depth-1, res);
            }
        }
    }

//===========================================================================
void SplineCurve::makeKnotStartRegular()
//===========================================================================
{
    // Testing whether knotstart is already d+1-regular.
    if (basis_.begin()[0] < basis_.begin()[order() - 1]) {
	
	double tpar = basis_.startparam();
	int ti = order() - 1; // Index of last occurence of tpar (in other_curve).
	int mt = 1; // Multiplicity of tpar.
	
	while ((basis_.begin()[ti - mt] == tpar) && (mt < order())) ++mt;
	std::vector<double> new_knots;
	for (int i = 0; i < order() - mt; ++i) new_knots.push_back(tpar);
	insertKnot(new_knots);
	coefs_.erase(coefs_begin(), coefs_begin() + (order() - mt) * dim_);
	basis_ = BsplineBasis(order(), basis_.begin() + order() - mt,
				basis_.end());
    }
}

QList<Model::CanceledOrder> CanceledOrder::getAll()
{
    QList<Model::CanceledOrder> canceledOrders;

    DatabaseManager mgr;
    QSqlQuery query("SELECT * from order_canceled");
    query.exec();

    while(query.next()) {
        int id = query.value(0).toInt();
        int order_id = query.value(1).toInt();
        QDateTime cancel_time = query.value(2).toDateTime();

        Model::Order order(order_id);
        Model::CanceledOrder canceledOrder(id, order, cancel_time);

        canceledOrders.append(canceledOrder);
    }

    return canceledOrders;
}

 std::vector<long> listEccentricities(const Graph & g)
 {
     dMatrix dist = distanceMatrix(g);
     long n = order(g);
     std::vector<long> res(n);
     for (long i = 0; i < n; i++)
     {
         long m = 0;
         for (long j = 0; j < n; j++)
         {
             if (m < dist[i][j])
             {
                 m = dist[i][j];
             }
         }
         res[i] = m;
     }
     make_heap(res.begin(), res.end());
     sort_heap(res.begin(), res.end());
     return res;
 }

void
sort(		/* sort primitives according to pcmp */
FILE  *infp,
int  (*pcmp)()		/* compares pointers to pointers to primitives! */
)
{
 PRIMITIVE  *prims[PBSIZE];		/* pointers to primitives */
 PLIST  primlist;			/* our primitives list */
 int  nprims;
 short  done;

 do  {

    for (nprims = 0; nprims < PBSIZE; nprims++)  {	/* read to global */

       if ((prims[nprims] = palloc()) == NULL)
          error(SYSTEM, "memory exhausted in sort");

       readp(prims[nprims], infp);

       if (isglob(prims[nprims]->com))
	  break;
       }

	qsort(prims, nprims, sizeof(*prims), pcmp);	/* sort pointer array */

	if (nprims < PBSIZE)			/* tack on global if one */
	    nprims++;

	order(prims, nprims, &primlist);	/* make array into list */

	sendsort(&primlist, pcmp);		/* send to merge sorter */

	done = primlist.pbot->com == PEOF;

	plfree(&primlist);			/* free up array */

    }  while (!done);

 }

void Application::onMessage( const FIX42::NewOrderSingle& message, const FIX::SessionID& )
{
  FIX::SenderCompID senderCompID;
  FIX::TargetCompID targetCompID;
  FIX::ClOrdID clOrdID;
  FIX::Symbol symbol;
  FIX::Side side;
  FIX::OrdType ordType;
  FIX::Price price;
  FIX::OrderQty orderQty;
  FIX::TimeInForce timeInForce( FIX::TimeInForce_DAY );

  message.getHeader().get( senderCompID );
  message.getHeader().get( targetCompID );
  message.get( clOrdID );
  message.get( symbol );
  message.get( side );
  message.get( ordType );
  if ( ordType == FIX::OrdType_LIMIT )
    message.get( price );
  message.get( orderQty );
  if ( message.isSetField( timeInForce ) )
    message.get( timeInForce );

  try
  {
    if ( timeInForce != FIX::TimeInForce_DAY )
      throw std::logic_error( "Unsupported TIF, use Day" );

    Order order( clOrdID, symbol, senderCompID, targetCompID,
                 convert( side ), convert( ordType ),
                 price, (long)orderQty );

    processOrder( order );
  }
  catch ( std::exception & e )
  {
    rejectOrder( senderCompID, targetCompID, clOrdID, symbol, side, e.what() );
  }
}

int run(){

const int order_ = 20;
int numshape = (order_+1)*(order_+1)*(order_+1);

  TPZVec<REAL> point(3,0.);
  TPZVec<int> id(8);
  int i;

  for(i = 0; i< 8; i ++)
  {
  	id[i] = i;
  }

  TPZVec<int> order(19);
  for(i = 0; i< 19; i ++)
  {
        order[i] = order_;
  }

  TPZCompEl::SetgOrder(order_);

  TPZVec<FADREAL> phi(numshape);
  TPZFMatrix OldPhi(numshape,1), OldDPhi(3,numshape);
  TPZFMatrix DiffPhi(numshape,1), DiffDPhi(3,numshape);

  TPZShapeCube::ShapeCube(point, id, order, phi);
  TPZShapeCube::ShapeCube(point, id, order, OldPhi, OldDPhi);

  /*cout << "Calculated by Fad" << phi;
  cout << "Old derivative method (phi)\n" << OldPhi;
  cout << "Old derivative method (dPhi)\n" << OldDPhi;

  shapeFAD::ExplodeDerivatives(phi, DiffPhi, DiffDPhi);
  DiffPhi-=OldPhi;
  DiffDPhi-=OldDPhi;*/
  //cout << "FAD derivative method (phi)\n" << /*TPZFMatrix (OldPhi -*/ DiffPhi;
  //cout << "FAD derivative method (dPhi)\n" <</* TPZFMatrix (OldDPhi -*/ DiffDPhi;
  return 0;
}

void main()
{
    int choice = 0;
    menu();
    scanf("%d", &choice);
    while(choice)
    {
        switch(choice)
        {
            case 1:
                init();
                break;
            case 2:
                search();
                break;
            case 3:
                del();
                break;
            case 4:
                modify();
                break;
            case 5:
                insert();
                break;
            case 6:
                order();
                break;
            case 7:
                total();
                break;
            default: break;
        }
        getchar();
        menu();
        scanf("%d", &choice);
    }
    getchar();
    return;
}

 long radius(const Graph & g)
 {
     dMatrix mat = distanceMatrix(g);
     long n = order(g);
     long rad = INF;
     for (long i = 0; i < n; ++i)
     {
         long max = -1;
         for (long j = 0; j < n; ++j)
         {
             if (mat[i][j] > max)
             {
                 max = mat[i][j];
             }
         }
         if (max < rad)
         {
             rad = max;
         }
     }
     return rad;
 }

int main()
{
    int i;
    int src[10];

    printf("input 10 number : ");
    for(i = 0; i < 10; i++)
    {
        scanf("%d",&src[i]);
    }

    order(src);

    printf("output ordering munber is :");
    for(i = 0; i < 10; i++)
    {
        printf("%d ",src[i]);

    }
    printf("\n");
    return 0;
}

int main()
{
    std::priority_queue<order, std::vector<order>, order> q;
    std::vector<order> v;
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        int x, y;
        scanf("%d %d", &x, &y);
        v.push_back(order(x, y, i));
    }
    std::sort(v.begin(), v.end(), 
              [] (const order& a, const order& b) { return a.deadline < b.deadline; });
    for(auto it = v.begin(); it < v.end(); it++)
    {
        if(it->deadline == q.size() && q.top().reward < it->reward)
        {    // The size of q is equal to the day number, if it surpasses the deadline of the
             // current order, we can't meet it, so we (possibly) replace some earlier order
             q.pop();
             q.push(*it);
        }
        else if(it->deadline > q.size())
            q.push(*it);
    }
    printf("%d\n", q.size());
    std::vector<order> ans;

    while(!q.empty())
    {
        ans.push_back(q.top());
        q.pop();
    }
    std::sort(ans.begin(), ans.end(), 
              [] (const order& o1, const order& o2) { return o1.deadline < o2.deadline; } );
    for(auto it = ans.begin(); it < ans.end(); it++)
        printf("%d ", it->number);
    return 0;
}

lsdouble SchedulingNativeFunction::call(const LSNativeContext& context) {
	vector<int> order(p.numJobs);
	if (context.count() < varCount()) return numeric_limits<double>::lowest();

	for (int i = 0; i < p.numJobs; i++) {
		order[i] = static_cast<int>(context.getIntValue(i));
		if (order[i] == Project::UNSCHEDULED)
			return numeric_limits<double>::lowest();
	}
	SGSResult result = decode(order, context);
	lsdouble profit = static_cast<lsdouble>(p.calcProfit(result));

	if (tr != nullptr) {
		if(profit > bks)
			bks = profit;
		tr->intervalTrace(static_cast<float>(bks));
	}

	// TODO: result.numSchedulesGenerated

	return profit;
}

 long eccentricConnectivity(const Graph & g)
 {
     long res = 0, n = order(g);
     dMatrix dist = distanceMatrix(g);
     for (long i = 0; i < n; i++)
     {
         long ecc = 0, deg = 0;
         for (long j = 0; j < n; j++)
         {
             if (edge(i,j,g).second)
             {
                 deg++;
             }
             if (dist[i][j] > ecc)
             {
                 ecc = dist[i][j];
             }
         }
         res += ecc * deg;
     }
     return res;
 }