UVA - 10110 - Light, more light (C solution)

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

bool is_Psquare(long x) {
        long root = (long) (floor(sqrt(x) + 0.5));
        return root * root == x;
    }

int main()
{
        long x;
        while(1){
            scanf("%ld",&x);
            if(x==0)
                break;
            if(is_Psquare(x)){
                puts("yes");
            }else{
                puts("no");
            }
        }
    return 0;
}

UVA - 10110 - Light, more light (Java Solution)

import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        StringBuffer sb = new StringBuffer("");
        while (true) {
            long x = s.nextLong();
            if (x == 0) {
                break;
            }
            if (is_Psquare(x)) {
                sb.append("yes\n");
            } else {
                sb.append("no\n");
            }
        }
        System.out.print(sb);
    }

    static boolean is_Psquare(long x) {
        long root = (long) (Math.floor(Math.sqrt(x) + 0.5));
        return root * root == x;
    }
}

UVA - 10338 - Mischievous Children

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m="";
        BigInteger[] arr = new BigInteger[21];
        for (int i = 0; i < 21; i++) {
            arr[i] = BigInteger.ZERO;
        }
        arr[0]=BigInteger.ONE;
        arr[1]=BigInteger.ONE;
        fact(20,arr);

        int cases=Integer.parseInt(br.readLine());
        int let[]=new int[26];
        for(int i=1;i<cases+1;i++) {
            m=br.readLine();
            int x=m.length();
            let=new int[26];
            StringBuilder temp=new StringBuilder(m);
            for(int j=0;j<temp.length();j++){
               let[m.charAt(j)-'A']++;
            }
            BigInteger sum=BigInteger.ONE;
            for(int j=0;j<26;j++){
                if(let[j]>1){
                     sum=sum.multiply(arr[let[j]]);
                }
            }
            BigInteger ans=arr[x].divide(sum);
            sb.append("Data set ").append(i).append(": ").append(ans).append("\n");
        }
        System.out.print(sb);
    }

    static BigInteger fact(int x, BigInteger[] arr) {
        if (x == 1 || x == 0) {
            return BigInteger.ONE;
        }
        if (arr[x] != BigInteger.ZERO) {
            return arr[x];
        }
        arr[x] = BigInteger.valueOf(x).multiply(fact(x - 1, arr));
        return arr[x];
    }
}

UVA - 10323 - Factorial! You Must be Kidding!!!

#include <stdio.h>

int main()
{
        int x;
        long i;
        long long arr[14];
        arr[0]=1;
        for(i=1;i<14;i++){
            arr[i]=arr[i-1]*i;
        }
        while(scanf("%d",&x)==1) {
            if(x<0){
                if(x%2==0){
                  puts("Underflow!");
                }
                else{
                  puts("Overflow!");
                }
            }
            else if(x<8 && x>-1){
                puts("Underflow!");
            }
            else if(x>13){
                puts("Overflow!");
            }
            else{
                printf("%lld\n",arr[x]);
            }
        }

    return 0;
}

UVA - 1225 - Digit Counting

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        StringBuilder seq=new StringBuilder("");
        int cases=Integer.parseInt(br.readLine().trim());
        for(int i=0;i<cases;i++) {
            int x = Integer.parseInt(br.readLine().trim());
            seq=new StringBuilder("");
            for(int j=1;j<x+1;j++){
                seq.append(j);
            }
            int[] arr=count(seq);
            for(int j=0;j<arr.length;j++){
                if(j>0)
                     sb.append(" ");
                sb.append(arr[j]);
            }
            sb.append("\n");
        }
        System.out.print(sb);
    }

    static int[] count(StringBuilder sb){
        int[] arr=new int[10];
        for(int i=0;i<sb.length();i++){
            arr[sb.charAt(i)-'0']++;
        }
        return arr;
    }
}

