Dataset Viewer
Auto-converted to Parquet
text
stringlengths
129
7.61k
/* * @lc app=leetcode.cn id=901 lang=cpp * * [901] 股票价格跨度 */ class StockSpanner { public: StockSpanner() { } int next(int price) { if(_i == 0 || price < _prices.back()) { _dp.push_back(1); } else { int j = _i - 1; while(j >= 0 && price >= _prices[j]) { j -= _dp[j]; } _dp.push_back(_i - j); } ++_i; _prices.push_back(price); return _dp.back(); } private: vector<int> _dp; vector<int> _prices; int _i = 0; }; /** * Your StockSpanner object will be instantiated and called as such: * StockSpanner* obj = new StockSpanner(); * int param_1 = obj->next(price); */
#include <bits/stdc++.h> #define chmin(a, b) ((a)=min((a), (b))) #define chmax(a, b) ((a)=max((a), (b))) #define fs first #define sc second #define eb emplace_back using namespace std; typedef long long ll; typedef pair<int, int> P; typedef tuple<int, int, int> T; const ll MOD=1e9+7; const ll INF=1e18; int dx[]={1, -1, 0, 0}; int dy[]={0, 0, 1, -1}; template <typename T> inline string toString(const T &a){ostringstream oss; oss<<a; return oss.str();}; ll solve(string &s){ int n=s.size(); ll dp[20][2][2]; // dp[決めた桁数][未満フラグ][4または9を含むか] := 求める総数 memset(dp, 0, sizeof(dp)); dp[0][0][0]=1; for(int i=0; i<n; i++){ // 桁 int D=s[i]-'0'; for(int j=0; j<2; j++){ // 未満フラグ for(int k=0; k<2; k++){ // k=1 のとき4または9を含む for(int d=0; d<=(j?9:D); d++){ dp[i+1][j || (d<D)][k || d==4 || d==9]+=dp[i][j][k]; } } } } return dp[n][0][1]+dp[n][1][1]; } int main(){ ll a, b; cin>>a>>b; string A=toString(a-1), B=toString(b); cout << solve(B) - solve(A) << endl; }
#include "Buffer.h" void CBuffer_Reset(struct CBuffer& Cbuf){ if(!Cbuf.buf){ Cbuf.buf = (char*) malloc(BUFFER_SIZE); memset(Cbuf.buf,0x00,Cbuf._free); } if(Cbuf.len > BUFFER_SIZE * 2 && Cbuf.buf){ //如果目前buf的大小是默认值的2倍,则对其裁剪内存,保持buf的大小为默认值,减小内存耗费 char* newbuf = (char*) realloc(Cbuf.buf,BUFFER_SIZE); if(newbuf != Cbuf.buf) Cbuf.buf = newbuf; } Cbuf.len = 0; Cbuf._free = BUFFER_SIZE; } bool Append(struct CBuffer& Cbuf,char* p, size_t size){ if(!p || !size) return true; if(size < Cbuf._free){ memcpy(Cbuf.buf + Cbuf.len, p , size); Cbuf.len += size; Cbuf._free -= size; }else{ return false; } return true; } char* GetBuf(struct CBuffer Cbuf,uint32_t& size){ size = Cbuf.len; return Cbuf.buf; } uint32_t GetBufLen(struct CBuffer Cbuf){ return Cbuf.len; } void Buf_init(struct CBuffer& Cbuf){ Cbuf.len=0; Cbuf._free=0; Cbuf.buf=0; CBuffer_Reset(Cbuf); }
#ifndef WORKER_H_ #define WORKER_H_ #include <memory> #include <optional> #include "OopUtils.h" namespace torrent_node_lib { struct BlockInfo; class Worker: public common::no_copyable, common::no_moveable{ public: virtual void start() = 0; virtual void process(std::shared_ptr<BlockInfo> bi, std::shared_ptr<std::string> dump) = 0; virtual std::optional<size_t> getInitBlockNumber() const = 0; virtual ~Worker() = default; }; } #endif // WORKER_H_
// Copyright (c) 2010 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SIMPLE_IPC_PIPE_WIN_H_ #define SIMPLE_IPC_PIPE_WIN_H_ #include "os_includes.h" #include "ipc_constants.h" class PipePair { public: PipePair(bool inherit_fd2 = false); HANDLE fd1() const { return srv_; } HANDLE fd2() const { return cln_; } static HANDLE OpenPipeServer(const wchar_t* name, bool low_integrity = false); static HANDLE OpenPipeClient(const wchar_t* name, bool inherit, bool impersonate); private: HANDLE srv_; HANDLE cln_; }; class PipeWin { public: PipeWin(); ~PipeWin(); bool OpenClient(HANDLE pipe); bool OpenServer(HANDLE pipe, bool connect = false); bool Write(const void* buf, size_t sz); bool Read(void* buf, size_t* sz); bool IsConnected() const { return INVALID_HANDLE_VALUE != pipe_; } private: HANDLE pipe_; }; class PipeTransport : public PipeWin { public: static const size_t kBufferSz = 4096; size_t Send(const void* buf, size_t sz) { return Write(buf, sz) ? ipc::RcOK : ipc::RcErrTransportWrite; } char* Receive(size_t* size); private: IPCCharVector buf_; }; #endif // SIMPLE_IPC_PIPE_WIN_H_
#include "stdafx.h" #include "LobbyBoard.h" #include "InputSystem.h" #include "PacketManager.h" LobbyBoard::LobbyBoard() { m_packetManager = PacketManager::getInstance(); m_inputSystem = new InputSystem(); } LobbyBoard::~LobbyBoard() { SafeDelete(m_inputSystem); } void LobbyBoard::Update() { m_inputSystem->CheckKeyboardPressed(); if (m_inputSystem->IsEnterPressed()) { m_on = true; } }
#include "..\..\leetcode.h" class Solution { public: void solveSudoku(vector<vector<char>>& board) { row = col = box = vector<int>(9); int count = 0; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (board[i][j] == '.') count++; else fill(i, j, i / 3 * 3 + j / 3, board[i][j] - '1'); } } dfs(count, board); } private: vector<int> row, col, box; void fill(int i, int j, int k, int n) { row[i] |= 1 << n; col[j] |= 1 << n; box[k] |= 1 << n; } void zero(int i, int j, int k, int n) { row[i] &= ~(1 << n); col[j] &= ~(1 << n); box[k] &= ~(1 << n); } int possible(int i, int j) { return ~(row[i] | col[j] | box[i / 3 * 3 + j / 3]) & ((1 << 9) - 1); } pair<int, int> next(vector<vector<char>>& board) { pair<int, int> res; int min_count = INT_MAX; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (board[i][j] != '.') continue; int c = count(possible(i, j)); if (c < min_count) { min_count = c; res = {i, j}; } } } return res; } bool dfs(int count, vector<vector<char>>& board) { if (count == 0) return true; auto [i, j] = next(board); int p = possible(i, j); int k = i / 3 * 3 + j / 3; while (p) { int n = __builtin_ctz(p & -p); board[i][j] = n + '1'; fill(i, j, k, n); if (dfs(count - 1, board)) return true; board[i][j] = '.'; zero(i, j, k, n); p &= p - 1; } return false; } int count(int p) { int count = 0; while (p) { count++; p &= p - 1; } return count; } };
#include <bits/stdc++.h> using namespace std; int main(int argc, char const *argv[]) { int t; cin>>t; cout<<"Lumberjacks:\n"; while(t--){ bool in = true; bool dec = true; int p; for(int i=0; i<10; i++){ int n; cin>>n; if(!i){ p = n; continue; } if(n<p || !in) in = false; if(n>p || !dec) dec = false; p = n; } if(!in && !dec) cout<<"Unordered\n"; else cout<<"Ordered\n"; } return 0; }
#ifndef BOOST_SIMD_TOOLBOX_CONSTANT_INCLUDE_CONSTANTS_MINEXPONENT_HPP_INCLUDED #define BOOST_SIMD_TOOLBOX_CONSTANT_INCLUDE_CONSTANTS_MINEXPONENT_HPP_INCLUDED #include <boost/simd/toolbox/constant/constants/minexponent.hpp> #endif
#include "Personnages.h" using namespace std; int main(){ srand(time(NULL)); int ok = 0; Hero* h = new Hero("Player"); Ennemi* e = new Ennemi(4); cout << "Hero : " << h->getName() << endl << "x : " << h->getX() << endl << "y : " << h->getY() << endl << "pv : " << h->getPv() << endl << "lv : " << h->getLv() << endl << "atk : " << h->getAtk() << endl << "def : " << h->getDef() << "\n\n" << "Ennemi :" << endl << "x : " << e->getX() << endl << "y : " << e->getY() << endl << "pv : " << e->getPv() << endl << "lv : " << e->getLv() << endl << "atk : " << e->getAtk() << endl << "def : " << e->getDef() << "\n\n"; assert(ok == h->lvUp()); cout << "lv : " << h->getLv() << endl << "atk : " << h->getAtk() << endl << "def : " << h->getDef() << endl; assert(ok == h->combat(e)); cout << "Ennemie - pv : " << e->getPv() << endl; assert(ok == h->setName("Terrine")); assert(ok == e->combat(h)); cout << h->getName() << " - pv : " << h->getPv(); delete e; delete h; return 0; }
#ifndef PYTHONIC_INCLUDE_BUILTIN_SET_ISDISJOINT_HPP #define PYTHONIC_INCLUDE_BUILTIN_SET_ISDISJOINT_HPP #include "pythonic/utils/proxy.hpp" #include "pythonic/types/set.hpp" namespace pythonic { namespace __builtin__ { namespace set { template<class T, class U> bool isdisjoint(types::set<T> const& calling_set, U const& arg_set); template<class U> bool isdisjoint(types::empty_set const& calling_set, U const& arg_set); PROXY_DECL(pythonic::__builtin__::set, isdisjoint); } } } #endif
// // Created by xgallom on 1/27/19. // #ifndef CHAT_UP_AUTHENTICATIONSERVICE_H #define CHAT_UP_AUTHENTICATIONSERVICE_H #include <Messaging/Message.h> #include <Messaging/MessageSender.h> #include <Outcome.h> #include <Authentication/User.h> class AuthenticationStorage; class AuthenticationService { AuthenticationStorage &m_storage; User m_user = User(); public: AuthenticationService() noexcept; Outcome::Enum run(MessageSender &sender, const Message &message); bool registerUser(const User &user); User user() const noexcept; }; #endif //CHAT_UP_AUTHENTICATIONSERVICE_H
// ARKSurvivalEvolved (332.8) SDK #ifdef _MSC_VER #pragma pack(push, 0x8) #endif #include "ARKSurvivalEvolved_Buff_PreventDismount_parameters.hpp" namespace sdk { //--------------------------------------------------------------------------- //Functions //--------------------------------------------------------------------------- // Function Buff_PreventDismount.Buff_PreventDismount_C.UserConstructionScript // () void ABuff_PreventDismount_C::UserConstructionScript() { static auto fn = UObject::FindObject<UFunction>("Function Buff_PreventDismount.Buff_PreventDismount_C.UserConstructionScript"); ABuff_PreventDismount_C_UserConstructionScript_Params params; auto flags = fn->FunctionFlags; UObject::ProcessEvent(fn, &params); fn->FunctionFlags = flags; } // Function Buff_PreventDismount.Buff_PreventDismount_C.ExecuteUbergraph_Buff_PreventDismount // () // Parameters: // int EntryPoint (Parm, ZeroConstructor, IsPlainOldData) void ABuff_PreventDismount_C::ExecuteUbergraph_Buff_PreventDismount(int EntryPoint) { static auto fn = UObject::FindObject<UFunction>("Function Buff_PreventDismount.Buff_PreventDismount_C.ExecuteUbergraph_Buff_PreventDismount"); ABuff_PreventDismount_C_ExecuteUbergraph_Buff_PreventDismount_Params params; params.EntryPoint = EntryPoint; auto flags = fn->FunctionFlags; UObject::ProcessEvent(fn, &params); fn->FunctionFlags = flags; } } #ifdef _MSC_VER #pragma pack(pop) #endif
#include <osg/AnimationPath> //includes #include <MetaQQuickLibraryRegistry.h> #include <customCode/osg/AnimationPath_pmoc.hpp> using namespace pmoc; osg::QMLAnimationPath::QMLAnimationPath(pmoc::Instance *i,QObject* parent):QReflect_AnimationPath(i,parent){ //custom initializations } QQuickItem* osg::QMLAnimationPath::connect2View(QQuickItem*i){ this->_view=QReflect_AnimationPath::connect2View(i); ///connect this's signals/slot to its qml component//////////////////////////////////////////////////////////////// ///CustomiZE here return this->_view; } void osg::QMLAnimationPath::updateModel(){ QReflect_AnimationPath::updateModel(); ///update this according to state of _model when it has been changed via pmoc///////////////////////////////////////////// ///CustomiZE here } #ifndef AUTOMOCCPP #define AUTOMOCCPP 1 #include "moc_AnimationPath_pmoc.cpp" #endif #include <MetaQQuickLibraryRegistry.h> #include <customCode/osg/AnimationPath_pmoc.hpp> using namespace pmoc; osg::QMLAnimationPathCallback::QMLAnimationPathCallback(pmoc::Instance *i,QObject* parent):QReflect_AnimationPathCallback(i,parent){ //custom initializations } QQuickItem* osg::QMLAnimationPathCallback::connect2View(QQuickItem*i){ this->_view=QReflect_AnimationPathCallback::connect2View(i); ///connect this's signals/slot to its qml component//////////////////////////////////////////////////////////////// ///CustomiZE here return this->_view; } void osg::QMLAnimationPathCallback::updateModel(){ QReflect_AnimationPathCallback::updateModel(); ///update this according to state of _model when it has been changed via pmoc///////////////////////////////////////////// ///CustomiZE here } #ifndef AUTOMOCCPP #define AUTOMOCCPP 1 #include "moc_AnimationPath_pmoc.cpp" #endif
#include <stdio.h> #include <iostream> using namespace std; int qipan[15][15] = { 0 }; int times = 0; int print(); bool is_win(int x, int y, int flag); bool is_near(int x, int y); bool AI_set(int flag); int calc_value(int x, int y, int flag, int depth, int _max_value); int qixing(int x, int y); int main(int argc, char **argv) { int flag = 1; while (true) { ++times; print(); int x, y; if (flag == 1) { while (true) { cin >> x >> y; if (!qipan[x][y] || x < 0 || x >= 15 || y < 0 || y >= 15) break; } qipan[x][y] = flag; if (is_win(x, y, flag)) break; } else { if (AI_set(flag)) break; } flag *= -1; } if (flag == 1) { printf("black\n"); } else { printf("white\n"); } system("pause"); return 0; } int print() { for (int i = 0; i < 15; ++i) { for (int j = 0; j < 15; ++j) cout << (qipan[i][j] ? (qipan[i][j] == 1 ? "*" : "#") : "0"); cout << endl; } cout << endl; return 0; } bool is_win(int x, int y, int flag) { int number = 1; for (int i = x + 1; i < 15; ++i) { if (qipan[i][y] == flag) ++number; else break; } for (int i = x - 1; i >= 0; --i) { if (qipan[i][y] == flag) ++number; else break; } if (number >= 5) return true; number = 1; for (int i = y + 1; i < 15; ++i) { if (qipan[x][i] == flag) ++number; else break; } for (int i = y - 1; i >= 0; --i) { if (qipan[x][i] == flag) ++number; else break; } if (number >= 5) return true; number = 1; for (int j = 1; x + j < 15 && y + j < 15; ++j) { if (qipan[x + j][y + j] == flag) ++number; else break; } for (int j = 1; x - j >= 0 && y - j >= 0; ++j) { if (qipan[x - j][y - j] == flag) ++number; else break; } if (number >= 5) return true; number = 1; for (int j = 1; x + j < 15 && y - j >= 0; ++j) { if (qipan[x + j][y - j] == flag) ++number; else break; } for (int j = 1; x - j >= 0 && y + j < 15; ++j) { if (qipan[x - j][y + j] == flag) ++number; else break; } if (number >= 5) return true; return false; } bool is_near(int x, int y) { // cout << x << " " << y << endl; int _near = 2; for (int i = (x - _near >= 0 ? x - _near : 0); i <= (x + _near < 15 ? x + _near : 14); ++i) { for (int j = (y - _near >= 0 ? y - _near : 0); j <= (y + _near < 15 ? y + _near : 14); ++j) { if (qipan[i][j]) return true; } } return false; } bool AI_set(int flag) { int max_value = -10000000; int x = 7, y = 7; for (int i = 0; i < 15; ++i) { for (int j = 0; j < 15; ++j) { if (qipan[i][j]) continue; if (!is_near(i, j)) continue; int t_value = calc_value(i, j, flag, 0, max_value); if (is_win(i, j, flag)) { qipan[i][j] = flag; return true; } if (t_value > max_value) { max_value = t_value; x = i; y = j; } } } qipan[x][y] = flag; cout << x << " " << y << " " << flag << " " << is_win(x, y, flag)<< endl; return false; } int calc_value(int x, int y, int flag, int depth, int _max_value) { int _value = 0; qipan[x][y] = flag; if (depth < 4) { int max_value = -10000000; for (int i = 0; i < 15; ++i) { for (int j = 0; j < 15; ++j) { if (qipan[i][j] || !is_near(i, j)) continue; int t_value = calc_value(i, j, -flag, depth + 1, max_value); if (t_value > -_max_value) { qipan[x][y] = 0; return t_value; } if (is_win(i, j, -flag)) { qipan[x][y] = 0; return -10000000; } if (t_value > max_value) { max_value = t_value; } } } _value -= max_value; } else _value += qixing(x, y); qipan[x][y] = 0; return _value; } int qixing(int x, int y) { int flag = qipan[x][y]; bool dead = false; int number = 1; int _value = 0; int sz_qixing[2][6] = { 0 }; // x 方向 number = 1; dead = false; for (int i = x + 1; ; ++i) { if (i < 15 && qipan[i][y] == flag) ++number; else { if (i >= 15 || qipan[i][y]) dead = true; break; } } for (int i = x - 1; i >= 0; --i) { if (i >= 0 && qipan[i][y] == flag) ++number; else { if ((i < 0 || qipan[i][y]) && dead) break; else { if (dead || qipan[i][y]) dead = true; ++sz_qixing[dead][number]; } } } // y方向 number = 1; dead = false; for (int i = y + 1; ; ++i) { if (i < 15 && qipan[x][i] == flag) ++number; else { if (i >= 15 || qipan[x][i]) dead = true; break; } } for (int i = y - 1; i >= 0; --i) { if (i >= 0 && qipan[x][i] == flag) ++number; else { if ((i < 0 || qipan[x][i]) && dead) break; else { if (dead || qipan[x][i]) dead = true; ++sz_qixing[dead][number]; } } } // x y 方向 number = 1; dead = false; for (int i = 1; ; ++i) { if (x + i < 15 && y + i < 15 && qipan[x + i][y + i] == flag) ++number; else { if (x + i >= 15 || y + i >= 15 || qipan[x + i][y + i]) dead = true; break; } } for (int i = 1; ; ++i) { if (x - i >= 0 && y - i >= 0 && qipan[x - i][y - i] == flag) ++number; else { if ((x - i < 0 || y - i < 0 || qipan[x - i][y - i]) && dead) break; else { if (dead || qipan[x - i][y - i]) dead = true; ++sz_qixing[dead][number]; } } } // x -y 方向 number = 1; dead = false; for (int i = 1; ; ++i) { if (x + i < 15 && y - i >= 0 && qipan[x + i][y - i] == flag) ++number; else { if (x + i >= 15 || y - i < 0 || qipan[x + i][y - i]) dead = true; break; } } for (int i = 1; ; ++i) { if (x - i >= 0 && y + i < 15 && qipan[x - i][y + i] == flag) ++number; else { if ((x - i < 0 || y + i >= 15 || qipan[x - i][y + i]) && dead) break; else { if (dead || qipan[x - i][y + i]) dead = true; ++sz_qixing[dead][number]; } } } if (sz_qixing[false][4] || (sz_qixing[true][4] + sz_qixing[false][3]) >= 2) _value += 1000000; _value += sz_qixing[false][3] * 10000; _value += sz_qixing[true][3] * 1000; _value += sz_qixing[false][2] * 100; _value += sz_qixing[true][2] * 10; return _value; }
/**************************************************************************** * Copyright (c) 2018 by the Cabana authors * * All rights reserved. * * * * This file is part of the Cabana library. Cabana is distributed under a * * BSD 3-clause license. For the licensing terms see the LICENSE file in * * the top-level directory. * * * * SPDX-License-Identifier: BSD-3-Clause * ****************************************************************************/ #include <Cabana_DeepCopy.hpp> #include <Cabana_AoSoA.hpp> #include <Cabana_Types.hpp> #include <gtest/gtest.h> namespace Test { //---------------------------------------------------------------------------// // Check the data given a set of values. template<class aosoa_type> void checkDataMembers( aosoa_type aosoa, const float fval, const double dval, const int ival, const int dim_1, const int dim_2, const int dim_3 ) { auto slice_0 = aosoa.template slice<0>(); auto slice_1 = aosoa.template slice<1>(); auto slice_2 = aosoa.template slice<2>(); auto slice_3 = aosoa.template slice<3>(); for ( std::size_t idx = 0; idx < aosoa.size(); ++idx ) { // Member 0. for ( int i = 0; i < dim_1; ++i ) for ( int j = 0; j < dim_2; ++j ) for ( int k = 0; k < dim_3; ++k ) EXPECT_EQ( slice_0( idx, i, j, k ), fval * (i+j+k) ); // Member 1. EXPECT_EQ( slice_1( idx ), ival ); // Member 2. for ( int i = 0; i < dim_1; ++i ) EXPECT_EQ( slice_2( idx, i ), dval * i ); // Member 3. for ( int i = 0; i < dim_1; ++i ) for ( int j = 0; j < dim_2; ++j ) EXPECT_EQ( slice_3( idx, i, j ), dval * (i+j) ); } } //---------------------------------------------------------------------------// // Perform a deep copy test. template<class DstMemorySpace, class SrcMemorySpace, int DstVectorLength, int SrcVectorLength> void testDeepCopy() { // Data dimensions. const int dim_1 = 3; const int dim_2 = 2; const int dim_3 = 4; // Declare data types. using DataTypes = Cabana::MemberTypes<float[dim_1][dim_2][dim_3], int, double[dim_1], double[dim_1][dim_2] >; // Declare the AoSoA types. using DstAoSoA_t = Cabana::AoSoA<DataTypes,DstMemorySpace,DstVectorLength>; using SrcAoSoA_t = Cabana::AoSoA<DataTypes,SrcMemorySpace,SrcVectorLength>; // Create AoSoAs. int num_data = 357; DstAoSoA_t dst_aosoa( num_data ); SrcAoSoA_t src_aosoa( num_data ); // Initialize data with the rank accessors. float fval = 3.4; double dval = 1.23; int ival = 1; auto slice_0 = src_aosoa.template slice<0>(); auto slice_1 = src_aosoa.template slice<1>(); auto slice_2 = src_aosoa.template slice<2>(); auto slice_3 = src_aosoa.template slice<3>(); for ( std::size_t idx = 0; idx < src_aosoa.size(); ++idx ) { // Member 0. for ( int i = 0; i < dim_1; ++i ) for ( int j = 0; j < dim_2; ++j ) for ( int k = 0; k < dim_3; ++k ) slice_0( idx, i, j, k ) = fval * (i+j+k); // Member 1. slice_1( idx ) = ival; // Member 2. for ( int i = 0; i < dim_1; ++i ) slice_2( idx, i ) = dval * i; // Member 3. for ( int i = 0; i < dim_1; ++i ) for ( int j = 0; j < dim_2; ++j ) slice_3( idx, i, j ) = dval * (i+j); } // Deep copy Cabana::deep_copy( dst_aosoa, src_aosoa ); // Check values. checkDataMembers( dst_aosoa, fval, dval, ival, dim_1, dim_2, dim_3 ); } //---------------------------------------------------------------------------// // TESTS //---------------------------------------------------------------------------// TEST_F( TEST_CATEGORY, deep_copy_to_host_same_layout_test ) { testDeepCopy<Cabana::HostSpace,TEST_MEMSPACE,16,16>(); } //---------------------------------------------------------------------------// TEST_F( TEST_CATEGORY, deep_copy_from_host_same_layout_test ) { testDeepCopy<TEST_MEMSPACE,Cabana::HostSpace,16,16>(); } //---------------------------------------------------------------------------// TEST_F( TEST_CATEGORY, deep_copy_to_host_different_layout_test ) { testDeepCopy<Cabana::HostSpace,TEST_MEMSPACE,16,32>(); testDeepCopy<Cabana::HostSpace,TEST_MEMSPACE,64,8>(); } //---------------------------------------------------------------------------// TEST_F( TEST_CATEGORY, deep_copy_from_host_different_layout_test ) { testDeepCopy<TEST_MEMSPACE,Cabana::HostSpace,64,8>(); testDeepCopy<TEST_MEMSPACE,Cabana::HostSpace,16,32>(); } //---------------------------------------------------------------------------// } // end namespace Test
// This file was generated based on '../../AppData/Local/Fusetools/Packages/Fuse.Nodes/1.0.2/$.uno'. // WARNING: Changes might be lost if you edit this file directly. #pragma once #include <Uno.h> namespace g{namespace Fuse{namespace Resources{struct ResourceConverters;}}} namespace g{namespace Uno{namespace Collections{struct Dictionary;}}} namespace g{ namespace Fuse{ namespace Resources{ // internal static class ResourceConverters :3538 // { uClassType* ResourceConverters_typeof(); void ResourceConverters__Get_fn(uType* __type, uObject** __retval); struct ResourceConverters : uObject { static uSStrong< ::g::Uno::Collections::Dictionary*> _converters_; static uSStrong< ::g::Uno::Collections::Dictionary*>& _converters() { return ResourceConverters_typeof()->Init(), _converters_; } static uObject* Get(uType* __type); }; // } }}} // ::g::Fuse::Resources
//////////////////////////////////////////////////////////////////////////////// // The following FIT Protocol software provided may be used with FIT protocol // devices only and remains the copyrighted property of Dynastream Innovations Inc. // The software is being provided on an "as-is" basis and as an accommodation, // and therefore all warranties, representations, or guarantees of any kind // (whether express, implied or statutory) including, without limitation, // warranties of merchantability, non-infringement, or fitness for a particular // purpose, are specifically disclaimed. // // Copyright 2017 Dynastream Innovations Inc. //////////////////////////////////////////////////////////////////////////////// // ****WARNING**** This file is auto-generated! Do NOT edit this file. // Profile Version = 20.24Release // Tag = production/akw/20.24.01-0-g5fa480b //////////////////////////////////////////////////////////////////////////////// #if !defined(FIT_DEVELOPER_FIELD_DESCRIPTION_HPP) #define FIT_DEVELOPER_FIELD_DESCRIPTION_HPP #include "fit_field_description_mesg.hpp" #include "fit_developer_data_id_mesg.hpp" #include <vector> namespace fit { class DeveloperFieldDescription { public: DeveloperFieldDescription() = delete; DeveloperFieldDescription(const DeveloperFieldDescription& other); DeveloperFieldDescription(const FieldDescriptionMesg& desc, const DeveloperDataIdMesg& developer); virtual ~DeveloperFieldDescription(); FIT_UINT32 GetApplicationVersion() const; FIT_UINT8 GetFieldDefinitionNumber() const; std::vector<FIT_UINT8> GetApplicationId() const; private: FieldDescriptionMesg* description; DeveloperDataIdMesg* developer; }; } // namespace fit #endif // defined(FIT_FIELD_DEFINITION_HPP)
// Copyright 2017 The PDFium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com #include "xfa/fxfa/parser/cxfa_solid.h" #include "fxjs/xfa/cjx_node.h" #include "xfa/fxfa/parser/cxfa_document.h" namespace { const CXFA_Node::PropertyData kSolidPropertyData[] = { {XFA_Element::Extras, 1, {}}, }; const CXFA_Node::AttributeData kSolidAttributeData[] = { {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr}, {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr}, {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr}, }; } // namespace CXFA_Solid::CXFA_Solid(CXFA_Document* doc, XFA_PacketType packet) : CXFA_Node(doc, packet, {XFA_XDPPACKET::kTemplate, XFA_XDPPACKET::kForm}, XFA_ObjectType::Node, XFA_Element::Solid, kSolidPropertyData, kSolidAttributeData, cppgc::MakeGarbageCollected<CJX_Node>( doc->GetHeap()->GetAllocationHandle(), this)) {} CXFA_Solid::~CXFA_Solid() = default;
/** * @file Storage.cpp */ /* * $Id: Storage.cpp,v 1.6 2009/07/11 17:16:09 hkmoffa Exp $ */ // Cantera includes #include "Kinetics.h" #include "TransportFactory.h" #include "Storage.h" using namespace std; using namespace Cantera; Storage::Storage() { addThermo(new ThermoPhase); addKinetics(new Kinetics); addTransport(newTransportMgr()); } Storage::~Storage() { clear(); } int Storage::addThermo(thermo_t* th) { if (th->index() >= 0) return th->index(); __thtable.push_back(th); int n = static_cast<int>(__thtable.size()) - 1; th->setIndex(n); //string id = th->id(); //if (__thmap.count(id) == 0) { // __thmap[id] = n; // th->setID(id); //} //else { // throw CanteraError("Storage::addThermo","id already used"); // return -1; //} return n; } int Storage::nThermo() { return static_cast<int>(__thtable.size()); } int Storage::addKinetics(Kinetics* kin) { if (kin->index() >= 0) return kin->index(); __ktable.push_back(kin); int n = static_cast<int>(__ktable.size()) - 1; kin->setIndex(n); return n; } int Storage::addTransport(Transport* tr) { if (tr->index() >= 0) return tr->index(); __trtable.push_back(tr); int n = static_cast<int>(__trtable.size()) - 1; tr->setIndex(n); return n; } // int Storage::addNewTransport(int model, char* dbase, int th, // int loglevel) { // try { // ThermoPhase* thrm = __thtable[th]; // Transport* tr = newTransportMgr(model, // string(dbase), thrm, loglevel); // __trtable.push_back(tr); // return __trtable.size() - 1; // } // catch (CanteraError) {return -1;} // catch (...) {return ERR;} // } int Storage::clear() { int i, n; n = static_cast<int>(__thtable.size()); for (i = 1; i < n; i++) { if (__thtable[i] != __thtable[0]) { delete __thtable[i]; __thtable[i] = __thtable[0]; } } n = static_cast<int>(__ktable.size()); for (i = 1; i < n; i++) { if (__ktable[i] != __ktable[0]) { delete __ktable[i]; __ktable[i] = __ktable[0]; } } n = static_cast<int>(__trtable.size()); for (i = 1; i < n; i++) { if (__trtable[i] != __trtable[0]) { delete __trtable[i]; __trtable[i] = __trtable[0]; } } return 0; } void Storage::deleteKinetics(int n) { if (n == 0) return; if (__ktable[n] != __ktable[0]) delete __ktable[n]; __ktable[n] = __ktable[0]; } void Storage::deleteThermo(int n) { if (n == 0) return; if (n < 0 || n >= (int) __thtable.size()) throw CanteraError("deleteThermo","illegal index"); __thtable[n] = __thtable[0]; } void Storage::deleteTransport(int n) { if (n == 0) return; if (__trtable[n] != __trtable[0]) delete __trtable[n]; __trtable[n] = __trtable[0]; } Storage* Storage::__storage = 0;
#include<bits/stdc++.h> #define sc(v) v.size() #define eb push_back #define pb pop_back #define f(i,a,b) for(int i=a;i<b;i++) #define TC() int t;cin>>t;while(t--) #define all(x) x.begin(),x.end() #define mk make_pair #define fi first #define se second #define endl "\n" #define eps 1e-9 #define pw(x) (1ll<<(x)) #define trace1(x) cout <<#x<<": "<<x<<endl; #define trace2(x, y) cout <<#x<<": "<<x<<" | "<<#y<<": "<<y<< endl; #define trace3(x, y, z) cout <<#x<<": "<<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl; #define trace4(a, b, c, d) cout <<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl; #define trace5(a, b, c, d, e) cout <<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<<": "<<e<<endl; using namespace std; typedef long long int ll; typedef vector<int> vi; typedef vector<ll> vll; typedef pair<string,string> pi; typedef pair<ll,ll> pll; inline bool EQ(double a,double b) { return fabs(a - b) < 1e-9; } inline void set_bit(int & n, int b) { n |= pw(b); } inline void unset_bit(int & n, int b) { n &= ~pw(b); } int main() { #ifndef ONLINE_JUDGE //freopen("input.txt","r",stdin); //freopen("output.txt","w",stdout); #endif clock_t tStart = clock(); int tc = 1; int n; map< pi,int > mp; vector< pi > v; set< pi > vv; vector<string> f,rr; string x,y; set<string> a,b; TC() { printf("Case #%d: ", tc++); mp.clear(); v.clear(); a.clear(); b.clear(); scanf("%d",&n); f(i,0,n) { cin>>x>>y; v.eb(mk(x,y)); mp[mk(x,y)] = 1; } int ans = 0; f(i,0,1 << n) { f.clear(); rr.clear(); vv.clear(); int c = 0; f(j,0,n) if(i&(1 << j)) { f.eb(v[j].fi); rr.eb(v[j].se); vv.insert(v[j]); } f(j,0,sc(f)) f(k,0,sc(rr)) { if(vv.find(mk(f[j],rr[k])) != vv.end()) continue; if(mp[mk(f[j],rr[k])]) c++; } ans = max(ans,c); } printf("%d\n",ans); } //printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC); return 0; }
#include<iostream> #include<assert.h> #include "EventManager.hpp" #include "definitions.hpp" #ifdef SDL2_IMP #include <SDL2/SDL.h> SDL_Event sdl2_event; #endif EventManager* EventManager::gInstance = nullptr; EventManager::EventManager() {} EventManager::~EventManager() {} EventManager* EventManager::GetSingletonPtr(void) { assert(EventManager::gInstance); return EventManager::gInstance; } EventManager& EventManager::GetSingleton(void) { assert(EventManager::gInstance); return *EventManager::gInstance; } void EventManager::StartUp() { std::cout << "starting up event manager" << std::endl; EventManager::gInstance = new EventManager(); } void EventManager::ShutDown() { std::cout << "shuting down event manager" << std::endl; delete EventManager::gInstance; } bool EventManager::Pool(Event *event) { #ifdef SDL2_IMP int pedding = SDL_PollEvent(&sdl2_event); switch (sdl2_event.type) { case SDL_QUIT: event->type = QUIT_EVENT; break; default: event->type = NULL_EVENT; break; } #else #error IMPLEMENTATION NOT DEFINED #endif return pedding; }
// // ETProtect.cpp // testcpp // // Created by etond on 14/12/3. // // #include "ETProtect.h" bool ETProtect::isOriginPackage() { unsigned int uHashValue = calculateValueFromFile(); unsigned int uReadValue = readValueFromFile(); #if (ETPROTECTDEBUG) CCLOG("[log] -- hash %u", uHashValue); CCLOG("[log] -- read %u", uReadValue); #endif if (uReadValue == 0 || uHashValue == 0) { return false; } return uReadValue == uHashValue; } unsigned int ETProtect::readValueFromFile(std::string filename /* default = config.et */) { unsigned int uValue = 0; Data data = FileUtils::getInstance()->getDataFromFile(filename); if (data.getSize() > 0) { uValue = ((ETProtectData *)data.getBytes())->getHashValue(); } return uValue; } unsigned int ETProtect::calculateValueFromFile(unsigned int seed /* default = 0x12345678 */) { std::string path = ""; #if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) JniMethodInfo minfo; bool isHave = JniHelper::getStaticMethodInfo(minfo, "org/cocos2dx/cpp/AppActivity", "getPath", "()Ljava/lang/String;"); if (isHave) { jobject jobj = minfo.env->CallStaticObjectMethod(minfo.classID, minfo.methodID); /* get the return value */ path = JniHelper::jstring2string((jstring)jobj).c_str(); CCLOG("JNI SUCCESS!"); } #endif unsigned int value = 0; if (path.length() > 0) { ssize_t len = 0; unsigned char *buf = FileUtils::getInstance()->getFileDataFromZip(path, "classes.dex", &len); if (buf) { value = XXH32(buf, len, seed); } delete[] buf; } return value; }
//===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 // <chrono> // class year_month_weekday_last_last; #include <chrono> #include <type_traits> #include <cassert> #include "test_macros.h" int main() { using year_month_weekday_last = std::chrono::year_month_weekday_last; static_assert(std::is_trivially_copyable_v<year_month_weekday_last>, ""); static_assert(std::is_standard_layout_v<year_month_weekday_last>, ""); }
// // //****************************************************************************************// // Copyright (c) 2002-2014, The MITRE Corporation // All rights reserved. // // Redistribution and use in source and binary forms, with or without modification, are // permitted provided that the following conditions are met: // // * Redistributions of source code must retain the above copyright notice, this list // of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright notice, this // list of conditions and the following disclaimer in the documentation and/or other // materials provided with the distribution. // * Neither the name of The MITRE Corporation nor the names of its contributors may be // used to endorse or promote products derived from this software without specific // prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT // SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT // OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR // TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // //****************************************************************************************// #ifndef PASSWORDPROBE_H #define PASSWORDPROBE_H #include "AbsProbe.h" #include "Item.h" #include "Object.h" #include <pwd.h> #include <string> /** This class is responsible for collecting information about unix password_objects. */ class PasswordProbe : public AbsProbe { public: virtual ~PasswordProbe(); /** Get all the files on the system that match the pattern and collect their attributes. */ virtual ItemVector* CollectItems(Object* object); /** Return a new Item created for storing file information */ virtual Item* CreateItem(); /** Ensure that the PasswordProbe is a singleton. */ static AbsProbe* Instance(); private: PasswordProbe(); /** Creates an item from a passwd struct */ Item *CreateItemFromPasswd(struct passwd const *pwInfo); /** Finds a single item by name. */ Item *GetSingleItem(const std::string& username); /** Finds multiple items according to the given object entity. */ ItemVector *GetMultipleItems(Object *passwordObject); /** Singleton instance */ static PasswordProbe* instance; }; #endif
#include <iostream> #include <cstdio> #include <algorithm> #include <string> using namespace std; int N; bool isName(string shop, string board) { int m = board.length(); for(int step=1; step<=m; step++) { for(int i=0; i<m; i++) { string s = ""; for(int j=i; j<m; j+=step) { s += board[j]; } if(s.find(shop) != string::npos) return true; } } return false; } int main(void) { cin >> N; string shop, board; cin >> shop; int ans = 0; for(int i=0; i<N; i++) { cin >> board; if(isName(shop, board)) ans++; } cout << ans << endl; return 0; }
class TeleClient { public: virtual void reset() { txCount = 0; txBytes = 0; rxBytes = 0; } virtual bool notify(byte event, const char* serverKey, const char* payload = 0) { return true; } virtual bool connect() { return true; } virtual bool transmit(const char* packetBuffer, unsigned int packetSize) { return true; } virtual void inbound() {} virtual bool begin() { return true; } virtual void end() {} uint32_t txCount = 0; uint32_t txBytes = 0; uint32_t rxBytes = 0; uint32_t lastSyncTime = 0; uint32_t lastSentTime = 0; uint16_t feedid = 0; }; class TeleClientUDP : public TeleClient { public: bool notify(byte event, const char* serverKey, const char* payload = 0); bool connect(); bool transmit(const char* packetBuffer, unsigned int packetSize); void inbound(); bool verifyChecksum(char* data); #if NET_DEVICE == NET_WIFI UDPClientWIFI net; #elif NET_DEVICE == NET_SIM800 UDPClientSIM800 net; #elif NET_DEVICE == NET_SIM5360 UDPClientSIM5360 net; #elif NET_DEVICE == NET_SIM7600 UDPClientSIM7600 net; #else NullClient net; #endif }; class TeleClientHTTP : public TeleClient { public: bool connect(); bool transmit(const char* packetBuffer, unsigned int packetSize); #if NET_DEVICE == NET_WIFI HTTPClientWIFI net; #elif NET_DEVICE == NET_SIM800 HTTPClientSIM800 net; #elif NET_DEVICE == NET_SIM5360 HTTPClientSIM5360 net; #elif NET_DEVICE == NET_SIM7600 HTTPClientSIM7600 net; #else NullClient net; #endif };
#ifndef _ROS_moveit_msgs_MoveGroupActionGoal_h #define _ROS_moveit_msgs_MoveGroupActionGoal_h #include <stdint.h> #include <string.h> #include <stdlib.h> #include "ros/msg.h" #include "std_msgs/Header.h" #include "actionlib_msgs/GoalID.h" #include "moveit_msgs/MoveGroupGoal.h" namespace moveit_msgs { class MoveGroupActionGoal : public ros::Msg { public: typedef std_msgs::Header _header_type; _header_type header; typedef actionlib_msgs::GoalID _goal_id_type; _goal_id_type goal_id; typedef moveit_msgs::MoveGroupGoal _goal_type; _goal_type goal; MoveGroupActionGoal(): header(), goal_id(), goal() { } virtual int serialize(unsigned char *outbuffer) const { int offset = 0; offset += this->header.serialize(outbuffer + offset); offset += this->goal_id.serialize(outbuffer + offset); offset += this->goal.serialize(outbuffer + offset); return offset; } virtual int deserialize(unsigned char *inbuffer) { int offset = 0; offset += this->header.deserialize(inbuffer + offset); offset += this->goal_id.deserialize(inbuffer + offset); offset += this->goal.deserialize(inbuffer + offset); return offset; } const char * getType(){ return "moveit_msgs/MoveGroupActionGoal"; }; const char * getMD5(){ return "df11ac1a643d87b6e6a6fe5af1823709"; }; }; } #endif
#ifndef ENTITY_H_ #define ENTITY_H_ #include <memory> #include <string> #include <vector> class Component; class Entity { public: static const unsigned short UNCATEGORIZED = 0; Entity(unsigned short category = UNCATEGORIZED, const std::string& name = std::string()); virtual ~Entity(); /** * <p> * Adds a component. * </p> * * @param component The component to add. */ void addComponent(Component* component); unsigned short getCategory() const; /** * <p> * Retrieves the components. * </p> * * @return The components. */ template<typename ComponentType> std::vector<ComponentType*> getComponents() const; unsigned int getId() const; /** * <p> * Retrieves the name of this <code>Entity</code>. * </p> * * @return The name of this <code>Entity</code>. */ const std::string& getName() const; /** * <p> * Retrieves a single component. * </p> * * @return The single component. */ template<typename ComponentType> ComponentType* getSingleComponent() const; /** * <p> * Removes a component. * </p> * * @param component The component to remove. */ void removeComponent(const Component& component); private: unsigned short category; /** * <p> * The components. * </p> */ std::vector<Component*> components; unsigned int id; /** * <p> * The name of this <code>Entity</code>. * </p> */ std::string name; static unsigned int nextId; }; #include "Entity.tpp" #endif /* ENTITY_H_ */
//////////////////////////////////////////////////////////////////////// // Source file for object descriptor class //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // Include files //////////////////////////////////////////////////////////////////////// #include "object.h" //////////////////////////////////////////////////////////////////////// // Functions //////////////////////////////////////////////////////////////////////// ObjectDescriptor:: ObjectDescriptor(const double *values, int nvalues) : nvalues(nvalues), values(NULL) { // Initialize values if (nvalues > 0) { this->values = new double [ nvalues ]; for (int i = 0; i < nvalues; i++) { this->values[i] = (values) ? values[i] : 0.0; } } } ObjectDescriptor:: ObjectDescriptor(const ObjectDescriptor& descriptor) : nvalues(descriptor.nvalues), values(NULL) { // Initialize values if (nvalues > 0) { values = new double [ nvalues ]; for (int i = 0; i < nvalues; i++) { values[i] = descriptor.values[i]; } } } ObjectDescriptor:: ~ObjectDescriptor(void) { // Delete values if (values) delete [] values; } ObjectDescriptor& ObjectDescriptor:: operator=(const ObjectDescriptor& descriptor) { // Copy values Reset(descriptor.values, descriptor.nvalues); return *this; } void ObjectDescriptor:: Reset(const double *values, int nvalues) { // Delete old values if ((this->nvalues > 0) && (this->values)) { delete [] this->values; this->values = NULL; this->nvalues = 0; } // Assign new values if (nvalues > 0) { // Allocate new values this->nvalues = nvalues; this->values = new double [ this->nvalues ]; // Copy values for (int i = 0; i < nvalues; i++) { this->values[i] = (values) ? values[i] : 0.0; } } } double ObjectDescriptor:: SquaredDistance(const ObjectDescriptor& descriptor) const { // Check dimensionality assert(nvalues == descriptor.nvalues); // Sum squared distances double sum = 0; for (int i = 0; i < nvalues; i++) { double delta = values[i] - descriptor.values[i]; sum += delta * delta; } // Return squared distance return sum; }
#include "cofiles/XML/Xerces/XMLNode.h" #include <xercesc/parsers/XercesDOMParser.hpp> #include <xercesc/dom/DOMNamedNodeMap.hpp> #include <xercesc/dom/DOMNodeList.hpp> #include <xercesc/dom/DOMElement.hpp> #include <xercesc/dom/DOMException.hpp> #include <xercesc/dom/DOMImplementation.hpp> #include "cofiles/Makros.h" #include "cofiles/XML/Xerces/XMLElement.h" #include "cofiles/XML/Xerces/XMLText.h" using namespace CoFiles; XERCES_CPP_NAMESPACE_USE DOMNode* ToDOMNode( void* _pNode ) { DOMNode* pNode = static_cast< DOMNode* >( _pNode ); return pNode; } const DOMNode* ToDOMNode( const void* _pNode ) { const DOMNode* pNode = static_cast< const DOMNode* >( _pNode ); return pNode; } Xerces::XMLNode::XMLNode() : m_pNode( NULL ), m_eNodeType( XML_NODE_TYPE_NONE ) { } void Xerces::XMLNode::SetNodeType( XMLNodeType _eNodeType ) { m_eNodeType = _eNodeType; } XMLNodeType Xerces::XMLNode::GetNodeType() const { return m_eNodeType; } bool Xerces::XMLNode::IsValid() const { return GetXMLNode() != NULL; } bool Xerces::XMLNode::HasChildren() const { if( IsValid() ) { return !ToDOMNode( GetXMLNode() )->getChildNodes()->getLength(); } else { return false; } } XMLNodePtr Xerces::XMLNode::GetFirstChild() const { m_spFirstChild.reset(); if ( ToDOMNode( GetXMLNode() ) != NULL ) { DOMNode *pNode = ToDOMNode( GetXMLNode() )->getFirstChild(); while ( pNode != NULL && !IsValidXMLNode( pNode ) ) { pNode = pNode->getNextSibling(); } if ( pNode != NULL ) { m_spFirstChild = CreateNode( pNode ); } } return m_spFirstChild; } XMLNodePtr Xerces::XMLNode::GetNextSibling() const { m_spNextSibling.reset(); if ( GetXMLNode() == NULL ) { return XMLNodePtr(); } DOMNode *pNode = ToDOMNode( GetXMLNode() )->getNextSibling(); while( pNode != NULL && !IsValidXMLNode( pNode ) ) { pNode = pNode->getNextSibling(); } if ( pNode != NULL ) { m_spNextSibling = CreateNode( pNode ); } return m_spNextSibling; } void Xerces::XMLNode::InsertChildFirst( CoFiles::XMLNode& _clChildNode ) { if ( IsValid() ) { try { ToDOMNode( GetXMLNode() )->insertBefore( ToDOMNode( _clChildNode.GetXMLNode() ), NULL ); } catch ( const DOMException& e ) { CO_WARN( "XMLNode::InsertChildFirst: %s", XMLString::transcode( e.msg ) ); } } } void Xerces::XMLNode::InsertChildBefore( CoFiles::XMLNode& _clChildNode, CoFiles::XMLNode& _clBefore ) { if( IsValid() ) { ToDOMNode( GetXMLNode() )->insertBefore( ToDOMNode( _clChildNode.GetXMLNode() ), ToDOMNode( _clBefore.GetXMLNode() ) ); } } void Xerces::XMLNode::InsertChildAfter( CoFiles::XMLNode& _clChildNode, CoFiles::XMLNode& _clAfter ) { if( IsValid() ) { if( _clAfter.GetXMLNode() != NULL ) { ToDOMNode( GetXMLNode() )->insertBefore( ToDOMNode( _clChildNode.GetXMLNode() ), ToDOMNode( _clAfter.GetXMLNode() )->getNextSibling() ); } else { ToDOMNode( GetXMLNode() )->appendChild( ToDOMNode( _clChildNode.GetXMLNode() ) ); } } } void Xerces::XMLNode::InsertChildLast( CoFiles::XMLNode& _clChildNode ) { if( IsValid() ) { DOMNode* pDOMNode = ToDOMNode( GetXMLNode() ); DOMNode* pChildDOMNode = ToDOMNode( _clChildNode.GetXMLNode() ); if ( pDOMNode != NULL && pChildDOMNode != NULL ) { try { pDOMNode->appendChild( pChildDOMNode ); } catch ( const DOMException& e ) { CO_WARN( "XMLNode::InsertChildLast: %s", XMLString::transcode( e.msg ) ); } } } } bool Xerces::XMLNode::IsDocument() const { return m_eNodeType == DOCUMENT_NODE; } bool Xerces::XMLNode::IsElement() const { return m_eNodeType == ELEMENT_NODE; } bool Xerces::XMLNode::IsText() const { return m_eNodeType == TEXT_NODE; } const void* Xerces::XMLNode::GetXMLNode() const { return m_pNode; } void* Xerces::XMLNode::GetXMLNode() { return m_pNode; } void Xerces::XMLNode::SetXMLNode( void* pNode ) { m_pNode = ToDOMNode( pNode ); } XMLNodePtr Xerces::XMLNode::CreateNode( DOMNode* _pNode ) { if ( _pNode == NULL ) { return XMLNodePtr(); } CoFiles::XMLNodePtr spNewNode; if ( _pNode->getNodeType() == DOMNode::ELEMENT_NODE ) { XMLElement* pElement = new Xerces::XMLElement(); spNewNode = CoFiles::XMLNodePtr( pElement ); } else if ( _pNode->getNodeType() == DOMNode::TEXT_NODE ) { XMLText* pText = new Xerces::XMLText(); spNewNode = CoFiles::XMLNodePtr( pText ); } if ( spNewNode!= NULL ) { spNewNode->SetXMLNode( _pNode ); } return spNewNode; } bool Xerces::XMLNode::IsValidXMLNode( DOMNode* pNode ) { if ( pNode == NULL ) { return false; } if ( pNode->getNodeType() == DOMNode::COMMENT_NODE ) { return false; } else if ( pNode->getNodeType() == DOMNode::NOTATION_NODE ) { return false; } else if ( pNode->getNodeType() == DOMNode::TEXT_NODE ) { XMLText clTextNode; clTextNode.SetXMLNode( pNode ); String sText = clTextNode.GetText(); if( sText == "" ) { return false; } } return true; }
/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * Copyright 2017 Couchbase, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <getopt.h> #include <mcbp/mcbp.h> #include <platform/dirutils.h> #include <platform/memorymap.h> #include <platform/sized_buffer.h> #include <algorithm> #include <iostream> enum class Format { Raw, Gdb, Lldb }; Format parseFormat(std::string format) { std::transform(format.begin(), format.end(), format.begin(), toupper); if (format == "RAW") { return Format::Raw; } if (format == "GDB") { return Format::Gdb; } if (format == "LLDB") { return Format::Lldb; } throw std::invalid_argument("Unknown format: " + format); } int main(int argc, char** argv) { Format format{Format::Raw}; static struct option longopts[] = { {"format", required_argument, nullptr, 'f'}, {nullptr, 0, nullptr, 0}}; int cmd; while ((cmd = getopt_long(argc, argv, "f:", longopts, nullptr)) != -1) { switch (cmd) { case 'f': try { format = parseFormat(optarg); } catch (const std::invalid_argument& e) { std::cerr << e.what() << std::endl; return EXIT_FAILURE; } break; default: std::cerr << "Usage: " << cb::io::basename(argv[0]) << " [options] file1-n" << std::endl << std::endl << "\t--format=raw|gdb|lldb\tThe format for the input file" << std::endl << std::endl << "For gdb the expected output would be produced by " "executing: " << std::endl << std::endl << "(gdb) x /24xb c->rcurr" << std::endl << "0x7f43387d7e7a: 0x81 0x0d 0x00 0x00 0x00 0x00 0x00 0x00" << std::endl << "0x7f43387d7e82: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00" << std::endl << "0x7f43387d7e8a: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00" << std::endl << std::endl << "For lldb the expected output would be generated by " "executing: " << std::endl << std::endl << "(lldb) x -c 32 c->rbuf" << std::endl << "0x7f43387d7e7a: 81 0d 00 01 04 00 00 00 00 00 00 06 00 " "00 00 06 ................" << std::endl << "0x7f43387d7e7a: 14 bf f4 26 8a e0 00 00 00 00 00 00 61 " "61 81 0a ................" << std::endl << std::endl; return EXIT_FAILURE; } } if (optind == argc) { std::cerr << "No file specified" << std::endl; return EXIT_FAILURE; } while (optind < argc) { try { cb::byte_buffer buf; std::vector<uint8_t> data; cb::MemoryMappedFile map(argv[optind], cb::MemoryMappedFile::Mode::RDONLY); map.open(); buf = {static_cast<uint8_t*>(map.getRoot()), map.getSize()}; switch (format) { case Format::Raw: break; case Format::Gdb: data = cb::mcbp::gdb::parseDump(buf); buf = {data.data(), data.size()}; break; case Format::Lldb: data = cb::mcbp::lldb::parseDump(buf); buf = {data.data(), data.size()}; break; } cb::mcbp::dumpStream(buf, std::cout); } catch (const std::exception& error) { std::cerr << error.what() << std::endl; return EXIT_FAILURE; } ++optind; } return EXIT_SUCCESS; }
STATIC void NES_mapper42_Init(); STATIC void NES_mapper42_Reset(); STATIC void NES_mapper42_MemoryWrite(u32 addr, u8 data); STATIC void NES_mapper42_HSync(u32 scanline); ///////////////////////////////////////////////////////////////////// // Mapper 42 STATIC void NES_mapper42_Init() { g_NESmapper.Reset = NES_mapper42_Reset; g_NESmapper.MemoryWrite = NES_mapper42_MemoryWrite; g_NESmapper.HSync = NES_mapper42_HSync; } STATIC void NES_mapper42_Reset() { // set CPU bank pointers g_NESmapper.set_CPU_bank3(0); g_NESmapper.set_CPU_bank4(g_NESmapper.num_8k_ROM_banks-4); g_NESmapper.set_CPU_bank5(g_NESmapper.num_8k_ROM_banks-3); g_NESmapper.set_CPU_bank6(g_NESmapper.num_8k_ROM_banks-2); g_NESmapper.set_CPU_bank7(g_NESmapper.num_8k_ROM_banks-1); // set PPU bank pointers g_NESmapper.set_PPU_banks8(0,1,2,3,4,5,6,7); } STATIC void NES_mapper42_MemoryWrite(u32 addr, u8 data) { switch(addr & 0xE003) { case 0x8000: g_NESmapper.set_PPU_banks8(((data&0x1f)<<3)+0,((data&0x1f)<<3)+1,((data&0x1f)<<3)+2,((data&0x1f)<<3)+3,((data&0x1f)<<3)+4,((data&0x1f)<<3)+5,((data&0x1f)<<3)+6,((data&0x1f)<<3)+7); break; case 0xE000: { g_NESmapper.set_CPU_bank3(data & 0x0F); } break; case 0xE001: { if(data & 0x08) { g_NESmapper.set_mirroring2(NES_PPU_MIRROR_HORIZ); } else { g_NESmapper.set_mirroring2(NES_PPU_MIRROR_VERT); } } break; case 0xE002: { if(data & 0x02) { g_NESmapper.Mapper42.irq_enabled = 1; } else { g_NESmapper.Mapper42.irq_enabled = 0; g_NESmapper.Mapper42.irq_counter = 0; } } break; } // LOG("W " << HEX(addr,4) << " " << HEX(data,2) << endl); } STATIC void NES_mapper42_HSync(u32 scanline) { if(g_NESmapper.Mapper42.irq_enabled) { if(g_NESmapper.Mapper42.irq_counter < 215) { g_NESmapper.Mapper42.irq_counter++; } if(g_NESmapper.Mapper42.irq_counter == 215) { NES6502_DoIRQ(); g_NESmapper.Mapper42.irq_enabled = 0; } } } /////////////////////////////////////////////////////////////////////
#include<bits/stdc++.h> using namespace std; // template starts here #define ll long long #define ull unsigned long long #define rs reserve #define pb push_back #define ff first #define ss second #define mp make_pair #define fi(i,s,e,inc) for(auto i=s;i<e;i+=inc) #define fie(i,s,e,inc) for(auto i=s;i<=e;i+=inc) #define fd(i,s,e,dec) for(auto i=s;i>e;i-=dec) #define fde(i,s,e,dec) for(auto i=s;i>=e;i-=dec) #define itr(i,ar) for(auto i=ar.begin();i!=ar.end();i++) #define mod 1000000007 ll N = 1000000; vector<bool> prime(N+1,true); void sieve() { prime[0] = false,prime[1] = false; for(ll i=2;i*i <= N;i++) { if(prime[i]) { for(ll j = i*i; j<= N ;j+=i) prime[j] = false; } } } ll pow(ll a, ll b) { if(b==0) return 1; if(b==1) return a; ll r = pow(a,b/2); if(b&1) return r*a*r; return r*r; } // template ends here int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); ll t; cin>>t; while(t--) { string s; cin>>s; ll n=0; ll a[s.length()]; memset(a,0,sizeof(a)); if(s[0]=='-') a[0] = -1; else a[0] = 1; fi(i,1,s.length(),1) { if(s[i]=='-') a[i] = a[i-1]-1; else a[i] = a[i-1] + 1; } ll b[s.length()]; fi(i,0,s.length(),1) { b[i] = (a[i] + i); } ll ans=0,i=0; while(i<s.length() and b[i]<0) { ans+=(i+1); i++; } ans+=s.length(); cout<<ans<<"\n"; } return 0; }
// Problem Code: ALEXNUMB #include <iostream> #include <vector> using namespace std; long magicPairs(vector<int> &a){ long N = a.size(); return N*(N-1)/2; } int main(){ int T, n, num; vector<int> a; cin >> T; while(T--){ cin >> n; for(int i=0 ; i<n ; i++){ cin >> num; a.push_back(num); } cout << magicPairs(a) << endl; a.clear(); } return 0; }
/**************************************************************************** ** Meta object code from reading C++ file 'UBExportCFF.h' ** ** Created: Fri 4. May 12:28:36 2018 ** by: The Qt Meta Object Compiler version 63 (Qt 4.8.0) ** ** WARNING! All changes made in this file will be lost! *****************************************************************************/ #include "../../../../../Sankore-3.1/src/adaptors/UBExportCFF.h" #if !defined(Q_MOC_OUTPUT_REVISION) #error "The header file 'UBExportCFF.h' doesn't include <QObject>." #elif Q_MOC_OUTPUT_REVISION != 63 #error "This file was generated using the moc from 4.8.0. It" #error "cannot be used with the include files from this version of Qt." #error "(The moc has changed too much.)" #endif QT_BEGIN_MOC_NAMESPACE static const uint qt_meta_data_UBExportCFF[] = { // content: 6, // revision 0, // classname 0, 0, // classinfo 0, 0, // methods 0, 0, // properties 0, 0, // enums/sets 0, 0, // constructors 0, // flags 0, // signalCount 0 // eod }; static const char qt_meta_stringdata_UBExportCFF[] = { "UBExportCFF\0" }; void UBExportCFF::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) { Q_UNUSED(_o); Q_UNUSED(_id); Q_UNUSED(_c); Q_UNUSED(_a); } const QMetaObjectExtraData UBExportCFF::staticMetaObjectExtraData = { 0, qt_static_metacall }; const QMetaObject UBExportCFF::staticMetaObject = { { &UBExportAdaptor::staticMetaObject, qt_meta_stringdata_UBExportCFF, qt_meta_data_UBExportCFF, &staticMetaObjectExtraData } }; #ifdef Q_NO_DATA_RELOCATION const QMetaObject &UBExportCFF::getStaticMetaObject() { return staticMetaObject; } #endif //Q_NO_DATA_RELOCATION const QMetaObject *UBExportCFF::metaObject() const { return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject; } void *UBExportCFF::qt_metacast(const char *_clname) { if (!_clname) return 0; if (!strcmp(_clname, qt_meta_stringdata_UBExportCFF)) return static_cast<void*>(const_cast< UBExportCFF*>(this)); return UBExportAdaptor::qt_metacast(_clname); } int UBExportCFF::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = UBExportAdaptor::qt_metacall(_c, _id, _a); if (_id < 0) return _id; return _id; } QT_END_MOC_NAMESPACE
/* Copyright 2011-2015 Roberto Daniel Gimenez Gamarra ([email protected]) * (C.I.: 1.439.390 - Paraguay) */ #ifndef CHILA_LIB_NODE__UTIL_HPP #define CHILA_LIB_NODE__UTIL_HPP #include <chila/lib/misc/util.hpp> #include "exceptions.hpp" #define my_assert CHILA_LIB_MISC__ASSERT #define CHILA_META_NODE__DEF_CHECK_BASES_ELEM(n, data, elem) \ chila::lib::node::checkAndAdd(list, [&]{ elem::check(newData.get()); }); #define CHILA_META_NODE__DEF_CHECK_BASES(Bases, defMyCheck) \ BOOST_PP_IF(defMyCheck, chila::lib::node::CheckDataUPtr createCheckData(chila::lib::node::CheckData *data) const;, ); \ BOOST_PP_IF(defMyCheck, void myCheck(chila::lib::node::CheckData *data = nullptr) const;, ); \ void check(chila::lib::node::CheckData *data = nullptr) const override \ { \ chila::lib::node::CheckExceptionList list; \ auto newData = BOOST_PP_IF(defMyCheck, createCheckData(data), chila::lib::node::CheckDataUPtr()); \ BOOST_PP_SEQ_FOR_EACH(CHILA_META_NODE__DEF_CHECK_BASES_ELEM,,Bases) \ BOOST_PP_IF(defMyCheck, BOOST_PP_IDENTITY(\ chila::lib::node::checkAndAdd(list, [&]{ myCheck(newData.get()); }); \ ), BOOST_PP_EMPTY)(); \ if (!list.exceptions.empty()) throw list; \ } #define CHILA_META_NODE__DEF_CHECK \ void check(chila::lib::node::CheckData *data = nullptr) const override; #include "nspDef.hpp" MY_NSP_START { template <typename CheckFun> void checkAndAdd(chila::lib::node::CheckExceptionList &list, const CheckFun &checkFun) try { checkFun(); } catch (ExceptionWrapper &ex) { list.add(ex.ex); } catch (CheckExceptionList &ex) { list.add(ex); } catch (Exception &ex) { list.add(ex); } chila::lib::misc::Path getNodePath(const Node &node); // to avoid cyclical dependency template <typename Fun> inline auto catchThrow(const Node &node, const Fun &fun) -> decltype(fun()) try { return fun(); } catch (const boost::exception &ex) { ex << chila::lib::misc::ExceptionInfo::Path(getNodePath(node)); throw; } template <typename ToType, typename Node> inline const ToType &castNode(const Node &node) try { return catchThrow(node, [&]() -> const ToType& { return chila::lib::misc::dynamicCast<ToType>(node); }); } catch (const boost::exception &ex) { InvalidNode exx; insert_error_info(chila::lib::misc::ExceptionInfo::TypeFrom) insert_error_info(chila::lib::misc::ExceptionInfo::TypeTo) insert_error_info(chila::lib::misc::ExceptionInfo::ActualType) insert_error_info(chila::lib::misc::ExceptionInfo::Path) BOOST_THROW_EXCEPTION(exx); } template <typename ToType, typename Node> inline ToType &castNode(Node &node) try { return catchThrow(node, [&]() -> ToType& { return chila::lib::misc::dynamicCast<ToType>(node); }); } catch (const boost::exception &ex) { InvalidNode exx; insert_error_info(chila::lib::misc::ExceptionInfo::TypeFrom) insert_error_info(chila::lib::misc::ExceptionInfo::TypeTo) insert_error_info(chila::lib::misc::ExceptionInfo::ActualType) insert_error_info(chila::lib::misc::ExceptionInfo::Path) BOOST_THROW_EXCEPTION(exx); } NodeWithChildren &mainParent(NodeWithChildren &node); PathVec getReferences( NodeWithChildren &node, const chila::lib::misc::Path &path); void replaceReferences(NodeWithChildren &node, const PathVec &paths, const Node &newRefNode); } MY_NSP_END #include "nspUndef.hpp" #endif
// Copyright 2017 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef ASH_LOGIN_UI_LOGIN_USER_VIEW_H_ #define ASH_LOGIN_UI_LOGIN_USER_VIEW_H_ #include "ash/ash_export.h" #include "ash/login/ui/login_display_style.h" #include "ash/public/interfaces/login_user_info.mojom.h" #include "base/macros.h" #include "ui/views/controls/button/button.h" #include "ui/views/view.h" namespace ash { class HoverNotifier; class LoginBubble; class LoginButton; // Display the user's profile icon, name, and a menu icon in various layout // styles. class ASH_EXPORT LoginUserView : public views::View, public views::ButtonListener { public: // TestApi is used for tests to get internal implementation details. class ASH_EXPORT TestApi { public: explicit TestApi(LoginUserView* view); ~TestApi(); LoginDisplayStyle display_style() const; const base::string16& displayed_name() const; views::View* user_label() const; views::View* tap_button() const; bool is_opaque() const; private: LoginUserView* const view_; }; using OnTap = base::RepeatingClosure; // Returns the width of this view for the given display style. static int WidthForLayoutStyle(LoginDisplayStyle style); LoginUserView(LoginDisplayStyle style, bool show_dropdown, bool show_domain, const OnTap& on_tap); ~LoginUserView() override; // Update the user view to display the given user information. void UpdateForUser(const mojom::LoginUserInfoPtr& user, bool animate); // Set if the view must be opaque. void SetForceOpaque(bool force_opaque); // Enables or disables tapping the view. void SetTapEnabled(bool enabled); const mojom::LoginUserInfoPtr& current_user() const { return current_user_; } // views::View: const char* GetClassName() const override; gfx::Size CalculatePreferredSize() const override; void Layout() override; // views::ButtonListener: void ButtonPressed(views::Button* sender, const ui::Event& event) override; private: class UserDomainInfoView; class UserImage; class UserLabel; class TapButton; // Called when hover state changes. void OnHover(bool has_hover); // Updates UI element values so they reflect the data in |current_user_|. void UpdateCurrentUserState(); // Updates view opacity based on input state and |force_opaque_|. void UpdateOpacity(); void SetLargeLayout(); void SetSmallishLayout(); // Executed when the user view is pressed. OnTap on_tap_; // The user that is currently being displayed (or will be displayed when an // animation completes). mojom::LoginUserInfoPtr current_user_; // Used to dispatch opacity update events. std::unique_ptr<HoverNotifier> hover_notifier_; LoginDisplayStyle display_style_; UserImage* user_image_ = nullptr; UserLabel* user_label_ = nullptr; LoginButton* user_dropdown_ = nullptr; TapButton* tap_button_ = nullptr; std::unique_ptr<LoginBubble> user_menu_; // Show the domain information for public account user. UserDomainInfoView* user_domain_ = nullptr; // True iff the view is currently opaque (ie, opacity = 1). bool is_opaque_ = false; // True if the view must be opaque (ie, opacity = 1) regardless of input // state. bool force_opaque_ = false; DISALLOW_COPY_AND_ASSIGN(LoginUserView); }; } // namespace ash #endif // ASH_LOGIN_UI_LOGIN_USER_VIEW_H_
// Copyright 2019 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef CHROME_BROWSER_UI_VIEWS_FRAME_TAB_STRIP_REGION_VIEW_H_ #define CHROME_BROWSER_UI_VIEWS_FRAME_TAB_STRIP_REGION_VIEW_H_ #include "chrome/browser/ui/views/tabs/tab_strip.h" #include "ui/views/accessible_pane_view.h" class TabSearchButton; class TabStrip; // Container for the tabstrip, new tab button, and reserved grab handle space. class TabStripRegionView final : public views::AccessiblePaneView, views::ViewObserver { public: explicit TabStripRegionView(std::unique_ptr<TabStrip> tab_strip); ~TabStripRegionView() override; // Returns true if the specified rect intersects the window caption area of // the browser window. |rect| is in the local coordinate space // of |this|. bool IsRectInWindowCaption(const gfx::Rect& rect); // A convenience function which calls |IsRectInWindowCaption()| with a rect of // size 1x1 and an origin of |point|. |point| is in the local coordinate space // of |this|. bool IsPositionInWindowCaption(const gfx::Point& point); // Called when the colors of the frame change. void FrameColorsChanged(); TabSearchButton* tab_search_button() { return tab_search_button_; } // views::AccessiblePaneView: const char* GetClassName() const override; void ChildPreferredSizeChanged(views::View* child) override; gfx::Size GetMinimumSize() const override; void OnThemeChanged() override; void GetAccessibleNodeData(ui::AXNodeData* node_data) override; views::View* GetDefaultFocusableChild() override; // views::ViewObserver: void OnViewPreferredSizeChanged(View* view) override; // TODO(958173): Override OnBoundsChanged to cancel tabstrip animations. private: DISALLOW_COPY_AND_ASSIGN(TabStripRegionView); int CalculateTabStripAvailableWidth(); // Scrolls the tabstrip towards the first tab in the tabstrip. void ScrollTowardsLeadingTab(); // Scrolls the tabstrip towards the last tab in the tabstrip. void ScrollTowardsTrailingTab(); views::View* tab_strip_container_; views::View* reserved_grab_handle_space_; TabStrip* tab_strip_; TabSearchButton* tab_search_button_ = nullptr; views::ImageButton* leading_scroll_button_; views::ImageButton* trailing_scroll_button_; }; #endif // CHROME_BROWSER_UI_VIEWS_FRAME_TAB_STRIP_REGION_VIEW_H_
/****************************************************************************** * Copyright 2017 The Apollo Authors. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *****************************************************************************/ #include "perception/lib/base/registerer.h" #include <string> #include <vector> namespace apollo { namespace perception { BaseClassMap& GlobalFactoryMap() { static BaseClassMap factory_map; return factory_map; } bool GetRegisteredClasses( const std::string& base_class_name, std::vector<std::string>* registered_derived_classes_names) { CHECK_NOTNULL(registered_derived_classes_names); BaseClassMap& map = GlobalFactoryMap(); auto iter = map.find(base_class_name); if (iter == map.end()) { AERROR << "class not registered:" << base_class_name; return false; } for (auto pair : iter->second) { registered_derived_classes_names->push_back(pair.first); } return true; } } // namespace perception } // namespace apollo
// ================================= // Copyright (c) 2022 Seppo Laakko // Distributed under the MIT license // ================================= #include <cmajor/cmbs/Error.hpp> #include <cmajor/symbols/Module.hpp> #include <cmajor/symbols/ModuleCache.hpp> #include <soulng/util/Unicode.hpp> namespace cmbs { using namespace soulng::unicode; CompileError ParsingExceptionToError(const soulng::lexer::ParsingException& ex) { CompileError error; error.message = ex.Message(); error.project = ex.Project(); error.file = ex.FileName(); soulng::lexer::Span span = ex.GetSpan(); error.line = span.line; cmajor::symbols::Module* mod = static_cast<cmajor::symbols::Module*>(ex.Module()); if (mod) { int startCol = 0; int endCol = 0; mod->GetColumns(span, startCol, endCol); error.scol = startCol; error.ecol = endCol; } return error; } std::vector<CompileError> SymbolsExceptionToErrors(const cmajor::symbols::Exception& ex) { std::vector<CompileError> errors; CompileError mainError; mainError.message = ex.Message(); cmajor::symbols::Module* mod = cmajor::symbols::GetModuleById(ex.DefinedModuleId()); if (mod) { Span span = ex.Defined(); std::u32string code = mod->GetErrorLines(span); mainError.message.append("\n").append(ToUtf8(code)); mainError.project = ToUtf8(mod->Name()); mainError.file = mod->GetFilePath(span.fileIndex); mainError.line = span.line; int startCol = 0; int endCol = 0; mod->GetColumns(span, startCol, endCol); mainError.scol = startCol; mainError.ecol = endCol; } errors.push_back(mainError); for (const std::pair<Span, boost::uuids::uuid>& spanModuleId : ex.References()) { CompileError referenceError; referenceError.message = "See:"; cmajor::symbols::Module* mod = cmajor::symbols::GetModuleById(spanModuleId.second); if (mod) { std::u32string code = mod->GetErrorLines(spanModuleId.first); referenceError.message.append("\n").append(ToUtf8(code)); referenceError.file = mod->GetFilePath(spanModuleId.first.fileIndex); referenceError.line = spanModuleId.first.line; int startCol = 0; int endCol = 0; mod->GetColumns(spanModuleId.first, startCol, endCol); referenceError.scol = startCol; referenceError.ecol = endCol; errors.push_back(referenceError); } } return errors; } } // namespace cmbs
#pragma once #include "Effect.h" class ExplodeSmoke : public Effect { public : ExplodeSmoke() = delete; ExplodeSmoke(const _In_ Vec); ExplodeSmoke( const _In_ Vec, const _In_ FLOAT, const _In_ Vec); ~ExplodeSmoke(); private : void init(); void LoadInitialImg() override; void InitialDataSubstitude() override; };
#include <iostream> #include <vector> using namespace std; class Solution { public: vector<int> majorityElement(vector<int>& nums) { int cnt1 = 0, cnt2 = 0, maj1 = 0, maj2 = 0; int len = nums.size(); vector<int> res; //cout << 1 << endl; for(int i = 0; i < len; i++) { if(cnt1 == 0 && nums[i] != maj2) { maj1 = nums[i]; cnt1 = 1; } else if(nums[i] == maj1) { cnt1++; } else if(cnt2 == 0 && nums[i] != maj1) { maj2 = nums[i]; cnt2 = 1; } else if(nums[i] == maj2) { cnt2++; } else { cnt1--; cnt2--; } } cnt1 = cnt2 = 0; for(int i = 0; i < len; i++) { if(nums[i] == maj1) cnt1++; else if(nums[i] == maj2) cnt2++; } if(cnt1 > len / 3) res.push_back(maj1); if(cnt2 > len / 3) res.push_back(maj2); return res; } }; int main() { int arr[] = {1, 2, 1, 2, 1, 3, 3}; Solution s; vector<int> v(arr, arr + 7); vector<int> res; res = s.majorityElement(v); for(int i = 0; i < res.size(); i++) { cout << res[i] << endl; } return 0; }
// Copyright (c) 2017-2018 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include <bip32/hdwalletutil.h> #include <util/logging.h> #include <util/system.h> #include <util/args.h> fs::path hdwalletutil::GetWalletDir() { fs::path path; if (ARGS.IsArgSet("-walletdir")) { path = ARGS.GetArg("-walletdir", ""); if (! fs::is_directory(path)) { // If the path specified doesn't exist, we return the deliberately // invalid empty string. path = ""; } } else { path = lutil::GetDataDir(); // If a wallets directory exists, use that, otherwise default to GetDataDir if (fs::is_directory(path / "wallets")) { path /= "wallets"; } } return path; } static bool IsBerkeleyBtree(const fs::path &path) { // A Berkeley DB Btree file has at least 4K. // This check also prevents opening lock files. boost::system::error_code ec; auto size = fs::file_size(path, ec); if (ec) logging::LogPrintf("%s: %s %s\n", __func__, ec.message(), path.string()); if (size < 4096) return false; fsbridge::ifstream file(path, std::ios::binary); if (! file.is_open()) return false; file.seekg(12, std::ios::beg); // Magic bytes start at offset 12 uint32_t data = 0; file.read((char*) &data, sizeof(data)); // Read 4 bytes of file to compare against magic // Berkeley DB Btree magic bytes, from: // https://github.com/file/file/blob/5824af38469ec1ca9ac3ffd251e7afe9dc11e227/magic/Magdir/database#L74-L75 // - big endian systems - 00 05 31 62 // - little endian systems - 62 31 05 00 return data == 0x00053162 || data == 0x62310500; } std::vector<fs::path> hdwalletutil::ListWalletDir() { const fs::path wallet_dir = GetWalletDir(); const size_t offset = wallet_dir.string().size() + 1; std::vector<fs::path> paths; boost::system::error_code ec; for (auto it = fs::recursive_directory_iterator(wallet_dir, ec); it != fs::recursive_directory_iterator(); it.increment(ec)) { if (ec) { logging::LogPrintf("%s: %s %s\n", __func__, ec.message(), it->path().string()); continue; } // Get wallet path relative to walletdir by removing walletdir from the wallet path. // This can be replaced by boost::filesystem::lexically_relative once boost is bumped to 1.60. const fs::path path = it->path().string().substr(offset); if (it->status().type() == fs::directory_file && IsBerkeleyBtree(it->path() / "wallet.dat")) { // Found a directory which contains wallet.dat btree file, add it as a wallet. paths.emplace_back(path); } else if (it.level() == 0 && it->symlink_status().type() == fs::regular_file && IsBerkeleyBtree(it->path())) { if (it->path().filename() == "wallet.dat") { // Found top-level wallet.dat btree file, add top level directory "" // as a wallet. paths.emplace_back(); } else { // Found top-level btree file not called wallet.dat. Current bitcoin // software will never create these files but will allow them to be // opened in a shared database environment for backwards compatibility. // Add it to the list of available wallets. paths.emplace_back(path); } } } return paths; } hdwalletutil::WalletLocation::WalletLocation(const std::string &name) : m_name(name) , m_path(fs::absolute(name, GetWalletDir())) { } bool hdwalletutil::WalletLocation::Exists() const { return fs::symlink_status(m_path).type() != fs::file_not_found; }
#include "stdafx.h" #include "P2C5_LitPyramid.h" #include <core/SRColor.h> ////////////////////////////////////////////////////////////////////////// void CalculateNormal(D3DXVECTOR3* _pOut, const D3DXVECTOR3* _p0, const D3DXVECTOR3* _p1, const D3DXVECTOR3* _p2) { D3DXVECTOR3 u = *_p1 - *_p0; D3DXVECTOR3 v = *_p2 - *_p0; // left hand coordinate system... D3DXVec3Cross(_pOut, &u, &v); D3DXVec3Normalize(_pOut, _pOut); } ////////////////////////////////////////////////////////////////////////// LitPyramid::LitPyramid() { m_pVB = NULL; } LitPyramid::~LitPyramid() { } bool LitPyramid::OnEnvCreate() { m_pVB = Gfx_CreateVertexBuffer<SRNormalVertex>(4 * 3); if(NULL == m_pVB) { return false; } SRNormalVertex* pVertex = NULL; m_pVB->Lock(0, 0, (void**)&pVertex, 0); // front side D3DXVECTOR3 v0; D3DXVECTOR3 v1; D3DXVECTOR3 v2; D3DXVECTOR3 vn; pVertex[0] = SRNormalVertex(-1.0f, 0.0f, -1.0f); pVertex[1] = SRNormalVertex(0.0f, 1.0f, 0.0f); pVertex[2] = SRNormalVertex(1.0f, 0.0f, -1.0f); v0.x = pVertex[0].GetX(); v0.y = pVertex[0].GetY(); v0.z = pVertex[0].GetZ(); v1.x = pVertex[1].GetX(); v1.y = pVertex[1].GetY(); v1.z = pVertex[1].GetZ(); v2.x = pVertex[2].GetX(); v2.y = pVertex[2].GetY(); v2.z = pVertex[2].GetZ(); CalculateNormal(&vn, &v0, &v1, &v2); pVertex[0].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[1].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[2].SetNormalXYZ(vn.x, vn.y, vn.z); // left side pVertex[3] = SRNormalVertex(-1.0f, 0.0f, 1.0f); pVertex[4] = SRNormalVertex(0.0f, 1.0f, 0.0f); pVertex[5] = SRNormalVertex(-1.0f, 0.0f, -1.0f); v0.x = pVertex[3].GetX(); v0.y = pVertex[3].GetY(); v0.z = pVertex[3].GetZ(); v1.x = pVertex[4].GetX(); v1.y = pVertex[4].GetY(); v1.z = pVertex[4].GetZ(); v2.x = pVertex[5].GetX(); v2.y = pVertex[5].GetY(); v2.z = pVertex[5].GetZ(); CalculateNormal(&vn, &v0, &v1, &v2); pVertex[3].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[4].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[5].SetNormalXYZ(vn.x, vn.y, vn.z); // right side pVertex[6] = SRNormalVertex(1.0f, 0.0f, -1.0f); pVertex[7] = SRNormalVertex(0.0f, 1.0f, 0.0f); pVertex[8] = SRNormalVertex(1.0f, 0.0f, 1.0f); v0.x = pVertex[6].GetX(); v0.y = pVertex[6].GetY(); v0.z = pVertex[6].GetZ(); v1.x = pVertex[7].GetX(); v1.y = pVertex[7].GetY(); v1.z = pVertex[7].GetZ(); v2.x = pVertex[8].GetX(); v2.y = pVertex[8].GetY(); v2.z = pVertex[8].GetZ(); CalculateNormal(&vn, &v0, &v1, &v2); pVertex[6].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[7].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[8].SetNormalXYZ(vn.x, vn.y, vn.z); // back side pVertex[9] = SRNormalVertex(1.0f, 0.0f, 1.0f); pVertex[10] = SRNormalVertex(0.0f, 1.0f, 0.0f); pVertex[11] = SRNormalVertex(-1.0f, 0.0f, 1.0f); v0.x = pVertex[9].GetX(); v0.y = pVertex[9].GetY(); v0.z = pVertex[9].GetZ(); v1.x = pVertex[10].GetX(); v1.y = pVertex[10].GetY(); v1.z = pVertex[10].GetZ(); v2.x = pVertex[11].GetX(); v2.y = pVertex[11].GetY(); v2.z = pVertex[11].GetZ(); CalculateNormal(&vn, &v0, &v1, &v2); pVertex[9].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[10].SetNormalXYZ(vn.x, vn.y, vn.z); pVertex[11].SetNormalXYZ(vn.x, vn.y, vn.z); m_pVB->Unlock(); m_pD3Dev9->SetRenderState(D3DRS_LIGHTING, TRUE); D3DMATERIAL9 mtrl; mtrl.Ambient = SRColor::GetCommonColor(SRColor::CC_WHITE); mtrl.Diffuse = SRColor::GetCommonColor(SRColor::CC_WHITE); mtrl.Specular = SRColor::GetCommonColor(SRColor::CC_WHITE); mtrl.Emissive = SRColor::GetCommonColor(SRColor::CC_BLACK); mtrl.Power = 5.0f; m_pD3Dev9->SetMaterial(&mtrl); D3DLIGHT9 lgt; ZeroMemory(&lgt, sizeof(lgt)); lgt.Type = D3DLIGHT_DIRECTIONAL; lgt.Diffuse = SRColor::GetCommonColor(SRColor::CC_WHITE); lgt.Specular = SRColor::GetCommonColor(SRColor::CC_WHITE) * 0.3f; lgt.Ambient = SRColor::GetCommonColor(SRColor::CC_WHITE) * 0.6f; lgt.Direction = D3DXVECTOR3(1.0f, 0.0f, 0.0f); m_pD3Dev9->SetLight(0, &lgt); m_pD3Dev9->LightEnable(0, TRUE); m_pD3Dev9->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE); m_pD3Dev9->SetRenderState(D3DRS_SPECULARENABLE, TRUE); D3DXVECTOR3 pos(0.0f, 1.0f, -3.0f); Gfx_SetViewTransform(&pos); Gfx_SetProjectionTransform(); return true; } void LitPyramid::OnEnvDestroy() { SSAFE_RELEASE(m_pVB); } void LitPyramid::OnDrawFrame() { SRRenderApp* pApp = SRRenderApp::GetInstancePtr(); static float s_fRotateY = 0.0f; s_fRotateY += pApp->GetTimeDelta(); static float s_fRotateX = 0.0f; s_fRotateX += pApp->GetTimeDelta() * 0.5f; D3DXMATRIX roty; D3DXMatrixRotationY(&roty, s_fRotateY); D3DXMATRIX rotx; D3DXMatrixRotationX(&rotx, s_fRotateX); D3DXMATRIX rot = rotx * roty; if(s_fRotateY > 6.28f) { s_fRotateY = 0.0f; } if(s_fRotateX > 6.28f) { s_fRotateX = 0.0f; } m_pD3Dev9->SetTransform(D3DTS_WORLD, &roty); m_pD3Dev9->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0); m_pD3Dev9->BeginScene(); m_pD3Dev9->SetStreamSource(0, m_pVB, 0, sizeof(SRNormalVertex)); m_pD3Dev9->SetFVF(SRNormalVertex::FVF); m_pD3Dev9->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 4); m_pD3Dev9->EndScene(); m_pD3Dev9->Present(0, 0, 0, 0); }
#include "quad.h" #include <osgWrapper\UtilCreator.h> Quad::Quad() { m_node = new OSGWrapper::QuadAttributeUtilNode(1); m_geometry = OSGWrapper::UtilCreator::CreateUnitQuad(); m_node->AddChild(m_geometry); } Quad::~Quad() { } void Quad::SetOffset(const osg::Vec2f& offset) { m_offset = offset; UpdateGeometry(); } void Quad::SetSize(const osg::Vec2f& size) { m_size = size; UpdateGeometry(); } void Quad::SetRect(const osg::Vec2f& offset, const osg::Vec2f& size) { m_offset = offset; m_size = size; UpdateGeometry(); } void Quad::UpdateGeometry() { osg::Vec2Array* coord_array = dynamic_cast<osg::Vec2Array*>(m_geometry->getVertexAttribArray(0)); if (coord_array) { coord_array->at(0) = m_offset; coord_array->at(1) = m_offset + osg::Vec2f(m_size.x(), 0.0f); coord_array->at(2) = m_offset + osg::Vec2f(m_size.x(), m_size.y()); coord_array->at(3) = m_offset + osg::Vec2f(0.0f, m_size.y()); coord_array->dirty(); } } OSGWrapper::QuadAttributeUtilNode* Quad::Generate() { return m_node; } OSGWrapper::UIQuad* Quad::HitTest(float x, float y) { OSGWrapper::UIQuad* q = OSGWrapper::UIQuad::HitTest(x, y); if (q) return q; if (x >= m_offset.x() && x <= m_offset.x() + m_size.x() && y >= m_offset.y() && y <= m_offset.y() + m_size.y()) return this; return 0; }
/* ID: leezhen TASK: practice LANG: C++11 */ #include <iostream> #include <fstream> #include <string> #include <vector> #include <algorithm> #include <cstdio> #include <cstring> #include <set> #include <map> #include <stack> #include <queue> #include <cmath> #include <bitset> using namespace std; typedef vector<int> vi; typedef pair<int, int> ii; typedef vector<pair<int, int> > vii; // struct #define inf 1e6 // data int nc, ne, nm; int dist[404][404]; char e[2][10]; vector<string> vstr; map<string, int> mpsi; int main() { int kase = 0; while(scanf("%d", &nc), nc) { mpsi.clear(); vstr.clear(); for(int i=0; i<404; i++) { for(int j=0; j<404; j++) { if(i == j) dist[i][j] = 0; else dist[i][j] = inf; } } for(int i=0; i<nc; i++) { scanf("%d", &ne); scanf("%s", e[0]); if(mpsi.find(e[0]) == mpsi.end()) { vstr.push_back(e[0]); mpsi[e[0]] = vstr.size()-1; } int last = 0; for(int j=1; j<ne; j++) { scanf("%s", e[1-last]); if(mpsi.find(e[1-last]) == mpsi.end()) { mpsi[e[1-last]] = vstr.size(); vstr.push_back(e[1-last]); } dist[mpsi[e[last]]][mpsi[e[1-last]]] = 1; last = 1-last; } } scanf("%d", &nm); for(int i=0; i<nm; i++) { scanf("%s %s", e[0], e[1]); dist[mpsi[e[0]]][mpsi[e[1]]] = 1; } int n = vstr.size(); for(int k=0; k<n; k++) { for(int i=0; i<n; i++) { for(int j=0; j<n; j++) { if(dist[i][j] > dist[i][k] + dist[k][j]) { dist[i][j] = dist[i][k] + dist[k][j]; } } } } vii ans; for(int i=0; i<n; i++) { for(int j=i+1; j<n; j++) { if(dist[i][j] == inf && dist[j][i] == inf) ans.push_back(ii(i, j)); } } if(ans.empty())printf("Case %d, no concurrent events.\n", ++kase); else { printf("Case %d, %d concurrent events:\n", ++kase, (int)ans.size()); if((int)ans.size() == 1) { printf("(%s,%s) \n", vstr[ans[0].first].c_str(), vstr[ans[0].second].c_str()); } else { printf("(%s,%s) (%s,%s) \n", vstr[ans[0].first].c_str(), vstr[ans[0].second].c_str(), vstr[ans[1].first].c_str(), vstr[ans[1].second].c_str()); } } } return 0; }
class Solution { public: /** * @param number: A 3-digit number. * @return: Reversed number. */ int reverseInteger(int number) { int a = number%10; int b = number/10%10; int c = number/100; return a*100+b*10+c; } };
/* * We can first split the circle at 0, initially marking each range from the lower number to the higher * number. First, we note that we never want to flip both [a, b) and [c, d) where a < b <= c < d. This * increases the count at each location not within the ranges by 2, and the values within the ranges don't * change. Therefore, this only makes the situation worse. * * We can then binary search for the answer. Let the answer we are checking for be m. We can also define * two other parameters: n will be the total number of ranges flipped, and t will be a point that all the * ranges flipped will have in common (which must exist as we have shown earlier). For a given point, if * there are currently a people that go over the point and there are n' tickets left to assign, then the * amount of ranges we have to flip is max(ceil((a + n' - m) / 2), 0). We maintain a set of ranges to flip * and then greedily flip the rightmost edges in the set, flipping as many as we need. Afterwards, we can * do a final check to see if it works. Overall, this is O(n^2 m log(n) log(sum of c)). * * We can do two optimizations to this. First, we will try to limit the values of n that we will check. * Let a_i denote the initial values, and b_i be the values after doing all necessary flips. We will prove * that we can always pick a value of t such that b_t = or b_t = max(b_i) - 1. First of all, t can * be any value in the intersection of all the ranges picked, so we can choose t to have the maximum value * in the range. Now, suppose that there is some value outside of the intersection i such that b_i > b_t. * We can then unflip both the flipped intervals with the leftmost right bound and the rightmost left bound * If both ranges are distinct, then the b_i value of everything within the intersection will increase by * +2 (increase by +1 if the ranges are not distinct). By repeating this process, we will either end up * with b_t = m or b_t = m - 1, so our proof is done. Since n ranges will cover t, the b_t = a_t - n, * so n = a_t - m or n = a_t - m + 1. * * Now, we want to limit the values of t that we have to check. We can first limit the candidates to t to * be the values of i where a_i is the maximum of the array. If we let x_i denote the number of ranges * flipped that include location i, then we know that x_j < x_t if j is not in the intersection. Taking the * maximum possible value of b_j, we have b_j <= b_t + 1 and x_j + 1 <= x_t. Since a_i = x_i + b_i, we get * that a_j <= a_t if j is not in the interesction, so a_t must be the maxmimum of a. * * Next, we will show that we only need to check the leftmost and rightmost indices where a_i is at its * maximum. Denote these left and right indices by l and r. First, we will show that there is no need to * flip a range [c, d) where l < c < d <= r. Suppose that there is some such range that we flip. If we * unflip it, then everything outside the range decrements by 1, so it is still valid. Everything inside * of the range increments by 1 as well. However, since x_l > x_t since l is not within the intersection * of all flipped intervals, b_l > b_t originally, so incrementing b_t by 1 does not make the configuration * invalid. Therefore, every interval that we flip must either include l or r. If there exists two intervals * where one does not include l and the other does not include r, then we can unflip both of them. Let b' * represent the new values at each location. For similar reasons as before, b'_l >= b'_i for l <= i <= r * because a_l and a_r are the max values of a over the entire array, but x'_l and x'_r are still the * lowest values between l and r (since they are the farthest from t). Everything outside of l and r will * either not change in value or decrease by 2, so overall, the combination is still valid. We can keep * repeating this process until all remaining ranges contain either l or r, so we could have chosen t = l * or t = r. Therefore, we only need to check these two location. * * Overall, this cuts a factor of O(nm) from the solution, so the new time complexity is * O(n log(n) log(sum of c)), which passes. */ #include <iostream> #include <iomanip> #include <fstream> #include <vector> #include <array> #include <algorithm> #include <utility> #include <map> #include <queue> #include <set> #include <cmath> #include <cstdio> #include <cstring> #define ll long long #define ld long double #define eps 1e-8 #define MOD 1000000007 #define INF 0x3f3f3f3f #define INFLL 0x3f3f3f3f3f3f3f3f // change if necessary #define MAXN 200010 using namespace std; int n, m; vector<array<int, 3>> range[MAXN]; ll init[MAXN]; int min_check, max_check; struct cmp { bool operator()(const array<int, 3> &a, const array<int, 3> &b) const { if (a[1] == b[1]) { if (a[0] == b[0]) { return a[2] < b[2]; } return a[0] > b[0]; } return a[1] < b[1]; } }; struct bit { ll vals[MAXN]; void reset() { for (int i = 0; i < n + 10; i++) { vals[i] = 0; } for (int i = 0; i < n; i++) { ll x = init[i]; if (i) x -= init[i - 1]; upd(i, x); } } void upd(int x, ll v) { x++; while (x < n + 10) { vals[x] += v; x += x & -x; } } void upd(int l, int r, ll v) { upd(l, v); upd(r, -v); } ll qry(int x) { x++; ll res = 0; while (x) { res += vals[x]; x -= x & -x; } return res; } } b; ll check(ll m, ll n, ll t) { b.reset(); priority_queue<array<int, 3>, vector<array<int, 3>>, cmp> pq; for (int i = 0; i <= t; i++) { ll need_rem = max((b.qry(i) + n - m + 1) / 2, 0LL); n -= need_rem; for (auto &arr : range[i]) { if (arr[1] > t) { pq.push(arr); } } while (need_rem) { if (pq.empty()) { return false; } auto t = pq.top(); pq.pop(); ll to_rem = min<ll>(t[2], need_rem); b.upd(0, t[0], to_rem); b.upd(t[0], t[1], -to_rem); b.upd(t[1], ::n, to_rem); t[2] -= to_rem; need_rem -= to_rem; if (t[2]) pq.push(t); } } for (int i = 0; i < ::n; i++) { if (b.qry(i) > m) { return false; } } return true; } ll check(ll m) { ll a = init[min_check]; return check(m, a - m, min_check) || check(m, a - m + 1, min_check) || check(m, a - m, max_check) || check(m, a - m + 1, max_check); } int main() { cin.tie(0)->sync_with_stdio(0); cin >> n >> m; for (int i = 0; i < m; i++) { int a, b, c; cin >> a >> b >> c; a--; b--; if (a > b) swap(a, b); init[a] += c; init[b] -= c; range[a].push_back({a, b, c}); } for (int i = 1; i < n; i++) { init[i] += init[i - 1]; } for (int i = 0; i < n; i++) { if (init[i] > init[min_check]) { min_check = i; max_check = i; } else if (init[i] == init[min_check]) { max_check = i; } } ll l = 0; ll r = init[min_check]; ll ans = init[min_check]; while (l <= r) { ll m = (l + r) / 2; if (check(m)) { ans = m; r = m - 1; } else { l = m + 1; } } cout << ans << '\n'; return 0; }
using namespace std; #include <stdio.h> #include <stdlib.h> #include <string.h> #include <vector> #include <iostream> #include <queue> #include <algorithm> #include <unordered_set> typedef long long int ll; typedef pair<int,int> ii; void bfs(vector<vector<int> > &adj,int s,vector<int> &dis,int n) { int i ; unordered_set<int> unvisited; for(i=1;i<=n;i++) unvisited.insert(i); queue<int> q; q.push(s); unvisited.erase(s); while(!q.empty()) { int tmp=q.front(); q.pop(); for(auto it=unvisited.begin();it!=unvisited.end();++it) { if(find(adj[tmp].begin(),adj[tmp].end(),*it)==adj[tmp].end()) { q.push(*it); dis[*it]=dis[tmp]+1; unvisited.erase(*it); } } } } int main() { int T; cin>>T; while(T--) { int i,n,m,u,v,s,w,start; cin>>n>>m; vector<vector<int > > adj(n+1); vector<int> dis(n+1,0); for(i=0;i<m;i++) { cin>>u>>v; adj[u].push_back(v); adj[v].push_back(u); } cin>>start; bfs(adj,start,dis,n); for(i=1;i<=n;i++) { if(start!=i) cout<<dis[i]<<" "; } cout<<endl; } return 0; }
#pragma once // Sea of Thieves (2.0) SDK #ifdef _MSC_VER #pragma pack(push, 0x8) #endif namespace SDK { //--------------------------------------------------------------------------- //Enums //--------------------------------------------------------------------------- // Enum Interaction.EInteractionBlockReason enum class EInteractionBlockReason : uint8_t { EInteractionBlockReason__None = 0, EInteractionBlockReason__Radial = 1, EInteractionBlockReason__Other = 2, EInteractionBlockReason__EInteractionBlockReason_MAX = 3 }; // Enum Interaction.EInteractionObject enum class EInteractionObject : uint8_t { EInteractionObject__None = 0, EInteractionObject__Shop = 1, EInteractionObject__Chest = 2, EInteractionObject__Barrel = 3, EInteractionObject__EInteractionObject_MAX = 4 }; } #ifdef _MSC_VER #pragma pack(pop) #endif
////////////////////////////////////////////////////////////////////////////// // // evcl - kernel - arch 64 // kernel/ke_arch64.cpp // // This file is part of Evita Common Lisp. // // Copyright (C) 1996-2006 by Project Vogue. // Written by Yoshifumi "VOGUE" INOUE. ([email protected]) // // @(#)$Id: //proj/evcl3/mainline/arch/generic/kernel/gen_ke_arch64.cpp#3 $ // #if SIZEOF_VAL == 8 #include "../../../kernel/ke_arch.h" namespace Kernel { const uint64 Kernel::Arch64::k_rgfBit[64] = { 1ull << 0, 1ull << 1, 1ull << 2, 1ull << 3, 1ull << 4, 1ull << 5, 1ull << 6, 1ull << 7, 1ull << 8, 1ull << 9, 1ull << 10, 1ull << 11, 1ull << 12, 1ull << 13, 1ull << 14, 1ull << 15, 1ull << 16, 1ull << 17, 1ull << 18, 1ull << 19, 1ull << 20, 1ull << 21, 1ull << 22, 1ull << 23, 1ull << 24, 1ull << 25, 1ull << 26, 1ull << 27, 1ull << 28, 1ull << 29, 1ull << 30, 1ull << 31, 1ull << 32, 1ull << 33, 1ull << 34, 1ull << 35, 1ull << 36, 1ull << 37, 1ull << 38, 1ull << 39, 1ull << 40, 1ull << 41, 1ull << 42, 1ull << 43, 1ull << 44, 1ull << 45, 1ull << 46, 1ull << 47, 1ull << 48, 1ull << 49, 1ull << 50, 1ull << 51, 1ull << 52, 1ull << 53, 1ull << 54, 1ull << 55, 1ull << 56, 1ull << 57, 1ull << 58, 1ull << 59, 1ull << 60, 1ull << 61, 1ull << 62, 1ull << 63 }; // Kernel::Arch64::k_rgfBit ////////////////////////////////////////////////////////////////////// // // Mask For Bit Stream Leader and Trailer // // Bit Stream: // LLLL LLLL xxxx xxxx ... xxxx xxxx TTTT TTTT // // x = bits for processing // L = leader bits (not affect) // T = trailer bits (not affect) // // Note: Bit stream is stored in each 32bit word from LSB to MSB. // // // (loop for i below 64 do (format t "0x~16,'0Xull, // ~D~%" (1- (ash 1 i)) i)) const Arch64::BitEltT Arch64::k_rgnLeaderMask[64] = { 0x0000000000000000ull, // 0 0x0000000000000001ull, // 1 0x0000000000000003ull, // 2 0x0000000000000007ull, // 3 0x000000000000000Full, // 4 0x000000000000001Full, // 5 0x000000000000003Full, // 6 0x000000000000007Full, // 7 0x00000000000000FFull, // 8 0x00000000000001FFull, // 9 0x00000000000003FFull, // 10 0x00000000000007FFull, // 11 0x0000000000000FFFull, // 12 0x0000000000001FFFull, // 13 0x0000000000003FFFull, // 14 0x0000000000007FFFull, // 15 0x000000000000FFFFull, // 16 0x000000000001FFFFull, // 17 0x000000000003FFFFull, // 18 0x000000000007FFFFull, // 19 0x00000000000FFFFFull, // 20 0x00000000001FFFFFull, // 21 0x00000000003FFFFFull, // 22 0x00000000007FFFFFull, // 23 0x0000000000FFFFFFull, // 24 0x0000000001FFFFFFull, // 25 0x0000000003FFFFFFull, // 26 0x0000000007FFFFFFull, // 27 0x000000000FFFFFFFull, // 28 0x000000001FFFFFFFull, // 29 0x000000003FFFFFFFull, // 30 0x000000007FFFFFFFull, // 31 0x00000000FFFFFFFFull, // 32 0x00000001FFFFFFFFull, // 33 0x00000003FFFFFFFFull, // 34 0x00000007FFFFFFFFull, // 35 0x0000000FFFFFFFFFull, // 36 0x0000001FFFFFFFFFull, // 37 0x0000003FFFFFFFFFull, // 38 0x0000007FFFFFFFFFull, // 39 0x000000FFFFFFFFFFull, // 40 0x000001FFFFFFFFFFull, // 41 0x000003FFFFFFFFFFull, // 42 0x000007FFFFFFFFFFull, // 43 0x00000FFFFFFFFFFFull, // 44 0x00001FFFFFFFFFFFull, // 45 0x00003FFFFFFFFFFFull, // 46 0x00007FFFFFFFFFFFull, // 47 0x0000FFFFFFFFFFFFull, // 48 0x0001FFFFFFFFFFFFull, // 49 0x0003FFFFFFFFFFFFull, // 50 0x0007FFFFFFFFFFFFull, // 51 0x000FFFFFFFFFFFFFull, // 52 0x001FFFFFFFFFFFFFull, // 53 0x003FFFFFFFFFFFFFull, // 54 0x007FFFFFFFFFFFFFull, // 55 0x00FFFFFFFFFFFFFFull, // 56 0x01FFFFFFFFFFFFFFull, // 57 0x03FFFFFFFFFFFFFFull, // 58 0x07FFFFFFFFFFFFFFull, // 59 0x0FFFFFFFFFFFFFFFull, // 60 0x1FFFFFFFFFFFFFFFull, // 61 0x3FFFFFFFFFFFFFFFull, // 62 0x7FFFFFFFFFFFFFFFull, // 63 }; // k_rgnLeaderMask // (loop with x = (1- (ash 1 64)) for i below 64 for m = (1- (ash 1 i)) // do (format t " 0x~16,'0Xull, // ~D~%" (- x m) i) ) const Arch64::BitEltT Arch64::k_rgnTrailerMask[64] = { 0xFFFFFFFFFFFFFFFFull, // 0 0xFFFFFFFFFFFFFFFEull, // 1 0xFFFFFFFFFFFFFFFCull, // 2 0xFFFFFFFFFFFFFFF8ull, // 3 0xFFFFFFFFFFFFFFF0ull, // 4 0xFFFFFFFFFFFFFFE0ull, // 5 0xFFFFFFFFFFFFFFC0ull, // 6 0xFFFFFFFFFFFFFF80ull, // 7 0xFFFFFFFFFFFFFF00ull, // 8 0xFFFFFFFFFFFFFE00ull, // 9 0xFFFFFFFFFFFFFC00ull, // 10 0xFFFFFFFFFFFFF800ull, // 11 0xFFFFFFFFFFFFF000ull, // 12 0xFFFFFFFFFFFFE000ull, // 13 0xFFFFFFFFFFFFC000ull, // 14 0xFFFFFFFFFFFF8000ull, // 15 0xFFFFFFFFFFFF0000ull, // 16 0xFFFFFFFFFFFE0000ull, // 17 0xFFFFFFFFFFFC0000ull, // 18 0xFFFFFFFFFFF80000ull, // 19 0xFFFFFFFFFFF00000ull, // 20 0xFFFFFFFFFFE00000ull, // 21 0xFFFFFFFFFFC00000ull, // 22 0xFFFFFFFFFF800000ull, // 23 0xFFFFFFFFFF000000ull, // 24 0xFFFFFFFFFE000000ull, // 25 0xFFFFFFFFFC000000ull, // 26 0xFFFFFFFFF8000000ull, // 27 0xFFFFFFFFF0000000ull, // 28 0xFFFFFFFFE0000000ull, // 29 0xFFFFFFFFC0000000ull, // 30 0xFFFFFFFF80000000ull, // 31 0xFFFFFFFF00000000ull, // 32 0xFFFFFFFE00000000ull, // 33 0xFFFFFFFC00000000ull, // 34 0xFFFFFFF800000000ull, // 35 0xFFFFFFF000000000ull, // 36 0xFFFFFFE000000000ull, // 37 0xFFFFFFC000000000ull, // 38 0xFFFFFF8000000000ull, // 39 0xFFFFFF0000000000ull, // 40 0xFFFFFE0000000000ull, // 41 0xFFFFFC0000000000ull, // 42 0xFFFFF80000000000ull, // 43 0xFFFFF00000000000ull, // 44 0xFFFFE00000000000ull, // 45 0xFFFFC00000000000ull, // 46 0xFFFF800000000000ull, // 47 0xFFFF000000000000ull, // 48 0xFFFE000000000000ull, // 49 0xFFFC000000000000ull, // 50 0xFFF8000000000000ull, // 51 0xFFF0000000000000ull, // 52 0xFFE0000000000000ull, // 53 0xFFC0000000000000ull, // 54 0xFF80000000000000ull, // 55 0xFF00000000000000ull, // 56 0xFE00000000000000ull, // 57 0xFC00000000000000ull, // 58 0xF800000000000000ull, // 59 0xF000000000000000ull, // 60 0xE000000000000000ull, // 61 0xC000000000000000ull, // 62 0x8000000000000000ull, // 63 }; // k_rgnTrailerMask CASSERT(sizeof(Arch64::k_rgnLeaderMask) == sizeof(Arch64::k_rgnTrailerMask)); } // Kernel #endif // SIZEOF_VAL == 8
#include <cstdio> #include <cmath> const char s[12][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"}; double d[12]; int main() { double x, y, z; scanf("%lf %lf %lf", &x, &y, &z); d[0] = pow(y, z) * log(x); d[1] = pow(z, y) * log(x); d[2] = d[3] = y * z * log(x); d[4] = pow(x, z) * log(y); d[5] = pow(z, x) * log(y); d[6] = d[7] = x * z * log(y); d[8] = pow(x, y) * log(z); d[9] = pow(y, x) * log(z); d[10] = d[11] = x * y * log(z); int mx = 0; for (int i = 1; i < 12; ++i) if (d[i] > d[mx]) mx = i; puts(s[mx]); return 0; }
#include<bits/stdc++.h> using namespace std; int main() { int n,m; cin>>n; int arr[n]; int x,y; map<int,int>a; map<int,int>::iterator p; for(int i=0;i<n;i++) { cin>>arr[i]; cin>>x; for(int j=0;j<x;j++) { cin>>y; p=a.find(y); if(p==a.end()) a.insert(make_pair(y,1)); } } p=a.begin(); for(int i=0;i<n;i++) { p=a.begin(); while(p!=a.end()) { // cout<<arr[i]<<" "<<p->first<<endl; if(arr[i]==p->first) p->second--; p++; } } p=a.begin(); int sum=0; while(p!=a.end()) { //cout<<p->first<<" "<<p->second<<endl; sum+=p->second; p++; } cout<<sum<<endl; return 0; }
// MemTracker.cpp //------------------------------------------------------------------------------ // Includes //------------------------------------------------------------------------------ #include "Core/PrecompiledHeader.h" #include "MemTracker.h" //------------------------------------------------------------------------------ #if defined( MEMTRACKER_ENABLED ) // Includes //------------------------------------------------------------------------------ #include "Core/Mem/MemPoolBlock.h" #include "Core/Process/Atomic.h" #include "Core/Process/Thread.h" #include "Core/Tracing/Tracing.h" // system #include <memory.h> // for memset // Static Data //------------------------------------------------------------------------------ /*static*/ uint32_t MemTracker::s_Id( 0 ); /*static*/ bool MemTracker::s_Enabled( true ); /*static*/ bool MemTracker::s_Initialized( false ); /*static*/ uint32_t MemTracker::s_AllocationCount( 0 ); /*static*/ uint64_t MemTracker::s_Mutex[]; /*static*/ MemTracker::Allocation ** MemTracker::s_AllocationHashTable = nullptr; /*static*/ MemPoolBlock * MemTracker::s_Allocations( nullptr ); // Thread-Local Data //------------------------------------------------------------------------------ THREAD_LOCAL uint32_t g_MemTrackerDisabledOnThisThread( 0 ); // Defines #define ALLOCATION_MINIMUM_ALIGN ( 0x4 ) // assume at least 4 byte alignment #define ALLOCATION_HASH_SHIFT ( 0x2 ) // shift off lower bits #define ALLOCATION_HASH_SIZE ( 0x100000 ) // one megabyte #define ALLOCATION_HASH_MASK ( 0x0FFFFF ) // mask off upper bits // Alloc //------------------------------------------------------------------------------ /*static*/ void MemTracker::Alloc( void * ptr, size_t size, const char * file, int line ) { if ( !s_Enabled ) { return; } // handle allocations during initialization if ( g_MemTrackerDisabledOnThisThread ) { return; } ++g_MemTrackerDisabledOnThisThread; if ( !s_Initialized ) { Init(); } const size_t hashIndex = ( ( (size_t)ptr >> ALLOCATION_HASH_SHIFT ) & ALLOCATION_HASH_MASK ); { MutexHolder mh( GetMutex() ); Allocation * a = (Allocation *)s_Allocations->Alloc( sizeof( Allocation ) ); ++s_AllocationCount; a->m_Id = ++s_Id; a->m_Ptr = ptr; a->m_Size = size; a->m_Next = s_AllocationHashTable[ hashIndex ]; a->m_File = file; a->m_Line = line; static size_t breakOnSize = (size_t)-1; static uint32_t breakOnId = 0; if ( ( size == breakOnSize ) || ( a->m_Id == breakOnId ) ) { BREAK_IN_DEBUGGER; } s_AllocationHashTable[ hashIndex ] = a; } --g_MemTrackerDisabledOnThisThread; } // Free //------------------------------------------------------------------------------ /*static*/ void MemTracker::Free( void * ptr ) { if ( !s_Enabled ) { return; } if ( !s_Initialized ) { return; } if ( g_MemTrackerDisabledOnThisThread ) { return; } const size_t hashIndex = ( ( (size_t)ptr >> ALLOCATION_HASH_SHIFT ) & ALLOCATION_HASH_MASK ); MutexHolder mh( GetMutex() ); Allocation * a = s_AllocationHashTable[ hashIndex ]; Allocation * prev = nullptr; while ( a ) { if ( a->m_Ptr == ptr ) { if ( prev == nullptr ) { s_AllocationHashTable[ hashIndex ] = a->m_Next; } else { prev->m_Next = a->m_Next; } ++g_MemTrackerDisabledOnThisThread; s_Allocations->Free( a ); --s_AllocationCount; --g_MemTrackerDisabledOnThisThread; break; } prev = a; a = a->m_Next; } } // DumpAllocations //------------------------------------------------------------------------------ /*static*/ void MemTracker::DumpAllocations() { if ( s_Enabled == false ) { OUTPUT( "DumpAllocations failed - MemTracker not enabled\n" ); return; } if ( s_Initialized == false ) { OUTPUT( "DumpAllocations : No allocations\n" ); return; } MutexHolder mh( GetMutex() ); if ( s_AllocationCount == 0 ) { OUTPUT( "DumpAllocations : No allocations\n" ); return; } uint64_t total = 0; uint64_t numAllocs = 0; // for each leak, we'll print a view of the memory unsigned char displayChar[256]; memset( displayChar, '.', sizeof( displayChar ) ); const unsigned char * okChars = (const unsigned char *)"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`1234567890-=!@#$^&*()_+[]{};:'\",<>/?|\\"; const unsigned char * ok = okChars; for ( ;; ) { unsigned char c = *ok; if ( c == 0 ) break; displayChar[ c ] = c; ++ok; } char memView[ 32 ] = { 0 }; OUTPUT( "--- DumpAllocations ------------------------------------------------\n" ); for ( size_t i=0; i<ALLOCATION_HASH_SIZE; ++i ) { Allocation * a = s_AllocationHashTable[ i ]; while ( a ) { uint32_t id = a->m_Id; uint64_t addr = (size_t)a->m_Ptr; uint64_t size = a->m_Size; // format a view of the memory contents const char * src = (const char *)addr; char * dst = memView; const size_t num = Math::Min< size_t >( (size_t)size, 31 ); for ( uint32_t j=0; j<num; ++j ) { unsigned char c = *src; *dst = displayChar[ c ]; ++src; ++dst; } *dst = 0; OUTPUT( "%s(%u): Id %u : %u bytes @ 0x%016llx (Mem: %s)\n", a->m_File, a->m_Line, id, size, addr, memView ); ++numAllocs; total += size; a = a->m_Next; } } OUTPUT( "--------------------------------------------------------------------\n" ); OUTPUT( "Total: %llu bytes in %llu allocs\n", total, numAllocs ); OUTPUT( "--------------------------------------------------------------------\n" ); } // Reset //------------------------------------------------------------------------------ /*static*/ void MemTracker::Reset() { MutexHolder mh( GetMutex() ); ++g_MemTrackerDisabledOnThisThread; // free all allocation tracking for ( size_t i=0; i<ALLOCATION_HASH_SIZE; ++i ) { Allocation * a = s_AllocationHashTable[ i ]; while ( a ) { s_Allocations->Free( a ); --s_AllocationCount; a = a->m_Next; } s_AllocationHashTable[ i ] = nullptr; } ASSERT( s_AllocationCount == 0 ); s_Id = 0; --g_MemTrackerDisabledOnThisThread; } // Init //------------------------------------------------------------------------------ /*static*/ void MemTracker::Init() { CTASSERT( sizeof( MemTracker::s_Mutex ) == sizeof( Mutex ) ); ASSERT( g_MemTrackerDisabledOnThisThread ); // first caller does init static uint32_t threadSafeGuard( 0 ); if ( AtomicIncU32( &threadSafeGuard ) != 1 ) { // subsequent callers wait for init while ( !s_Initialized ) {} return; } // construct primary mutex in-place INPLACE_NEW ( &GetMutex() ) Mutex; // init hash table s_AllocationHashTable = new Allocation*[ ALLOCATION_HASH_SIZE ]; memset( s_AllocationHashTable, 0, ALLOCATION_HASH_SIZE * sizeof( Allocation * ) ); // init pool for allocation structures s_Allocations = new MemPoolBlock( sizeof( Allocation ), __alignof( Allocation ) ); MemoryBarrier(); s_Initialized = true; } //------------------------------------------------------------------------------ #endif // MEMTRACKER_ENABLED //------------------------------------------------------------------------------
/* 在二维数组grid中,grid[i][j]代表位于某处的建筑物的高度。 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度。 高度 0 也被认为是建筑物。 最后,从新数组的所有四个方向(即顶部,底部,左侧和右侧)观看的“天际线”必须与原始数组的天际线相同。 城市的天际线是从远处观看时,由所有建筑物形成的矩形的外部轮廓。 请看下面的例子。 建筑物高度可以增加的最大总和是多少? 例子: 输入: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]] 输出: 35 解释: The grid is: [ [3, 0, 8, 4], [2, 4, 5, 7], [9, 2, 6, 3], [0, 3, 1, 0] ] 从数组竖直方向(即顶部,底部)看“天际线”是:[9, 4, 8, 7] 从水平水平方向(即左侧,右侧)看“天际线”是:[8, 7, 9, 3] 在不影响天际线的情况下对建筑物进行增高后,新数组如下: gridNew = [ [8, 4, 8, 7], [7, 4, 7, 7], [9, 4, 8, 7], [3, 3, 3, 3] ] 说明: 1 < grid.length = grid[0].length <= 50。  grid[i][j] 的高度范围是: [0, 100]。 一座建筑物占据一个grid[i][j]:换言之,它们是 1 x 1 x grid[i][j] 的长方体。 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/max-increase-to-keep-city-skyline 著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 class Solution { public: int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) { if (grid.empty()) return 0; int R = grid.size(); int C = grid[0].size(); vector<int> row_max(R, 0); vector<int> col_max(C, 0); for (int i = 0; i < R; ++i) { for (int j = 0; j < C; ++j) { row_max[i] = max(row_max[i], grid[i][j]); col_max[j] = max(col_max[j], grid[i][j]); } } int res = 0; for (int i = 0; i < R; ++i) { for (int j = 0; j < C; ++j) { res += min(row_max[i], col_max[j]) - grid[i][j]; } } return res; } }; */ /* 就是找行列最大 */
#ifndef _FF_BFC_AUTORES_H #define _FF_BFC_AUTORES_H #include <utility> #include <iterator> #include"ffdef.h" _FF_BEG //To help implement reference-counter in @AutoRes. template<typename ValT> class ReferenceCounter { typedef std::pair<int,ValT> _CounterT; private: _CounterT *_pdata; void _inc() const { ++_pdata->first; } void _dec() const { --_pdata->first; } public: ReferenceCounter() :_pdata(new _CounterT(1,ValT())) { } ReferenceCounter(const ValT& val) :_pdata(new _CounterT(1,val)) { } ReferenceCounter(const ReferenceCounter& right) :_pdata(right._pdata) { this->_inc(); } ReferenceCounter& operator=(const ReferenceCounter& right) { if(_pdata!=right._pdata) { if(this->IsLast()) delete _pdata; else this->_dec(); _pdata=right._pdata; right._inc(); } return *this; } //whether current reference is the last one. bool IsLast() const { return _pdata->first==1; } //get the value stored with the counter. const ValT& Value() const { return _pdata->second; } ValT& Value() { return _pdata->second; } //swap two counters. void Swap(ReferenceCounter& right) { std::swap(this->_pdata,right._pdata); } ~ReferenceCounter() { if(this->IsLast()) delete _pdata; else this->_dec(); } }; //auto-resource, which is the base to implement AutoPtr,AutoArrayPtr and AutoComPtr. template<typename PtrT,typename RetPtrT,typename ReleaseOpT> class AutoRes { enum{_F_DETACHED=0x01}; struct _ValT { PtrT ptr; ReleaseOpT rel_op; int flag; public: _ValT() :ptr(PtrT()),flag(0) { } _ValT(const PtrT & _ptr,const ReleaseOpT & _rel_op, int _flag=0) :ptr(_ptr),rel_op(_rel_op),flag(_flag) { } void release() { if((flag&_F_DETACHED)==0) rel_op(ptr); } }; typedef ReferenceCounter<_ValT> _CounterT; protected: _CounterT _counter; void _release() { //release the referenced object with the stored operator. _counter.Value().release(); } public: AutoRes() { } explicit AutoRes(PtrT ptr,const ReleaseOpT& op=ReleaseOpT()) :_counter(_ValT(ptr,op)) { } AutoRes& operator=(const AutoRes& right) { if(this!=&right) { if(_counter.IsLast()) this->_release(); _counter=right._counter; } return *this; } RetPtrT operator->() const { return &*_counter.Value().ptr; } typename std::iterator_traits<RetPtrT>::reference operator*() const { return *_counter.Value().ptr; } void Swap(AutoRes& right) { _counter.Swap(right._counter); } //detach the referenced object from @*this. RetPtrT Detach() { _counter.Value().flag|=_F_DETACHED; return &*_counter.Value().ptr; } operator PtrT() { return _counter.Value().ptr; } ~AutoRes() throw() { if(_counter.IsLast()) this->_release(); } }; //operator to delete a single object. class DeleteObj { public: template<typename _PtrT> void operator()(_PtrT ptr) { delete ptr; } }; template<typename _ObjT> class AutoPtr :public AutoRes<_ObjT*,_ObjT*,DeleteObj> { public: explicit AutoPtr(_ObjT* ptr=NULL) :AutoRes<_ObjT*,_ObjT*,DeleteObj>(ptr) { } }; //operator to delete array of objects. class DeleteArray { public: template<typename _PtrT> void operator()(_PtrT ptr) { delete[]ptr; } }; template<typename _ObjT> class AutoArrayPtr :public AutoRes<_ObjT*,_ObjT*,DeleteArray> { public: explicit AutoArrayPtr(_ObjT* ptr=NULL) :AutoRes<_ObjT*,_ObjT*,DeleteArray>(ptr) { } //_ObjT& operator[](int i) const //{ // return this->_counter.Value().ptr[i]; //} }; class OpCloseFile { public: void operator()(const FILE *fp) { if(fp) fclose((FILE*)fp); } }; class AutoFilePtr :public AutoRes<FILE*,FILE*,OpCloseFile> { public: explicit AutoFilePtr(FILE *fp=NULL) :AutoRes<FILE*,FILE*,OpCloseFile>(fp) { } }; //operator to release COM object. class ReleaseObj { public: template<typename _PtrT> void operator()(_PtrT ptr) { if(ptr) ptr->Release(); } }; template<typename _ObjT> class AutoComPtr :public AutoRes<_ObjT*,_ObjT*,ReleaseObj> { public: explicit AutoComPtr(_ObjT* ptr=NULL) :AutoRes<_ObjT*,_ObjT*,ReleaseObj>(ptr) { } }; class DestroyObj { public: template<typename _PtrT> void operator()(_PtrT ptr) { if(ptr) ptr->Destroy(); } }; template<typename _ObjT> class AutoDestroyPtr :public AutoRes<_ObjT*,_ObjT*,DestroyObj> { public: explicit AutoDestroyPtr(_ObjT* ptr=NULL) :AutoRes<_ObjT*,_ObjT*,DestroyObj>(ptr) { } }; template<typename _ServerPtrT> class ReleaseClientOp { private: _ServerPtrT m_pServer; public: ReleaseClientOp(_ServerPtrT pServer=_ServerPtrT()) :m_pServer(pServer) { } template<typename _ClientPtrT> void operator()(_ClientPtrT ptr) { if(m_pServer) m_pServer->ReleaseClient(ptr); } }; template<typename _ServerPtrT,typename _ClientPtrT> class AutoClientPtr :public AutoRes<_ClientPtrT,_ClientPtrT,ReleaseClientOp<_ServerPtrT> > { typedef AutoRes<_ClientPtrT,_ClientPtrT,ReleaseClientOp<_ServerPtrT> > _MyBaseT; public: explicit AutoClientPtr(_ServerPtrT pServer=_ServerPtrT(),_ClientPtrT pClient=_ClientPtrT()) :_MyBaseT(pClient,ReleaseClientOp<_ServerPtrT>(pServer)) { } }; _FF_END #endif
/* * Copyright (c) Facebook, Inc. and its affiliates. * * This source code is licensed under the MIT license found in the LICENSE * file in the root directory of this source tree. */ #ifndef HERMES_VM_JIT_DENSEUINT64_H #define HERMES_VM_JIT_DENSEUINT64_H #include "hermes/VM/HermesValue.h" #include "llvm/ADT/DenseMapInfo.h" namespace hermes { namespace vm { /// A wrapper for using uint64_t with llvm::DenseMap/Set. class DenseUInt64 { public: /// Enum to differentiate between LLVM's empty/tombstone and normal values. enum class MapKeyType { empty, tombstone, valid, }; DenseUInt64(uint64_t cval) : keyType_(MapKeyType::valid), rawValue_(cval) {} DenseUInt64(void *addr) : keyType_(MapKeyType::valid), rawValue_((uint64_t)addr) {} DenseUInt64(HermesValue hv) : keyType_(MapKeyType::valid), rawValue_(hv.getRaw()) {} DenseUInt64(double v) : DenseUInt64(HermesValue::encodeDoubleValue(v)) {} DenseUInt64(MapKeyType keyType) : keyType_(keyType), rawValue_(0) { assert(keyType_ != MapKeyType::valid && "valid entries must have a value"); } bool operator==(const DenseUInt64 &other) const { return keyType_ == other.keyType_ && rawValue_ == other.rawValue_; } HermesValue valueAsHV() const { assert( keyType_ == MapKeyType::valid && "attempting to get the value of tombstone/empty entry"); return HermesValue(rawValue_); } void *valueAsAddr() const { assert( keyType_ == MapKeyType::valid && "attempting to get the value of tombstone/empty entry"); return (void *)rawValue_; } uint64_t rawValue() const { return rawValue_; } private: /// The type of value we have: empty/tombstone/normal. MapKeyType keyType_; /// A raw uint64_t: it could be a HermesValue or an address uint64_t rawValue_; }; } // namespace vm } // namespace hermes namespace llvm { /// Traits to enable using UInt64Constant with llvm::DenseSet/Map. template <> struct DenseMapInfo<hermes::vm::DenseUInt64> { using UInt64Constant = hermes::vm::DenseUInt64; using MapKeyType = UInt64Constant::MapKeyType; static inline UInt64Constant getEmptyKey() { return MapKeyType::empty; } static inline UInt64Constant getTombstoneKey() { return MapKeyType::tombstone; } static inline unsigned getHashValue(UInt64Constant x) { return DenseMapInfo<uint64_t>::getHashValue(x.rawValue()); } static inline bool isEqual(UInt64Constant a, UInt64Constant b) { return a == b; } }; } // namespace llvm #endif // HERMES_VM_JIT_DENSEUINT64_H
// CodeGear C++Builder // Copyright (c) 1995, 2015 by Embarcadero Technologies, Inc. // All rights reserved // (DO NOT EDIT: machine generated header) 'uTPLb_MemoryStreamPool.pas' rev: 29.00 (iOS) #ifndef Utplb_memorystreampoolHPP #define Utplb_memorystreampoolHPP #pragma delphiheader begin #pragma option push #pragma option -w- // All warnings off #pragma option -Vx // Zero-length empty class member #pragma pack(push,8) #include <System.hpp> #include <SysInit.hpp> #include <System.Classes.hpp> //-- user supplied ----------------------------------------------------------- namespace Utplb_memorystreampool { //-- forward type declarations ----------------------------------------------- __interface IMemoryStreamPool; typedef System::DelphiInterface<IMemoryStreamPool> _di_IMemoryStreamPool; class DELPHICLASS TPooledMemoryStream; //-- type declarations ------------------------------------------------------- __interface INTERFACE_UUID("{ADB2D4BA-40F6-4249-923E-201D4719609B}") IMemoryStreamPool : public System::IInterface { virtual int __fastcall BayCount(void) = 0 ; virtual void __fastcall GetUsage(int Size, int &Current, int &Peak) = 0 ; virtual int __fastcall GetSize(int Idx) = 0 ; virtual System::Classes::TMemoryStream* __fastcall NewMemoryStream(int InitSize) = 0 ; }; #pragma pack(push,4) class PASCALIMPLEMENTATION TPooledMemoryStream : public System::Classes::TMemoryStream { typedef System::Classes::TMemoryStream inherited; protected: _di_IMemoryStreamPool FPool; int FCoVector; virtual void * __fastcall Realloc(int &NewCapacity); public: __fastcall TPooledMemoryStream(const _di_IMemoryStreamPool Pool1); public: /* TMemoryStream.Destroy */ inline __fastcall virtual ~TPooledMemoryStream(void) { } }; #pragma pack(pop) //-- var, const, procedure --------------------------------------------------- extern DELPHI_PACKAGE _di_IMemoryStreamPool __fastcall NewPool(void); } /* namespace Utplb_memorystreampool */ #if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_UTPLB_MEMORYSTREAMPOOL) using namespace Utplb_memorystreampool; #endif #pragma pack(pop) #pragma option pop #pragma delphiheader end. //-- end unit ---------------------------------------------------------------- #endif // Utplb_memorystreampoolHPP
#include "Common.hpp" #include "FrmFileRecv.hpp" #include "FrmFileSend.hpp" #include "FrmMain.hpp" #include "Ucl.hpp" #include <nana/gui/filebox.hpp> using namespace nana; FrmMain::FrmMain() : form(nullptr, {768, 480}, appear::decorate< appear::taskbar, appear::minimize, appear::maximize, appear::sizable >()) { caption(Title(L"Client")); events().destroy(std::bind(&FrmMain::X_OnDestroy, this, std::placeholders::_1)); events().user(std::bind(&FrmMain::X_OnUser, this, std::placeholders::_1)); events().unload([this] (const arg_unload &e) { msgbox mbx {nullptr, TitleU8(L"Exit"), msgbox::yes_no}; mbx.icon(msgbox::icon_question); mbx << L"Are you sure to exit Uch?"; if (mbx() != mbx.pick_yes) e.cancel = true; }); x_btnSend.caption(L"Send"); x_btnSend.events().click(std::bind(&FrmMain::X_OnSend, this)); x_btnSend.events().key_press([this] (const arg_keyboard &e) { if (e.key == keyboard::enter) X_OnSend(); }); x_btnFile.caption(L"Send File"); x_btnFile.events().click(std::bind(&FrmMain::X_OnFile, this)); x_btnFile.events().key_press([this] (const arg_keyboard &e) { if (e.key == keyboard::enter) X_OnFile(); }); x_btnExit.caption(L"Exit"); x_btnExit.events().click(std::bind(&FrmMain::close, this)); x_btnExit.events().key_press([this] (const arg_keyboard &e) { if (e.key == keyboard::enter) close(); }); x_txtMessage.multi_lines(false).tip_string(u8"Message:"); x_txtMessage.events().focus([this] (const arg_focus &e) { x_txtMessage.select(e.getting); }); x_txtMessage.events().key_press([this] (const arg_keyboard &e) { if (e.key == keyboard::enter) X_OnSend(); }); x_lbxUsers.enable_single(true, false); x_lbxUsers.append_header(L"Who", 110); x_lbxUsers.append({L"Online", L"Offline"}); x_lbxMessages.sortable(false); x_lbxMessages.append_header(L"When", 80); x_lbxMessages.append_header(L"How", 180); x_lbxMessages.append_header(L"What", 310); x_pl.div( "margin=[14,16]" " <weight=120 List> <weight=8>" " <vert" " <Msgs> <weight=7>" " <weight=25 Imsg> <weight=7>" " <weight=25 <> <weight=259 gap=8 Btns>>" " >" ); x_pl["List"] << x_lbxUsers; x_pl["Msgs"] << x_lbxMessages; x_pl["Imsg"] << x_txtMessage; x_pl["Btns"] << x_btnExit << x_btnFile << x_btnSend; x_pl.collocate(); Ucl::Bus().Register(*this); } void FrmMain::OnEvent(event::EvMessage &e) noexcept { constexpr static auto kszFmt = L"(%s) %s => %s"; x_lbxMessages.at(0).append({ FormattedTime(), FormatString(L"(%s) %s => %s", e.sCat.c_str(), e.sFrom.c_str(), e.sTo.c_str()), e.sWhat }); x_lbxMessages.scroll(true); } void FrmMain::OnEvent(event::EvListUon &e) noexcept { x_lbxUsers.at(1).model<std::recursive_mutex>( e.vecUon, [] (auto &c) { return AsWideString(c.front().text); }, [] (auto &s) { return std::vector<listbox::cell> {AsUtf8String(s)}; } ); } void FrmMain::OnEvent(event::EvListUff &e) noexcept { x_lbxUsers.at(2).model<std::recursive_mutex>( e.vecUff, [] (auto &c) { return AsWideString(c.front().text); }, [] (auto &s) { return std::vector<listbox::cell> {AsUtf8String(s)}; } ); } void FrmMain::OnEvent(event::EvFileReq &e) noexcept { user(std::make_unique<event::EvFileReq>(e).release()); } void FrmMain::X_OnSend() { auto vec = x_lbxUsers.selected(); if (vec.empty()) { msgbox mbx {nullptr, TitleU8(L"Send message"), msgbox::ok}; mbx.icon(msgbox::icon_error); mbx << L"Please select a recipient"; mbx(); return; } auto &idx = vec.front(); auto sUser = AsWideString(x_lbxUsers.at(idx.cat).at(idx.item).text(0)); switch (idx.cat) { case 1: // Online X_AddMessage({kszCatChat, kszSelf, sUser, x_txtMessage.caption_wstring()}); (*Ucl::Pmg())[sUser].PostPacket(protocol::EvpMessage { x_txtMessage.caption_wstring() }); break; case 2: // Offline X_AddMessage({kszCatFmsg, kszSelf, sUser, x_txtMessage.caption_wstring()}); Ucl::Con()->PostPacket(protocol::EvcMessageTo { sUser, x_txtMessage.caption_wstring() }); break; default: throw ExnIllegalState {}; } x_txtMessage.caption(String {}); } void FrmMain::X_OnFile() { auto vec = x_lbxUsers.selected(); if (vec.empty()) { msgbox mbx {TitleU8(L"Send file")}; mbx.icon(msgbox::icon_error); mbx << L"Please select a recipient"; mbx(); return; } auto &idx = vec.front(); if (idx.cat != 1) { msgbox mbx {TitleU8(L"Send file")}; mbx.icon(msgbox::icon_error); mbx << L"Please select an online user"; mbx(); return; } auto sUser = AsWideString(x_lbxUsers.at(idx.cat).at(idx.item).text(0)); filebox fbx {nullptr, true}; if (!fbx()) return; auto sPath = AsWideString(fbx.file()); UccPipl *pPipl; try { pPipl = &(*Ucl::Pmg())[sUser]; } catch (std::out_of_range) { msgbox mbx {TitleU8(L"Send file")}; mbx << L"The user if offline"; mbx(); return; } form_loader<FrmFileSend>() (*this, pPipl, sPath).show(); } void FrmMain::X_OnDestroy(const nana::arg_destroy &e) { Ucl::Con()->PostPacket(protocol::EvcExit {Ucl::Usr()}); Ucl::Con()->Shutdown(); Ucl::Pmg()->Shutdown(); Ucl::Bus().Unregister(*this); } void FrmMain::X_OnUser(const nana::arg_user &e) { std::unique_ptr<event::EvFileReq> up { reinterpret_cast<event::EvFileReq *>(e.param) }; try { form_loader<FrmFileRecv>() (*this, up->pPipl, up->eReq).show(); } catch (ExnIllegalState) {} } void FrmMain::X_AddMessage(event::EvMessage &&e) noexcept { OnEvent(e); }
/**************************************************************************** ** Meta object code from reading C++ file 'mainwindow.h' ** ** Created by: The Qt Meta Object Compiler version 67 (Qt 5.8.0) ** ** WARNING! All changes made in this file will be lost! *****************************************************************************/ #include "../../OpenGL_Material/mainwindow.h" #include <QtCore/qbytearray.h> #include <QtCore/qmetatype.h> #if !defined(Q_MOC_OUTPUT_REVISION) #error "The header file 'mainwindow.h' doesn't include <QObject>." #elif Q_MOC_OUTPUT_REVISION != 67 #error "This file was generated using the moc from 5.8.0. It" #error "cannot be used with the include files from this version of Qt." #error "(The moc has changed too much.)" #endif QT_BEGIN_MOC_NAMESPACE QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED struct qt_meta_stringdata_MainWindow_t { QByteArrayData data[1]; char stringdata0[11]; }; #define QT_MOC_LITERAL(idx, ofs, len) \ Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ qptrdiff(offsetof(qt_meta_stringdata_MainWindow_t, stringdata0) + ofs \ - idx * sizeof(QByteArrayData)) \ ) static const qt_meta_stringdata_MainWindow_t qt_meta_stringdata_MainWindow = { { QT_MOC_LITERAL(0, 0, 10) // "MainWindow" }, "MainWindow" }; #undef QT_MOC_LITERAL static const uint qt_meta_data_MainWindow[] = { // content: 7, // revision 0, // classname 0, 0, // classinfo 0, 0, // methods 0, 0, // properties 0, 0, // enums/sets 0, 0, // constructors 0, // flags 0, // signalCount 0 // eod }; void MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) { Q_UNUSED(_o); Q_UNUSED(_id); Q_UNUSED(_c); Q_UNUSED(_a); } const QMetaObject MainWindow::staticMetaObject = { { &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindow.data, qt_meta_data_MainWindow, qt_static_metacall, Q_NULLPTR, Q_NULLPTR} }; const QMetaObject *MainWindow::metaObject() const { return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; } void *MainWindow::qt_metacast(const char *_clname) { if (!_clname) return Q_NULLPTR; if (!strcmp(_clname, qt_meta_stringdata_MainWindow.stringdata0)) return static_cast<void*>(const_cast< MainWindow*>(this)); return QMainWindow::qt_metacast(_clname); } int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QMainWindow::qt_metacall(_c, _id, _a); if (_id < 0) return _id; return _id; } QT_WARNING_POP QT_END_MOC_NAMESPACE
// Copyright (C) 2002-2007 Nikolaus Gebhardt // This file is part of the "Irrlicht Engine". // For conditions of distribution and use, see copyright notice in irrlicht.h #ifndef __C_GUI_COLOR_SELECT_DIALOG_H_INCLUDED__ #define __C_GUI_COLOR_SELECT_DIALOG_H_INCLUDED__ #include "IGUIColorSelectDialog.h" #include "IGUIButton.h" #include "IGUIEditBox.h" #include "IGUIScrollBar.h" #include "IGUIImage.h" #include "irrArray.h" namespace irr { namespace gui { class CGUIColorSelectDialog : public IGUIColorSelectDialog { public: //! constructor CGUIColorSelectDialog(const wchar_t* title, IGUIEnvironment* environment, IGUIElement* parent, s32 id); //! destructor virtual ~CGUIColorSelectDialog(); //! called if an event happened. virtual bool OnEvent(SEvent event); //! draws the element and its children virtual void draw(); private: //! sends the event that the file has been selected. void sendSelectedEvent(); //! sends the event that the file choose process has been canceld void sendCancelEvent(); core::position2d<s32> DragStart; bool Dragging; IGUIButton* CloseButton; IGUIButton* OKButton; IGUIButton* CancelButton; struct SBatteryItem { f32 Incoming; f32 Outgoing; IGUIEditBox * Edit; IGUIScrollBar *Scrollbar; }; core::array< SBatteryItem > Battery; struct SColorCircle { IGUIImage * Control; video::ITexture * Texture; }; SColorCircle ColorRing; void buildColorRing( const core::dimension2d<s32> & dim, s32 supersample, const u32 borderColor ); }; } // end namespace gui } // end namespace irr #endif
#include <stdio.h> #include <string.h> #include <algorithm> #include <vector> using namespace std; vector<int>tab[50010]; int n,m,q; int ans[50010]; int main(int argc, char const *argv[]) { while (scanf("%d%d%d",&n,&m,&q) != EOF) { memset(ans,0,sizeof(ans)); for (int i=1;i<=n;i++) tab[i].clear(); for (int i=0;i<m;i++) { int u,v; scanf("%d%d",&u,&v); if (v<u) tab[u].push_back(v); } int m1=n,m2=n; for (int i=n;i>1;i--) { for (int j=0;j<tab[i].size();j++) if (tab[i][j]<m1) { m2=m1; m1=tab[i][j]; } else if (tab[i][j]<m2) { m2=tab[i][j]; } ans[i]=max(i-m2,0); } int ask; for (int i=0;i<q;i++) { scanf("%d",&ask); printf("%d\n", ans[ask]); } } return 0; }
// Copyright 2016 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "testing/gtest/include/gtest/gtest.h" #include "third_party/blink/renderer/core/dom/document.h" #include "third_party/blink/renderer/core/html/html_link_element.h" #include "third_party/blink/renderer/core/testing/sim/sim_request.h" #include "third_party/blink/renderer/core/testing/sim/sim_test.h" namespace blink { class LinkElementLoadingTest : public SimTest {}; TEST_F(LinkElementLoadingTest, ShouldCancelLoadingStyleSheetIfLinkElementIsDisconnected) { SimRequest main_resource("https://example.com/test.html", "text/html"); SimRequest css_resource("https://example.com/test.css", "text/css"); LoadURL("https://example.com/test.html"); main_resource.Start(); main_resource.Write( "<!DOCTYPE html><link id=link rel=stylesheet href=test.css>"); // Sheet is streaming in, but not ready yet. css_resource.Start(); // Remove a link element from a document HTMLLinkElement* link = ToHTMLLinkElement(GetDocument().getElementById("link")); EXPECT_NE(nullptr, link); link->remove(); // Finish the load. css_resource.Complete(); main_resource.Finish(); // Link element's sheet loading should be canceled. EXPECT_EQ(nullptr, link->sheet()); } } // namespace blink
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> void generation(int* Arr, int n) { int i; srand(time(NULL)); for ( i=0;i<n;++i) { Arr[i] = rand()%100 - 50; printf("%d ", Arr[i]); } printf("\n"); } int cmp_(void* a, void* b){ return (*(int*)a - *(int*)b); } void swap(void* a, void* b, size_t size) { char* x = (char*)(malloc(size)); memcpy(x, a, size); memcpy(a, b, size); memcpy(b, x, size); free(x); } void QuickSort ( void* Arr, int first, int last, size_t size, int(*cmp)(void*, void*)) { if ((last - first) > 10) { int i, j; i = first; j = last; int key = (rand() % last + first) % last; char *buf = (char*)malloc(size); memcpy(buf, (char*)Arr + key*size, size); do { while (cmp((char*)Arr + i*size, buf) < 0) i++; while (cmp((char*)Arr + j*size, buf) > 0) j--; if(i <= j) { if (i < j) swap((char*)Arr + i*size, (char*)Arr + j*size, size); i++; j--; } } while (i <= j); if (i < last) QuickSort(Arr, i, last, size, cmp); if (first < j) QuickSort(Arr, first,j, size, cmp); } } void InsertSort(void* a, int n, size_t size, int(*cmp)(void*, void*)) { int i; for (i = 1; i < n; ++i) { char* key = (char*)(malloc(size)); memcpy(key, (char*)a + i* size, size); int j = i - 1; while ((j >= 0) && (cmp((char*)a + j * size, key) > 0)) { swap((char*)a + j*size, (char*)a + (j + 1) * size, size); j--; } memcpy((char*)a + (j + 1) * size, key, size); } } int main() { int i, n; printf("Number: "); scanf("%d", &n); printf ("\n"); int* Arr = (int*)(malloc(sizeof(int)*n)); generation(Arr, n); int(*p)(void*, void*); p = cmp_; QuickSort(Arr, 0, n - 1, sizeof(int), p); InsertSort(Arr, n, sizeof(int), p); for (i = 0; i < n; ++i) { printf("%d ", Arr[i]); } free(Arr); return 0; }
#pragma once // Sea of Thieves (2.0) SDK #ifdef _MSC_VER #pragma pack(push, 0x8) #endif #include "SoT_BP_FishingFish_Wrecker_05_Colour_05_Moon_structs.hpp" namespace SDK { //--------------------------------------------------------------------------- //Classes //--------------------------------------------------------------------------- // BlueprintGeneratedClass BP_FishingFish_Wrecker_05_Colour_05_Moon.BP_FishingFish_Wrecker_05_Colour_05_Moon_C // 0x0000 (0x0990 - 0x0990) class ABP_FishingFish_Wrecker_05_Colour_05_Moon_C : public ABP_FishingFish_Wrecker_05_C { public: static UClass* StaticClass() { static auto ptr = UObject::FindObject<UClass>(_xor_("BlueprintGeneratedClass BP_FishingFish_Wrecker_05_Colour_05_Moon.BP_FishingFish_Wrecker_05_Colour_05_Moon_C")); return ptr; } void UserConstructionScript(); }; } #ifdef _MSC_VER #pragma pack(pop) #endif
version https://git-lfs.github.com/spec/v1 oid sha256:2995f98908d109d3d0c6f3843c95855164d1b5d8229cdc1d99bcf3b7094d3655 size 7412
#ifndef BOOST_METAPARSE_V1_PUSH_BACK_C_HPP #define BOOST_METAPARSE_V1_PUSH_BACK_C_HPP // Copyright Abel Sinkovics ([email protected]) 2013. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include <boost/metaparse/config.hpp> #include <boost/metaparse/v1/fwd/string.hpp> #include <boost/metaparse/v1/impl/update_c.hpp> #include <boost/metaparse/v1/impl/size.hpp> namespace boost { namespace metaparse { namespace v1 { namespace impl { template <class S, char C> struct push_back_c; #ifdef BOOST_METAPARSE_VARIADIC_STRING template <char... Cs, char C> struct push_back_c<string<Cs...>, C> : string<Cs..., C> {}; #else template <class S, char C> struct push_back_c : update_c<typename S::type, size<typename S::type>::type::value, C> {}; #endif } } } } #endif
class TRecusalBookDialog : public TFloatDialog { public: TRecusalBookDialog(TWindow* parent, TRecusalBookGroup *group, int resId = IDD_RECUSAL_BOOK); protected: TCharListFace *types; TCharAutoListFace *compositions; TDateFace *minDate; TDateFace *maxDate; TLongFace *autogen; TCheckFace *filtered; TCheckFace *recujed; virtual bool IsValid(); };
//**************************************************************************** // Copyright © 2022 Jan Erik Breimo. All rights reserved. // Created by Jan Erik Breimo on 2022-05-07. // // This file is distributed under the BSD License. // License text is included with the source distribution. //**************************************************************************** #include "Xyz/SimplexNoise.hpp" #include <algorithm> // Copied (and slightly adapted) // from https://gist.github.com/Flafla2/f0260a861be0ebdeef76 namespace { // Hash lookup table as defined by Ken SimplexNoise. This is a randomly // arranged array of all numbers from 0-255 inclusive. uint8_t PERMUTATION[256] = { 151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180 }; double gradient(int hash, double x, double y, double z) { switch (hash & 0xF) { case 0x0: return x + y; case 0x1: return -x + y; case 0x2: return x - y; case 0x3: return -x - y; case 0x4: return x + z; case 0x5: return -x + z; case 0x6: return x - z; case 0x7: return -x - z; case 0x8: return y + z; case 0x9: return -y + z; case 0xA: return y - z; case 0xB: return -y - z; case 0xC: return y + x; case 0xD: return -y + z; case 0xE: return y - x; case 0xF: return -y - z; default: return 0; } } double fade(double t) { // Fade function as defined by Ken SimplexNoise. This eases coordinate // values so that they will "ease" towards integral values. // This ends up smoothing the final output. return t * t * t * (t * (t * 6 - 15) + 10); // 6t^5 - 15t^4 + 10t^3 } double lerp(double a, double b, double x) { return a + x * (b - a); } } SimplexNoise::SimplexNoise() { std::copy(std::begin(PERMUTATION), std::end(PERMUTATION), permutation_); std::copy(std::begin(PERMUTATION), std::end(PERMUTATION), permutation_ + 256); } double SimplexNoise::simplex(double x, double y, double z) { // Calculate the "unit cube" that the point asked will be located in. // The left bound is ( |_x_|,|_y_|,|_z_| ) and the right bound is that // plus 1. Next we calculate the location (from 0.0 to 1.0) in that cube. // We also fade the location to smooth the result. int xi = int(x) & 255; int yi = int(y) & 255; int zi = int(z) & 255; double xf = x - int(x); double yf = y - int(y); double zf = z - int(z); double u = fade(xf); double v = fade(yf); double w = fade(zf); int aaa, aba, aab, abb, baa, bba, bab, bbb; aaa = permutation_[permutation_[permutation_[xi] + yi] + zi]; aba = permutation_[permutation_[permutation_[xi] + ++yi] + zi]; aab = permutation_[permutation_[permutation_[xi] + yi] + ++zi]; abb = permutation_[permutation_[permutation_[xi] + ++yi] + ++zi]; baa = permutation_[permutation_[permutation_[++xi] + yi] + zi]; bba = permutation_[permutation_[permutation_[++xi] + ++yi] + zi]; bab = permutation_[permutation_[permutation_[++xi] + yi] + ++zi]; bbb = permutation_[permutation_[permutation_[++xi] + ++yi] + ++zi]; double x1, x2, y1, y2; // The gradient function calculates the dot product between a pseudorandom // gradient vector and the vector from the input coordinate to the 8 // surrounding points in its unit cube. x1 = lerp(gradient(aaa, xf, yf, zf), gradient(baa, xf - 1, yf, zf), u); // This is all then lerped together as a sort of weighted average based on // the faded (u,v,w) values we made earlier. x2 = lerp(gradient(aba, xf, yf - 1, zf), gradient(bba, xf - 1, yf - 1, zf), u); y1 = lerp(x1, x2, v); x1 = lerp(gradient(aab, xf, yf, zf - 1), gradient(bab, xf - 1, yf, zf - 1), u); x2 = lerp(gradient(abb, xf, yf - 1, zf - 1), gradient(bbb, xf - 1, yf - 1, zf - 1), u); y2 = lerp(x1, x2, v); // For convenience, we reduce it to 0 - 1 (theoretical min/max before // is -1 - 1) return (lerp(y1, y2, w) + 1) / 2; } double SimplexNoise::simplex(double x, double y, double z, int octaves, double persistence) { double total = 0; double frequency = 1; double amplitude = 1; double max_value = 0; for (int i = 0; i < octaves; i++) { total += simplex(x * frequency, y * frequency, z * frequency) * amplitude; max_value += amplitude; amplitude *= persistence; frequency *= 2; } return total / max_value; }
#include <iostream> #include <map> #include <vector> using namespace std; #define N 4 int main(void) { ios::sync_with_stdio(false); int a[N], b[N]; int hit, blow; while(cin >> a[0] >> a[1] >> a[2] >> a[3], !cin.eof()) { for(int i=0; i<N; i++) cin >> b[i]; hit = blow = 0; for(int i=0; i<N; i++) { for(int j=0; j<N; j++) { if(a[i] == b[j]) { if(i == j) hit++; else blow++; } } } cout << hit << " " << blow << endl; } return 0; }
/* * SignalToStop.hpp * */ #ifndef INCLUDE_CORE_SIGNALTOSTOP_HPP_FILE #define INCLUDE_CORE_SIGNALTOSTOP_HPP_FILE /* public header */ #include "System/SignalRegistrator.hpp" #include "Logger/Node.hpp" #include "Core/WorkThreads.hpp" namespace Core { /** \brief handles given signal's registration and unregistration. * * when given signal is received system is triggered to stop. */ class SignalToStop: public System::SignalRegistrator { public: /** \brief registers handle for signal. * \param signum signal number to be handled. * \param wt main system threads. if NULL, signal is ignored. */ SignalToStop(int signum, WorkThreads *wt); /** \brief unregisters signal handle. */ ~SignalToStop(void); private: int signum_; Logger::Node log_; }; // class SignalToStop } // namespace Core #endif
/**************************************************************************** ** ** Copyright (C) 2015 The Qt Company Ltd. ** Contact: http://www.qt.io/licensing/ ** ** This file is part of the QtQml module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL21$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see http://www.qt.io/terms-conditions. For further ** information use the contact form at http://www.qt.io/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 or version 3 as published by the Free ** Software Foundation and appearing in the file LICENSE.LGPLv21 and ** LICENSE.LGPLv3 included in the packaging of this file. Please review the ** following information to ensure the GNU Lesser General Public License ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** As a special exception, The Qt Company gives you certain additional ** rights. These rights are described in The Qt Company LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #ifndef QV4PROFILING_H #define QV4PROFILING_H // // W A R N I N G // ------------- // // This file is not part of the Qt API. It exists purely as an // implementation detail. This header file may change from version to // version without notice, or even be removed. // // We mean it. // #include "qv4global_p.h" #include "qv4engine_p.h" #include "qv4function_p.h" #include <QElapsedTimer> QT_BEGIN_NAMESPACE namespace QV4 { namespace Profiling { enum Features { FeatureFunctionCall, FeatureMemoryAllocation }; enum MemoryType { HeapPage, LargeItem, SmallItem }; struct FunctionCallProperties { qint64 start; qint64 end; QString name; QString file; int line; int column; }; struct MemoryAllocationProperties { qint64 timestamp; qint64 size; MemoryType type; }; class FunctionCall { public: FunctionCall() : m_function(0), m_start(0), m_end(0) { Q_ASSERT_X(false, Q_FUNC_INFO, "Cannot construct a function call without function"); } FunctionCall(Function *function, qint64 start, qint64 end) : m_function(function), m_start(start), m_end(end) { m_function->compilationUnit->addref(); } FunctionCall(const FunctionCall &other) : m_function(other.m_function), m_start(other.m_start), m_end(other.m_end) { m_function->compilationUnit->addref(); } ~FunctionCall() { m_function->compilationUnit->release(); } FunctionCall &operator=(const FunctionCall &other) { if (&other != this) { if (m_function) m_function->compilationUnit->release(); m_function = other.m_function; m_start = other.m_start; m_end = other.m_end; m_function->compilationUnit->addref(); } return *this; } FunctionCallProperties resolve() const; private: friend bool operator<(const FunctionCall &call1, const FunctionCall &call2); Function *m_function; qint64 m_start; qint64 m_end; }; #define Q_V4_PROFILE_ALLOC(engine, size, type)\ (engine->profiler &&\ (engine->profiler->featuresEnabled & (1 << Profiling::FeatureMemoryAllocation)) ?\ engine->profiler->trackAlloc(size, type) : size) #define Q_V4_PROFILE_DEALLOC(engine, pointer, size, type) \ (engine->profiler &&\ (engine->profiler->featuresEnabled & (1 << Profiling::FeatureMemoryAllocation)) ?\ engine->profiler->trackDealloc(pointer, size, type) : pointer) #define Q_V4_PROFILE(engine, function)\ (engine->profiler &&\ (engine->profiler->featuresEnabled & (1 << Profiling::FeatureFunctionCall)) ?\ Profiling::FunctionCallProfiler::profileCall(engine->profiler, engine, function) :\ function->code(engine, function->codeData)) class Q_QML_EXPORT Profiler : public QObject { Q_OBJECT Q_DISABLE_COPY(Profiler) public: Profiler(QV4::ExecutionEngine *engine); size_t trackAlloc(size_t size, MemoryType type) { MemoryAllocationProperties allocation = {m_timer.nsecsElapsed(), (qint64)size, type}; m_memory_data.append(allocation); return size; } void *trackDealloc(void *pointer, size_t size, MemoryType type) { MemoryAllocationProperties allocation = {m_timer.nsecsElapsed(), -(qint64)size, type}; m_memory_data.append(allocation); return pointer; } quint64 featuresEnabled; public slots: void stopProfiling(); void startProfiling(quint64 features); void reportData(); void setTimer(const QElapsedTimer &timer) { m_timer = timer; } signals: void dataReady(const QVector<QV4::Profiling::FunctionCallProperties> &, const QVector<QV4::Profiling::MemoryAllocationProperties> &); private: QV4::ExecutionEngine *m_engine; QElapsedTimer m_timer; QVector<FunctionCall> m_data; QVector<MemoryAllocationProperties> m_memory_data; friend class FunctionCallProfiler; }; class FunctionCallProfiler { Q_DISABLE_COPY(FunctionCallProfiler) public: // It's enough to ref() the function in the destructor as it will probably not disappear while // it's executing ... FunctionCallProfiler(Profiler *profiler, Function *function) : profiler(profiler), function(function), startTime(profiler->m_timer.nsecsElapsed()) {} ~FunctionCallProfiler() { profiler->m_data.append(FunctionCall(function, startTime, profiler->m_timer.nsecsElapsed())); } static ReturnedValue profileCall(Profiler *profiler, ExecutionEngine *engine, Function *function) { FunctionCallProfiler callProfiler(profiler, function); return function->code(engine, function->codeData); } Profiler *profiler; Function *function; qint64 startTime; }; } // namespace Profiling } // namespace QV4 Q_DECLARE_TYPEINFO(QV4::Profiling::MemoryAllocationProperties, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(QV4::Profiling::FunctionCallProperties, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(QV4::Profiling::FunctionCall, Q_MOVABLE_TYPE); QT_END_NAMESPACE Q_DECLARE_METATYPE(QVector<QV4::Profiling::FunctionCallProperties>) Q_DECLARE_METATYPE(QVector<QV4::Profiling::MemoryAllocationProperties>) #endif // QV4PROFILING_H
/* * Copyright (c) 2020 ARM Limited. * * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #ifndef ARM_COMPUTE_ICLGEMMKERNELSELECTION_H #define ARM_COMPUTE_ICLGEMMKERNELSELECTION_H #include "arm_compute/core/GPUTarget.h" #include "arm_compute/core/Types.h" #include "arm_compute/runtime/CL/CLTypes.h" namespace arm_compute { namespace cl_gemm { /** Basic interface for the GEMM kernel selection */ class ICLGEMMKernelSelection { public: /** Constructor * * @param[in] arch GPU target */ ICLGEMMKernelSelection(GPUTarget arch) : _target(arch) { } /** Default Move Constructor. */ ICLGEMMKernelSelection(ICLGEMMKernelSelection &&) = default; /** Default move assignment operator */ ICLGEMMKernelSelection &operator=(ICLGEMMKernelSelection &&) = default; /** Virtual destructor */ virtual ~ICLGEMMKernelSelection() = default; /** Given the input parameters passed through @ref CLGEMMKernelSelectionParams, this method returns the @ref CLGEMMKernelType to use * * @param[in] params Input parameters used by the function to return the OpenCL GEMM's kernel * * @return @ref CLGEMMKernelType */ virtual CLGEMMKernelType select_kernel(const CLGEMMKernelSelectionParams &params) = 0; protected: GPUTarget _target; /**< GPU target could be used to call a dedicated heuristic for each GPU IP for a given GPU architecture */ }; } // namespace cl_gemm } // namespace arm_compute #endif /*ARM_COMPUTE_ICLGEMMKERNELSELECTION_H */
#pragma G++ optimize("O3") #include <cstdio> #include <cstdlib> #include <cmath> #include <cstring> #include <iostream> #include <algorithm> #include <vector> #include <string> #include <stack> #include <queue> #include <deque> #include <map> #include <set> #include <bitset> using std::cin; using std::cout; using std::endl; typedef int INT; inline INT readIn() { INT a = 0; bool minus = false; char ch = getchar(); while (!(ch == '-' || ch >= '0' && ch <= '9')) ch = getchar(); if (ch == '-') { minus = true; ch = getchar(); } while (ch >= '0' && ch <= '9') { a *= 10; a += ch; a -= '0'; ch = getchar(); } if (minus) a = -a; return a; } inline void printOut(INT x) { if (!x) { putchar('0'); } else { char buffer[12]; INT length = 0; bool minus = x < 0; if (minus) x = -x; while (x) { buffer[length++] = x % 10 + '0'; x /= 10; } if (minus) buffer[length++] = '-'; do { putchar(buffer[--length]); } while (length); } putchar(' '); } const INT maxn = INT(1e6) + 5; INT n, maxc; INT c[maxn]; INT v[maxn]; struct stack : public std::vector<INT> { INT back2() { return std::vector<INT>::operator[](std::vector<INT>::size() - 2); } }; #define RunInstance(x) delete new x struct cheat1 { static const INT maxN = 5005; INT f[maxN]; cheat1() : f() { f[0] = 0; for (int i = 1; i <= n; i++) { f[i] = -1; for (int j = 0; j < i; j++) { if ((i - j) % c[j] || f[j] == -1) continue; INT t = f[j] + (i - j) / c[j] * v[j]; if (f[i] == -1 || f[i] > t) f[i] = t; } printOut(f[i]); } putchar('\n'); } }; struct cheat2 { cheat2() { INT cnt = v[0]; INT sum = 0; for (int i = 1; i <= n; i++) { printOut(sum += cnt); cnt = std::min(cnt, v[i]); } } }; struct work { INT f[maxn]; stack q[11][10]; INT y(INT s) { return c[s] * f[s] - s * v[s]; } INT x(INT s) { return v[s]; } INT y(INT i, INT j) { return y(i) - y(j); } INT x(INT i, INT j) { return x(j) - x(i); } double slope(INT i, INT j) { INT x2 = x(i, j); if (!x2) return 1e100; return double(y(i, j)) / x2; } INT dp(INT i, INT j) { return f[j] + (i - j) / c[j] * v[j]; } work() : f() { f[0] = 0; q[c[0]][0].push_back(0); for (int i = 1; i <= n; i++) { INT& ans = f[i]; ans = -1; for (int j = 1; j <= maxc; j++) { stack& s = q[j][i % j]; if (s.empty()) continue; while (s.size() > 1 && dp(i, s.back()) >= dp(i, s.back2())) s.pop_back(); INT k = s.back(); INT t = dp(i, k); if (ans == -1 || ans > t) ans = t; } printOut(ans); if (i != n && f[i] != -1) { stack& s = q[c[i]][i % c[i]]; while (s.size() && v[s.back()] >= v[i]) s.pop_back(); while (s.size() > 1 && slope(i, s.back()) >= slope(s.back(), s.back2())) s.pop_back(); s.push_back(i); } } } }; void run() { n = readIn(); maxc = readIn(); for (int i = 0; i < n; i++) { c[i] = readIn(); v[i] = readIn(); } //if (n <= 5000) // RunInstance(cheat1); //else if (maxc == 1) // RunInstance(cheat2); //else RunInstance(work); } int main() { #ifndef JUDGE freopen("bus.in", "r", stdin); freopen("bus.out", "w", stdout); #endif run(); return 0; }
// Generated by Creer at 01:31AM on December 23, 2015 UTC, git hash: '1b69e788060071d644dd7b8745dca107577844e1' // Can put out fires completely. #ifndef JOUEUR_ANARCHY_FIREDEPARTMENT_H #define JOUEUR_ANARCHY_FIREDEPARTMENT_H #include "anarchy.h" #include "building.h" // <<-- Creer-Merge: includes -->> - Code you add between this comment and the end comment will be preserved between Creer re-runs. // you can add addtional #includes(s) here. // <<-- /Creer-Merge: includes -->> /// <summary> /// Can put out fires completely. /// </summary> class Anarchy::FireDepartment : public Anarchy::Building { friend Anarchy::GameManager; protected: virtual void deltaUpdateField(const std::string& fieldName, boost::property_tree::ptree& delta); FireDepartment() {}; ~FireDepartment() {}; public: /// <summary> /// The amount of fire removed from a building when bribed to extinguish a building. /// </summary> int fireExtinguished; // <<-- Creer-Merge: fields -->> - Code you add between this comment and the end comment will be preserved between Creer re-runs. // you can add addtional fields(s) here. None of them will be tracked or updated by the server. // <<-- /Creer-Merge: fields -->> /// <summary> /// Bribes this FireDepartment to extinguish the some of the fire in a building. /// </summary> /// <param name="building">The Building you want to extinguish.</param> /// <returns>true if the bribe worked, false otherwise</returns> bool extinguish(Anarchy::Building* building); // <<-- Creer-Merge: methods -->> - Code you add between this comment and the end comment will be preserved between Creer re-runs. // you can add addtional method(s) here. // <<-- /Creer-Merge: methods -->> }; #endif
// // Created by Andri Yadi on 8/1/16. // #include "ESPectroBase_GpioEx.h" ESPectroBase_GpioEx::ESPectroBase_GpioEx(uint8_t address): SX1508(address), i2cDeviceAddress_(address) { } ESPectroBase_GpioEx::~ESPectroBase_GpioEx() { } byte ESPectroBase_GpioEx::begin(byte address, byte resetPin) { byte addr = (address != ESPECTRO_BASE_GPIOEX_ADDRESS)? address: i2cDeviceAddress_; byte res = SX1508::begin(addr, resetPin); if (res) { SX1508::pinMode(ESPECTRO_BASE_GPIOEX_LED_PIN, OUTPUT); clock(INTERNAL_CLOCK_2MHZ, 4); } return res; } void ESPectroBase_GpioEx::turnOnLED() { SX1508::digitalWrite(ESPECTRO_BASE_GPIOEX_LED_PIN, LOW); } void ESPectroBase_GpioEx::turnOffLED() { SX1508::digitalWrite(ESPECTRO_BASE_GPIOEX_LED_PIN, HIGH); } void ESPectroBase_GpioEx::blinkLED(unsigned long tOn, unsigned long tOff, byte onIntensity, byte offIntensity) { blink(ESPECTRO_BASE_GPIOEX_LED_PIN, tOn, tOff, onIntensity, offIntensity); }
/*========================================================================= Program: CMake - Cross-Platform Makefile Generator Module: $RCSfile: cmSeparateArgumentsCommand.cxx,v $ Language: C++ Date: $Date: 2012/03/29 17:21:08 $ Version: $Revision: 1.1.1.1 $ Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "cmSeparateArgumentsCommand.h" // cmSeparateArgumentsCommand bool cmSeparateArgumentsCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) { if(args.size() != 1 ) { this->SetError("called with incorrect number of arguments"); return false; } const char* cacheValue = this->Makefile->GetDefinition(args[0].c_str()); if(!cacheValue) { return true; } std::string value = cacheValue; cmSystemTools::ReplaceString(value," ", ";"); this->Makefile->AddDefinition(args[0].c_str(), value.c_str()); return true; }
// Copyright David Abrahams 2002. Permission to copy, use, // modify, sell and distribute this software is granted provided this // copyright notice appears in all copies. This software is provided // "as is" without express or implied warranty, and with no claim as // to its suitability for any purpose. #ifndef SLICE_NIL_DWA2002620_HPP # define SLICE_NIL_DWA2002620_HPP # include <boost/python/detail/prefix.hpp> namespace boost { namespace python { namespace api { class object; enum slice_nil { # ifndef _ // Watch out for GNU gettext users, who #define _(x) _ # endif }; template <class T> struct slice_bound { typedef object type; }; template <> struct slice_bound<slice_nil> { typedef slice_nil type; }; } using api::slice_nil; # ifndef _ // Watch out for GNU gettext users, who #define _(x) using api::_; # endif }} // namespace boost::python #endif // SLICE_NIL_DWA2002620_HPP
// WARNING: Please don't edit this file. It was generated by C++/WinRT v2.0.201113.7 #ifndef WINRT_Windows_UI_Xaml_Printing_2_H #define WINRT_Windows_UI_Xaml_Printing_2_H #include "winrt/impl/Windows.UI.Xaml.1.h" #include "winrt/impl/Windows.UI.Xaml.Printing.1.h" WINRT_EXPORT namespace winrt::Windows::UI::Xaml::Printing { struct AddPagesEventHandler : Windows::Foundation::IUnknown { AddPagesEventHandler(std::nullptr_t = nullptr) noexcept {} AddPagesEventHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {} template <typename L> AddPagesEventHandler(L lambda); template <typename F> AddPagesEventHandler(F* function); template <typename O, typename M> AddPagesEventHandler(O* object, M method); template <typename O, typename M> AddPagesEventHandler(com_ptr<O>&& object, M method); template <typename O, typename M> AddPagesEventHandler(weak_ref<O>&& object, M method); auto operator()(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Printing::AddPagesEventArgs const& e) const; }; struct GetPreviewPageEventHandler : Windows::Foundation::IUnknown { GetPreviewPageEventHandler(std::nullptr_t = nullptr) noexcept {} GetPreviewPageEventHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {} template <typename L> GetPreviewPageEventHandler(L lambda); template <typename F> GetPreviewPageEventHandler(F* function); template <typename O, typename M> GetPreviewPageEventHandler(O* object, M method); template <typename O, typename M> GetPreviewPageEventHandler(com_ptr<O>&& object, M method); template <typename O, typename M> GetPreviewPageEventHandler(weak_ref<O>&& object, M method); auto operator()(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Printing::GetPreviewPageEventArgs const& e) const; }; struct PaginateEventHandler : Windows::Foundation::IUnknown { PaginateEventHandler(std::nullptr_t = nullptr) noexcept {} PaginateEventHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {} template <typename L> PaginateEventHandler(L lambda); template <typename F> PaginateEventHandler(F* function); template <typename O, typename M> PaginateEventHandler(O* object, M method); template <typename O, typename M> PaginateEventHandler(com_ptr<O>&& object, M method); template <typename O, typename M> PaginateEventHandler(weak_ref<O>&& object, M method); auto operator()(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Printing::PaginateEventArgs const& e) const; }; struct __declspec(empty_bases) AddPagesEventArgs : Windows::UI::Xaml::Printing::IAddPagesEventArgs { AddPagesEventArgs(std::nullptr_t) noexcept {} AddPagesEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Xaml::Printing::IAddPagesEventArgs(ptr, take_ownership_from_abi) {} AddPagesEventArgs(); }; struct __declspec(empty_bases) GetPreviewPageEventArgs : Windows::UI::Xaml::Printing::IGetPreviewPageEventArgs { GetPreviewPageEventArgs(std::nullptr_t) noexcept {} GetPreviewPageEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Xaml::Printing::IGetPreviewPageEventArgs(ptr, take_ownership_from_abi) {} GetPreviewPageEventArgs(); }; struct __declspec(empty_bases) PaginateEventArgs : Windows::UI::Xaml::Printing::IPaginateEventArgs { PaginateEventArgs(std::nullptr_t) noexcept {} PaginateEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Xaml::Printing::IPaginateEventArgs(ptr, take_ownership_from_abi) {} PaginateEventArgs(); }; struct __declspec(empty_bases) PrintDocument : Windows::UI::Xaml::Printing::IPrintDocument, impl::base<PrintDocument, Windows::UI::Xaml::DependencyObject>, impl::require<PrintDocument, Windows::UI::Xaml::IDependencyObject, Windows::UI::Xaml::IDependencyObject2> { PrintDocument(std::nullptr_t) noexcept {} PrintDocument(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Xaml::Printing::IPrintDocument(ptr, take_ownership_from_abi) {} PrintDocument(); [[nodiscard]] static auto DocumentSourceProperty(); }; } #endif
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */ /* $Id: osaTrajectory.h 4202 2013-05-17 15:39:06Z adeguet1 $ Author(s): Simon Leonard Created on: 2012 (C) Copyright 2012-2014 Johns Hopkins University (JHU), All Rights Reserved. --- begin cisst license - do not edit --- This software is provided "as is" under an open source license, with no warranty. The complete license can be found in license.txt and http://www.cisst.org/cisst/license.txt. --- end cisst license --- */ #ifndef _osaTrajectory_h #define _osaTrajectory_h #include <cisstRobot/robFunction.h> #include <cisstRobot/robManipulator.h> #include <cisstVector/vctFrame4x4.h> #include <cisstVector/vctDynamicVectorTypes.h> #include <list> #include <sawTrajectories/sawTrajectoriesExport.h> class CISST_EXPORT osaTrajectory : public robManipulator{ public: enum Errno { ESUCCESS, EPENDING, EEXPIRED, EEMPTY, EUNSUPPORTED, ETRANSITION, EINVALID }; private: double currenttime; vctDynamicVector<double> q; robFunction* function; enum Space{ R3, RN, SO3, SE3 }; // segment base class class Segment{ private: osaTrajectory::Space inspace; osaTrajectory::Space outspace; protected: double duration; public: Segment( osaTrajectory::Space is, osaTrajectory::Space os ) : inspace( is ), outspace( os ), duration( -1.0 ){} virtual ~Segment() {} virtual osaTrajectory::Space InputSpace() const { return inspace; } virtual osaTrajectory::Space OutputSpace() const { return outspace; } }; std::list< osaTrajectory::Segment* > segments; osaTrajectory::Errno LoadNextSegment(); // Inverse kinematics segment class IKSegment : public Segment { private: vctFrame4x4<double> Rtstart; /**< start Cartesian position */ vctFrame4x4<double> Rtfinal; /**< final Carteisan position */ double v; /**< linear velocity */ double w; /**< angular velocity */ public: IKSegment( const vctFrame4x4<double>& Rts, const vctFrame4x4<double>& Rtf, double v, double w); //! Get segment start position (Cartesian pos 4x4 matrix) vctFrame4x4<double> StateStart() const { return Rtstart; } //! Get segment final position (Cartesian pos 4x4 matrix) vctFrame4x4<double> StateFinal() const { return Rtfinal; } //! Get segment linear velocity double VelocityLinear() const { return v; } //! Get segment angular velocity double VelocityAngular() const { return w; } }; // IK segment // ZC: NOT USED ? // Forward kinematics segment class FKSegment : public Segment { private: vctDynamicVector<double> qstart; vctDynamicVector<double> qfinal; public: FKSegment( const vctDynamicVector<double>& qs, const vctDynamicVector<double>& qf, double ) : Segment( osaTrajectory::SE3, osaTrajectory::RN ), qstart( qs ), qfinal( qf ){} //! Get segment start position (joint space ??? ZC) vctDynamicVector<double> StateStart() const { return qstart; } //! Get segment final position (joint space ??? ZC) vctDynamicVector<double> StateFinal() const { return qfinal; } }; // FK segment // Joint segment class RnSegment : public Segment { private: vctDynamicVector<double> qstart; /**< start joint position */ vctDynamicVector<double> qfinal; /**< final joint position */ vctDoubleVec vel; /**< joint velocity */ public: RnSegment( const vctDynamicVector<double>& qs, const vctDynamicVector<double>& qf, double ); //! Get segment start position (joint space ??? ZC) vctDynamicVector<double> StateStart() const { return qstart; } //! Get segment final position (joint space ??? ZC) vctDynamicVector<double> StateFinal() const { return qfinal; } //! Get segment linear velocity vctDoubleVec VelocityJoint() const { return vel; } }; // Joint segment double GetTime() const { return currenttime; } void SetTime( double t ){ currenttime = t; } osaTrajectory::Errno PostProcess(); public: osaTrajectory( const std::string& robotfilename, const vctFrame4x4<double>& Rtw0, const vctDynamicVector<double>& qinit ); /** * @brief Insert inverse kinematic segment * * @param Rt2 * @param vmax * @param wmax * @return osaTrajectory::Errno Error number */ osaTrajectory::Errno InsertIK( const vctFrame4x4<double>& Rt2, double vmax, double wmax ); osaTrajectory::Errno Insert( const vctFrame4x4<double>& Rt2, double dt ); osaTrajectory::Errno Evaluate( double t, vctFrame4x4<double>& Rt, vctDynamicVector<double>& q ); friend std::ostream& operator<<( std::ostream& os, const osaTrajectory::Errno& e ){ switch( e ){ case osaTrajectory::ESUCCESS: os << "SUCCESS"; break; case osaTrajectory::EPENDING: os << "EPENDING"; break; case osaTrajectory::EEXPIRED: os << "EEXPIRED"; break; case osaTrajectory::EEMPTY: os << "EEMPTY"; break; case osaTrajectory::EUNSUPPORTED: os << "EUNSUPPORTED"; break; case osaTrajectory::ETRANSITION: os << "ETRANSITION"; break; case osaTrajectory::EINVALID: os << "EINVALID"; break; } return os; } }; #endif // _osaTrajectory_h
End of preview. Expand in Data Studio
README.md exists but content is empty.
Downloads last month
16