Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+15
public:
std::string GetDescriptionString() const
{
std::stringstream strStream;
strStream << std::string(mErrorDescription);
return strStream.str();
}
private:
//! Error description
std::string mErrorDescription;Как вернуть std::string?
letheriem,
29 Июля 2013
+15
#include<iostream>
#include<set>
#include<vector>
#include<hash_set>
#include<math.h>
#include<stdlib.h>
using namespace std;
inline int po(int a,int b){
int ans =1;
for(int i=0;i<b;++i)ans*=a;
return ans;
}
inline bool isnotsq(int a){
return sqrt(0.0+a)!=int(sqrt(a+0.0));
}
int main(){
int t,n,k;
cin>>t;
int SQRT = 100000,primes[100100]={0};
primes[2]=1;
vector<int> pr;
pr.push_back(2);
for(int i = 3;i<=SQRT;i+=2){
if(primes[i]==0) {
pr.push_back(i);
for(int j = 2*i;j<=SQRT;j+=i) primes[j]=1;
}
}
while(t--){
cin>>n>>k;
int nn=n;
int divisors[1001];
int divisecount[1001]={0};
int divc=0;
int count = 0;
for(int i =0;i<pr.size();++i){
if(n%pr[i]==0) divisors[divc++]=pr[i];
while(n%pr[i]==0) divisecount[divc-1]++,n/=pr[i],count++;
}
if(n!=1) divisors[divc++]=n,divisecount[divc-1]=1;
//for(int i =0;i<divc;++i) cout<<divisors[i]<<' '<<divisecount[i]<<'\n';
vector< int> cbused;
vector<int> rem;
rem.push_back(0);
cbused.push_back(1);
for(int i =0;i<divc;++i){
int cs = cbused.size();
for(int j =0;j<cs;++j){
int cc = divisors[i];
int ops=1;
while(1){
if(nn%(cbused[j]*cc)==0) {
if(isnotsq(cbused[j]*cc))
cbused.push_back(cbused[j]*cc),rem.push_back(rem[j]+ops);
}
else break;
cc*=divisors[i];
ops+=1;
}
}
}
//for(int i = 0;i<cbused.size();++i) cout<<cbused[i]<<' '<<rem[i]<<'\n';
int siz= cbused.size();
set< pair<int,int > > anse;
anse.insert(make_pair(1,0));
for(int j = 1;j<siz;++j){
for(int i = cbused[j],k=1;nn%i==0;i*=cbused[j],k++) if(i%2==1) anse.insert(make_pair(i,k));
}
for(int i = 1;i<siz;++i){
vector<pair<int , int> > toa;
for(set< pair<int,int> >::iterator it=anse.begin();it!=anse.end();it++){
if(nn%(cbused[i]*it->first)==0&&it->second<k) toa.push_back(make_pair(cbused[i]*it->first,it->second+1));
for(int q=0;q<toa.size();q++) anse.insert(toa[q]);
}
}
bool f = false;
for(set< pair<int,int> >::iterator it=anse.begin();it!=anse.end();it++){
if(it->first==nn&&it->second==k) f=true;
}
cout<<(f?"YES":"NO")<<"\n";
if(t==0) return 0;
}
}
Задано целое положительное число n. Выясните, может ли оно быть представлено в виде произведения k целых положительных чисел, ни одно из которых не является квадратом целого числа.
(с яндекс.алгоритма)
AvadaKedavra,
14 Июля 2013
+15
typedef std::intptr_t difference_type;
//...
const difference_type index_relative_unsigned=std::abs(index_relative);
LispGovno,
04 Июля 2013
+15
for(std::list<Eff_t*>::iterator i = m_effects.begin(); i != m_effects.end(); ++i)
{
Rot3DEff_t* pRot3DEff = dynamic_cast<Rot3DEff_t*>(*i);
//иначе вместо деструктра Rot3DEff_t вызывается деструктор Eff_t
//если этого не делать не освободится текстура m_pText класса Rot3DEff_t
if (pRot3DEff)
delete pRot3DEff;
else
delete *i;
}
lifemaker,
16 Апреля 2013
+15
String testName;
//...
std::swap(testName, _testName);String из thirdparty-библиотеки, а swap везде в нашем коде. По очевидным причинам получаем подение производительности.
LispGovno,
16 Марта 2013
+15
/**
* @brief Serializer generic interface.
*/
template<typename ValueType>
struct serializer
{
/**
* @brief Parses value from raw bytes.
* @param from byte buffer parse value from
*/
static ValueType parse(uint8_t *from);
/**
* @brief Writes value to raw byte buffer.
* @param value value to write
* @param dest destination buffer
*/
static void write(ValueType value, uint8_t *dest);
};
template<>
struct serializer<uint8_t>
{
static uint8_t parse(uint8_t *from)
{
return *from;
}
static void write(const uint8_t value, uint8_t *to)
{
*to = value;
}
};
template<>
struct serializer<uint16_t>
{
static uint16_t parse(uint8_t *from)
{
return (uint16_t)from[0] << 8 | from[1];
}
static void write(const uint16_t value, uint8_t *to)
{
to[0] = (value >> 8);
to[1] = value & 0xff;
}
};
template<>
struct serializer<uint32_t>
{
static uint32_t parse(uint8_t *from)
{
return from[0] << 24 | from[1] << 16 | from[2] << 8 | from[3];
}
static void write(const uint32_t value, uint8_t *to)
{
serializer<uint16_t>::write(value >> 16, to);
serializer<uint16_t>::write(value & 0xffff, to + 2);
}
};
template<>
struct serializer<uint64_t>
{
static uint64_t parse(uint8_t *from)
{
const uint32_t high = serializer<uint32_t>::parse(from);
const uint32_t low = serializer<uint32_t>::parse(from + 4);
return ((uint64_t) high << 32) | low;
}
static void write(const uint64_t value, uint8_t *to)
{
serializer<uint32_t>::write(value >> 32, to);
serializer<uint32_t>::write(value & 0xffffffff, to + 4);
}
};
Тут поднялась тема неуместного битолюбства... Решил поделиться одним из моих первых крестОпусов.
"кроссплатформенный hton(sl)".
roman-kashitsyn,
22 Января 2013
+15
LambdaVar<1> X;
LambdaVar<2> Y;
// The next line prints 10:
cout << lambda(X,Y)[ plus[ multiplies[3,X], Y ] ] (3,1) << endl;
cout << lambda(X,Y)[ (3 %multiplies% X) %plus% Y ] << endl;
//...
lambda(X)[ X %plus% getCurrentTime[_*_] ]
//...
let[ X == someLambdaExp,
Y == someOtherLambdaExpWhichMayInvolveX ]
.in[ someLambdaExpInvolvingXandY ]
//...
lambda(X)[
letrec[ F == lambda(Y)[ if1[ Y %equals% 0,
1,
Y %multiplies% F[Y %minus% 1] ] ] ]
.in[ F[X] ] ]
//...
Maybe<int> mx = just(2);
Maybe<int> my = just(3);
mx = lambda()[ compM<MaybeM>()[ plus[X,Y] | X<=mx, Y<=my, guard[false] ] ]();
cout << mx << endl; // Nothing
//...
compM<ListM>()[ makePair[X,Y] | X<=list_with(1,2), guard[true],
Y<=list_with(3,4), guard[ (Y %divides% X) %equal% 3 ] ] ]
Грибки отсюда:
http://people.cs.umass.edu/~yannis/fc++/
LispGovno,
10 Декабря 2012
+15
#include <iostream>
#include <functional>
template<class Container, class F, class A>
auto accumulate(Container c, F f, A acc) -> A
{
auto id = [](const A& a) -> const A& {return a;};
typedef decltype(std::begin(c)) Iterator;
const std::function<A(const Iterator& lst, const std::function<A(const A&)>&)> doIt =
[&](const Iterator& lst, const std::function<A(const A&)>& cont) -> A
{
if(lst==c.end())
return cont(acc);
else
{
auto conter=[&](const A& acc) -> A {return cont(f(*lst, acc));};
return doIt(lst+1, conter);
}
};
return doIt(std::begin(c), id);
}
int main() {
std::cout<<accumulate({1,2,3,4}, std::plus<int>(), 0);
return 0;
}
Похоже написал какой-то монадолог.
http://ideone.com/y4Dm9z
Пример использования accumulate сам накатал.
Я побаловался с этим примером, чтобы разобраться и GCC ожидаемо упал:
http://ideone.com/XWfuoP
Я убежден, что эта функция должна была выглядеть как-то так:
template<class Container, class F>
accumulate(const Container& c, const F& f=std::plus<decltype(*(std::begin(c)))>(), const decltype(*(std::begin(c))) acc=decltype(*(std::begin(c)))()) -> decltype(*(std::begin(c)))
{
return std::accumulate(c.begin(), c.end(), acc, f);
}
//Вызов этой функции:
accumulate({1,2,3,4});let fold_right func acc list =
let rec loop list cont = //сюда мы передаем текущую функцию континуации
match list with
|[] -> cont acc //а вот и наше ключевое вычисление.
|head::tail -> loop tail (fun racc -> cont (func head racc))
loop list (fun x -> x)
LispGovno,
23 Ноября 2012
+15
for(int y=0; y<height; ++y)
{
for(int x=0; x<width; ++x)
b[y,x] = a[y,x];
}
LispGovno,
12 Ноября 2012
+15
#include <iostream>
#include <cxxabi.h>
#include <typeinfo>
int main(void)
{
uint8_t i = 63;
int status;
std::cout << i << std::endl;
char *realname = abi::__cxa_demangle(typeid(i).name(), 0, 0, &status);
std::cout << "Real type of uint8_t is: " << realname << std::endl;
delete (realname);
std::cout << (unsigned int)i << std::endl;
return 0;
}...нативный 8bit-ый беззнаковый int.
sayidandrtfm,
28 Октября 2012
Follow us!