UVA - 10220 - I Love Big Numbers !

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        BigInteger[] arr = new BigInteger[1001];
        for (int i = 0; i < 1001; i++) {
            arr[i] = BigInteger.ZERO;
        }
        for (int i = 0; i < 1001; i++) {
            fact(i, arr);
        }
        int sum[] = new int[1001];
        for (int i = 0; i < 1001; i++) {
            String temp = arr[i].toString();
            for (int j = 0; j < temp.length(); j++) {
                sum[i] += temp.charAt(j) - '0';
            }
        }
        while ((m = br.readLine()) != null) {
            int x = Integer.parseInt(m);
            sb.append(sum[x]).append("\n");
        }
        System.out.print(sb);
    }

    static BigInteger fact(int x, BigInteger[] arr) {
        if (x == 1 || x == 0) {
            return BigInteger.ONE;
        }
        if (arr[x] != BigInteger.ZERO) {
            return arr[x];
        }
        arr[x] = BigInteger.valueOf(x).multiply(fact(x - 1, arr));
        return arr[x];
    }
}

UVA - 10924 - Prime Words

//This problem got a false trick as it suppose that 1 is a prime number

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        boolean notPrime[] = sievePrime(1050);
        while ((m = br.readLine()) != null) {
            int x=0;
            for(int i=0;i<m.length();i++){
                if(m.charAt(i)>96 && m.charAt(i)<123){
                    x+=m.charAt(i)-96;
                }
                else if(m.charAt(i)>64 && m.charAt(i)<91){
                    x+=m.charAt(i)-38;
                }
            }
           
            if (notPrime[x]) {
                sb.append("It is not a prime word.\n");
            }else{
                sb.append("It is a prime word.\n");
            }
        }
        System.out.print(sb);
    }

    static boolean[] sievePrime(int x) {
        boolean[] notPrime = new boolean[x + 1];
        notPrime[0] = true;
        notPrime[1] = false;
        for (int i = 2; i * i < x + 1; i++) {
            if (!notPrime[i]) {
                for (int j = i; i * j < x + 1; j++) {
                    notPrime[i * j] = true;
                }
            }
        }
        return notPrime;
    }

}

UVA - 10235 - Simply Emirp

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        boolean notPrime[] = sievePrime(1000 * 1000);
        while ((m = br.readLine()) != null) {
            int x = Integer.parseInt(m);
            if (notPrime[x]) {
                sb.append(x).append(" is not prime.\n");
            } else {
                int temp=reverse(x);
                if (notPrime[temp] || temp==x) {
                    sb.append(x).append(" is prime.\n");
                } else {
                    sb.append(x).append(" is emirp.\n");
                }
            }
        }
        System.out.print(sb);
    }

    static boolean[] sievePrime(int x) {
        boolean[] notPrime = new boolean[x + 1];
        notPrime[0] = true;
        notPrime[1] = true;
        for (int i = 2; i * i < x + 1; i++) {
            if (!notPrime[i]) {
                for (int j = i; i * j < x + 1; j++) {
                    notPrime[i * j] = true;
                }
            }
        }
        return notPrime;
    }

    static int reverse(int x) {
        StringBuilder sb = new StringBuilder(x + "");
        sb = sb.reverse();
        return Integer.parseInt(sb.toString());
    }
}

UVA - 686 - Goldbach's Conjecture (II)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        boolean notPrime[]=sievePrime(100*1000);
        while (true) {
            int x = Integer.parseInt(br.readLine());
            int counter=0;
            if(x==0)
                break;
            int i=1,j=x-1;
            while(true){
                if(i>j)
                    break;
                while(notPrime[i]){
                    i++;
                }
                while(notPrime[j]){
                    j--;
                }
                if(i>j)
                    break;
               
                if(i+j==x){
                   counter++;
                   j--;
                   i++;
                }
                else if(i+j>x){
                  j--;
                }
                else if(i+j<x){
                  i++;
                }
            }
            sb.append(counter).append("\n");
        }
        System.out.print(sb);
    }

static boolean [] sievePrime(int x){
        boolean[] notPrime = new boolean[x + 1];
        notPrime[0]=true;
        notPrime[1]=true;
        for (int i = 2; i*i < x+1; i++) {
            if (!notPrime[i]) {
                for (int j = i; i*j < x+1; j++) {
                    notPrime[i*j] = true;
                }
            }
        }
        return notPrime;
    }

}

