```c++
#include <iostream>;
//needs to be able to handle integers longer than long long as in the longest possible ints

using namespace std;

int main(){
	long n; 

	while(cin >> n){
		bool isLeapYear = ((n % 4 == 0) && (n % 100 != 0)) || (n % 400 == 0);
		bool isHuluculu = n % 15 == 0;
		bool isBulukulu = (n % 55 == 0) && isLeapYear;

		bool ordinaryYear =  !isLeapYear && !isHuluculu && !isBulukulu; 


		// cout << "LeapYear? " << isLeapYear << endl;
		// cout << "huluculu? " << isHuluculu << endl;
		// cout << "bulukulu? " << isBulukulu << endl;

		if(ordinaryYear){
			cout << "This is an ordinary year." << endl;

		} else {
			if(isLeapYear){
				cout << "This is leap year." << endl;
			} 

			if(isHuluculu){
				cout << "This is huluculu festival year." << endl;
			}

			if(isBulukulu){
				cout << "This is bulukulu festival year." << endl;
			}
		}

		cout << endl;

	}

	return 0;


}
```

Leap Year or Not Leap Year and ...

```c++
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <cstdio>
#include <cctype>


using namespace std;

int main(){
	
	int n;
	string in;
	int array[26] = {};
	priority_queue<pair<int,int> > pq;


	cin >> n;

	getline(cin, in);
	for(int i = 0; i < n; i++){
		getline(cin, in);
		transform(in.begin(), in.end(), in.begin(), ::toupper);
		// cout << in << endl;
		for(int j = 0; j < in.length(); j++){
			if(in[j] >= 'A' && in[j] <= 'Z'){
				int c = (int)in[j];
				array[c - 65]++;
			}
		}
	}

	
	for(int i = 0; i < 26; i++){
		if(array[i] > 0){
			pq.push(make_pair(array[i], -(i + 'A')));
		}
	}

	while(!pq.empty()){
		char letter = (char)-pq.top().second;
		int freq = pq.top().first;

		cout << letter << " " << freq << endl; 
		pq.pop();

	}
			

	return 0;

}
```



What's Cryptanalysis?

```c++
#include <iostream>
#include <string>
#include <sstream>


using namespace std;

int main(){
	int cases, 


	stringstream ss;




	return 0;
}
```





Where's Waldorf?


```c++
#include <iostream>;

using namespace std;

int main(){
	int n1, n2;
	
	

	while(cin >> n1 >> n2){
		if(n1 == 0 && n2 == 0){
			break;
		}

		int counter = 0;
		int carry = 0; 
		int sum = 0; 


		while(n1 > 0 || n2 > 0){

		
			sum = carry + (n1 % 10) + (n2 % 10);

			if(sum >= 10){
				counter++;
			}

			carry = sum/10;

			n1 /= 10;
			n2 /= 10;

	}

		if(counter == 1){
			cout << counter << " carry operation." << endl; 

		} else if(counter > 1){
			
			cout << counter << " carry operations." << endl; 

		} else {
			
			cout << "No carry operation." << endl;

		}


	}	


	return 0;
}
```


Primary Arithmetic

```c++
#include <iostream>

using namespace std;


int main(){
	long long v, t;


	while(cin >> v >> t){

		long long t2 = t * 2;

		if(t2 == 0 || v == 0){
			cout << 0 << endl;

		} else {
			long long a = v/t2;
			long long displacement = v * t2 + (1/2 * a * t2 * t2); 
			cout << displacement << endl;

		}

		

	}
	

	return 0;
}
```

Back to High School Physics

