public class PrimeGenerator {

	public static void main(String[] args) {
		long start = System.nanoTime();
		new PrimeGenerator().generatePrimesArray(100000);
		long end = System.nanoTime();
		System.out.println(\"time in milliseconds: \" + (end - start) / 1000000);
	}

	private int[] generatePrimesArray(int number) {
		int[] primes = new int[number];
		for (int primesFound = 0, i = 0; primesFound < number; i++) {
			if (isPrime(i)) {
				System.out.println((primesFound + 1) + \": \" + i); // delete this line for the second try
				primes[primesFound] = i;
				primesFound++;
			}
		}
		return primes;
	}

	private boolean isPrime(int n) {
		if (n < 2) {
			return false;
		}
		if (n == 2) {
			return true;
		}
		for (int i = 2; i < Math.sqrt(n); i++) {
			if (n % i == 0) {
				return false;
			}
		}
		return true;
	}

}

start = getTime();
for(i = 0; i < TIMES; i++){
   myTask();
}
end = getTime();
result = (end - start) / TIMES;

#include<p18cxxx.h>
unsigned char var, var1,var2,i,j;
void main()
{
TRISD=0x00;
var=0x00;
i=0x08;
while(1)
{
var2=0x00;
j=i;
for(i=8;i>0;i--)
{
var=var2;
var1=0x01;
for(j=i;j>0;j--)
{
var2=var+var1;
LATD=var2;
var1=var1<<1;
}
}
}
}

int led1 = 11;
int led2 = 12;
int led3 = 10;
int led4 = 9;


void setup() {
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  
}

void loop() {
  digitalWrite(led1, HIGH);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  delay(200);
  digitalWrite(led1, LOW);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  delay(200);
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, LOW);
  delay(200);
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, HIGH);
  delay(200);
}

#include<p18cxxx.h>
void delay(void);
unsigned char var1,var2,i;
void main()
{
TRISD=0x00;
while(1)
{
var1=0x01;
var2=0x80;
for(i=0;i<=7;i++)
{
LATD=var1|var2;
var1=var1<<1;
var2=var2>>1;
delay();
}
}
}
void delay(void)
{
int j;
for(j=0;j<=4;j++)
{
;
}
}

int buttonpin = 2;
int buttonstate = 0;
int led1 = 12;
void setup() {
  pinMode(led1, OUTPUT);
  pinMode(buttonpin, INPUT);  
}

void loop() {
  buttonstate = digitalRead(buttonpin);
  Serial.println(digitalRead(buttonpin));
  if (buttonstate == HIGH) {
  digitalWrite(led1, HIGH);
    
  }
else {
  digitalWrite(led1, LOW);
  
  }
}

import Data.List
import System.Cmd

main = do 
	x <- readFile \"/etc/pacman.d/mirrorlist.pacnew\"
	writeFile \"/etc/pacman.d/mirrorlist.backup\" $ unlines (prepareList (lines x)) 
	system \"rankmirrors -n 6 /etc/pacman.d/mirrorlist.backup > /etc/pacman.d/mirrorlist\"

prepareList :: [String] -> [String]
prepareList xss = _prepareList xss \"German\" \"#\" \"Server\"