UVA - 294 - Divisors

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) throws IOException {

        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        int cases=Integer.parseInt(br.readLine());
        for(int iz=0;iz<cases;iz++) {
            String[] str = br.readLine().split(" ");
            long x = Long.parseLong(str[0]);
            long y = Long.parseLong(str[1]);
          
            long max = -1, indexP = -1;
            for (long i = x; i < y + 1; i++) {
                long counter = 0;
                for (int j = 1; j * j < i + 1; j++) {

                    if (i % j == 0) {
                        counter++;
                        if (j *j!= i) {
                            counter++;
                        }
                    }
                }
                if (max < counter) {
                    indexP = i;
                    max = counter;
                }
            }
            sb.append("Between ").append(x).append(" and ").append(y).append(", ")
                    .append(indexP).append(" has a maximum of ")
                    .append(max).append(" divisors.\n");
        }
        System.out.print(sb);
    }
}

UVA - 406 - Prime Cuts

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        boolean notPrime[]=sievePrime(1000);
        ArrayList<Integer> arr=new ArrayList<Integer>();
        for(int i=1;i<1001;i++){
            if(!notPrime[i]){
                arr.add(i);
            }
        }
        while ((m=br.readLine())!=null) {
            String[] str=m.split(" ");
            int n = Integer.parseInt(str[0]);
            int c = Integer.parseInt(str[1]);
            int index=-1 ,temp=n;
            while(index==-1){
                index =arr.indexOf(temp);
                temp--;
            }
            List<Integer> subArr=arr.subList(0, index+1);
            if(2*c<subArr.size()){
                if(subArr.size()%2==0){
                   subArr=arr.subList((subArr.size()-2*c)/2, (subArr.size()+2*c)/2);
                }
                else{
                   subArr=arr.subList((subArr.size()-2*c+2)/2, (subArr.size()+2*c)/2);
                }
            }
            sb.append(n).append(" ").append(c).append(":");
            for(int i=0;i<subArr.size();i++){
                sb.append(" ").append(subArr.get(i));
            }
            sb.append("\n\n");
        }
        System.out.print(sb);
    }

static boolean [] sievePrime(int x){
        boolean[] notPrime = new boolean[x + 1];
        notPrime[0]=true;
        notPrime[1]=false;
        for (int i = 2; i*i < x+1; i++) {
            if (!notPrime[i]) {
                for (int j = i; i*j < x+1; j++) {
                    notPrime[i*j] = true;
                }
            }
        }
        return notPrime;
    }
 
}

UVA - 543 - Goldbach's Conjecture

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        boolean notPrime[]=sievePrime(1000*1000);
        while (true) {
            int x = Integer.parseInt(br.readLine());
            if(x==0)
                break;
            int i=1,j=x-1;
            while(true){
                if(i>j)
                    break;
                while(notPrime[i]){
                    i++;
                }
                while(notPrime[j]){
                    j--;
                }
                if(i+j==x){
                   sb.append(x).append(" = ").append(i).append(" + ").append(j).append("\n");
                   break;
                }
                else if(i+j>x){
                  j--;
                }
                else if(i+j<x){
                  i++;
                }
            }
        }
        System.out.print(sb);
    }

static boolean [] sievePrime(int x){
        boolean[] notPrime = new boolean[x + 1];
        notPrime[0]=true;
        notPrime[1]=true;
        for (int i = 2; i*i < x+1; i++) {
            if (!notPrime[i]) {
                for (int j = i; i*j < x+1; j++) {
                    notPrime[i*j] = true;
                }
            }
        }
        return notPrime;
    }
 
}

UVA - 10892 - LCM Cardinality

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        while ((m = br.readLine()) != null) {
            if ("0".equals(m)) {
                break;
            }
            LinkedList<Long> arr = new LinkedList<Long>();
            long x = Long.parseLong(m);
            for (long i = 1; i * i < x + 1; i++) {
                if (x % i == 0) {
                    arr.add(i);
                    if(i!=x/i)
                        arr.add(x/i);
                }
            }
            
            int counter=0;
           
            for (int i = 0; i < arr.size(); i++) {
                for (int j = i; j <arr.size(); j++) {
                    if (lcm(arr.get(i), arr.get(j)) == x) {
                        counter++;
                    }
                }
            }
            sb.append(x).append(" ").append(counter).append("\n");
        }
        System.out.print(sb);
    }

    static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }
}

UVA - 11388 - GCD LCM

#include <stdio.h>

int main()
{   int x,y,cases,i;
    scanf("%d",&cases);
    for(i=0;i<cases;i++){
        scanf("%d %d",&x,&y);
        if(y%x==0){
            printf("%d %d\n",x,y);
        }
       else{
            puts("-1");
       }

    }
       return 0;
}

