vector<int> searchRange(vector<int>& nums, int target) {
vector<int> res{-1, -1};
if (nums.empty() || nums[0] > target || nums[nums.size()-1] < target) return res;
int l = 0, r = nums.size() - 1, mid = 0;
int start = -1, end = -1;
while (l < r)
{
mid = (l + r) / 2 + 1;
if (nums[mid] == target)
{
vector<int> ltmp(nums.begin() + l, nums.begin() + mid);
vector<int> rtmp(nums.begin()+mid+1, nums.begin()+r+1);
auto lvec = searchRange(ltmp, target), rvec = searchRange(rtmp, target);
if (lvec != res) start = lvec[0] + l;
else start = mid;
if (rvec != res) end = rvec[1] + mid + 1;
else end = mid;
break;
}
else if (nums[mid] < target) l = mid + 1;
else r = mid - 1;
}
if (start == -1 && end == -1 && nums[l] == target && l == r) start = end = l;
res[0] = start;
res[1] = end;
return res;
}
std::vector<std::pair<cord,T> > quadtree<T>::searchRange(
node<T> *nd, cord start,cord end )
{
std::vector<std::pair<cord, T> > results;
std::vector<std::pair<cord, T> > quad;
if(nd == nullptr) return results;
if(nd->first != nullptr)
{
cord q1start(nd->first->x.first,nd->first->y.first);
cord q1end(nd->first->x.second,nd->first->y.second);
cord q2start(nd->second->x.first,nd->second->y.first);
cord q2end(nd->second->x.second,nd->second->y.second);
cord q3start(nd->third->x.first,nd->third->y.first);
cord q3end(nd->third->x.second,nd->third->y.second);
cord q4start(nd->fourth->x.first,nd->fourth->y.first);
cord q4end(nd->fourth->x.second,nd->fourth->y.second);
if(overlapRect(q1start,q1end,start,end))
{
quad = searchRange(nd->first,start,end);
results.insert(results.end(),quad.begin(),quad.end());
}
if(overlapRect(q2start,q2end,start,end))
{
quad = searchRange(nd->second,start,end);
results.insert(results.end(),quad.begin(),quad.end());
}
if(overlapRect(q3start,q3end,start,end))
{
quad = searchRange(nd->third,start,end);
results.insert(results.end(),quad.begin(),quad.end());
}
if(overlapRect(q4start,q4end,start,end))
{
quad = searchRange(nd->fourth,start,end);
results.insert(results.end(),quad.begin(),quad.end());
}
} else {
for(auto i:nd->objects)
{
if(i.first.first < end.first && i.first.first > start.first
&& i.first.second > end.second && i.first.second < start.second)
results.push_back(i);
}
}
return results;
}
void searchRange(TreeNode* root, int k1, int k2, vector<int> &range) {
if (NULL == root) {
return;
}
searchRange(root->left, k1, k2, range);
if (k1 <= root->val && root->val <= k2) {
range.push_back(root->val);
}
searchRange(root->right, k1, k2, range);
}
int main(void)
{
int arr[] = { 5, 7, 7, 8, 8, 10, };
int *a, n;
a = searchRange(arr, sizeof(arr) / sizeof(arr[0]), 8, &n);
return(0);
}
static PassRefPtr<Range> makeSearchRange(const Position& pos)
{
Node* n = pos.node();
if (!n)
return 0;
Document* d = n->document();
Node* de = d->documentElement();
if (!de)
return 0;
Node* boundary = n->enclosingBlockFlowElement();
if (!boundary)
return 0;
RefPtr<Range> searchRange(Range::create(d));
ExceptionCode ec = 0;
Position start(rangeCompliantEquivalent(pos));
searchRange->selectNodeContents(boundary, ec);
searchRange->setStart(start.node(), start.deprecatedEditingOffset(), ec);
ASSERT(!ec);
if (ec)
return 0;
return searchRange.release();
}
JSValue JSInspectorFrontendHost::search(ExecState* exec, const ArgList& args)
{
if (args.size() < 2)
return jsUndefined();
Node* node = toNode(args.at(0));
if (!node)
return jsUndefined();
String target = args.at(1).toString(exec);
if (exec->hadException())
return jsUndefined();
MarkedArgumentBuffer result;
RefPtr<Range> searchRange(rangeOfContents(node));
ExceptionCode ec = 0;
do {
RefPtr<Range> resultRange(findPlainText(searchRange.get(), target, true, false));
if (resultRange->collapsed(ec))
break;
// A non-collapsed result range can in some funky whitespace cases still not
// advance the range's start position (4509328). Break to avoid infinite loop.
VisiblePosition newStart = endVisiblePosition(resultRange.get(), DOWNSTREAM);
if (newStart == startVisiblePosition(searchRange.get(), DOWNSTREAM))
break;
result.append(toJS(exec, resultRange.get()));
setStart(searchRange.get(), newStart);
} while (true);
return constructArray(exec, result);
}
void SpellChecker::markMisspellingsOrBadGrammar(const VisibleSelection& selection, bool checkSpelling, RefPtr<Range>& firstMisspellingRange)
{
// This function is called with a selection already expanded to word boundaries.
// Might be nice to assert that here.
// This function is used only for as-you-type checking, so if that's off we do nothing. Note that
// grammar checking can only be on if spell checking is also on.
if (!isContinuousSpellCheckingEnabled())
return;
RefPtr<Range> searchRange(selection.toNormalizedRange());
if (!searchRange)
return;
// If we're not in an editable node, bail.
Node* editableNode = searchRange->startContainer();
if (!editableNode || !editableNode->hasEditableStyle())
return;
if (!isSpellCheckingEnabledFor(editableNode))
return;
TextCheckingHelper checker(spellCheckerClient(), searchRange);
if (checkSpelling)
checker.markAllMisspellings(firstMisspellingRange);
else if (isGrammarCheckingEnabled())
checker.markAllBadGrammar();
}
static PassRefPtrWillBeRawPtr<Range> makeSearchRange(const Position& pos)
{
Node* node = pos.deprecatedNode();
if (!node)
return nullptr;
Document& document = node->document();
if (!document.documentElement())
return nullptr;
Element* boundary = enclosingBlockFlowElement(*node);
if (!boundary)
return nullptr;
RefPtrWillBeRawPtr<Range> searchRange(Range::create(document));
TrackExceptionState exceptionState;
Position start(pos.parentAnchoredEquivalent());
searchRange->selectNodeContents(boundary, exceptionState);
searchRange->setStart(start.containerNode(), start.offsetInContainerNode(), exceptionState);
ASSERT(!exceptionState.hadException());
if (exceptionState.hadException())
return nullptr;
return searchRange.release();
}
static PassRefPtr<Range> makeSearchRange(const Position& pos)
{
Node* n = pos.deprecatedNode();
if (!n)
return 0;
Document& d = n->document();
Node* de = d.documentElement();
if (!de)
return 0;
Node* boundary = n->enclosingBlockFlowElement();
if (!boundary)
return 0;
RefPtr<Range> searchRange(Range::create(d));
TrackExceptionState es;
Position start(pos.parentAnchoredEquivalent());
searchRange->selectNodeContents(boundary, es);
searchRange->setStart(start.containerNode(), start.offsetInContainerNode(), es);
ASSERT(!es.hadException());
if (es.hadException())
return 0;
return searchRange.release();
}
static PassRefPtr<Range> makeSearchRange(const Position& pos)
{
Node* n = pos.deprecatedNode();
if (!n)
return 0;
Node* de = n->document().documentElement();
if (!de)
return 0;
Element* boundary = deprecatedEnclosingBlockFlowElement(n);
if (!boundary)
return 0;
RefPtr<Range> searchRange(Range::create(n->document()));
ExceptionCode ec = 0;
Position start(pos.parentAnchoredEquivalent());
searchRange->selectNodeContents(boundary, ec);
searchRange->setStart(start.containerNode(), start.offsetInContainerNode(), ec);
ASSERT(!ec);
if (ec)
return 0;
return searchRange.release();
}
int main() {
int nums[] = { 1 };
int target = 0, returnSize;
int *ans = searchRange(nums, sizeof(nums) / sizeof(int), target, &returnSize);
printf("%d\t%d\n", ans[0], ans[1]);
system("pause");
return 0;
}
int main(int argc, char *argv[])
{
//int nums[] = {1};int size;
int nums[] = {5, 7, 7, 8, 8, 10};int size;
int *p = searchRange(nums, sizeof(nums) / 4, 8, &size);
printf("%d, %d\n", p[0], p[1]);
return 0;
}
int main(void)
{
int *res, n;
int x[] = { 5, 7, 7, 8, 8, 10 };
res = searchRange(x, 6, 8, &n);
printf("%d %d\n", res[0], res[1]);
return(0);
}
vector<int> searchRange(TreeNode* root, int k1, int k2)
{
if(root==NULL)
return result;
if(root->val>k2)
{
searchRange(root->left,k1,k2);
}
else if(root->val<k1)
{
searchRange(root->right,k1,k2);
}
else
{
searchRange(root->left,k1,k2);
result.push_back(root->val);
searchRange(root->right,k1,k2);
}
return result;
}
int main() {
int nums[] = {5, 7};
int numsSize = 2;
int target = 10;
int returnSize;
int i;
int *result;
result = searchRange(nums, numsSize, target, &returnSize);
for (i = 0; i < returnSize; i++) {
printf("%d\n", result[i]);
}
return 0;
}
static JSValueRef search(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
{
InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
if (!controller)
return JSValueMakeUndefined(ctx);
if (argumentCount < 2 || !JSValueIsString(ctx, arguments[1]))
return JSValueMakeUndefined(ctx);
Node* node = toNode(toJS(arguments[0]));
if (!node)
return JSValueMakeUndefined(ctx);
JSStringRef string = JSValueToStringCopy(ctx, arguments[1], 0);
String target(JSStringGetCharactersPtr(string), JSStringGetLength(string));
JSStringRelease(string);
JSObjectRef globalObject = JSContextGetGlobalObject(ctx);
JSStringRef constructorString = JSStringCreateWithUTF8CString("Array");
JSObjectRef arrayConstructor = JSValueToObject(ctx, JSObjectGetProperty(ctx, globalObject, constructorString, 0), 0);
JSStringRelease(constructorString);
JSObjectRef array = JSObjectCallAsConstructor(ctx, arrayConstructor, 0, 0, 0);
JSStringRef pushString = JSStringCreateWithUTF8CString("push");
JSValueRef pushValue = JSObjectGetProperty(ctx, array, pushString, 0);
JSStringRelease(pushString);
JSObjectRef push = JSValueToObject(ctx, pushValue, 0);
RefPtr<Range> searchRange(rangeOfContents(node));
int exception = 0;
do {
RefPtr<Range> resultRange(findPlainText(searchRange.get(), target, true, false));
if (resultRange->collapsed(exception))
break;
// A non-collapsed result range can in some funky whitespace cases still not
// advance the range's start position (4509328). Break to avoid infinite loop.
VisiblePosition newStart = endVisiblePosition(resultRange.get(), DOWNSTREAM);
if (newStart == startVisiblePosition(searchRange.get(), DOWNSTREAM))
break;
KJS::JSLock lock;
JSValueRef arg0 = toRef(toJS(toJS(ctx), resultRange.get()));
JSObjectCallAsFunction(ctx, push, array, 1, &arg0, 0);
setStart(searchRange.get(), newStart);
} while (true);
return array;
}
int main() {
int n, target;
while (cin >> n >> target) {
int temp;
vector<int> nums;
for (int i = 0; i < n; i++) {
cin >> temp;
nums.push_back(temp);
}
vector<int> result = searchRange(nums, target);
cout << result[0] << " " << result[1] << endl;
}
return 0;
}
std::vector<std::pair<cord,T> > quadtree<T>::searchRange( cord start, cord end )
{
return searchRange(root,start,end);
}
void InPageSearchManager::scopeStringMatches(const String& text, bool reset, Frame* scopingFrame)
{
if (reset) {
m_activeMatchCount = 0;
m_resumeScopingFromRange = 0;
m_scopingComplete = false;
m_locatingActiveMatch = true;
// New search should always start from mainFrame.
scopeStringMatchesSoon(m_webPage->mainFrame(), text, false /* reset */);
return;
}
if (m_resumeScopingFromRange && scopingFrame != m_resumeScopingFromRange->ownerDocument()->frame())
m_resumeScopingFromRange = 0;
RefPtr<Range> searchRange(rangeOfContents(scopingFrame->document()));
Node* originalEndContainer = searchRange->endContainer();
int originalEndOffset = searchRange->endOffset();
ExceptionCode ec = 0, ec2 = 0;
if (m_resumeScopingFromRange) {
searchRange->setStart(m_resumeScopingFromRange->startContainer(), m_resumeScopingFromRange->startOffset(ec2) + 1, ec);
if (ec || ec2) {
m_scopingComplete = true; // We should stop scoping because of some stale data.
return;
}
}
int matchCount = 0;
bool timeout = false;
double startTime = currentTime();
do {
RefPtr<Range> resultRange(findPlainText(searchRange.get(), text, CaseInsensitive));
if (resultRange->collapsed(ec)) {
if (!resultRange->startContainer()->isInShadowTree())
break;
searchRange->setStartAfter(resultRange->startContainer()->shadowAncestorNode(), ec);
searchRange->setEnd(originalEndContainer, originalEndOffset, ec);
continue;
}
if (scopingFrame->editor()->insideVisibleArea(resultRange.get())) {
++matchCount;
bool foundActiveMatch = false;
if (m_locatingActiveMatch && areRangesEqual(resultRange.get(), m_activeMatch.get())) {
foundActiveMatch = true;
m_locatingActiveMatch = false;
m_activeMatchIndex = m_activeMatchCount + matchCount;
// FIXME: We need to notify client with m_activeMatchIndex.
}
resultRange->ownerDocument()->markers()->addTextMatchMarker(resultRange.get(), foundActiveMatch);
}
searchRange->setStart(resultRange->endContainer(ec), resultRange->endOffset(ec), ec);
Node* shadowTreeRoot = searchRange->shadowTreeRootNode();
if (searchRange->collapsed(ec) && shadowTreeRoot)
searchRange->setEnd(shadowTreeRoot, shadowTreeRoot->childNodeCount(), ec);
m_resumeScopingFromRange = resultRange;
timeout = (currentTime() - startTime) >= MaxScopingDuration;
} while (!timeout);
if (matchCount > 0) {
scopingFrame->editor()->setMarkedTextMatchesAreHighlighted(true /* highlight */);
m_activeMatchCount += matchCount;
}
if (timeout)
scopeStringMatchesSoon(scopingFrame, text, false /* reset */);
else {
// Scoping is done for this frame.
Frame* nextFrame = DOMSupport::incrementFrame(scopingFrame, true /* forward */, false /* wrapFlag */);
if (!nextFrame) {
m_scopingComplete = true;
return; // Scoping is done for all frames;
}
scopeStringMatchesSoon(nextFrame, text, false /* reset */);
}
}
/**
* @param root: The root of the binary search tree.
* @param k1 and k2: range k1 to k2.
* @return: Return all keys that k1<=key<=k2 in ascending order.
*/
vector<int> searchRange(TreeNode* root, int k1, int k2) {
// write your code here
vector<int> range;
searchRange(root, k1, k2, range);
return range;
}
void InPageSearchManager::scopeStringMatches(const String& text, bool reset, bool locateActiveMatchOnly, Frame* scopingFrame)
{
if (reset) {
if (!locateActiveMatchOnly) {
m_activeMatchCount = 0;
m_scopingComplete = false;
}
m_resumeScopingFromRange = 0;
m_locatingActiveMatch = true;
m_activeMatchIndex = 0;
// New search should always start from mainFrame.
scopeStringMatchesSoon(m_webPage->mainFrame(), text, false /* reset */, locateActiveMatchOnly);
return;
}
if (m_resumeScopingFromRange && scopingFrame != m_resumeScopingFromRange->ownerDocument().frame())
m_resumeScopingFromRange = 0;
RefPtr<Range> searchRange(rangeOfContents(scopingFrame->document()));
Node* originalEndContainer = searchRange->endContainer();
int originalEndOffset = searchRange->endOffset();
ExceptionCode ec = 0, ec2 = 0;
if (m_resumeScopingFromRange) {
searchRange->setStart(m_resumeScopingFromRange->startContainer(), m_resumeScopingFromRange->startOffset(ec2) + 1, ec);
if (ec || ec2) {
m_scopingComplete = true; // We should stop scoping because of some stale data.
return;
}
}
int matchCount = 0;
bool timeout = false;
double startTime = currentTime();
do {
RefPtr<Range> resultRange(findPlainText(searchRange.get(), text, m_scopingCaseInsensitive ? CaseInsensitive : 0));
if (resultRange->collapsed(ec)) {
if (!resultRange->startContainer()->isInShadowTree())
break;
searchRange->setStartAfter(resultRange->startContainer()->deprecatedShadowAncestorNode(), ec);
searchRange->setEnd(originalEndContainer, originalEndOffset, ec);
continue;
}
++matchCount;
bool foundActiveMatch = false;
if (m_locatingActiveMatch && areRangesEqual(resultRange.get(), m_activeMatch.get())) {
foundActiveMatch = true;
m_locatingActiveMatch = false;
if (locateActiveMatchOnly) {
m_activeMatchIndex += matchCount;
m_webPage->m_client->updateFindStringResult(m_activeMatchCount, m_activeMatchIndex);
return;
}
m_activeMatchIndex = m_activeMatchCount + matchCount;
}
if (!locateActiveMatchOnly && m_highlightAllMatches)
resultRange->ownerDocument().markers().addTextMatchMarker(resultRange.get(), foundActiveMatch);
searchRange->setStart(resultRange->endContainer(ec), resultRange->endOffset(ec), ec);
ShadowRoot* shadowTreeRoot = searchRange->shadowRoot();
if (searchRange->collapsed(ec) && shadowTreeRoot)
searchRange->setEnd(shadowTreeRoot, shadowTreeRoot->childNodeCount(), ec);
m_resumeScopingFromRange = resultRange;
timeout = (currentTime() - startTime) >= MaxScopingDuration;
} while (!timeout);
if (matchCount > 0) {
if (locateActiveMatchOnly) {
// We have not found it yet.
// m_activeMatchIndex now temporarily remember where we left over in this time slot.
m_activeMatchIndex += matchCount;
} else {
if (m_highlightAllMatches)
scopingFrame->editor().setMarkedTextMatchesAreHighlighted(true /* highlight */);
m_activeMatchCount += matchCount;
m_webPage->m_client->updateFindStringResult(m_activeMatchCount, m_activeMatchIndex);
}
}
if (timeout)
scopeStringMatchesSoon(scopingFrame, text, false /* reset */, locateActiveMatchOnly);
else {
// Scoping is done for this frame.
Frame* nextFrame = DOMSupport::incrementFrame(scopingFrame, true /* forward */, false /* wrapFlag */);
if (!nextFrame) {
m_scopingComplete = true;
return; // Scoping is done for all frames;
}
scopeStringMatchesSoon(nextFrame, text, false /* reset */, locateActiveMatchOnly);
}
}
int main(){
int arr[] = {2,2};
vector<int> nums(arr, arr + sizeof(arr) / sizeof(int));
print_int(searchRange(nums,2));
return 0;
}
int main(){
int arr[] = {5};
vector<int> nums ( arr , arr + sizeof(arr) / sizeof(int));
printVector( searchRange(nums, 5));
return 0;
}
void Barbarian::_check4attack()
{
auto movables = empire()->objects().select<MovableObject>();
movables.remove( this );
std::map< int, MovableObjectPtr > distanceMap;
for( auto obj : movables )
{
float distance = location().distanceTo( obj->location() );
distanceMap[ (int)distance ] = obj;
}
for( auto& item : distanceMap )
{
if( item.first < config::barbarian::attackRange )
{
_attackObject( item.second.as<Object>() );
break;
}
else if( item.first < searchRange() )
{
bool validWay = _findWay( location(), item.second->location() );
if( validWay )
{
_d->mode = Impl::go2object;
break;
}
}
}
if( _way().empty() )
{
CityList cities = empire()->cities();
std::map< int, CityPtr > citymap;
DateTime currentDate = game::Date::current();
for( auto city : cities )
{
if( city->states().population < (unsigned int)_d->minPop4attack )
continue;
float distance = location().distanceTo( city->location() );
int month2lastAttack = math::clamp<int>( DateTime::monthsInYear - city->lastAttack().monthsTo( currentDate ), 0, DateTime::monthsInYear );
citymap[ month2lastAttack * 100 + (int)distance ] = city;
}
for( auto& item : citymap )
{
bool validWay = _findWay( location(), item.second->location() );
if( validWay )
{
_d->mode = Impl::go2object;
events::GameEventPtr e = events::Notify::attack( item.second->name(), "##barbaria_attack_empire_city##", this );
e->dispatch();
break;
}
}
}
}
vector<int> searchRange(TreeNode* root, int k1, int k2) {
// write your code here
vector<int> result;
searchRange(root, k1, k2,result);
return result;
}
int scanBam()
{
std::vector< std::map<std::string, ScanResults> > resultlist;
// std::ostream* pWriter;
// pWriter = &std::cout;
bool isExome = opt::exomebedfile.size()==0? false: true;
std::cout << opt::bamlist << "\n";
std::cout << opt::bamlist.size() << " BAMs" << std::endl;
for(std::size_t i=0; i<opt::bamlist.size(); i++) {
// storing results for each read group (RG tag). use
// read group ID as key.
std::map<std::string, ScanResults> resultmap;
// store where the overlap was last found in the case of exome seq
std::map<std::string, std::vector<range>::iterator> lastfound;
std::vector<range>::iterator searchhint;
std::cerr << "Start analysing BAM " << opt::bamlist[i] << "\n";
// Open the bam files for reading/writing
BamTools::BamReader* pBamReader = new BamTools::BamReader;
pBamReader->Open(opt::bamlist[i]);
// get bam headers
const BamTools::SamHeader header = pBamReader ->GetHeader();
// for(BamTools::SamSequenceConstIterator it = header.Sequences.Begin();
// it != header.Sequences.End();++it){
// std::cout << "Assembly ID:" << it->AssemblyID << ", Name:" << it->Name << std::endl;
// }
// exit(0);
bool rggroups=false;
if(opt::ignorerg){ // ignore read groups
std::cerr << "Treat all reads in BAM as if they were from a same sample" << std::endl;
ScanResults results;
results.sample = opt::unknown;
resultmap[opt::unknown]=results;
}else{
std::map <std::string, std::string> readgroups;
std::map <std::string, std::string> readlibs;
rggroups = header.HasReadGroups();
if(rggroups){
for(BamTools::SamReadGroupConstIterator it = header.ReadGroups.Begin();
it != header.ReadGroups.End();++it){
readgroups[it->ID]= it->Sample;
if(it->HasLibrary()){
readlibs[it->ID] = it -> Library;
}else{
readlibs[it->ID] = opt::unknown;
}
}
std::cerr<<"Specified BAM has "<< readgroups.size()<< " read groups" << std::endl;
for(std::map<std::string, std::string>::iterator it = readgroups.begin(); it != readgroups.end(); ++it){
ScanResults results;
std::string rgid = it -> first;
results.sample = it -> second;
results.lib = readlibs[rgid];
resultmap[rgid]=results; //results are identified by RG tag.
}
}else{
std::cerr << "Warning: can't find RG tag in the BAM header" << std::endl;
std::cerr << "Warning: treat all reads in BAM as if they were from a same sample" << std::endl;
ScanResults results;
results.sample = opt::unknown;
results.lib = opt::unknown;
resultmap[opt::unknown]=results;
}
}
BamTools::BamAlignment record1;
bool done = false;
int nprocessed=0; // number of reads analyzed
int ntotal=0; // number of reads scanned in bam (we skip some reads, see below)
while(!done)
{
ntotal ++;
done = !pBamReader -> GetNextAlignment(record1);
std::string tag = opt::unknown;
if(rggroups){
// skip reads that do not have read group tag
if(record1.HasTag("RG")){
record1.GetTag("RG", tag);
// std::cerr << c << " reads:{" << record1.QueryBases << "} tag:{" << tag << "}\n";
}else{
std::cerr << "can't find RG tag for read at position {" << record1.RefID << ":" << record1.Position << "}" << std::endl;
std::cerr << "skip this read" << std::endl;
continue;
}
}
// skip reads with readgroup not defined in BAM header
if(resultmap.find(tag) == resultmap.end()){
std::cerr << "RG tag {" << tag << "} for read at position ";
std::cerr << "{" << record1.RefID << ":" << record1.Position << "} doesn't exist in BAM header.";
continue;
}
// for exome, exclude reads mapped to the exome regions.
if(isExome){
range rg;
rg.first = record1.Position;
rg.second = record1.Position + record1.Length;
std::string chrm = refID2Name(record1.RefID);
if(chrm != "-1"){ // check if overlap exome when the read is mapped to chr1-22, X, Y
// std::cerr << "read: " << chrm << " " << rg << "\n" << std::endl;
std::map<std::string, std::vector<range> >::iterator chrmit = opt::exomebed.find(chrm);
if(chrmit == opt::exomebed.end())
{
// std::cerr<<"chromosome or reference sequence: " << chrm << " is not present in the specified exome bed file." <<std::endl;
// std::cerr<<"please check sequence name encoding, i.e. for chromosome one, is it chr1 or 1" << std::endl;
// unmapped reads can have chr names as a star (*). We also don't consider MT reads.
resultmap[tag].n_exreadsChrUnmatched +=1;
}else{
std::vector<range>::iterator itend = opt::exomebed[chrm].end();
std::map<std::string, std::vector<range>::iterator>::iterator lastfoundchrmit = lastfound.find(chrm);
if(lastfoundchrmit == lastfound.end()){ // first entry to this chrm
lastfound[chrm] = chrmit->second.begin();// start from begining
}
// set the hint to where the previous found is
searchhint = lastfound[chrm];
std::vector<range>::iterator itsearch = searchRange(searchhint, itend, rg);
// if found
if(itsearch != itend){// if found
searchhint = itsearch;
resultmap[tag].n_exreadsExcluded +=1;
lastfound[chrm] = searchhint; // update search hint
continue;
}
}
}
}
resultmap[tag].numTotal +=1;
if(record1.IsMapped())
{
resultmap[tag].numMapped += 1;
}
if(record1.IsDuplicate()){
resultmap[tag].numDuplicates +=1;
}
double gc = calcGC(record1.QueryBases);
int ptn_count = countMotif(record1.QueryBases, opt::PATTERN, opt::PATTERN_REV);
// when the read length exceeds 100bp, number of patterns might exceed the boundary
if (ptn_count > ScanParameters::TEL_MOTIF_N-1){
continue;
}
resultmap[tag].telcounts[ptn_count]+=1;
if(gc >= ScanParameters::GC_LOWERBOUND && gc <= ScanParameters::GC_UPPERBOUND){
// get index for GC bin.
int idx = floor((gc-ScanParameters::GC_LOWERBOUND)/ScanParameters::GC_BINSIZE);
assert(idx >=0 && idx <= ScanParameters::GC_BIN_N-1);
// std::cerr << c << " GC:{"<< gc << "} telcounts:{"<< ptn_count <<"} GC idx{" << idx << "}\n";
if(idx > ScanParameters::GC_BIN_N-1){
std::cerr << nprocessed << " GC:{"<< gc << "} telcounts:{"<< ptn_count <<"} GC bin index out of bound:" << idx << "\n";
exit(EXIT_FAILURE);
}
resultmap[tag].gccounts[idx]+=1;
}
// if(resultmap[tag].n_exreadsChrUnmatched > 1000){
// std::cerr<<"too many reads found with unmatched chromosome ID between BAM and exome BED. \n" << std::endl;
// }
nprocessed++;
if( nprocessed%10000000 == 0){
std::cerr << "[scan] processed " << nprocessed << " reads \n" ;
}
}
pBamReader->Close();
delete pBamReader;
// consider each BAM separately
resultlist.push_back(resultmap);
std::cerr << "[scan] total reads in BAM scanned " << ntotal << std::endl;
std::cerr << "Completed scanning BAM\n";
}
if(opt::onebam){
merge_results_by_readgroup(resultlist);
}
outputresults(resultlist);
if(isExome){
printlog(resultlist);
}
std::cerr << "Completed writing results\n";
return 0;
}