_prepareList :: Eq a => [[a]] -> [a] -> [a] -> [a] -> [[a]]
_prepareList xss start comment server = case xss of
	[] -> []
	xs : xss' -> if contains xs start
			then [xs] ++ (removeComments xss' comment server)
			else [xs] ++ (_prepareList xss' start comment server)

removeComments :: Eq a => [[a]] -> [a] -> [a] -> [[a]]
removeComments xss comment server = case xss of
	[] -> []
	xs : xss' -> if contains xs server
			then [drop 1 xs] ++ (removeComments xss' comment server) 
			else xs : xss'

contains :: Eq a => [a] -> [a] -> Bool
contains xs [] = True
contains xs (y : ys') = case xs of
	[] -> False
	x : xs' -> if x == y
			then contains xs' ys'
			else contains xs' (y : ys') 

.
              points display
                  ^
                  |
                  |
card table <--  state --> chart A 
                  |
                  |
                  v
                chart B

class PointsDisplay {
   
   attribute GameState gameState;

   method testForUpdate() {
      every second do {
         if(gameState.hasStateChanged()){
            displayPoints(gameState.getPoints());
         }
      }
   }

}

class AI {

  method nextMove(){
     Card card = takeCard();
     updateChartA(card);
     updateChartB(card);
     updateCardTable(card);
     updatePointsDisplay(card);
  }

}

class CardTable { //This is the gui that shows data, but also 
                  //retrieves input of the human player

  method playersHasChosenCard(Card card){
     updateChartA(card);
     updateChartB(card);
     updateCardTable(card);
     updatePointsDisplay(card);
  }

}

class GameState {
   
  attribute ChartA chartA;
  attribute ChartB chartB;
  attribute PointsDisplay points;
  attribute CardTable table;

  method update(){
    chartA.update(updateInfo);
    chartB.update(updateInfo);
    points.update(updateInfo);
    table.update(updateInfo);
  }

}

class GameState {
   
  attribute ChartA chartA;
  attribute ChartB chartB;
  attribute PointsDisplay points;
  attribute CardTable table;

  method update(){
    if(chartA.isAvailable()) {
       chartA.update(updateInfo);
    }
    if(chartB.isAvailable()) {
       chartB.update(updateInfo);
    }

    points.update(updateInfo);
    table.update(updateInfo);
  }

}

class GameState {
   
  attribute ObserverCollection observers;  

  method notify(){
    foreach Observer o in observers {
       o.update();
    }
  }

}

class PointsDisplay extends Observer {
   
   attribute GameState gameState;

   method update() {
      State state = gameState.getState();
      displayPoints(state.getPoints());
   }

}

public class WordListGen {

	public static void main(String[] args) {
		generate();
	}

	private static void generate() {
		int wordlength = 3;
		char[] alphabet = { '1', '0' };
	}
}

final long MAX_WORDS = (long) Math.pow(alphabet.length,
				wordlength);

for (long i = 0; i < MAX_WORDS; i++) {
}

final int RADIX = alphabet.length;

private static int[] convertToRadix(int radix, long number, int wordlength) {
	int[] result = new int[wordlength];
	for (int i = wordlength - 1; i >= 0; i--) {
		if (number > 0) {
			int rest = (int) (number % radix);
			number /= radix;
			result[i] = rest;
		} else {
			result[i] = 0;
		}

	}
	return result;
}

private static void generate() {
	int wordlength = 3;
	char[] alphabet = { '0', '1' };
	final long MAX_WORDS = (long) Math.pow(alphabet.length, wordlength);
	final int RADIX = alphabet.length;

	for (long i = 0; i < MAX_WORDS; i++) {
		int[] indices = convertToRadix(RADIX, i, wordlength);
		for(int index : indices){
			System.out.print(index);
		}
		System.out.println();
	}
}

char[] alphabet = { 'a', 'b' };

char[] word = new char[wordlength];
for (int k = 0; k < wordlength; k++) {
	word[k] = alphabet[indices[k]];
}
System.out.println(word);

public class WordListGen {

	public static void main(String[] args) {
			generate();
	}

	private static void generate() {
		int wordlength = 3;
		char[] alphabet = { 'a', 'b' };
		final long MAX_WORDS = (long) Math.pow(alphabet.length, wordlength);
		final int RADIX = alphabet.length;
	
		for (long i = 0; i < MAX_WORDS; i++) {
			int[] indices = convertToRadix(RADIX, i, wordlength);
			char[] word = new char[wordlength];
			for (int k = 0; k < wordlength; k++) {
				word[k] = alphabet[indices[k]];
			}
			System.out.println(word);
		}
	}

	private static int[] convertToRadix(int radix, long number, int wordlength) {
		int[] indices = new int[wordlength];
		for (int i = wordlength - 1; i >= 0; i--) {
			if (number > 0) {
				int rest = (int) (number % radix);
				number /= radix;
				indices[i] = rest;
			} else {
				indices[i] = 0;
			}
	
		}
		return indices;
	}
}