UVA - 10407 - Simple Division

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        while ((m = br.readLine()) != null) {
            if("0".equals(m))
                break;
            String[] str = m.split(" ");
            int[] x=new int[str.length-1];
            int min=Integer.MAX_VALUE;
            for(int i=0;i<x.length;i++){
                x[i]=Integer.parseInt(str[i]);
                if(x[i]<min)
                    min=x[i];
            }
            for(int i=0;i<x.length;i++){
                x[i]-=min;
            }
            int result=0;
           
            for(int i=0;i<x.length;i++){
                result=gcd(result,x[i]);
            }
            sb.append(result).append("\n");
        }
        System.out.print(sb);
    }

    static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

}

UVA - 568 - Just the Facts

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        BigInteger[] fact=new BigInteger[10002];
         for (int i = 0; i < 10002; i++) {
            fact[i]=BigInteger.ZERO;
        }
        
        for (int i = 0; i < 10002; i++) {
           fact(i,fact);
        }
        int xl=2;
       while((m=br.readLine())!=null) {
            int x=Integer.parseInt(m);
            String temp1=x+"";
            for(int i=temp1.length();i<5;i++){
                sb.append(' ');
            }
            String temp=fact[x].toString();
            char rem='0';
            for(int i=temp.length()-1;i>-1;i--){
                if(temp.charAt(i)!='0'){
                    rem=temp.charAt(i);
                    break;
                }
            }
            sb.append(temp1).append(" -> ").append(rem).append("\n");
        }
        System.out.print(sb);
    }

    static BigInteger fact(int x,  BigInteger[]arr) {
        if (x == 0) {
            return BigInteger.ONE;
        }
        if(arr[x].compareTo(BigInteger.ONE) == 1){
            return arr[x];
        }
        else{
            arr[x]=BigInteger.valueOf(x).multiply(fact(x-1, arr));
        }
        return arr[x];
    }
}

UVA - 324 - Factorial Frequencies

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        BigInteger[] fact=new BigInteger[367];
         for (int i = 0; i < 367; i++) {
            fact[i]=BigInteger.ZERO;
        }
        fact(366,fact);
       while(true) {
            int x=Integer.parseInt(br.readLine());
            int arr[]=new int[10];
            if(x==0)
                break;
            String temp=fact[x].toString();
            for(int i=0;i<temp.length();i++){
               if(temp.charAt(i)>='0' && temp.charAt(i)<='9'){
                   arr[temp.charAt(i)-'0']++;
               }
            }
            sb.append(x).append("! --\n");
            for(int i=0;i<arr.length;i++){
                sb.append("   (").append(i).append(")    ").append(arr[i]);
                if(i==4|| i==9)
                    sb.append("\n");
            }
        }
        System.out.print(sb);
    }

    static BigInteger fact(int x,  BigInteger[]arr) {
        if (x == 0) {
            return BigInteger.ONE;
        }
        if(arr[x].compareTo(BigInteger.ONE) == 1){
            return arr[x];
        }
        else{
            arr[x]=BigInteger.valueOf(x).multiply(fact(x-1, arr));
        }
        return arr[x];
    }
}

UVA - 11827 - Maximum GCD

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        int cases = Integer.parseInt(br.readLine());
        for (int i = 0; i < cases; i++) {
            StringTokenizer str= new StringTokenizer(br.readLine());
            int[] x = new int[str.countTokens()];
            for(int j=0;j<x.length;j++){
                x[j]=Integer.parseInt(str.nextToken());
            }
            int max=Integer.MIN_VALUE;
            for(int j=0;j<x.length;j++){
               for(int k=j+1;k<x.length;k++){
                   max=Math.max(GCD(x[j],x[k]),max);
               }
            }
            sb.append(max).append("\n");
        }
        System.out.print(sb);
    }

    static int GCD(int x, int y) {
        if (y == 0) {
            return x;
        }
        return GCD(y, x % y);
    }
}

