Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
0
#include <iostream>
#include <string>
int main()
{
std::cout << "Купи слона!" << std::endl;
while(true)
{
std::string temp;
std::getline(std::cin, temp);
std::printf("Все говорят: \"%s\", а ты купи слона!\n", temp.c_str());
}
}Когда не любишь 1c.
Losyash1337,
28 Июня 2017
0
void DrawLine(Vec2Si32 a, Vec2Si32 b, Rgba color_a, Rgba color_b) { // https://pastebin.com/p26FvZdd
Vec2Si32 ab = b - a;
Vec2Si32 abs_ab(std::abs(ab.x), std::abs(ab.y));
if (abs_ab.x >= abs_ab.y) {
if (a.x > b.x) {
DrawLine(b, a, color_b, color_a);
} else {
Sprite back = GetEngine()->GetBackbuffer();
Vec2Si32 back_size = back.Size();
if (ab.x == 0) {
if (a.x >= 0 && a.x < back_size.x &&
a.y >= 0 && a.y < back_size.y) {
back.RgbaData()[a.x + a.y * back.StridePixels()] = color_a;
}
return;
}
Si32 x1 = std::max(0, a.x);
Si32 x2 = std::min(back_size.x - 1, b.x);
Si32 y1 = a.y + ab.y * (x1 - a.x) / ab.x;
Si32 y2 = a.y + ab.y * (x2 - a.x) / ab.x;
if (y1 < 0) {
if (y2 < 0) {
return;
}
// lower left -> upper right
y1 = 0;
x1 = a.x + ab.x * (y1 - a.y) / ab.y;
x1 = std::max(0, x1);
} else if (y1 >= back_size.y) {
if (y2 >= back_size.y) {
return;
}
// upper left -> lower right
y1 = back_size.y - 1;
x1 = a.x + ab.x * (y1 - a.y) / ab.y;
x1 = std::max(0, x1);
}
if (y2 < 0) {
// upper left -> lower right
y2 = 0;
x2 = a.x + ab.x * (y2 - a.y) / ab.y;
x2 = std::min(back_size.x - 1, x2);
} else if (y2 >= back_size.y) {
// lower left -> upper right
y2 = back_size.y - 1;
x2 = a.x + ab.x * (y2 - a.y) / ab.y;
x2 = std::min(back_size.x - 1, x2);
}
Vec4Si32 rgba_a(static_cast<Si32>(color_a.r),static_cast<Si32>(color_a.g),static_cast<Si32>(color_a.b),static_cast<Si32>(color_a.a));
Vec4Si32 rgba_b(static_cast<Si32>(color_b.r),static_cast<Si32>(color_b.g),static_cast<Si32>(color_b.b),static_cast<Si32>(color_b.a));
Vec4Si32 rgba_ab = rgba_b - rgba_a;
Vec4Si32 rgba_1 = rgba_a + rgba_ab * (x1 - a.x) / ab.x;
Vec4Si32 rgba_2 = rgba_a + rgba_ab * (x2 - a.x) / ab.x;
Vec4Si32 rgba_12 = rgba_2 - rgba_1;
if (x2 <= x1) {
if (x2 == x1) {
Rgba color(rgba_1.x, rgba_1.y, rgba_1.z, rgba_1.w);
back.RgbaData()[x1 + y1 * back.StridePixels()] = color;
}
return;
}
Vec4Si32 rgba_16 = rgba_1 * 65536;
Vec4Si32 rgba_12_16 = rgba_12 * 65536;
Vec4Si32 rgba_12_16_step = rgba_12_16 / (x2 - x1);
Si32 y_16 = y1 * 65536;
Si32 y12_16_step = ((y2 - y1) * 65536) / (x2 - x1);
Si32 stride = back.StridePixels();
for (Si32 x = x1; x <= x2; ++x) {
Rgba color(rgba_16.x >> 16,rgba_16.y >> 16,rgba_16.z >> 16,rgba_16.w >> 16);
back.RgbaData()[x + (y_16 >> 16) * stride] = color;
rgba_16 += rgba_12_16_step;
y_16 += y12_16_step;
}
}
} else { // тут почти тоже самое
if (a.y > b.y) {
DrawLine(b, a, color_b, color_a);
} else {
Sprite back = GetEngine()->GetBackbuffer();
Vec2Si32 back_size = back.Size();
if (ab.y == 0) {
if (a.y >= 0 && a.y < back_size.y && a.x >= 0 && a.x < back_size.x) {
back.RgbaData()[a.x + a.y * back.StridePixels()] = color_a;
}
return;
}
Si32 y1 = std::max(0, a.y);
Si32 y2 = std::min(back_size.y - 1, b.y);
Si32 x1 = a.x + ab.x * (y1 - a.y) / ab.y;
Si32 x2 = a.x + ab.x * (y2 - a.y) / ab.y;
if (x1 < 0) {
if (x2 < 0) {
return;
}
// lower left -> upper right
x1 = 0;
y1 = a.y + ab.y * (x1 - a.x) / ab.x;
y1 = std::max(0, y1);
} else if (x1 >= back_size.x) {
if (x2 >= back_size.x) {
Взято отсюда https://github.com/FrostyMorning/arctic/blob/master/engine/easy.cpp
https://pastebin.com/p26FvZdd
cin,
22 Июня 2017
−2
throw new runtime_errorhttps://github.com/search?l=C%2B%2B&q=%22throw+new+runtime_ error%22&type=Code&utf8=%E2%9C%93
subaru,
11 Июня 2017
+2
#include <iostream>
#include <Windows.h>
#define OCT_1 0
#define OCT_2 12
#define OCT_3 24
#define OCT_4 36
#define OCT_5 48
#define OCT_6 60
#define OCT_7 72
#define OCT_8 84
#define OCT_9 96
#define NOTE_C 0
#define NOTE_Ch 1
#define NOTE_Db 1
#define NOTE_D 2
#define NOTE_Dh 3
#define NOTE_Eb 3
#define NOTE_E 4
#define NOTE_F 5
#define NOTE_Fh 6
#define NOTE_Gb 6
#define NOTE_G 7
#define NOTE_Gh 8
#define NOTE_Ab 8
#define NOTE_A 9
#define NOTE_Ah 10
#define NOTE_Bb 10
#define NOTE_B 11
long double notes[200];
#define TEMPO 100
#define LEN1 (120000 / TEMPO)
#define LEN2 (LEN1 / 2)
#define LEN4 (LEN1 / 4)
#define LEN8 (LEN1 / 8)
#define LEN16 (LEN1 / 16)
#define melody_len 28
struct s {
int key, len;
s(int key, int len) {
this->key = key;
this->len = len;
}
} melody[melody_len] = {
s(OCT_4 + NOTE_E, LEN8),
s(OCT_4 + NOTE_E, LEN8),
s(OCT_5 + NOTE_C, LEN4),
s(OCT_4 + NOTE_E, LEN8),
s(OCT_4 + NOTE_E, LEN8),
s(OCT_5 + NOTE_C, LEN4),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_4 + NOTE_B, LEN8),
s(OCT_4 + NOTE_B, LEN8),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_4 + NOTE_E, LEN4),
s(OCT_5 + NOTE_E, LEN8),
s(OCT_5 + NOTE_E, LEN8),
s(OCT_4 + NOTE_D, LEN8),
s(OCT_4 + NOTE_D, LEN8),
s(OCT_5 + NOTE_E, LEN8),
s(OCT_5 + NOTE_E, LEN8),
s(OCT_4 + NOTE_B, LEN8),
s(OCT_4 + NOTE_B, LEN8),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_4 + NOTE_B, LEN8),
s(OCT_4 + NOTE_B, LEN8),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_5 + NOTE_C, LEN8),
s(OCT_4 + NOTE_E, LEN4),
};
int main(int argc, char** argv) {
notes[0] = 32.7032;
for(int i = 1; i < 200; ++i)
notes[i] = notes[i - 1] * 1.05946309436;
for(int i = 0; i < melody_len; ++i) {
int key = melody[i].key;
int len = melody[i].len;
if(key < 0) Sleep(len);
else Beep(notes[key], len);
}
return 0;
}Дохуя мелодия... с 1 класса музыкалки...
Losyash1337,
27 Мая 2017
−1
for (int i = 0; i < WorkedVerts.count(); i++)
{
int R0 = (i + Offset0) % WorkedVerts.count();
int R1 = (i + Offset1) % WorkedVerts.count();
int R2 = (i + Offset2) % WorkedVerts.count();
XA << WorkedVerts.at(R0).Position;
XB << WorkedVerts.at(R1).Position;
XC << WorkedVerts.at(R2).Position;
}
PrepareDataPointers(XA, XB, XC);
Inset_Cuda(InputData0, InputData1, InputData2, OutputData, XA.count(), -Amount);
for (int x = 0; x < XA.count(); x++)
{
if (fabs(OutputData[x].x) < 0.0001f && fabs(OutputData[x].y) < 0.0001f && fabs(OutputData[x].z < 0.0001f))
{
int Start = x;
int Start1 = (x + (XA.count() - 1)) % XA.count();
QVector3D StartVec = QVector3D(OutputData[Start1].x, OutputData[Start1].y, OutputData[Start1].z);
QVector3D EndVec = StartVec;
int End = 0;
while (true)
{
End = Start++;
if (fabs(OutputData[End].x) > 0.0001f && fabs(OutputData[End].y) > 0.0001f && fabs(OutputData[End].z > 0.0001f))
{
EndVec = QVector3D(OutputData[End].x, OutputData[End].y, OutputData[End].z);
break;
}
}
QVector3D OffsetX0 = WorkedVerts.at(Start).Position - StartVec;
QVector3D OffsetX1 = WorkedVerts.at(End).Position - EndVec;
QVector3D Mid2 = OffsetX0 + (OffsetX1 - OffsetX0) * 0.5f;
OutputData[x].x = Mid2.x();
OutputData[x].y = Mid2.y();
OutputData[x].z = Mid2.z();
}
}
int VertsCounter = SharedVerts.count();
for (int i = 0; i < WorkedVerts.count(); i++)
{
SharedVertex NewVert;
int Count3 = WorkedVerts.count();
int index = (i + (Count3 - 1)) % Count3;
NewVert.Position = QVector3D(OutputData[index].x, OutputData[index].y, OutputData[index].z);
NewVert.Index = VertsCounter++;
SV2 << NewVert;
}Код нахождения копии контура вершин с оффсетом.
IVK,
26 Мая 2017
0
#include <bits/stdc++.h>
using namespace std;
int B[105], N, k, u, v, i, z;
map<int, int> A;
main()
{
for(cin >> N; cin >> k; B[i++] = k)
++A[k] > v ? v = A[u = k] :
A[k] ^ v ?: u = min(u, k);
for(; z < N; z++)
B[z] == u || cout << B[z] << " ";
while(v--) cout << u << " ";
}
Решение задачи из acmp, первое место по количеству символов, обогнав других участников на 30 и более символов.
Обычное решение задачи, тех которые не участвовали у конке, количество символов от 600-700 символов, тут же 208 символов
aat,
24 Мая 2017
0
template<typename T> FORCEINLINE typename std::enable_if<Is_CastToFloat<T>::value, UFloatStat*>::
type Add(T &v ,const FStatInfo &Info=FStatInfo::Empty, bool Visible=true)
{
float vf=(float)v;
auto r=_AddFloat(vf, Info, Visible);
T vb=static_cast<T>(vf);
if(vb!=v)
v=vb;//const_cast<T&>(v)=vb;
return r;
}// Method for Enum, Integer types and bool
antondoe,
24 Мая 2017
0
#include "hex.h"
#include "aes.h"
#include <stdio.h>
#define KEY (0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c)
#define DATA (0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34)
unsigned char enc[] = { BPP_AES_ENCRYPT_ARRAY(KEY, DATA) };
int main() {
for (int i=0; i<sizeof(enc); ++i) {
printf("%02X ", enc[i]);
}
printf("\n");
return 0;
HAPKOMAH,
14 Мая 2017
−17
#include <iostream>
template <unsigned long destiny>
struct dice {
static const unsigned long roll = destiny * 1103515245 + 12345;
};
struct happiness {};
template <typename XX, typename XY>
struct love {
typedef XX HACTEHbKA;
typedef XY bormand;
};
template <int magic>
struct bormand {
static const unsigned long destiny = magic;
};
typedef
love<bormand<196>, love<bormand<136>, love<bormand<230>,
love<bormand< 80>, love<bormand< 83>, love<bormand<237>,
love<bormand<100>, love<bormand< 51>, love<bormand< 19>,
love<bormand<166>, love<bormand< 12>, love<bormand<153>,
love<bormand<229>, love<bormand<141>, love<bormand<125>,
happiness >>>>>>>>>>>>>>> HACTEHbKA;
template<typename LOVE, unsigned long destiny>
struct mystery {
typedef
love<bormand<LOVE::HACTEHbKA::destiny ^ dice<destiny>::roll>,
typename mystery<typename LOVE::bormand,
dice<destiny>::roll>::unveiled> unveiled;
};
template<unsigned long destiny>
struct mystery<happiness, destiny> {
typedef happiness unveiled;
};
template<typename love>
std::string dreams_come_true(const love&) {
return std::string(1, love::HACTEHbKA::destiny) +
dreams_come_true(typename love::bormand());
}
std::string dreams_come_true(const happiness&) {
return std::string();
}
int main() {
std::cout << dreams_come_true(mystery<HACTEHbKA, 1>::unveiled());
}Я перепесала http://govnokod.ru/21198 через вычесления на чистом уровне и кампеляции как моя чистая любовь
guestinh0,
11 Мая 2017
−2
void __attribute__ ((naked)) c8_handler_i() {
asm volatile (
"push %%ebp \n\
mov %%esp, %%ebp \n\
sub $20, %%esp \n\
mov %%eax, -4(%%ebp) \n\
mov %%ebx, -8(%%ebp) \n\
mov %%edx, -12(%%ebp) \n\
mov %[tasks], %%ebx \n\
mov %[cur_task], %%eax \n\
mov %[t_sz], %%edx \n\
mov (%%eax), %%eax \n\
mul %%edx \n\
add %%eax, %%ebx \n\
mov -4(%%ebp), %%eax \n\
mov %%eax, (%%ebx) \n\
mov -8(%%ebp), %%eax \n\
mov %%eax, 4(%%ebx) \n\
mov %%ecx, 8(%%ebx) \n\
mov -12(%%ebp), %%eax \n\
mov %%eax, 12(%%ebx) \n\
mov %%esi, 16(%%ebx) \n\
mov %%edi, 20(%%ebx) \n\
mov %%ebp, 24(%%ebx) \n\
addl $4, 24(%%ebx) \n\
mov (%%ebp), %%eax \n\
mov %%eax, 28(%%ebx) \n\
mov -4(%%ebp), %%eax \n\
mov -8(%%ebp), %%ebx \n\
mov -12(%%ebp), %%edx \n\
add $20, %%esp \n\
pop %%ebp \n\
iret"
:: [tasks] "i" (tasks), [cur_task] "i" (&cur_task),
[t_sz] "i" (sizeof(task)), [t_eip] "i" (offsetof(task, eip)),
[t_ebx] "i" (offsetof(reg_values, ebx))
);
}Когда решился написать ОС на C++
cykablyad,
11 Мая 2017
Follow us!