#29 PHP +40
<?php 
foreach (array_keys($values['services']) as $serviceId) {
    $service = $this->_em->find('\cut\Entity\Service', $serviceId);

    //\Doctrine\Common\Util\Debug::print_r($service); exit();
    //$reservation->addService($this->_em->find('\cut\Entity\Service', $serviceId));
    $this->view->serviceDeposits[$serviceId] = $service->getDeposit();
}
# checkign if clinic want's bill
$notifications = array();
$reservationServices = array();
foreach (array_keys($values['services']) as $serviceId) {
    $reservationServices[$serviceId] = new \cut\Entity\ReservationService();
    $service                         = $this->_em->find('\cut\Entity\Service', $serviceId);
    //\Doctrine\Common\Util\Debug::print_r($service); exit();
    $reservationServices[$serviceId]->setService($service);
    $reservationServices[$serviceId]->setReservation($reservation);
    $reservationServices[$serviceId]->setPatient($this->_helper->LoggedUser());

    switch ($service->getDeposit()) {
        case 'yes':
            $reservationServices[$serviceId]->setBillStatus(\cut\Entity\ReservationService::BILL_STATUS_NOT_PAID);
            break;
        default:
            $reservationServices[$serviceId]->setBillStatus(\cut\Entity\ReservationService::BILL_STATUS_NOT_WANTED);
    }

    $this->view->serviceDeposits[$serviceId] = $service->getDeposit();
}
By Anonymous, 2015-07-20 21:12:05
int phoneNumberFinder(int phoneNum){
int num = 0;
   while (true){
    if(phoneNum == num){
     return num;
    else{
      num++;
    }
  }
}
By Neeson, 2017-12-13 21:33:52
// Is this valid?
function validateStockInItems() {
    if (stockInItemsToUpdate.length === 0)
        return true;
    return true;
}

Found in a legacy code base for a stock management system. I will be rewriting said system soon.

By Anonymous, 2017-12-13 09:15:42
public void Method1(Enum foo)
{
    if (GetCondition1(foo))
    {
        doSomething();
    }
}

private bool GetCondition1(Enum foo)
{
    if (foo == Enum.Value1)
        return true;

    return false;
}
By Anonymous, 2018-02-23 17:34:55
var filter = options.dataSource.filter();

if(e.filter) {
   filter = filter && filter.filters.length ? filter.filters.concat(e.filter.filter) : e.filter.filters;
}
else {
   filter = filter && filter.filters.length ? filter.filters.linqRemove({ field: e.field }) : [];
}
options.dataSource.filter(filter);
By Anonymous, 2018-02-09 19:03:07
private void reset_kolejnosc()
{
	this.kolejnosc_s[0] = 1;
	this.kolejnosc_s[1] = 2;
	this.kolejnosc_s[2] = 3;
	this.kolejnosc_s[3] = 4;
	this.kolejnosc_s[4] = 5;
	this.kolejnosc_s[5] = 6;
	this.kolejnosc_s[6] = 7;
	this.kolejnosc_s[7] = 8;
	this.kolejnosc_s[8] = 9;
	this.kolejnosc_s[9] = 10;
}
By winek, 2016-07-17 00:16:00
boolean darkModeSelected = (!darkModeSelected ? true : false);
By Anonymous, 2017-12-13 09:40:59
if (i === 1 || i === 2 || i === 3 || i === 4 || i === 5 || i === 6 || i === 7 || i === 8 || i === 9 || i === 10){
 return true;
}
By foxy, 2017-12-13 23:25:17

// enum - full enumeration of knapsack solutions
// (C) Joshua Knowles

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

FILE *fp;  // file pointer for reading the input files
int Capacity;     // capacity of the knapsack (total weight that can be stored)
int Nitems;    // number of items available
int *item_weights;  // vector of item weights
int *item_values;  // vector of item profits or values
int *temp_indexes;  // list of temporary item indexes for sorting items by value/weight
int QUIET=0; // this can be set to 1 to suppress output

extern void read_knapsack_instance(char *filename);
extern void print_instance();
extern void sort_by_ratio();
extern int check_evaluate_and_print_sol(int *sol,  int *total_value, int *total_weight);
void enumerate();
int next_binary(int *str, int Nitems);

int main(int argc, char *argv[])
{
  read_knapsack_instance(argv[1]);
  print_instance();
  enumerate();
  return(0);
}

void enumerate()
{
  // Do an exhaustive search (aka enumeration) of all possible ways to pack
  // the knapsack.
  // This is achieved by creating every binary solution vector of length Nitems.
  // For each solution vector, its value and weight is calculated.


  int i;  // item index
  int solution[Nitems+1];   // (binary) solution vector representing items packed
  int best_solution[Nitems+1];  // (binary) solution vector for best solution found
  int best_value; // total value packed in the best solution
  double j=0;
  int total_value, total_weight; // total value and total weight of current knapsack solution
  int infeasible;  // 0 means feasible; -1 means infeasible (violates the capacity constraint)

  // set the knapsack initially empty
  for(i=1;i<=Nitems;i++)
    {
      solution[i]=0;
    }
  QUIET=1;
  best_value=0;

 while(!(next_binary(&solution[1], Nitems)))
    {

      /* ADD CODE IN HERE TO KEEP TRACK OF FRACTION OF ENUMERATION DONE */

          // calculates the value and weight and feasibility:
      infeasible=check_evaluate_and_print_sol(solution, &total_value, &total_weight);  
      /* ADD CODE IN HERE TO KEEP TRACK OF BEST SOLUTION FOUND*/

    }
 /* ADD CODE TO PRINT OUT BEST SOLUTION */

}


int next_binary(int *str, int Nitems)
{
  // Called with a binary string of length Nitems, this 
  // function adds "1" to the string, e.g. 0001 would turn to 0010.
  // If the string overflows, then the function returns 1, else it returns 0.
  int i=Nitems-1;
  while(i>=0)
    {
      if(str[i]==1)
	{
	  str[i]=0;
	  i--;
	}
      else
	{
	  str[i]=1;
	  break;
	}
    }
  if(i==-1)
    {
      return(1);
    }
  else
    {
      return(0);
    }
}

A genuine UoM lab.

By Joshua Knowles, 2018-02-23 10:58:03
int length = 0;
for(int idx = 0; idx < a.length; i++) {
     length++;
}
System.out.println("length is : " + length);
By Slacki, 2015-07-22 14:25:02
Double value = item.getPrice() * loyaltyPointMultiplier;
String[] s = String.split(value.toString(), "\\.");
points = Integer.parseInt(s[0]);
if(Integer.parseInt(s[1]) > 0) {
    points++;
}
    
return points;

Want to round up? Math.ceil() uses too little memory! Use this instead!

By phytyca, 2017-12-12 05:02:48
public static int[] sleepSort(int... args) {
        final int[] sorted = new int[args.length];
        final AtomicInteger index = new AtomicInteger(0);
        List<Thread> threads = new ArrayList<Thread>(0);
        for (int i = 0; i < args.length; i++) {
            final int x = i;
            Thread sorter = new Thread(() -> {
                try {
                    Thread.sleep(args[x]);
                } catch (InterruptedException ex) { 
                    // shrug
                }
                sorted[index.getAndIncrement()] = args[x];
            });
            sorter.setDaemon(true);
            sorter.start();
            threads.add(sorter);
        }
        try {
            for (Thread t : threads) { t.join(); }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return sorted;
    }

Takes an unsorted array of integers, sorts by sleeping for the int value of each item in the array and then writing that into the resulting sorted array. Big-O analysis is... difficult.

By Sum YungGui, 2017-12-12 17:10:56
    $partnerChargesRegular = $row['charges'];
    $partnerChargesIrregular = $row['charges'];
    if (!isset($partnerChargesIrregular) || $partnerChargesIrregular == "") {
      $partnerChargesIrregular = $partnerChargesRegular;
    }

Look. We take A from X and B from X. Then, you make a check, and if it is true you assing A to B. BUT A AND B ARE TAKEN FROM THE SAME X PLACE!!! HOW CAN THEY DIFFER?!?!!!?!?!?!?!!

By My boss, 2018-02-20 10:06:53
int number = -1;
                //todo: refactor this horse shit.
                for (String res: results) {
                    if(number == -1){
                        if(res.toLowerCase().contains("ten") || res.contains("10") || res.contains("10") || res.contains("十") || res.contains("십")){
                            number = 10;
                        }
                        else if(res.toLowerCase().contains("nine") || res.contains("9") || res.contains("9") || res.contains("九") || res.contains("구")){
                            number = 9;
                        }
                        else if(res.toLowerCase().contains("eight") || res.contains("8") || res.contains("8") || res.contains("八") || res.contains("팔")){
                            number = 8;
                        }
                        else if(res.toLowerCase().contains("seven") || res.contains("7") || res.contains("7") || res.contains("七") || res.contains("칠")){
                            number = 7;
                        }
                        else if(res.toLowerCase().contains("six") || res.contains("6") || res.contains("6") || res.contains("六") || res.contains("육")){
                            number = 6;
                        }
                        else if(res.toLowerCase().contains("five") || res.contains("5") || res.contains("5") || res.contains("五") || res.contains("오")){
                            number = 5;
                        }
                        else if(res.toLowerCase().contains("four") || res.contains("4") || res.contains("4") || res.contains("四") || res.contains("사")){
                            number = 4;
                        }
                        else if(res.toLowerCase().contains("three") || res.contains("3") || res.contains("3") || res.contains("三") || res.contains("삼")){
                            number = 3;
                        }
                        else if(res.toLowerCase().contains("two") || res.contains("2") || res.contains("2") || res.contains("二") || res.contains("이")){
                            number = 2;
                        }
                        else if(res.toLowerCase().contains("one") || res.contains("1") || res.contains("1") || res.contains("一") || res.contains("일")){
                            number = 1;
                        }
                    }
                }

refactor this horse shit.

By mister MVC, plus grumpy commenter, 2017-12-13 07:28:20
	void insert(const uint64& g)
	{
		// avoid loops for performance
		if (guid[0] == 0) { guid[0] = g; return; }
		else if (g <= guid[0]) { if (guid[3]) guid[4] = guid[3]; if (guid[2]) guid[3] = guid[2]; if (guid[1]) guid[2] = guid[1]; guid[1] = guid[0]; guid[0] = g; return; }
		if (guid[1] == 0) { guid[1] = g; return; }
		else if (g <= guid[1]) { if (guid[3]) guid[4] = guid[3]; if (guid[2]) guid[3] = guid[2]; guid[2] = guid[1]; guid[1] = g; return; }
		if (guid[2] == 0) { guid[2] = g; return; }
		else if (g <= guid[2]) { if (guid[3]) guid[4] = guid[3]; guid[3] = guid[2]; guid[2] = g; return; }
		if (guid[3] == 0) { guid[3] = g; return; }
		else if (g <= guid[3]) { guid[4] = guid[3]; guid[3] = g; return; }
		guid[4] = g;
	}
	void force_insert_front(const uint64& g)
	{
		if (guid[3]) guid[4] = guid[3]; if (guid[2]) guid[3] = guid[2]; if (guid[1]) guid[2] = guid[1]; guid[1] = guid[0]; guid[0] = g;
	}
	void remove(const uint64& g)
	{
		// avoid loops for performance
		if (guid[0] == g) { if (guid[1]) guid[0] = guid[1]; else { guid[0] = 0; return; } if (guid[2]) guid[1] = guid[2]; else { guid[1] = 0; return; } if (guid[3]) guid[2] = guid[3]; else { guid[2] = 0; return; } if (guid[4]) guid[3] = guid[4]; else { guid[3] = 0; return; } guid[4] = 0; return; }
		if (guid[1] == g) { if (guid[2]) guid[1] = guid[2]; else { guid[1] = 0; return; } if (guid[3]) guid[2] = guid[3]; else { guid[2] = 0; return; } if (guid[4]) guid[3] = guid[4]; else { guid[3] = 0; return; } guid[4] = 0; return; }
		if (guid[2] == g) { if (guid[3]) guid[2] = guid[3]; else { guid[2] = 0; return; } if (guid[4]) guid[3] = guid[4]; else { guid[3] = 0; return; } guid[4] = 0; return; }
		if (guid[3] == g) { if (guid[4]) guid[3] = guid[4]; else { guid[3] = 0; return; } guid[4] = 0; return; }
		if (guid[4] == g) guid[4] = 0;
	}
	bool hasGuid(const uint64& g) const
	{
		return g && (guid[0] == g || guid[1] == g || guid[2] == g || guid[3] == g || guid[4] == g);
	}
	bool operator<(const Lfg5Guids& x) const
	{
		// not neat, but fast xD
		if (guid[0]<=x.guid[0]) {
			if (guid[0] == x.guid[0]) {
				if (guid[1]<=x.guid[1]) {
					if (guid[1] == x.guid[1]) {
						if (guid[2]<=x.guid[2]) {
							if (guid[2] == x.guid[2]) {
								if (guid[3]<=x.guid[3]) {
									if (guid[3] == x.guid[3]) {
										if (guid[4]<=x.guid[4]) {
											if (guid[4] == x.guid[4]) return false; else return true;
										} else return false;
									} else return true;
								} else return false;
							} else return true;
						} else return false;
					} else return true;
				} else return false;
			} else return true;
		} else return false;
	}
	bool operator==(const Lfg5Guids& x) const
	{
		return guid[0] == x.guid[0] && guid[1] == x.guid[1] && guid[2] == x.guid[2] && guid[3] == x.guid[3] && guid[4] == x.guid[4];
	}
By Pussywizard, 2017-12-13 14:15:46