UVA - 1210 - Sum of Consecutive Prime Numbers

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb=new StringBuffer("");
        String m="";
        boolean notPrime[]=sievePrime(10000);
        notPrime[0]=true;
        notPrime[1]=true;
        int[] sum=new int[10001];
        int temp=0;
        for(int i=2;i<10001;i++){
            if(!notPrime[i]){
                sum[i]++;
                temp=i;
                for(int j=i+1;j<10001;j++) {
                    if(!notPrime[j]){
                        temp+=j;
                        if(temp<10001)
                            sum[temp]++;
                    }
                }
            }
        }
        while(true){
            int x=Integer.parseInt(br.readLine().trim());
            if(x==0)
                break;
            sb.append(sum[x]).append("\n");
        }
        System.out.print(sb);
    }
   
    static boolean [] sievePrime(int x){
        boolean[] notPrime = new boolean[x + 1];
        for (int i = 2; i*i < x+1; i++) {
            if (!notPrime[i]) {
                for (int j = i; i*j < x+1; j++) {
                    notPrime[i*j] = true;
                }
            }
        }
        return notPrime;
    }
  
}

UVA - 10334 - Ray Through Glasses

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb=new StringBuffer("");
        String m="";
      
        BigInteger []arr=new BigInteger[5001];
        arr[0]=BigInteger.ONE;
        arr[1]=BigInteger.valueOf(2);
        for(int i=2;i<5001;i++){
            arr[i]=arr[i-1].add(arr[i-2]);
        }
        while((m=br.readLine())!=null){
            int x=Integer.parseInt(m);
            sb.append(arr[x]).append("\n");
        }
        System.out.print(sb);
    }
 
}

UVA - 900 - Brick Wall Patterns

//Just Fibonacci series

#include <stdio.h>

int main()
{   int cases,i;
    long long add[51];
        add[0]=1;
        add[1]=1;
        for(i=2;i<51;i++){
            add[i]=add[i-2]+add[i-1];

        }
    while(1){
        scanf("%d",&cases);
        if(cases==0)
            break;
        printf("%lld\n",add[cases]);
    }
       return 0;
}

UVA - 580 - Critical Mass (C solution)

//same algorithm as java solution

#include <stdio.h>

int main()
{   int cases,i;
    long add[31];
        add[3]=1;
        add[4]=2;
        add[5]=4;
        for( i=6;i<31;i++){
            add[i]=add[i-3]+add[i-2]+add[i-1];

        }

    long bg[31];
        bg[0]=0;
        bg[1]=0;
        bg[2]=1;
        for( i=3;i<31;i++){
            bg[i]=2*bg[i-1]+add[i];
        }

    while(1){
        scanf("%d",&cases);
        if(cases==0)
            break;
        printf("%ld\n",bg[cases-1]);
    }
       return 0;
}

UVA - 580 - Critical Mass (Java solution)

/*by trial i found that  the pattern that array follows is f[n]=2*f[n-1]+sumof[last 3 remainders]
 ex:
 f[i] =2 *f[i-1] + f[i-1]%f[i-2] + f[i-2]%f[i-3] + f[i-3]%f[i-4]
as i>7
or  f[i] =2 *f[i-1]+add[i]
as add works for all values of i>2
*/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb=new StringBuffer("");
       
        long[] add=new long[31];
        add[3]=1;
        add[4]=2;
        add[5]=4;
        for(int i=6;i<31;i++){
            add[i]=add[i-3]+add[i-2]+add[i-1];
           
        }
       
        long []bg=new long[31];
        bg[0]=0;
        bg[1]=0;
        bg[2]=1;
        for(int i=3;i<31;i++){
            bg[i]=2*bg[i-1]+add[i];
        }
        while(true){
            int x=Integer.parseInt(br.readLine());
            if(x==0)
                break;
            sb.append(bg[x-1]).append("\n");
        }
        System.out.println(sb);
    }
}

UVA - 11417 - GCD

#include <stdio.h>

int GCD(int i,int j){
    if (j==0)
        return i;
    return GCD(j, i % j);
}

int main()
{   int cases,i,j;
    int G[501];

    //using a DP approach
    G[0]=0;
    G[1]=0;
    for(cases=2;cases<501;cases++){
        G[cases]=G[cases-1];
        for(i=1;i<cases;i++){
            if(i<cases-1){
                G[cases]+=GCD(i,cases);
            }else{
                for(j=i+1;j<=cases;j++){
                    G[cases]+=GCD(i,j);
                }
            }
            }
    }
    while(1){
        scanf("%d",&cases);
        if(cases==0)
            break;
        printf("%d\n",G[cases]);
    }
       return 0;
}

UVA - 108 - Maximum Sum