```c++
#include <cstdio>
#include <map>
using namespace std;
 
int main() {
    char c;
    map<char, char> t;
    t[' '] =    ' ';
    t['\n'] =   '\n';
    t['1'] =    '`';
    t['2'] =    '1';
    t['3'] =    '2';
    t['4'] =    '3';
    t['5'] =    '4';
    t['6'] =    '5';
    t['7'] =    '6';
    t['8'] =    '7';
    t['9'] =    '8';
    t['0'] =    '9';
    t['-'] =    '0';
    t['='] =    '-';
    t['W'] =    'Q';
    t['E'] =    'W';
    t['R'] =    'E';
    t['T'] =    'R';
    t['Y'] =    'T';
    t['U'] =    'Y';
    t['I'] =    'U';
    t['O'] =    'I';
    t['P'] =    'O';
    t['['] =    'P';
    t[']'] =    '[';
    t['\\'] =   ']';
    t['S'] =    'A';
    t['D'] =    'S';
    t['F'] =    'D';
    t['G'] =    'F';
    t['H'] =    'G';
    t['J'] =    'H';
    t['K'] =    'J';
    t['L'] =    'K';
    t[';'] =    'L';
    t['\''] =   ';';
    t['X'] =    'Z';
    t['C'] =    'X';
    t['V'] =    'C';
    t['B'] =    'V';
    t['N'] =    'B';
    t['M'] =    'N';
    t[','] =    'M';
    t['.'] =    ',';
    t['/'] =    '.';

    while ((c = getchar()) != EOF) {
        putchar(t[c]);
    }
    return 0;
}
```

WERTYU

```java
import java.util.*;
import java.math.*;


public class Main{
	
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);

		while(sc.hasNextLine()){

			String num1 = sc.nextLine();
			String num2 = sc.nextLine();

			BigInteger n1 = new BigInteger(num1);
			BigInteger n2 = new BigInteger(num2);


			BigInteger product = n1.multiply(n2);

			System.out.println(product);


		}

	}
}
```


Product


```c++
#include <iostream>
#include <math.h>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

int main(){
	
	long n; 
	vector<long> vec;
	vector<long>::iterator it;

	bool first = true;
	while(cin >> n){
		if(first){
			vec.push_back(n);
			first = false;
		} else {	
			it = upper_bound(vec.begin(), vec.end(), n);
			vec.insert(it, n);
		}	

		int n = vec.size();
		int med = n/2;

		if(n % 2 == 1){
			cout << vec[med] << endl;
		} else {
			cout << (vec[med-1] + vec[med])/2 << endl;

		}
		

	}
	
	return 0; 
}
```


What is the Median?


```c++
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cctype>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <map>
#include <sstream>
#include <cmath>
#include <bitset>
#include <utility>
#include <set>
using namespace std;
 
int main ()
{
    int n,m;
    int counter=0;
   while(true)
   {
       cin >> m >> n;
       if (n ==0 && m ==0) break;
       counter++;
       if (counter > 1) cout << '\n';
       int field[102][102] = {0};
      for (int i=1; i<m+1; i++)
          for (int j=1; j<n+1; j++)
          {
              char temp;
              cin >> temp;
              if (temp == '*')
                  {
                      //111
                      //1*1
                      //111
                      field[i][j] = -1;
                      if (field[i-1][j] != -1) field[i-1][j]++; //top
                      if (field[i-1][j-1] != -1) field[i-1][j-1]++; //top left
                       if (field[i-1][j+1] != -1) field[i-1][j+1]++; //top right
                      if (field[i][j-1] != -1) field[i][j-1]++;//left
                      if (field[i+1][j] != -1) field[i+1][j]++; // bottom
                      if (field[i+1][j+1] != -1) field[i+1][j+1]++; //bottom right
                      if (field[i+1][j-1] != -1) field[i+1][j-1]++; //bottom right
                      if (field[i][j+1] != -1) field[i][j+1]++; //right
                  }
          }
 
           cout << "Field #" << counter << ":\n";
            for (int i=1; i<m+1; i++)
           {
 
                for (int j=1; j<n+1; j++)
                    {
                        if (field[i][j] == -1) cout << '*';
                        else cout << field[i][j];
                }
                cout << "\n";
           }
 
   }
 
    return 0;
}
```





Minesweeper


```c++
#include <iostream>;

using namespace std;

int main(){
	int s, p, y, j;
	int d = 12;

	while(cin >> s >> p >> y >> j){
		int total_age = d + j;
	}

	return 0; 
}
```

Dick and Jane


```c++
#include <iostream>

using namespace std;

long long table[100001];

long long factorial(long a){
	if(a == 0 || a == 1){
		return 1; 

	} else {
		if(table[a] != 0) {
			return table[a];
		} else {
			return a * factorial(a-1);
		}
	
	}
}

int main(){

	for(int i = 0; i < 100001; i++){
		table[i] = 0;
	}

	long long factorial = factorial(100000); 
	// cout << factorial(10) << endl;

	return 0; 
}
```


Factorial! You Must be Kidding!!!

```c++
#include <iostream>
#include <stdio.h>

using namespace std;


