link := "file:///" pathrep := "" CR := Chr(13) LF := Chr(10) GetUNCPath(letter) { localName = %letter% length := 1000 VarSetCapacity(remoteName, length) result := DllCall("Mpr\WNetGetConnection" , "Str", localName , "Str", remoteName , "UInt *", length) if (ErrorLevel <> 0 || result != 0) { return "" } else { ; MsgBox, %remoteName% (%length%) -- result: %result% return remotename ; end function } } Loop Read, %1% { p := A_LoopReadLine ;MsgBox %p% if ( RegExMatch( p , "[A-Za-z][:]") ) ; match a regex for drive letter "^:" { unc := GetUNCPath( SubStr( p, 1, 2) ) if ( unc <> "" ) { withoutDriveLetter := SubStr( p, 3, strLen(p)-2 ) pathrep = %link%%unc%%withoutDriveLetter%%CR%%LF%%pathrep% } } else ; should already be an unc (check to be sure) { if ( RegExMatch( p , "\\\\") ) { pathrep = %link%%p%%CR%%LF%%pathrep% } else { ; Msgbox "ignored " %p% } } } StringReplace, pathrep, pathrep, \, /, All ; MsgBox %pathrep% clipboard = %pathrep%
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | class event_t { public: event_t(const std::string& _date) { memset(&_start_date, 0, sizeof(struct tm)); sscanf(_date.c_str(), "%d-%d-%d;%d", &_start_date.tm_year, &_start_date.tm_mon, &_start_date.tm_mday, &_duration); _start_date.tm_year -= 1900; _start_date.tm_mon -= 1; _start_pt = mktime(&_start_date); _end_pt = _start_pt + _duration * 24 * 60 * 60; memset(&_end_date, 0, sizeof(struct tm)); memcpy(&_end_date, gmtime(&_end_pt), sizeof(struct tm)); } event_t(const event_t& e) { _duration = e._duration; _start_date = e._start_date; _start_pt = e._start_pt; _end_pt = e._end_pt; _end_date = e._end_date; } bool operator < (const event_t& r) { return this->_end_pt < r._end_pt; } friend std::ostream& operator<< (std::ostream& stream, const event_t& evt); public: struct tm _start_date; unsigned int _duration; struct tm _end_date; time_t _start_pt; time_t _end_pt; } ; |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | void CreatePlanning( std::vector<event_t> &_list ) { std::ostream_iterator< event_t > dump_events( std::cout, "" ); std::sort(_list.begin(), _list.end()); std::cout << " Start \t End \t Duration \n", std::copy(_list.begin(),_list.end(), dump_events); std::vector<event_t> _planning; _planning.push_back(_list[0]); unsigned int j = 0; for (unsigned int i = 1 ; i < _list.size() ; ++i) { if(_list[i]._start_pt >= _list[j]._end_pt) { _planning.push_back(_list[i]); j = i; } } std::cout << "Nb event planned : " << _planning.size() << std::endl; std::cout << " Start \t End \t Duration \n", std::copy(_planning.begin(),_planning.end(), dump_events); } |
class test
{
public:
test(){}
~test(){}
int DoConstOp() const { return 0;}
int DoNotConstOp() { return 0;}
};
process_as_const_ref(t);
process_as_const_ptr(&t);
process_as_const_ptr_const(&t);
process_as_ptr_const(&t);
void process_as_const_ref(const test& t)
{
t.DoConstOp();
//t.DoNotConstOp();//Cannot build: cannot convert 'this' pointer from 'const test' to 'test &'
}
void process_as_const_ptr(const test* t)
{
t->DoConstOp();
//t->DoNotConstOp(); //Cannot build: cannot convert 'this' pointer from 'const test' to 'test &'
(const_cast<test*>(t))->DoNotConstOp(); //trick
}
void process_as_const_ptr_const(const test* const t)
{
t->DoConstOp();
//t->DoNotConstOp();//Cannot build: cannot convert 'this' pointer from 'const test' to 'test &'
(const_cast<test* const>(t))->DoNotConstOp(); //trick remove the const on the class not on pointer
//t++;//but this you can't do : 't' : you cannot assign to a variable that is const
}
void process_as_ptr_const(test* const t)
{
t->DoConstOp();
t->DoNotConstOp();
//t++;//but this you can't do : 't' : you cannot assign to a variable that is const
}
#container div.fixedbackgroundimg {
position: relative;
overflow: visible;
}
.fixedbackgroundimg.example {
background: url("http://www.wired.com/images_blogs/gadgetlab/2013/05/0521-tall-controller-v1.jpg") repeat-y fixed 50% center transparent !important;
}
<div class="fixedbackgroundimg example" data-type="background" data-speed="5">
<h2 class=""> test </h2>
<img src="http://www.wired.com/images_blogs/gadgetlab/2013/05/0521-tall-controller-v1.jpg" style="visibility: hidden; height: 500px" data-lazy-loaded="true"></img>
</div>
const color_code_map_t color_code = map_list_of (color_e::white, 'A')(color_e::blue, 'B')(color_e::green, 'C')(color_e::yellow, 'D')(color_e::orange, 'E')(color_e::red, 'F') ;
vector<char> elements;
std::for_each(color_code.begin(), color_code.end(), [&elements](const color_code_map_t::value_type& p) { elements.push_back(p.second); });
auto combi_found = combinations_with_repetitions(elements, TheHiddenCode.size());
std::cout << "total combination you can try = " << combi_found.size() << std::endl;
void combinations_with_repetitions_recursion(deque< vector<char> >& combi, const vector<char> &elems,
unsigned long req_len,
vector<unsigned long> &pos,
unsigned long depth)
{
// Have we selected the number of required elements?
if (depth >= req_len) {
vector<char> depth_r_combi;
for (unsigned long ii = 0; ii < pos.size(); ++ii){
depth_r_combi += elems[pos[ii]];
}
//copy(depth_r_combi.begin(), depth_r_combi.end(), ostream_iterator<char>(cout, " ")), cout << endl;
combi.push_back(depth_r_combi);
return;
}
// Try to select new elements to the right of the last selected one.
for (unsigned long ii = 0; ii < elems.size(); ++ii) {
pos[depth] = ii;
combinations_with_repetitions_recursion(combi, elems, req_len, pos, depth + 1);
}
return;
}
deque<vector<char>> combinations_with_repetitions(const vector<char> &elems, unsigned long r)
{
if(r > elems.size()){
throw std::logic_error("combination length (r) cannot be greater than the elements list (n)");
}
vector<unsigned long> positions(r, 0);
deque<vector<char>> combi;
combinations_with_repetitions_recursion(combi, elems, r, positions, 0);
return combi;
}
cout << "Code of " << TheHiddenCode.size() << " peg" << endl;
cout << "Number of try to guess " << nb_line << endl;
cout << "Color are ", for_each(color_code.begin(), color_code.end(), [](const color_t& c){cout << c.second << " " ;}), cout << endl;
while( exact < TheHiddenCode.size() && nb_try < nb_line) {
cout << "\n\nguess--> ", cin >> guess;
if(guess.size() == 4) {
exact = color = 0;
transform( begin(TheHiddenCode), end(TheHiddenCode),
begin(guess), begin(answer),
Count( TheHiddenCode, color, exact ) );
cout << "Answer => " << "Incorrect place " << color << " Correct place " << exact << " : " ,
copy(answer.begin(), answer.end(), ostream_iterator<char>(cout, " ")),
cout << endl;
nb_try++;
} else {
cout << "incorrect number peg on the line" << endl;
}
}
struct Count {
Count( hidden_code_t code, int& incorrect_place, int& exact )
: incorrect_place_(incorrect_place), exact_(exact=0), code_(code) { }
char operator()( color_t c, char g ){
bool correct_place = (c.second == toupper(g));
if(correct_place) { //Argh, conditionnal are ugly !
exact_++;
return 'W';
} else {
//does that color be somewhere else in the code...
auto f = std::find_if(begin(code_), end(code_), [&g](const color_t& tobecheck_) { return (tobecheck_.second == toupper(g));} );
auto misplaced = (f != code_.end());
incorrect_place_ += (int) (misplaced);
if(misplaced)
return 'B';
else
return ' ';
}
}
~Count(){
}
int &incorrect_place_, &exact_;
hidden_code_t code_;
};
#include <string>
#include <map>
#include <algorithm>
#include <time.h>
#include <iostream>
#include <sstream>
using namespace std;
#include "boost/assign.hpp"
using namespace boost::assign;
enum color_e { white = 0, blue, green, yellow, orange, red };
typedef map<color_e, char> color_code_map_t;
typedef pair<color_e, char> color_t;
typedef vector<color_t> guess_code_t;
typedef vector<color_t> hidden_code_t;
const color_code_map_t color_code = map_list_of (color_e::white, 'A')(color_e::blue, 'B')(color_e::green, 'C')(color_e::yellow, 'D')(color_e::orange, 'E')(color_e::red, 'F') ;
const auto comb_length = 4;
const auto nb_line = 8;
hidden_code_t TheHiddenCode(comb_length);
vector<bool> answer(comb_length);
//how many of 4(k) peg can make from 6(N) ==> N^k
string guess;
struct acc_char {
void operator () (color_t c) {
acc_ += c.second;
}
string get() {return acc_;}
string acc_;
};
template<typename T> string colorCodeString(const T& m) {
bool is_vector_of_peg = std::is_same<T, guess_code_t>::value || std::is_same<T, hidden_code_t>::value ;
if(!is_vector_of_peg)
return ""; //or throw ?
acc_char acc;
return std::for_each(begin(m), end(m), acc).get();
}
color_t ChooseRandomPeg() { return *color_code.find((color_e)(rand() % color_code.size())); }
struct Count {
Count( int& incorrect_place, int& exact )
: incorrect_place_(incorrect_place), exact_(exact=0) { }
bool operator()( color_t c, char g ){
exact_ += c.second == toupper(g);
return (c.second == toupper(g));
}
~Count(){
}
int &incorrect_place_, &exact_;
};
class WinnerOrLoser {
public:
WinnerOrLoser(int exact, int code_length, int nb_try, int nb_line) : state_(false), msg_("not found") {
state_ = (exact == code_length);
stringstream builder;
if(state_) {
builder << "found in " << nb_try << "/" << nb_line;
msg_ = builder.str();
}
}
~WinnerOrLoser(){}
bool getState() {return state_;}
string getMsg() {return msg_;}
private:
bool state_;
string msg_;
};
int main() {
int color, exact = color = 0;
srand( time(0) ),
generate( TheHiddenCode.begin(), TheHiddenCode.end(), ChooseRandomPeg );
int nb_try = 0;
while( exact < TheHiddenCode.size() && nb_try < nb_line) {
cout << "\n\nguess--> ", cin >> guess;
if(guess.size() == 4) {
transform( begin(TheHiddenCode), end(TheHiddenCode),
begin(guess), begin(answer),
Count( color, exact ) );
cout << color << ' ' << exact << " : " ,
for_each(answer.begin(), answer.end(), [](bool pegExact){ cout << ((pegExact) ? "T" : "F") ;}),
cout << endl;
nb_try++;
} else {
cout << "incorrect number peg on the line" << endl;
}
}
cout << "Hidden code " << colorCodeString(TheHiddenCode) << " " << WinnerOrLoser(exact, TheHiddenCode.size(), nb_try, nb_line).getMsg() << "!\n";
}
#include <string>
#include <map>
#include <algorithm>
#include <time.h>
#include <iostream>
using namespace std;
#include "boost/assign.hpp"
using namespace boost::assign;
enum color_e { white = 0, blue, green, yellow, orange, red };
typedef map<color_e, char> color_code_map_t;
typedef pair<color_e, char> color_t;
typedef vector<color_t> gess_code_t;
typedef vector<color_t> hidden_code_t;
const color_code_map_t color_code = map_list_of (color_e::white, 'A')(color_e::blue, 'B')(color_e::green, 'C')(color_e::yellow, 'D')(color_e::orange, 'E')(color_e::red, 'F') ;
const auto comb_length = 4;
const auto nb_line = 8;
hidden_code_t TheHiddenCode(comb_length);
struct acc_char {
void operator () (color_t c) {
acc_ += c.second;
}
string get() {return acc_;}
string acc_;
};
template<typename T> string colorCodeString(const T& m) {
bool is_vector_of_peg = std::is_same<T, gess_code_t>::value || std::is_same<T, hidden_code_t>::value ;
if(!is_vector_of_peg)
return ""; //or throw ?
acc_char acc;
return std::for_each(begin(m), end(m), acc).get();
}
color_t ChooseRandomPeg() { return *color_code.find((color_e)(rand() % color_code.size())); }
int main() {
do
{
srand( time(0) ),
generate( TheHiddenCode.begin(), TheHiddenCode.end(), ChooseRandomPeg );
std::cout << colorCodeString(TheHiddenCode);
} while (getchar() != EOF);
return 0;
}
template<class InputIteratorT1, typename InputIteratorT2> void CheckEqualForGivenAccuracy( InputIteratorT1 first_left, InputIteratorT1 last_left, InputIteratorT2 first_right, InputIteratorT2 last_right, double tstEspilon = (double)std::numeric_limits<typename InputIteratorT1::value_type>::epsilon(), std::ostream& stream = null_ostream )
{
CHECK(std::distance(first_left, last_left) && std::distance(first_right, last_right));
stream << std::string(__FUNCTION__) << " of " << std::distance(first_left, last_left) << " elements with epsilon = " << tstEspilon << std::endl;
unsigned int nb_error = 0;
double sum_abs_diff = 0.0;
double max_diff = 0.0;
double min_diff = 0.0;
while(first_left != last_left)
{
if(fabs((double)*first_left - (double)*first_right) > tstEspilon)
{
nb_error++;
double diff = (double)*first_left - (double)*first_right;
sum_abs_diff += std::abs<double>(diff);
max_diff = std::max(max_diff, diff);
min_diff = std::min(min_diff, diff);
}
first_left++; first_right++;
}
if(nb_error > 0)
{
stream << std::string(__FUNCTION__) << " error= " << nb_error << " sum_abs_diff = " << sum_abs_diff << " max_diff = " << max_diff << " min_diff = " << min_diff << std::endl;
}
CHECK(nb_error == 0);
}
// ==UserScript==
// @name Skip feedsportal Add
// @namespace http://da.feedsportal.com/*
// @match http://da.feedsportal.com/*
// @grant none
// @version 1
// ==/UserScript==
(function ()
{
var articleLink = document.getElementsByTagName("a")[1];
location.href = articleLink;
})();
// ==UserScript==
// @name Skip feedsportal Add
// @namespace http://da.feedsportal.com/*
// @match http://da.feedsportal.com/*
// @grant none
// @version 1
// ==/UserScript==
(function ()
{
var articleLink = document.getElementsByTagName("a")[1];
location.href = articleLink;
})();
// ==UserScript==
// @name Skip feedsportal Add
// @namespace http://da.feedsportal.com/*
// @match http://da.feedsportal.com/*
// @grant none
// @version 1
// ==/UserScript==
(function ()
{
var articleLink = document.getElementsByTagName("a")[1];
location.href = articleLink;
})();
// ==UserScript==// ==UserScript==
// @name Skip feedsportal Add
// @namespace http://da.feedsportal.com/*
// @match http://da.feedsportal.com/*
// @grant none
// @version 1
// ==/UserScript==
(function ()
{
var articleLink = document.getElementsByTagName("a")[1];
location.href = articleLink;
})();
// ==UserScript==
// @name Skip feedsportal Add
// @namespace http://da.feedsportal.com/*
// @match http://da.feedsportal.com/*
// @grant none
// @version 1
// ==/UserScript==
(function ()
{
var articleLink = document.getElementsByTagName("a")[1];
location.href = articleLink;
})();
// ==UserScript==
// @name Skip feedsportal Add
// @namespace http://da.feedsportal.com/*
// @match http://da.feedsportal.com/*
// @grant none
// @version 1
// ==/UserScript==
(function ()
{
var articleLink = document.getElementsByTagName("a")[1];
location.href = articleLink;
})();
#include <stdlib.h>//linux aligned malloc
#include <malloc.h>
#if defined(WIN32) || defined(WIN64)
#define simd_alloc(alignment, len) _aligned_malloc(len, alignment)
#define simd_free _aligned_free
#else
#define simd_alloc(alignment, len) memalign(alignment, len)
#define simd_free free
#endif
template<typename T>
class aligned_allocator : public std::allocator<T>
{
public:
void deallocate(pointer _Ptr, size_type)
{ // deallocate object at _Ptr, ignore size
simd_free(_Ptr);
}
pointer allocate(size_type _Count)
{ // allocate array of _Count elements
return (T*)simd_alloc(16, _Count*sizeof(T));
}
};
template struct myType
{
typedef boost::numeric::ublas::vector<T, boost::numeric::ublas::unbounded_array<T, aligned_allocator<T> > > boost_vector;
typedef std::vector<T, aligned_allocator<T> > std_vector;
};
1 2 3 4 | std::vector<double> vec(10); std::ofstream output("out.bin", std::ios::binary|std::ios::out); output.write(reinterpret_cast<char*>(&vec[0]), vec.size()*sizeof(vec[0])); output.close(); |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | // ProcessMemDumper.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <windows.h> #include <string> #include <iostream> #include <fstream> #include <vector> #include <stdexcept> #include <sstream> #include "boost/shared_ptr.hpp" void delete_HANDLE(HANDLE p) { std::cout << "Releasing Handle ...." << std::endl; CloseHandle(p); }; int _tmain(int argc, _TCHAR* argv[]) { try { unsigned int procPID = atoi(argv[1]); std::string procAddressHexa = std::string(argv[2]); std::stringstream hexToInt; hexToInt << std::hex << procAddressHexa; unsigned int procAddress = 0; hexToInt >> procAddress; unsigned int nbbytetoRead = atoi(argv[3]); std::string targetFileName = std::string(argv[4]); boost::shared_ptr<void> procHandle(OpenProcess(PROCESS_VM_READ, false, DWORD(procPID)), &::delete_HANDLE); if(procHandle) { std::vector<char> memCopyofProcMem(nbbytetoRead); SIZE_T NumberOfBytesRead = 0; if(ReadProcessMemory(procHandle.get(), LPCVOID(procAddress), LPVOID(&memCopyofProcMem[0]), SIZE_T(nbbytetoRead), &NumberOfBytesRead) && NumberOfBytesRead == nbbytetoRead) { std::ofstream targetFile(targetFileName, std::ios::binary|std::ios::out); targetFile.write(&memCopyofProcMem[0], nbbytetoRead); targetFile.close(); } else { std::cout << "ReadProcessMemory return false, or NumberOfBytesRead != of the requested number of byte." << std::endl; return -1; } } } catch (const std::exception& e) { std::cout << "std::exception: " << e.what() << std::endl; return -1; } catch (...) { std::cout << "unknown exception: " << std::endl; return -1; } return 0; } |