import java.io.IOException;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner s = new Scanner(System.in);
        String m = "";
        int cases = s.nextInt();
        int[][] arr = new int[cases][cases];
        int maxNum = 0;
        for(int i=0;i<cases;i++){
           for(int j=0;j<cases;j++){
               arr[i][j]=s.nextInt();
           }
        }
       


        //Using kadane which gave a O(n³) solution
        int sumF=Integer.MIN_VALUE;       
        for(int i=0;i<cases;i++){
            int []sum=new int[cases];
            for(int j=i;j<cases;j++){
                int max=Integer.MIN_VALUE;
                int tempSum=0;
                for(int l=0;l<cases;l++){
                    sum[l]+=arr[j][l];
                    tempSum+=sum[l];
                    max=Math.max(max, tempSum);
                    if(tempSum<0)
                        tempSum=0;
                }
                sumF=Math.max(max, sumF);
            }
        }
        System.out.println(sumF);
    }
}

UVA - 488 - Triangle Wave

#include <stdio.h>

int main()
{   int x,y,cases,i;
    scanf("%d",&cases);
    for(i=0;i<cases;i++){
        if(i>0)
            printf("\n");
        scanf("%d",&x);
        scanf("%d",&y);
        int j=0,k=0,l=0;
        for(l=0;l<y;l++){
            if(l>0)
                printf("\n");
            for(j=1;j<x+1;j++){
                for(k=0;k<j;k++){
                    printf("%d",j);
                }
                printf("\n");
            }
            for(j=x-1;j>0;j--){
                for(k=0;k<j;k++){
                    printf("%d",j);
                }
                printf("\n");
            }
        }
    }
       return 0;
}

UVA - 10035 - Primary Arithmetic

#include <stdio.h>

int main()
{   long x,y;
    int carry;
    int add;
    while(1){
        scanf("%ld %ld",&x,&y);
        carry=0;
        add=0;
        if(x==0 && y==0)
            break;
        while(x!=0 ||y!=0){
           if((x%10+y%10)+add>9){
                carry++;
                add=1;
           }
           else{
            add=0;
           }
           x/=10;
           y/=10;
        }
        if(carry==0){
            puts("No carry operation.");
        }
        else if(carry==1){
             printf("%d carry operation.\n",carry);
        }
        else{
            printf("%d carry operations.\n",carry);
        }
    }
       return 0;
}

UVA - 389 - Basically Speaking

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        while ((m = br.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(m);
            String[] str = new  String[st.countTokens()];
            for(int i=0;i<str.length;i++){
                str[i]=st.nextToken();
            }
            int baseFrom=Integer.parseInt(str[1]);
            int baseTo=Integer.parseInt(str[2]);
            int temp=Integer.parseInt(str[0],baseFrom);
            StringBuilder result=new StringBuilder(Integer.toString(temp, baseTo));
            for(int i=result.length();i<7;i++){
                result.insert(0, ' ');
            }
            if(result.length()==7)
                sb.append(result.toString().toUpperCase()).append("\n");
            else
                sb.append("  ERROR\n");
        }
        System.out.print(sb);
    }
}

UVA - 10083 - Division

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        while ((m = br.readLine()) != null) {
            String[] str = m.split(" ");
            int t = Integer.parseInt(str[0]);
            int a = Integer.parseInt(str[1]);
            int b = Integer.parseInt(str[2]);
           
    //to check if the the result is the base is not equal to 0.
            if(t==1){
                sb.append("(").append(t).append("^").append(a).append("-1)/(").append(t).append("^").append(b).append("-1) ").append("is not an integer with less than 100 digits.\n");
                continue;
            }
          

            if(a==b){
                sb.append("(").append(t).append("^").append(a).append("-1)/(").append(t).append("^").append(b).append("-1) ").append("1\n");
                continue;
            }
           
    //to check if the the result is an integer
            if(a%b !=0 || a<b){
                sb.append("(").append(t).append("^").append(a).append("-1)/(").append(t).append("^").append(b).append("-1) ").append("is not an integer with less than 100 digits.\n");
                continue;
            }
           
           
            //to check if the the result is less than 100 digits
            if( (a - b) * Math.log10(t) > 99){
                sb.append("(").append(t).append("^").append(a).append("-1)/(").append(t).append("^").append(b).append("-1) ").append("is not an integer with less than 100 digits.\n");
                continue;
            }
           
           
          BigInteger bg=(BigInteger.valueOf(t).pow(a).subtract(BigInteger.ONE)).divide(BigInteger.valueOf(t).pow(b).subtract(BigInteger.ONE));
         
          sb.append("(").append(t).append("^").append(a).append("-1)/(").append(t).append("^").append(b).append("-1) ").append(bg).append("\n"); 
        }
        System.out.print(sb);
    }
}