int main(){
	int n, m, in;

	cin >> n;

	for(int i = 0; i < n; i++){
		cin >> m;
		int arr[m];
		double ave = 0;
		double percent = 0;

		for(int j = 0; j < m; j++){
			cin >> in;
			arr[j] = in;
			ave += in;
		}

		ave = ave/m;

		// cout << ave << endl;
		for(int j = 0; j < m; j++){
			if(arr[j] > ave){
				percent++;
			}
		}

		percent = percent/m;

		printf("%.3f%%\n", percent * 100);
		
	}
	return 0; 

}
```



Above Average

```c++
#include <iostream>
#include <string>
#include <sstream>


using namespace std;

int main(){
	
	string s; 
	stringstream ss;
	string country, girl; 
	int n; 
	cin >> n;
	for(int i = 0; i < n; i++){
		getline(cin, s);

		ss << s;
		ss >> country;

	}
	
	return 0; 
}
```

List of Conquests

```c++
#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

double scoreIT(string s){
	int score[26] = {};
	double total = 0;
	transform(s.begin(), s.end(), s.begin(), ::tolower);
	for(int i = 0; i < s.length(); i++){
		if(s[i] >= 'a' && s[i] <= 'z'){
			int index = s[i] - 'a';
			score[index]++;
		}	
	}

	for(int i = 0; i < 26; i++){
		if(score[i] > 0){
			cout << "score " << score[i] << endl;
			total += ((i + 1) * score[i]);
			cout << "total " << total << endl;
		}
	}	

	cout << "total " << total << endl;


	return total;
}




int main(){
	
	string first, second;


	while(cin >> first >> second){
		double score1 = scoreIT(first);
		double score2 = scoreIT(second);
		double total = 0;

		if(score1 >= score2){
			total = score2/score1;
		} else {
			total = score1/score2;
		}

		//total *= 1000.0;
		
		cout << total << endl;	

	}

	return 0;

}
```

Love Calculator


```c++
#include <cmath>
#include <iostream>

using namespace std;

int main(){
	int n, m, in; 
	int c = 1; 

	while(cin >> n){
		if(n== 0) break;

		int nums[n];
		for(int i = 0; i < n; i++){
			cin >> in;
			nums[i] = in;
		}


		cin >> m;
		int queries[m];
		for(int i = 0; i < m; i++){
			cin >> in;
			queries[i] = in;
		}

		// sort(nums, nums + n, greater<int>());
		sort(nums, nums + n);


		cout << "Case " << c << ":" << endl;
		c++;

	
	}

	return 0; 

}
```


Closest Sums



```java
import java.util.*;
import java.math.*;


public class Main{
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext()){
			int N = sc.nextInt();
			int A = sc.nextInt();
			BigInteger sum = new BigInteger("0");
			BigInteger tempA = BigInteger.valueOf(A);
			for(int i = 1; i <= N; i++){
				sum = sum.add(BigInteger.valueOf(i).multiply(tempA.pow(i)));
			}

			System.out.println(sum);
		}

	}

}
```


Very Easy !!!


```c++
#include &lt;iostream&gt;
#include &lt;math.h&gt;

using namespace std;

int main(){
	int start, n1, n2, n3;

	while(cin >> start >> n1 >> n2 >> n3){
		if(start == 0 && n1 == 0 && n2 == 0 && n3 == 0){
			break;
		}

		int degree = 0;
	}	

	return 0; 
}
```


Combination Lock

```c++
#include <iostream>
#include <cmath>

using namespace std;

int main(){
	long long s1, s2, n, a, b;
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> s1 >> s2;

		b = abs(s1 - s2)/2;

		a = s1 - b;

		if(a + b != s1 || abs(a - b) != s2){
			cout << "impossible" << endl;
		} else if (a > b) {
			cout << a << " " << b << endl;
		} else if (a <= b){
			cout << b << " "  << a << endl;
		}
	}
	return 0; 
}
```


Beat the Spread!


```c++
#include <iostream>
#include <string>

using namespace std;



