- 1
'x'.repeat(a).concat('x'.repeat(b)).length
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
0
'x'.repeat(a).concat('x'.repeat(b)).length
Сложение чисел a и b без использования операторов + и -
0
# ------------------- fUnicodeToUTF8----------------------
:global fUnicodeToUTF8
:if (!any $fUnicodeToUTF8) do={ :global fUnicodeToUTF8 do={
:global fByteToEscapeChar
# :local Ubytes [:tonum $1]
:local Nbyte
:local EscapeStr ""
:if ($1 < 0x80) do={
:set EscapeStr [$fByteToEscapeChar $1]
} else={
:if ($1 < 0x800) do={
:set Nbyte 2
} else={
:if ($1 < 0x10000) do={
:set Nbyte 3
} else={
:if ($1 < 0x20000) do={
:set Nbyte 4
} else={
:if ($1 < 0x4000000) do={
:set Nbyte 5
} else={
:if ($1 < 0x80000000) do={
:set Nbyte 6
}
}
}
}
}
:for i from=2 to=$Nbyte do={
:set EscapeStr ([$fByteToEscapeChar ($1 & 0x3F | 0x80)] . $EscapeStr)
:set $1 ($1 >> 6)
}
:set EscapeStr ([$fByteToEscapeChar (((0xFF00 >> $Nbyte) & 0xFF) | $1)] . $EscapeStr)
}
:return $EscapeStr
}}
угадай язык
0
if (condition)
{
return result;
}
for (let i = 0; i < 5; i++)
{
console.log(i)
}
Зачастую у многих программистов, который пишут на джаваскрипте, наблюдаю следующую картину - вероятно, унаследованную из какого-нибудь си шарпа.
Можно ли назвать это говнокодом, в рамках JS?
0
#include <iostream>
#include <vector>
template <typename T>
struct Vec {
T x, y;
Vec& operator /=(const T& d) {
x /= d;
y /= d;
return *this;
}
};
Найдите баг в коде.
Посмотрел этот видос: https://www.youtube.com/watch?v=4M1MlW0sP0Q
0
// https://www.linux.org.ru/forum/development/16099510/
// c++ шаблон zip-like итератора?
// В python есть крайне полезные функции zip, enumerate, range. Мне нужно что-то подобное для cpp/cuda (c++17).
// Если c range и enumerate более менее понятно, то как реализовать zip не соображу. Семантически это должно быть variadic template
template<typename t, typename... ts>
class zip : zip<ts...>{
zip(t arg, ts... args);
struct iterator;
begin() -> iterator;
end() -> iterator;
};
// Где итератор возвращает кортеж ссылок на элементы что с контейнерами можно было работать как:
for(auto [x,y,z] : zip(xs,ys,zs))
// Рекурсивное наследование должно быть ограничено тривиальным случаем одного аргумента.
//Но, кажется, я думаю не в правильную сторону, в частности, не соображу как рекурсивно вывести тип возвращаемых итератором кортежей:
using ret_type = tuple<decltype(begin(declval<t>())), decltype(???)>
Блять, как всё сложно. Какие-то рекурсивные выводы типов возвращаемых итераторов кортежей блядь.
Вот если б вместо ущербного триждыблядского типодрочерского шаблоноговна сделали что-то помощнее...
0
import fnmatch,os,datetime,time,re,shutil,sys
def find(pattern, startdir=os.curdir):
for (thisDir, subsHere, filesHere) in os.walk(startdir): #
for name in subsHere + filesHere:
if fnmatch.fnmatch(name,pattern):
fullpath = os.path.join(thisDir,name)
yield fullpath
def timeconvert(x):
convert = time.strftime("%Y-%m-%d",time.localtime(os.path.getctime(x)))
return convert
print("select action: delete: delete files: copy: copy files: view: view files")
action = input(" ")
if action == "copy":
print("inter path")
dest = input(" ")
else:
print ("inter date")
cursive = input("")
optime = re.search('20[0-12]\d{1,2}.\d{1,2}',cursive)
if optime == None:
print ('error')
else:
if __name__== '__main__':
import sys
namepattern,startdir, = sys.argv[1],sys.argv[2]
for name in find(namepattern,startdir):
if not str(cursive) <= timeconvert(name):
if action == 'copy':
shutil.copy(name, dest)
elif action == 'delete':
os.remove(name)
elif action == "view":
print(name + timeconvert(name))
else:
print ('error')
Я по сусекам метён,
По коробам скребён,
На сыром масле мешен,
На окошке стужен;
Я от дедушки ушёл,
Я от бабушки ушёл,
И от тебя убегу.
−6
includelib C:\Irvine\User32.Lib
includelib C:\Irvine\Kernel32.Lib
includelib D:\masm32\lib\Irvine32.lib
include \masm32\include\Irvine32.inc
; D:/masm32/bin/ml.exe /c /coff "D:\asm\rcl.asm"
; D:/masm32\bin\link.exe /subsystem:console "D:\asm\rcl.obj"
.data
.code
main PROC
xor eax, eax
xor edx , edx
mov al , 10101010b
cmp al,80h
jns just
shr al,1
jmp print
just:
shr al,1
or ax,80h
print:
call WriteBin
exit
main ENDP
END main
Дай бог здоровья товарищу Ирвину.
−3
int hlp_fix(char data[] , char dump_alpha[] ){
int run = 0;
char prev = '0';
int count_bracket = 0 ;
puts(dump_alpha);
if(my_isdigit(data[0]) || my_isalpha(data[0]) ){
prev = data[0];
}
else if (data[0] == '('){
count_bracket++;
prev = data[0];
}
else{
puts("!!! first error !!!");
exit(1);
}
for(run = 1;data[run] != '\0' ;run++){
if ( data[run + 1] == '\0' && isOperator(prev ) ){
puts("!!! error isOperator !!!");
exit(1);
}
if(isgraph(data[run] )){
if( secure_1(data[run], dump_alpha ) ) {
printf("!!! error this no list = %c !!!", data[run] );
exit(1);
}
if(prev == '.' ){
if( data[run - 1 ] == '.' && my_isdigit(data[run]) ) {
prev = data[run];
}
else{
puts(" !!! error point !!!");
exit(1);
}
}
else if(my_isdigit(prev) ){
if( data[run] == ')' ) {
prev = data[run];
--count_bracket;
}
else if( ( my_isdigit(data[ run - 1 ]) || data[run - 1 ] == '.' ||
isOperator(data[run]) ) ){
prev = data[run];
}
else{
puts("error isdigit");
exit(1);
}
}
else if(isOperator(prev)){
if( (my_isdigit(data[run]) || my_isalpha(data[run] ) ) ){
prev = data[run];
}
else if ( data[run] == '(' ){
prev = data[run];
count_bracket++;
}
else{
puts("error isOperator");
exit(1);
}
}
else if(prev == '(' ){
if( (my_isdigit(data[run] ) || my_isalpha(data[run] ) ) ){
prev = data[run];
}
else if ( data[run] == '('){
count_bracket++;
prev = data[run];
}
else{
Ни что так не вдохновляет на бейсджампинг без парашюта как "отлов ошибок" который не работает ))))
https://ideone.com/rjrwMQ
−2
This would raise the true nightmare. A type variable is a different beast than the actual type of a concrete instance.
A type variable could resolve to a, e.g. ? extends Comparator<? super Number> to name one (rather simple) example.
Providing the necessary meta information would imply that not only object allocation becomes much more expensive,
every single method invocation could impose these additional cost, to an even bigger extend as we are now not only
talking about the combination of generic classes with actual classes, but also every possible wildcarded combination,
even of nested generic types.
https://stackoverflow.com/a/38060012
Джавист-долбоеб с пеной у рта защищает type erasure, задавая вопросы "Does it [c#] have an equivalent of Function.identity()? " в комментариях и собирая плюсы таких же поехавших.
В качестве аргументов он предлагает:
1) сложна
2) хранить информацию о типах в рантайме означает что в рантайме придется хранить информацию о типах!!!
3) [s]ма-те-ма-ти-ка[/x] реф-лек-си-я
Причем ведь наверняка знает и про темплейты в крестах, и про то что шарп такой хуйней не страдает.
0
#include <string>
#include <iostream>
int main() {
std::string kakoi("Какой багор )))", 5);
std::string bagor((std::string)"Какой багор )))" , 5);
std::cout << kakoi << bagor << std::endl;
}
Наверняка было, но ладно.
https://ideone.com/syFnI2