UVA - 636 - Squares (III)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuffer sb = new StringBuffer("");
        String m = "";
        ArrayList<Long> arr = new ArrayList<Long>();
        long z = 1;
        while (z * z < 1000000000) {
            arr.add(z * z);
            z++;
        }
        while (true) {
            m = br.readLine();
            int x = Integer.parseInt(m);
            if (x == 0) {
                break;
            }
            char max = '0';
            for (int i = 0; i < m.length(); i++) {
                if (m.charAt(i) > max) {
                    max = m.charAt(i);
                }
            }
            int minBase = Integer.parseInt(max + "") + 1;

            for (int j = minBase; j < 100; j++) {
                long sum=0;
                for (int k = m.length()-1,index=0; k > -1; k--,index++) {
                    sum+=Integer.parseInt(m.charAt(index)+"")*(Math.pow(j, k));
                }
                if(arr.contains(sum)){
                    minBase=j;
                    break;
                }
            }
            sb.append(minBase).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 11185 - Ternary

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        StringBuilder sb = new StringBuilder("");
        String m = "";
        while (true) {
            m = br.readLine();
            if (Integer.parseInt(m) < 0) {
                break;
            }
            sb.append(Integer.toString(Integer.parseInt(m),3)).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 10473 - Simple Base Conversion

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException{
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);
        StringBuilder sb = new StringBuilder("");
        String m="";
        while(true) {
            m=br.readLine();
            if(m.charAt(0) =='0' && m.charAt(1) =='x'){
                m=m.substring(2);
                sb.append(Integer.parseInt(m, 16)).append("\n");
            }else{
                if(Integer.parseInt(m)<0){
                    break;
                }
                sb.append("0x").append(Integer.toHexString(Integer.parseInt(m)).toUpperCase()).append("\n");
            }
        }
        System.out.print(sb);
    }
}

UVA - 446 - Kibbles "n" Bits "n" Bits "n" Bits

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException{
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);
        StringBuilder sb = new StringBuilder("");
        int cases=Integer.parseInt(br.readLine());
        for(int i=0;i<cases;i++) {
            String[] str=br.readLine().split(" ");
            int x=Integer.parseInt(str[0], 16);
            int y=Integer.parseInt(str[2], 16);
            int result;
            if("+".equals(str[1])){
                result=x+y;
            }else{
                result=x-y;
            }
            StringBuilder tempX=new StringBuilder(Integer.toBinaryString(x));
            StringBuilder tempY=new StringBuilder(Integer.toBinaryString(y));
            while(tempX.length()<13){
                tempX.insert(0, '0');
            }
            while(tempY.length()<13){
                tempY.insert(0, '0');
            }
            sb.append(tempX).append(" ").append(str[1]).append(" ")
                    .append(tempY).append(" = ").append(result).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 10038 - Jolly Jumpers

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        StringBuilder sb = new StringBuilder("");
        while (s.hasNext()) {
            int size=s.nextInt();
            int[] arr=new int[size];
            for(int i=0;i<arr.length;i++){
                arr[i]=s.nextInt();
            }
            if(size ==1){
                sb.append("Jolly").append("\n");
                continue;
            }
            boolean jolly=true;
            ArrayList<Integer> col=new ArrayList<Integer>();
            int dist=Math.abs(arr[1]-arr[0]);
            if(dist>size-1 || dist==0){
                sb.append("Not jolly").append("\n");
                continue;
            }
            col.add(dist);
            for(int i=1;i<arr.length-2;i++){
                int aft=Math.abs(arr[i+1]-arr[i]);
                if(col.contains(aft) ||aft==0 || aft>size-1){
                    jolly=false;
                    break;
                }
                col.add(aft);
                dist=aft;
            }
            if(jolly)
                sb.append("Jolly").append("\n");
            else
                sb.append("Not jolly").append("\n");
        }
        System.out.print(sb);
    }
}