string convert(string s){
	string number = "";
	for(int i = 0; i < s.length(); i++){
		char l = s[i];

		if(l == '0'){
			number+= '0';

		} else if (l == '1'){
			number+= '1';

		} else if(l >= 'A' && l <= 'C'){
			number+= '2';

		} else if(l >= 'D' && l <= 'F'){
			number+= '3';

		} else if(l >= 'G' && l <= 'I'){
			number+= '4';

		} else if(l >= 'J' && l <= 'L'){
			number+= '5';

		} else if(l >= 'M' && l <= 'O'){
			number+= '6';

		} else if(l >= 'P' && l <= 'S'){
			number+= '7';

		} else if(l >= 'T' && l <= 'V'){
			number+= '8';

		} else if(l >= 'W' && l <= 'Z'){
			number+= '9';

		} else {
			number += l;
		}
	}

	return number; 



}



int main(){
		
	string num; 

	while(cin >> num){
		cout << convert(num) << endl;

	}

	return 0; 

}

```

Simple Minded Hashing

```c++
#include <iostream>
#include <string>
#include <bitset>


using namespace std;


string toBinary(int n){
	string s = "";


	while(n > 0){
		if(n % 2 != 0){
			s += '1';
		} else {
			s += '0';
		}	

		n /= 2; 
	}

	return string(s.rbegin(), s.rend());
}


int main(){
	int n; 

	while(cin >> n){
			
		if(n == 0){
			break;
		}


		 string binary = toBinary(n);

		 int count = 0;
		 for(int i = 0; i < binary.length(); i++){
		 	if(binary[i] == '1'){
		 		count++;
		 	}

		 }

		 cout << "The parity of " << binary << " is " << count << " (mod 2)." << endl;

	}

	return 0;
}
```


Parity

```c++
#include <iostream>
#include <math.h>
#include <string>
#include <algorithm>

using namespace std;

int main(){

	int n, ni, m;
	
	while(cin >> n){
		
		int array[n];
		for(int i = 0; i < n; i++){
			cin >> ni;
			array[i] = ni;
		}
		cin >> m;

		sort(array, array + n);

		int max = 0;
		for(int i = 0; i < n; i++){
			for(int j = i+1; j < n; j++){
				if(array[i] + array[j] == m){
					max = array[i];
				}
			}
		}

		cout << "Peter should buy books whose prices are " << max << " and " << m - max << "." << endl;
		cout << endl;


	}

	return 0;


}
```


Exact Sum

```c++
#include <iostream>
#include <sstream>
#include <vector>
#include <string>

using namespace std;

int main(){
	int n;
	cin >> n;

	while(n != 0){
			for(int i = 0; i < n; i++){
			
			vector<int> v;
			int k;
			string s;

			while(getline(cin, s)){
				stringstream ss(s);
				
				while(ss >> k){
					v.push_back(k);
				}

			}
			

		}

	}


	cout << "end" << endl;	


	return 0;
}
```


Hoax or what


```c++
//Still a time limit
#include <iostream>
#include <limits>


using namespace std;
	
int getSum(int sequence[], int s, int n){
	int min = numeric_limits<int>::max();
	for(int i = 0; i < n; i++){
		int sum = 0; 
		for(int j = i; j < n; j++){
			sum += sequence[j];
			// cout << "At i = " << i << " and j = "  << j << " sum is " << sum << endl;
			if(sum >= s && (j - i) + 1 <= min){
				min = (j - i) + 1;
			}
		}
	}

	return min;
}


int main(){
	int n, s, num;

	while(cin >> n >> s){
		
		int sequence[n];
		for(int i = 0; i < n; i++){
			cin >> num;
			sequence[i] = num;
		}

		int sum = getSum(sequence, s, n);

		if(sum == numeric_limits<int>::max()){
			cout << 0 << endl;
		} else {
			cout << sum << endl;
		}
	}

	return 0;

}
```

Subsequence

```c++
#include <iostream>
#include <string>

using namespace std;


int solve(int x){
	if(x < 10){
		return x;
	}

	int sum = 0;
	while(x > 0){
		sum += x % 10;
		x /= 10; 
	}

	return solve(sum);
}



int main(){
	
	int x;

	while(cin >> x){
		if(x == 0)
			break;
	
		cout << solve(x) << endl;
	}

	return 0;

}
```

Summing Digits

```c++
#include <iostream>
#include <math.h>
#include <string>
#include <algorithm>

using namespace std;


long long convert(int num[], int len){
	string s = "";
		for(int i = 0; i < len; i++){
			string c = to_string(num[i]);
			s += c;
		}

	return stoll(s);
}




