int main(){ char map[MARGIN_X][MARGIN_Y] = { "#############", "#GG.GGG#GGG.#", "###.#G#G#G#G#", "#.......#..G#", "#G#.###.#G#G#", "#GG.GGG.#.GG#", "#G#.#G#.#.#.#", "##G...G.....#", "#G#.#G###.#G#", "#...G#GGG.GG#", "#G#.#G#G#.#G#", "#GG.GGG#G.GG#", "#############" }; int max,m_x,m_y; m_x = 3; m_y = 3; max = statistic(3,3,map); book[3][3] = 1; dfs_bomber(3,3,&max,&m_x,&m_y,map); printf("(%d,%d) max is %d\n",m_x,m_y,max); return 0; }
int main(void) { int number1, number2; printf("Please input two integer numbers: "); scanf("%d %d", &number1, &number2); printf("The number of the same digits between %d and %d is %d\n",number1, number2, statistic(number1,number2)); return 0; }
void RingBuffer::skip(int len) { m_head += len; if (m_head >= m_size) { m_head = 0; LOG_WARN << "restart"; statistic(); exit(0); } }
bool PcapParser::Parse(const std::string& dataFile) { char errbuf[PCAP_ERRBUF_SIZE]={0}; pcap_t* handler = NULL; const u_char* data; struct pcap_pkthdr hdr; handler = pcap_open_offline(dataFile.c_str(), errbuf); if (handler == NULL) { return false; } while ((data = pcap_next(handler, &hdr)) != NULL) { statistic(&hdr, data); } return true; }
RingBufferBlock* RingBuffer::allocFreeBlock(int size) { // 先从当前位置往后找起 RingBufferBlock *block = searchFreeBlock(size); // 如果找不到则从头开始找 if (NULL == block) { LOG_WARN << "try to find from head = 0"; statistic(); m_head = 0; block = searchFreeBlock(size); } // m_head = getBlockOffset(getNextBlock(block)); return block; }
xbox_live_result<std::shared_ptr<statistic_change_subscription>> user_statistics_service_impl::subscribe_to_statistic_change( _In_ const string_t& xboxUserId, _In_ const string_t& serviceConfigurationId, _In_ const string_t& statisticName ) { std::weak_ptr<user_statistics_service_impl> thisWeakPtr = shared_from_this(); std::shared_ptr<statistic_change_subscription> statChangeSub = std::make_shared<statistic_change_subscription>( xboxUserId, serviceConfigurationId, statistic( statisticName, string_t(), string_t() ), ([thisWeakPtr](const statistic_change_event_args& eventArgs) { std::shared_ptr<user_statistics_service_impl> pThis(thisWeakPtr.lock()); if (pThis != nullptr) { pThis->statistic_changed(eventArgs); } }), ([thisWeakPtr](const xbox::services::real_time_activity::real_time_activity_subscription_error_event_args& eventArgs) { std::shared_ptr<user_statistics_service_impl> pThis(thisWeakPtr.lock()); if (pThis != nullptr) { pThis->m_realTimeActivityService->_Trigger_subscription_error(eventArgs); } }) ); auto subscriptionSucceeded = m_realTimeActivityService->_Add_subscription( statChangeSub ); if (!subscriptionSucceeded.err()) { return xbox_live_result<std::shared_ptr<statistic_change_subscription>>(statChangeSub); } return xbox_live_result<std::shared_ptr<statistic_change_subscription>>(subscriptionSucceeded.err(), subscriptionSucceeded.err_message()); }
static void search_fopen(char *db, char **s) { FILE *fp; #ifdef DEBUG long t0; #endif /* can only read stdin once */ if (f_stdin) { fp = stdin; if (*(s+1) != NULL) { warnx("read database from stdin, use only `%s' as pattern", *s); *(s+1) = NULL; } } else if ((fp = fopen(path_fcodes, "r")) == NULL) err(1, "`%s'", path_fcodes); /* count only chars or lines */ if (f_statistic) { statistic(fp, path_fcodes); (void)fclose(fp); return; } /* foreach search string ... */ while(*s != NULL) { #ifdef DEBUG t0 = cputime(); #endif if (!f_stdin && fseek(fp, (long)0, SEEK_SET) == -1) err(1, "fseek to begin of ``%s''\n", path_fcodes); if (f_icase) fastfind_icase(fp, *s, path_fcodes); else fastfind(fp, *s, path_fcodes); #ifdef DEBUG warnx("fastfind %ld ms", cputime () - t0); #endif s++; } (void)fclose(fp); }
Formats::Chiptune::Container::Ptr Parse(const Binary::Container& rawData, Builder& target) { const Binary::TypedContainer data = CreateContainer(rawData); if (!FastCheck(data)) { return Formats::Chiptune::Container::Ptr(); } try { const Format format(data); StatisticCollectingBuilder statistic(target); format.ParseCommonProperties(statistic); format.ParsePositions(statistic); Indices usedPatterns = statistic.GetUsedPatterns(); const uint_t mode = statistic.GetMode(); if (mode != SINGLE_AY_MODE && !AddTSPatterns(mode, usedPatterns)) { target.SetMode(SINGLE_AY_MODE); } format.ParsePatterns(usedPatterns, statistic); const Indices& usedSamples = statistic.GetUsedSamples(); format.ParseSamples(usedSamples, target); const Indices& usedOrnaments = statistic.GetUsedOrnaments(); format.ParseOrnaments(usedOrnaments, target); Require(format.GetSize() >= MIN_SIZE); const Binary::Container::Ptr subData = rawData.GetSubcontainer(0, format.GetSize()); const RangeChecker::Range fixedRange = format.GetFixedArea(); return CreateCalculatingCrcContainer(subData, fixedRange.first, fixedRange.second - fixedRange.first); } catch (const std::exception&) { Dbg("Failed to create"); return Formats::Chiptune::Container::Ptr(); } }
void dfs_bomber(int x, int y, int* max,int* m_x, int* m_y,char **map){ int next[4][2] = { { 0,1 }, { 1,0 }, { 0,-1 }, { -1,0 } }; int k, N_x, N_y, sum; sum = statistic(x,y,map); if(sum > (*max)){ *max = sum; *m_x = x; *m_y = y; } for(k = 0 ; k<=3 ;k++){ N_x = x + next[k][0]; N_y = y + next[k][1]; if(N_x < 0 || N_y < 0 || N_x > MARGIN_X || N_y > MARGIN_Y){ continue; } if(book[N_x][N_y] == 0 && map[N_x][N_y] == '.'){ book[N_x][N_y] = 1; dfs_bomber(N_x,N_y,max,m_x,m_y,map); } } }
int main(void){ FILE *in = fopen( "010_test.in", "r" ); FILE *stttc_file = fopen( "010_test.statistic", "w+" ); FILE *HT_file = fopen( "010_test.huffman-tree", "w+" ); FILE *HC_file = fopen( "010_test.huffman-code", "w+" ); FILE *out = fopen( "010_test.out", "w" ); int symbol_total = statistic( in, stttc_file ); HuffmanTree tree = generate_HT( stttc_file, symbol_total, HT_file ); HuffmanCode code = generate_HC( tree, symbol_total, HC_file ); code_file( in, code, out ); fclose( in ); fclose( stttc_file ); fclose( HT_file ); fclose( HC_file ); fclose( out ); free( tree ); free( code ); return 0; }
RingBufferBlock* RingBuffer::splitBlock(int sum, int size) { int alignLength = ALIGN(sizeof(struct RingBufferBlock) + size); // 切割出第一个长度为size的block struct RingBufferBlock *head = getHead(); head->m_length = size; head->m_skip = 0; head->m_next = NULL; head->m_link = NULL; // 切割出第二个长度为sum - size的block struct RingBufferBlock *next = getNextBlock(head); if (next) { int nextOffset = getBlockOffset(next); // 如果第二块位于末尾,判断空间是否足够再构造一个block if (m_size - nextOffset > sizeof(RingBufferBlock)) { if (alignLength < sum) { next->m_length = sum - alignLength - sizeof(RingBufferBlock); next->m_link = NULL; next->m_next = NULL; next->m_skip = 0; if (next->m_length <= 0) { LOG_ERROR << "next->m_length = " << next->m_length; statistic(); } } } } else { // m_head = 0; } // 返回第一块block return head; }
QString CSMesEmma::exportEMMAStatistic(const QString &filename,int coverage_level,Instrumentation::coverage_method_t method) const { const ExecutionNames executions=selectedExecutions(); int nb_executions=executions.count(); if (nb_executions==0) return QObject::tr("No executions selected"); QFile f; f.setFileName(filename); if (f.open(QFile::WriteOnly)) { bool is_test_count_mode_selected=isTestCountModeSelected(); CSMesInstrumentations _instrumentations ; copyInstrumentation(_instrumentations,instrumentations); selectExecutionsComparaison(_instrumentations,executions,ExecutionNames(),is_test_count_mode_selected,method,false); CSMesInstrumentations _instrumentations_block ; copyInstrumentation(_instrumentations_block,instrumentations); selectExecutionsComparaison(_instrumentations_block,executions,ExecutionNames(),is_test_count_mode_selected,Instrumentation::COVERAGE_BRANCH,false); ExecutionNames::const_iterator it_fct; const QList<CSMesFunctionInfo::functionskey_t> functions= Functions(); int nb_functions=functions.count(); QHash<CSMesFunctionInfo::functionskey_t,int> nb_tested_function_list; QHash<CSMesFunctionInfo::functionskey_t,int> nb_untested_function_list; QSet<QString> classes; if ( statisticFunctionsExecution(executions,coverage_level,method,nb_tested_function_list,nb_untested_function_list,_instrumentations) ) { for ( QList<CSMesFunctionInfo::functionskey_t>::const_iterator itFunction=functions.begin();itFunction<functions.end();++itFunction++) { const CSMesFunctionInfo::functionskey_t &f=*itFunction; if (nb_tested_function_list.contains(f) && nb_untested_function_list.contains(f) ) { const QString &func=f.method.getScopedName(); classes+=classFromFunction(func); } } } int nb_class=classes.count(); QHash<ExecutionName,int> nb_tested_source_list; QHash<ExecutionName,int> nb_untested_source_list; const SourceFiles sources= Sources(NON_EMPTY); int nb_sources=sources.count(); statisticSourcesExecution(sources,executions,coverage_level,method,nb_tested_source_list,nb_untested_source_list,_instrumentations) ; int nb_tested,nb_untested; statistic(coverage_level,method,nb_tested,nb_untested,_instrumentations) ; int nb_tested_block,nb_untested_block; statistic(coverage_level,Instrumentation::COVERAGE_BRANCH,nb_tested_block,nb_untested_block,_instrumentations_block) ; QHash<ExecutionName,int> nb_tested_source_block_list; QHash<ExecutionName,int> nb_untested_source_block_list; statisticSourcesExecution(sources,executions,coverage_level,Instrumentation::COVERAGE_BRANCH,nb_tested_source_block_list,nb_untested_source_block_list,_instrumentations_block) ; QHash<CSMesFunctionInfo::functionskey_t,int> nb_tested_function_block_list; QHash<CSMesFunctionInfo::functionskey_t,int> nb_untested_function_block_list; statisticFunctionsExecution(executions,coverage_level,Instrumentation::COVERAGE_BRANCH,nb_tested_function_block_list,nb_untested_function_block_list,_instrumentations_block) ; int nb_instrumentation=0; for (CSMesInstrumentations::Modules::const_iterator mod_it=_instrumentations.modules.begin();mod_it!=_instrumentations.modules.end();++mod_it) nb_instrumentation += mod_it->nb_measurements_items; QXmlStreamWriter stream(&f); stream.setAutoFormatting(true); stream.writeStartDocument(); stream.writeStartElement("report"); stream.writeStartElement("stats"); stream.writeEmptyElement("packages"); stream.writeAttribute("value",QString::number(1)); stream.writeEmptyElement("methods"); stream.writeAttribute("value",QString::number(nb_functions)); stream.writeEmptyElement("srcfiles"); stream.writeAttribute("value",QString::number(nb_sources)); stream.writeEmptyElement("srclines"); stream.writeAttribute("value",QString::number(nb_tested+nb_untested)); stream.writeEmptyElement("classes"); stream.writeAttribute("value",QString::number(nb_class)); stream.writeEndElement(); stream.writeStartElement("data"); stream.writeStartElement("all"); stream.writeAttribute("name","all classes"); { int nb_tested_line=nb_tested; int nb_untested_line=nb_untested; int nb_tested_method; int nb_untested_method; int nb_tested_class; int nb_untested_class; int nb_tested_blocks=nb_tested_block; int nb_untested_blocks=nb_untested_block; emmaStatisticMethods(nb_tested_function_list,nb_tested_method,nb_untested_method); emmaStatisticClasses(nb_tested_function_list,nb_tested_class,nb_untested_class); exportEmmaStatistics(stream,nb_tested_line,nb_untested_line,nb_tested_method,nb_untested_method,nb_tested_class,nb_untested_class,nb_tested_blocks,nb_untested_blocks); } stream.writeStartElement("packages"); stream.writeAttribute("name",getFilename()); for (SourceFiles::const_iterator itSrc=sources.begin();itSrc!=sources.end();++itSrc) { stream.writeStartElement("srcfile"); stream.writeAttribute("name",*itSrc); QList<CSMesFunctionInfo::functionskey_t> functions_source; QSet<QString> classes_source; for (QList<CSMesFunctionInfo::functionskey_t>::const_iterator itMeth=functions.begin();itMeth!=functions.end();++itMeth) { if ((*itMeth).source==*itSrc) { functions_source+=*itMeth; const QString &func=(*itMeth).method.getScopedName(); classes_source+=classFromFunction(func); } } { int nb_tested_line=0; int nb_untested_line=0; if (nb_tested_source_list.contains(*itSrc) && nb_untested_source_list.contains(*itSrc) ) { nb_tested_line=nb_tested_source_list[*itSrc]; nb_untested_line=nb_untested_source_list[*itSrc]; } QHash<CSMesFunctionInfo::functionskey_t,int> nb_tested_functions; for (QHash<CSMesFunctionInfo::functionskey_t,int>::const_iterator itFunc=nb_tested_function_list.begin();itFunc!=nb_tested_function_list.end();++itFunc) { if (itFunc.key().source==*itSrc) nb_tested_functions[itFunc.key()]=itFunc.value(); } int nb_tested_method=0; int nb_untested_method=0; int nb_tested_class=0; int nb_untested_class=0; int nb_tested_blocks=0; int nb_untested_blocks=0; if (nb_tested_source_block_list.contains(*itSrc) && nb_untested_source_block_list.contains(*itSrc) ) { nb_tested_blocks=nb_tested_source_block_list[*itSrc]; nb_untested_blocks=nb_untested_source_block_list[*itSrc]; } emmaStatisticMethods(nb_tested_functions,nb_tested_method,nb_untested_method); emmaStatisticClasses(nb_tested_functions,nb_tested_class,nb_untested_class); exportEmmaStatistics(stream,nb_tested_line,nb_untested_line,nb_tested_method,nb_untested_method,nb_tested_class,nb_untested_class,nb_tested_blocks,nb_untested_blocks); } for (QSet<QString>::const_iterator itClass=classes_source.begin();itClass!=classes_source.end();++itClass) { stream.writeStartElement("class"); stream.writeAttribute("name",*itClass); { int nb_tested_line=0; int nb_untested_line=0; int nb_tested_blocks=0; int nb_untested_blocks=0; QHash<CSMesFunctionInfo::functionskey_t,int> nb_tested_functions; for (QHash<CSMesFunctionInfo::functionskey_t,int>::const_iterator itFunc=nb_tested_function_list.begin();itFunc!=nb_tested_function_list.end();++itFunc) { if ( (itFunc.key().source==*itSrc) && (classFromFunction(itFunc.key().method.getScopedName())==*itClass)) { nb_tested_functions[itFunc.key()]=itFunc.value(); nb_tested_line+=itFunc.value(); nb_untested_line+=nb_untested_function_list[itFunc.key()]; nb_tested_blocks+=nb_tested_function_block_list[itFunc.key()]; nb_untested_blocks+=nb_untested_function_block_list[itFunc.key()]; } } int nb_tested_method=0; int nb_untested_method=0; int nb_tested_class=0; int nb_untested_class=0; emmaStatisticMethods(nb_tested_functions,nb_tested_method,nb_untested_method); emmaStatisticClasses(nb_tested_functions,nb_tested_class,nb_untested_class); exportEmmaStatistics(stream,nb_tested_line,nb_untested_line,nb_tested_method,nb_untested_method,nb_tested_class,nb_untested_class,nb_tested_blocks,nb_untested_blocks); } for (QList<CSMesFunctionInfo::functionskey_t>::const_iterator itMeth=functions_source.begin();itMeth!=functions_source.end();++itMeth) { if ( classFromFunction(itMeth->method.getScopedName())==*itClass) { stream.writeStartElement("method"); stream.writeAttribute("name",(*itMeth).method.getScopedName()); { int nb_tested_line=0; int nb_untested_line=0; int nb_tested_blocks=0; int nb_untested_blocks=0; QHash<CSMesFunctionInfo::functionskey_t,int> nb_tested_functions; for (QHash<CSMesFunctionInfo::functionskey_t,int>::const_iterator itFunc=nb_tested_function_list.begin();itFunc!=nb_tested_function_list.end();++itFunc) { if ( itFunc.key()==*itMeth ) { nb_tested_functions[itFunc.key()]=itFunc.value(); nb_tested_line+=itFunc.value(); nb_untested_line+=nb_untested_function_list[itFunc.key()]; nb_tested_blocks+=nb_tested_function_block_list[itFunc.key()]; nb_untested_blocks+=nb_untested_function_block_list[itFunc.key()]; } } int nb_tested_method=0; int nb_untested_method=0; emmaStatisticMethods(nb_tested_functions,nb_tested_method,nb_untested_method); exportEmmaStatistics(stream,nb_tested_line,nb_untested_line,nb_tested_method,nb_untested_method,-1,-1,nb_tested_blocks,nb_untested_blocks); } stream.writeEndElement(); } } stream.writeEndElement(); } stream.writeEndElement(); } stream.writeEndElement(); stream.writeEndElement(); stream.writeEndElement(); stream.writeEndDocument(); f.close(); return QString(); } else return QObject::tr("Error opening file '%1':%2").arg(filename).arg(f.errorString()); }
/** * A convenience method for implementing statistics for both evaluation and * endowment function. It assumes that the statistic can be calculated by * iterating over ties (i,j) of a network Y and summing up some terms * s_{ij}(X) with respect to another network X, namely, * s(X,Y) = sum_{(i,j) \in Y} s_{ij}(X). * For evaluation function, X = Y. * For endowment function, X is the initial network of the period, and Y is the * network of ties that have been lost during the network evolution. */ double NetworkEffect::statistic(const Network * pSummationTieNetwork) { return statistic(pSummationTieNetwork, false).first; }