- 1
 - 2
 - 3
 - 4
 
function H2I takes handle h returns integer
  return h
  return 0
endfunction
                                    Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 7
+4
function H2I takes handle h returns integer
  return h
  return 0
endfunction
                                    Return Bug. Интересно, кто-то ещё помнит?
+8
constexpr auto auto()
{
  return 1;
}
typedef decltype(auto()) auto;
const auto auto = auto();
template <typename auto>
constexpr auto auto() {
    return auto;
}
template <typename auto, typename auto, typename... auto>
constexpr auto auto() {
    return auto + auto<auto, auto...>();
}
int main()
{
  constexpr auto auto = auto<auto,auto,auto,auto,auto,auto>();
  constexpr auto auto = auto<auto,auto,auto,auto,auto,auto,auto>();
  return auto*auto; 
}
                                    
            auto auto auto...
https://twitter.com/RichardKogelnig/status/943497972481953792
https://godbolt.org/g/Yvczo1
        
+5
template<typename T>
T* sanitize(T* p)
{
    return reinterpret_cast<T*>(
      reinterpret_cast<uintptr_t>(p) & ~(alignof(T)-1));
}
template<typename T>
constexpr size_t avaliable_width()
{
  	switch(alignof(T))
    {
      case 1: return 0;
      case 2: return 1;
      case 4: return 2;
      case 8: return 3;
      case 16: return 4;
      case 32: return 5;
      case 64: return 6;
      case 128: return 7;
      case 256: return 8;
      default: return 0;
    }
}
template<size_t bit, typename T>
T* set_tag(T* p, bool tagged = true)
{
  	static_assert(bit < avaliable_width<T>(), "bad_width");
	if(tagged) {
     	return reinterpret_cast<T*>(
        	reinterpret_cast<uintptr_t>(p) | 1 << bit); 
    }
  	return reinterpret_cast<T*>(
      	reinterpret_cast<uintptr_t>(p) & ~(uintptr_t(1) << bit));
}
template<size_t bit, typename T>
bool get_tag(T* p)
{
  	static_assert(bit < avaliable_width<T>(), "bad_width");
  	return reinterpret_cast<uintptr_t>(p) >> bit & 1;
}
                                    Младшие биты указателей на выравненные типы всегда нулевые. Из за этого (по формуле Шеннона) указатель несёт в себе меньше информации, оставаясь того же размера. Битоёбов это расстраивает.
−23
package com.engineerdollery;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static java.util.stream.Collectors.*;
public class FizzBuzz {
    private static final String NUMBER = "\\d+";
    public String basic() {
        return IntStream.rangeClosed(1, 20)
                .parallel()
                .mapToObj(i -> i % 15 == 0 ? "fizzbuzz"
                        : i % 3 == 0 ? "fizz"
                        : i % 5 == 0 ? "buzz"
                        : Integer.toString(i))
                .collect(joining(" "));
    }
    public String lucky() {
        return IntStream.rangeClosed(1, 20)
                .parallel()
                .mapToObj(i -> Integer.toString(i).contains("3") ? "lucky" // this is the only change from basic()
                        : i % 15 == 0 ? "fizzbuzz"
                        : i % 3 == 0 ? "fizz"
                        : i % 5 == 0 ? "buzz"
                        : Integer.toString(i))
                .collect(joining(" "));
    }
    public String counter() {
        List<String> fizzBuzzList = IntStream.rangeClosed(1, 20)
                .parallel()
                .mapToObj(i -> Integer.toString(i).contains("3") ? "lucky"
                        : i % 15 == 0 ? "fizzbuzz"
                        : i % 3 == 0 ? "fizz"
                        : i % 5 == 0 ? "buzz"
                        : Integer.toString(i))
                .collect(Collectors.toList());
        Map<String, Long> countMap = fizzBuzzList
                .parallelStream()
                .collect(groupingBy(s -> s.matches(NUMBER) ? "integer" : s, counting()));
        // reports
        String fizzbuzz = fizzBuzzList.parallelStream().collect(joining(" "));
        String counts = countMap.entrySet().parallelStream()
                .map(e -> e.getKey() + ": " + e.getValue())
                .collect(joining("\n"));
        return fizzbuzz + "\n" + counts;
    }
}
                                    
            Поддерживаемый вариант FizzBuzz с параллелизмом и регулярными выражениями.
Взято отсюда: http://codereview.stackexchange.com/questions/126845/interview-coding-test-fizz-buzz
        
−43
damage, self.magic_shield_hp = sorted([0, magic_shield_hp - damage])
damage = -damage
                                    Интуитивно понятный способ реализовать урон, пробивающий защиту.
+56
std::uint8_t octets[4];
for(int i = 0; i < 4; ++i) {
    if(i != 0 && inp.get() != '.')
        { assert(false && "unexpected symbol"); }
    inp >> octets[i];
}
                                    Два вида говна: в коде и в языке.
+8
{
    if(find(p) == board.end() || (*find(p))->suit != (*selected)->suit)[&]
    {
        {
          auto it = std::find_if(board.pieceCapturings().begin(),
                       board.pieceCapturings().end(),
                                   [&](board::Board::Movements_t::value_type const &m)
                                   {
                                       return m.first == selected && m.second == p;
                                   });
            if(it != board.pieceCapturings().end())
            {
                for(auto jt = board.pieceCapturables().begin(); jt != board.pieceCapturables().end(); ++jt)
                {
                    if(jt->second == p)
                    {
                        if(board.capture(selected, it, jt))
                        {
                            nextTurn();
                            return;
                        }
                    }
                }
            }
        }
        {
            auto it = std::find_if(board.pieceTrajectories().begin(),
                                   board.pieceTrajectories().end(),
                                   [&](board::Board::Movements_t::value_type const &m)
                                   {
                                       return m.first == selected && m.second == p;
                                   });
            if(it != board.pieceTrajectories().end())
            {
                if(board.move(selected, it))
                {
                    nextTurn();
                }
            }
        }
    }();
    selected = board.end(); //deselect
}
                                    
            https://github.com/cpluspluscom/ChessPlusPlus/blob/master/src/app/ChessPlusPlusState.cpp   
When you see it...