int main(){
		
	string n;
	while(cin >> n){
		int len = n.length();
		long long min, max, diff;
		int numbers[len];
		string s;


		for(int i = 0; i < len; i++){
			numbers[i] = n[i] - '0';
		}

		sort(numbers, numbers+ len, greater<int>());
		

		max = convert(numbers, len);

		//sort by descending then swap first non zero element 
		sort(numbers, numbers+len);

		for(int i = 0; i < len; i++){
			if(numbers[i] == 0){
				for(int j = i; j < len; j++){
					if(numbers[j] != 0){
						swap(numbers[i], numbers[j]);
						break;
					}	
				}
			break;	
			}
		}
		
		min = convert(numbers, len);

		diff = max - min;
		cout << max << " - " << min << " = " << diff << " = 9 * " << diff/9 << endl;


	}


	return 0;


}
```

Number Theory for Newbies

```c++
#include <iostream>;

using namespace std;


int main(){
	int t; 
	long long num; 
	cin >> t;

	for(int i = 0; i < t; i++){
		cin >> num; 


		num = ((((((num * 567)/9) + 7492) * 235)/47)-498);

		string s = to_string(num);
		s = s[s.length() -2];


		cout << s << endl;

	}



	return 0; 


}
```





Automatic Answer


```java
import java.util.*;

public class number11559{
    static class Hotel{
    	public int price;
    	public boolean isEnough = true;
    	public Hotel(int price, boolean isEnough){
    		this.price = price;
    		this.isEnough = isEnough;
    	}


    }

    public static void main(String args[]){
     	Scanner sc = new Scanner(System.in);
     	while(sc.hasNext()){
     		int n = sc.nextInt();
	     	int b = sc.nextInt();
	     	int h = sc.nextInt();
	     	int w = sc.nextInt();

	     	Hotel[] hotellist = new Hotel[h];
 	     	

	    	
	     	for(int i = 0; i < h; i++){
	     		int p = sc.nextInt();
	     		boolean isEnough = false;
	     		for(int j = 0; j < w; j++){
	     			int acc = sc.nextInt();
	     			if(acc >= w){
	     				isEnough = true;
	     			}
	     		}
	     		Hotel ho = new Hotel(p * n, isEnough);
	     		hotellist[i] = ho;
	     	}
	     
	     	boolean inBudget = true;
	     	int min = 0;
	     	for(int i = 0; i < hotellist.length; i++){
	     		if(hotellist[i].isEnough == true){
	     			if(hotellist[i].price < hotellist[min].price ){
	     				min = i;
	     			}	
	     		} 
	     	}	

	     	if(hotellist[min].price >= b){
	     		inBudget = false;
	     	}

	     	if(!inBudget){
	     		System.out.println("stay home");
	     	} else {
	     		System.out.println(hotellist[min].price);
	     	}

     	}
    }   
}
```


Event Planning

```c++
#include <iostream>;

using namespace std;

int main(){
	int n; 
	int number = 1;
	while(cin >> n){
		if(n < 0){
			break;
		}


		int counter = 1;
		int copy = 0; 
		while(counter < n){
			counter *= 2;
			copy++;
		}

		cout << "Case " << number << ": " << copy << endl;
		number++;
	}

	return 0; 
}
```

Hello World!

```c++
#include <iostream>

using namespace std;


int main(){
	int n, len, num;

	cin >> n;

	for(int i = 0; i < n; i++){
		cin >> len;
		int arr[len];
		for(int j = 0; j < len; j++){
			cin >> num;
			arr[j] = num;
		}

		int index = (len/2);

		cout << "Case " << i+1 << ": " << arr[index] << endl; 

	}
	return 0; 
}
```

Brick Game


```java
import java.util.*;
import java.math.*;

public class Main{

	static class Person {
		private String name;
		private int amount, received;
		private String[] gifts;

		public Person (String name, int amount, int received, String[] gifts){
			this.name = name;
			this.amount = amount;
			this.gifts = gifts;
			this.received = received;
		}
	}

	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);

		while(sc.hasNextInt()){
			int n = sc.nextInt();
			Person[] givers = new Person[n];

			for(int i = 0; i < n; i++){
				String s = sc.next();
				givers[i] = new Person(s, 0, 0, null);
			}	

			for(int i = 0; i < n; i++){
				String name = sc.next();
				for(int j = 0; j < n; j++){
					if(givers[j].name.equals(name)){
						int amount = sc.nextInt();
						int num = sc.nextInt();
						
						String[] gifts = new String[num];
						
						for(int k = 0; k < num; k++){
							gifts[k] = sc.next();
						}

						givers[j].amount = amount; 
						givers[j].gifts = gifts;						

					}
				}	
			}


			for(int i = 0; i < n; i++){
				int len = givers[i].gifts.length;
				int money = 0; 
				int given = givers[i].amount;

				if(len != 0){
					money = givers[i].amount/len;
				}

				for(int j = 0; j < len; j++){
					for(int k = 0; k < n; k++){
						if(givers[i].gifts[j].equals(givers[k].name)){
							givers[i].amount -= money;
							givers[k].received += money;
						}
					}
				}

				givers[i].amount = given - givers[i].amount;

			}

			for(int i = 0; i < n; i++){
				System.out.println(givers[i].name + " " + (givers[i].received - givers[i].amount));
			}


			if(sc.hasNextInt()){
				System.out.println();
			}
			
		}
		}

}	
```

Greedy Gift Givers


```c++
#include <iostream>;

using namespace std;

bool isAs(int a[], int len){
	for(int i = 0; i < len -1; i++){
		if(a[i] > a[i+1]){
			return false;
		}
	}
	return true;
}

bool isDec(int a[], int len){
	for(int i = 0; i < len -1; i++){
		if(a[i] < a[i+1]){
			return false;
		}
	}
	return true;
}


int main(){
	int n, lumberjack; 

	cin >> n;
	int lumber[10];

	for(int i = 0; i < n; i++){		
		for(int jack = 0; jack < 10; jack++){
			cin >> lumberjack;
			lumber[jack] = lumberjack;
		}

		if(i == 0){
			cout << "Lumberjacks:" << endl;
		}

		if(isAs(lumber, 10) || isDec(lumber, 10)){
			cout << "Ordered" << endl;
		}  else {
			cout << "Unordered" << endl;
		}

	}

	return 0;

}
```


Lumberjack Sequencing


```c++
#include <iostream>
#include <iterator>
#include <string>
#include <list>

using namespace std;

int main(){
	string s;

	while(cin >> s){
		int len = s.length();

		list<char> list;
		list<char>::iterator it;
		it = lst.end();
	}

	return 0;
}

 int sl=s.size();
    list<char>lst;
    list<char>::iterator it;
    it=lst.end();
    for(int i=0;i<sl;i++)
        if(s[i]=='[') it=lst.begin();
        else if(s[i]==']') it=lst.end();
        else lst.insert(it, s[i]);
    for(it=lst.begin();it!=lst.end();it++)
        cout<<*it;
    cout<<endl; 
```


Broken Keyboard (a.k.a. Beiju Text)

```c++
#include <iostream>
#include <queue>
#include <string>

using namespace std;


int main(){
	int n; 
	cin >> n;
	int c = 1; 


	for(int i = 0; i < n; i++){

		queue <string> q = queue <string>(); 
		bool first = true;
		int number; 
		int max = 0;
		string url;

		for(int i = 1; i <= 10; i++){
			cin >> url >> number; 

			if (number > max){
				
				q = queue<string>();  
				max = number; 
				q.push(url);
				
			} else if (max == number){
				q.push(url);
			
			} 

		}

		cout << "Case #" << c << ":" << endl; 
		c++;

		while(!q.empty()){
			
			string a = q.front();
			q.pop();

			cout << a << endl;

		}
	}

	return 0; 
}

```

Google is Feeling Lucky


```c++s
#include &lt;iostream&gt;
#include &lt;string&gt;


using namespace std;

int main(){
	int n;
	string s;
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> s;

		if(s.length() == 5){
			cout << 3 << endl;
		} else {
			bool one = (s[0] == 'o' && s[2] == 'e') || (s[0] == 'o' && s[1] == 'n') ||
					(s[1] == 'n' && s[2] == 'e');

			cout << (one ? 1:2) << endl;

		}



	}




	return 0;


}
```


One-Two-Three

```c++
#include <iostream>

using namespace std; 

int main(){
	int n, m, in; 

	cin >> n; 
	for(int i = 0; i < n; i++){
		cin >> m;
		int arr[m];
		for(int j = 0; j < m; j++){
			cin >> in;
			arr[j] = in;
		}

		int store = 0; 

		for(int k = m-1; k >= 0; k--){
			int b = 0; 
			for(int u = k -1; u >= 0; u--){
				if(arr[k] >= arr[u]){
					b++;
				}
			}

			store += b;

		}

		cout << store << endl;

	}

	return 0;

}
```

Sales

```java
import java.util.*;
import java.math.*;

public class Main{
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);

		BigInteger sum = new BigInteger("0");
		while(sc.hasNext()){

			String in = sc.nextLine();
			BigInteger temp = new BigInteger(in);

			sum = sum.add(temp);

			if(in.equals("0")){
				System.out.println(sum);
				break;
			}


		}

	}

}

```	


Integer Inquiry

```c++
#include <iostream>
#include <string>
#include <stdio.h>


using namespace std;

int main(){
	
	string s; 
	while(getline(cin,s)){

		if(s.empty()){
			cout << endl;
		}


		string result = "";
		int sum = 0;
		for(int i = 0; i < s.length(); i++){
			bool isDigit = s[i] >= '0' && s[i] <= '9';
		
			if(isDigit){
				sum += s[i] - '0';
			} else {
				char add = s[i];

				if(s[i] == 'b'){
					add = ' ';
				} else if(s[i] == '!'){
					result += '\n';
				}

				for(int u = 0; u < sum; u++){
					result += add;
				}
				sum = 0;
			} 

		}

		cout << result;

		if(!cin.eof() && !s.empty()){
			cout << endl;
		}



	}

	return 0; 
}
```


Marvelous Mazes

```c++
#include <iostream>;
#include <string>;

using namespace std;

int main(){
	string s; 

	while(cin >> s){
		
		for(int i = 0; i < s.length(); i++){
			s[i] -= 7;
		}

		cout << s << endl;

	}

	return 0; 
}
```

The Decoder


```c++
#include <iostream>
#include <math.h>
#include <string>
#include <algorithm>

using namespace std;

int main(){
	int n, in; 
	int basis[n];
	string tests; 


	for(int i = 0; i < n; i++){
		cin >> in;
		basis[i] = in;
	}
	
	newline(cin, tests);
	newline(cin, tests);

	while(cin >> tests){
		int lis[n];
		for(int i = 0; i < n; i++){
			int index = i;
			int num = tests[i];
			lis[i] = num;
			index += 1;
		}
	}
	return 0; 
}
```

Triangle Wave

```c++
#include <iostream>
#include <string>
#include <algorithm>


using namespace std;

//returns true if word is solved
bool solved(string s){
	bool b = true;
	for(int i = 0; i < s.length(); i++){
		if(s[i] != '!'){
			b = false;
			break;
		}
	}

	return b;
}


string removeDuplicate(string s){
	int length = s.length();

	for(int i = 0; i < length; i++){
		for(int j = i+1; j < length;){
			if(s[i] == s[j]){
				s[j] = s[--length];
			} else {
				j++;
			}

		}
	}

	s = s.substr(0, length);
	
	return s;


}

int main(){
	
	int n;
	while(cin >> n){
		
		if(n == -1){
			break;
		}

		string word, guess;
		cin >> word >> guess;


		// cout << "before removing " << guess << endl;
		guess = removeDuplicate(guess);

		// cout << "after removing " << guess << endl;


		int len_word = word.length();
		int len_guess = guess.length();
		// cout << len_guess << endl;

		for(int i = 0; i < len_guess; i++){
			for(int j = 0; j < len_word; j++){
				if(guess[i] == word[j]){
					word[j] = '!';
				}
			}
		}

		cout << "Round " << n << endl;
		if(len_guess < 7 && solved(word)){
			cout << "You win." << endl;
		} else if (len_guess >= 7 && !solved(word)){
			cout << "You lose." << endl;
		} else {
			cout << "You chickened out." << endl;
		}

		// cout << "Guess " << guess << endl;
		// cout << "Word " << word << endl;

	}
	
	return 0;

}
```


Hangman Judge

```c++
#include <iostream>
#include <string>

using namespace std;

int main(){
	
	string s;

	// string h="hello world"; 
	// string v="aeiou"; 
	
	// cout << *find_first_of(h.begin(), h.end(), v.begin(), v.end()) << endl;
	while(getline(cin, s)){
		string result = "";
		
		for(int c = 0; c < s.length(); c++){
			int i = 0;
			string word = "";
			while(true){
				bool isLetter = (s[i + c] >= 'a' && s[i + c] <= 'z') 
					|| (s[i + c] >= 'A' && s[i + c] <= 'Z');

				if(isLetter){
					word += s[i + c];
					i++;

				} else {
					c += i;
					break;
				}
			}

			// cout << "Word is: " << word << endl;

			if(!word.empty()){

				bool isVowel = word[0] == 'A' || word[0] == 'E' || 
						  		word[0] == 'I' || word[0] == 'O' ||
						  		word[0] == 'U' || word[0] == 'a' ||
							  	word[0] == 'e' || word[0] == 'i' ||
								word[0] == 'o' || word[0] == 'u'; 

				if(isVowel){
					result += word + "ay";
				} else {
					result += word.substr(1) + word[0] + "ay";

				}

			}
			
			result += s[c];

		}

		cout << result << endl;

	}

	return 0; 

}
```


Pig-Latin

```c++
#include <iostream>
#include <string>

using namespace std;


int main(){
	string s;


	while(getline(cin, s)){
		int counter = 0; 
		bool start = true;

		for(int i = 0; i < s.length(); i++){
			bool isLetter = (s[i] >= 'a' && s[i] <= 'z') ||  (s[i] >= 'A' && s[i] <= 'Z');
			
			if(isLetter){
				if(start){
					counter++;
					start = false;
				} 

			} else {
				start = true;
			}
		}

		cout << counter << endl;

	}

	return 0;

}
```

Kindergarten Counting Game

```java
import java.util.*;

public class Main{
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		
		while(sc.hasNextLine()){
			String c = sc.nextLine();
			String x = sc.nextLine();
			if(c.length() == 0 || x.length() == 0) break;

			// System.out.println(c.length());

			String[] coeffs = c.split(" ");
			// System.out.println(coeffs.length);
			String[] xx = x.split(" ");

			

			for(int i = 0; i < xx.length; i++){
				
				long nn = Long.parseLong(xx[i]);

				System.out.print(solve(coeffs, nn));

				if(i < xx.length -1){
					System.out.print(" ");
				}


			}
			System.out.println("");
		}

		System.exit(0);	

	}
	

	public static long solve(String[] a, long x){
		long num = 0;
		int c = 0;
		for(int i = a.length -1; i >= 0; i--){
			long nn = Long.parseLong(a[c]);
			num += nn * Math.pow(x, i); 
			c++;
		}	

		return num;
	}


}
```



Polly the Polynomial


```java
import java.util.*;
import java.math.*;

public class Main{
	
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		int counter = 1;

		while(sc.hasNextLine()){
			int n = sc.nextInt();
			int m = sc.nextInt();
			int c = sc.nextInt();


			if(n == 0 && m == 0 && c == 0){
				break;
			}


			int[] devices = new int[n]; 
			boolean[] switches = new boolean[n];
			int[] operations = new int[m];
			
 	
			for(int i = 0; i < n; i++){
				int x = sc.nextInt();
				devices[i] = x;
				switches[i] = true;

			}

			for(int i = 0; i < m; i++){
				int x = sc.nextInt();
				operations[i] = (x - 1);

			}


			
			boolean blown = false;
			int max = 0;
			int currCapacity = 0; 
			for(int i = 0; i < m; i++){
				int power = devices[operations[i]];

				if(switches[operations[i]]){
					currCapacity += power;
					switches[operations[i]] = !(switches[operations[i]]);

				} else {
					currCapacity -= power;
					switches[operations[i]] = !(switches[operations[i]]);
				}				

				if(currCapacity > max){
					max = currCapacity; 
				}

				if(currCapacity > c){
					blown = true;
				}

			}

			System.out.println("Sequence " + counter);
			counter++;

			if(blown){
				System.out.println("Fuse was blown.");

			} else {
				System.out.println("Fuse was not blown.");
				System.out.println("Maximal power consumption was " + max + " amperes.");

			}
		
			System.out.println("");

		}
	}
}
```

Blowing Fuses

```c++
#include <iostream>

using namespace std;
long fib_table[101] = {};

long fib(int n){
	if(n == 1){
		return 1;
	}
	if(n == 2){
		return 2;
	}

	if(fib_table[n] == 0){
		fib_table[n] = fib(n-1) + fib(n-2);
	}

	return fib_table[n];

}

int main(){	
	long n; 
	while(cin >> n){
		if (n == 0){
			break;
		}
		cout << fib(n) << endl;
	}

	return 0;	
}
```

UVA Problems