CodeEval - Magic Numbers - Moderate

import sys

def is_magic(x):
    arr_char = list(str(x))
    arr_sorted = ''.join(sorted(arr_char))
    n = len (arr_char)
    for i in range(n-1):
        if arr_sorted[i] == arr_sorted[i+1]:
            return False
    arr_checked = [False]*n
    pos = 0
    while True:
        if  arr_checked[pos]:
            break
        arr_checked[pos] = True
        index = int(arr_char[pos])
        pos = (pos + index) % n
    if not pos == 0:
        return False
    for checked in arr_checked:
        if not checked:
            return False
    return True

test_cases = open(sys.argv[1], 'r')
arr = []
for i in range(1,10001):
    if is_magic(i):
        arr.append(i)
for test in test_cases:
    bound = test.split()
    a = int (bound[0])
    b = int (bound[1])
    sol = ""
    for x in arr:
        if a > x :
            continue
        if b < x :
            break
        if not sol == "" :
            sol += " "
        sol += str(x)
    if sol ==  "":
        print -1
    else :
        print sol
test_cases.close()

CodeEval - Filename Pattern - Moderate

import sys
import re

test_cases = open(sys.argv[1], 'r')
for test in test_cases:
    arr=test.split()
    regex=""
    for c in arr[0]:
        if c == '.':
            regex += '\.'
        elif c == '?':
            regex +='.'
        elif c == '*':
            regex +='.*'
        else:
            regex +=c
    sol=[]
    for x in range(1,len(arr)):
        if re.match('^'+regex+'$', arr[x]):
            sol.append(arr[x])
    value=""
    for i in range(len(sol)):
        if i>0 :
            value += " "
        value += sol[i]
    if not value:
        value = "-"
    print value

test_cases.close()

CodeEval - Chardonnay or Cabernet - Easy

import sys

test_cases = open(sys.argv[1], 'r')
for test in test_cases:
    test=test.split(" | ")
    word=test[1]
    word_char=[0]*26
    for x in word.lower():
        if x.isalpha():
            word_char[ord(x)-ord('a')] += 1
    wine_list=test[0].split()
    sol_list=[]
    for wine in wine_list:
        wine_chars=[0]*26
        for x in wine.lower():
            if x.isalpha():
                wine_chars[ord(x)-ord('a')] += 1
        listed=True
        for i in range(len(wine_chars)):
            if wine_chars[i] < word_char[i]:
                listed=False
                break
        if listed:
            sol_list.append(wine)
    sol=""
    for i in range(len(sol_list)):
        if i>0 :
            sol += " "
        sol += sol_list[i]
    if sol:
        print sol
    else:
        print False

test_cases.close()

CodeEval - Clean up the words - Easy

import sys

test_cases = open(sys.argv[1], 'r')
for test in test_cases:
    sol=""
    for char in test:
        if char.isalpha():
            sol += char
        else :
            sol += " "
    sol = sol.strip()
    words = sol.split()
    sol = ""
    for i in range(len(words)):
        if i > 0 :
            sol += " "
        sol += words[i].lower()
    print sol

test_cases.close()

CodeEval - Strings and arrows - Easy

import sys

test_cases = open(sys.argv[1], 'r')
for test in test_cases:
    window=""
    for i in range(4):
        window+=test[i]
    counter=0
    for i in range(4,len(test)):
        window+=test[i]
        if(window==">>-->" or window=="<--<<"):
            counter+=1
        window=window[1:]
    print counter

test_cases.close()

CodeEval - Column Names - Moderate

import sys

test_cases = open(sys.argv[1], 'r')
for test in test_cases:
    value=int(test)
    result = ""
    while (value > 0):
        value-=1;
        result = str(chr(ord('A') + value % 26)) + result
        value /= 26
    print result

test_cases.close()

CodeEval - String mask - Easy

import sys

 test_cases = open(sys.argv[1], 'r')
for test in test_cases:
    arr=test.split()
    string=""
    for i in range(len(arr[0])):
        if(int(arr[1][i])==0):
            string+=str(arr[0][i])
        else:
            string+=str(arr[0][i]).swapcase()
    print string
test_cases.close()

CodeEval - Swap Numbers - Easy

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    public static void main (String[] args) throws IOException {
        BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
        String line;
        StringBuffer out=new StringBuffer();
        while ((line = buffer.readLine()) != null) {
            if(line.equals("#")){
                break;
            }
            StringTokenizer st=new StringTokenizer(line);
            int n=st.countTokens();
            for(int i=0;i<n;i++){
                if(i>0){
                    out.append(' ');
                }
                String nextToken=st.nextToken();
                out.append(nextToken.charAt(nextToken.length()-1))
                   .append(nextToken.substring(1,nextToken.length()-1))
                   .append(nextToken.charAt(0));
            }
            out.append('\n');
        }
        System.out.print(out);
    }
}

CodeEval - Read More - Easy

import java.io.*;

public class Main {
    public static void main (String[] args) throws IOException {
       
        BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
        String line;
        StringBuffer out=new StringBuffer();
        while ((line = buffer.readLine()) != null) {
            line = line.trim();
            if(line.length()>55){
                if(line.charAt(39)==' '){
                   out.append(line.substring(0, 39));
                }
                else{
                   boolean flag=true;
                   for(int i=39;i>0;i--){
                       if(line.charAt(i)==' '){
                           out.append(line.substring(0, i));
                           flag=false;
                           break;
                       }
                   }
                   if(flag){
                       out.append(line.substring(0, 40));
                   }
                }
                out.append("... <Read More>");
            }else{
                out.append(line);
            }
            out.append("\n");
        }
        System.out.print(out);
    }
}

UVA - 12718 - Dromicpalin Substrings

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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        int cases = Integer.parseInt(br.readLine());
        for (int i = 0; i < cases; i++) {
            sb.append("Case ").append(i + 1).append(": ");
            sb.append(dromicpalinSubstrings(br.readLine()));
            sb.append("\n");
        }
        System.out.print(sb);
    }

    static int dromicpalinSubstrings(String str) {
        int counter = 0;
        for (int i = 0; i < str.length(); i++) {
            StringBuilder sb = new StringBuilder();
            int[] arr = new int[26];
            int odd = 0;
            for (int j = i; j < str.length(); j++) {
                char c = str.charAt(j);
                sb.append(c);
                arr[c - 'a']++;
                if (arr[c - 'a'] % 2 == 1) {
                    odd++;
                } else {
                    odd--;
                }
                int diff = j - i + 1;
                if ((diff % 2 == 0 && odd == 0) || (diff % 2 == 1 && odd == 1)) {
                    counter++;
                }

            }
        }
        return counter;
    }

}

CodeEval - Roller Coaster - Easy

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class Main {

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

    File file = new File(args[0]);
    BufferedReader in = new BufferedReader(new FileReader(file));
        StringBuffer sb=new StringBuffer();
        String line;
        while ((line = in.readLine()) != null) {
            boolean upperCase=true;
            for(int i=0;i<line.length();i++){
               char c=line.charAt(i);
               if(c>='a' &&c<='z'){
                   if(upperCase){
                      sb.append((char)(c-32));
                   }else{
                       sb.append(c);
                   }
                   upperCase=!upperCase;
               }else if(c>='A'&&c<='Z'){
                   if(!upperCase){
                      sb.append((char)(c+32));
                   }else{
                       sb.append(c);
                   }
                   upperCase=!upperCase;
               }else{
                   sb.append(c);
               }
            }
            sb.append('\n');
        }
        System.out.print(sb);
    }
   
}

CodeEval - Distinct Subsequences - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class Main {

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

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String line;
        while ((line = in.readLine()) != null) {
           StringTokenizer st=new StringTokenizer(line,",");
           wholeStr=st.nextToken();
           str=st.nextToken();
           sb.append(getOccurence(0, 0, new StringBuilder()));
           sb.append('\n');
        }
        System.out.print(sb);
    }
   
    static String str;
    static String wholeStr;
   
    static int getOccurence(int j,int i,StringBuilder string){
        if(j==str.length())
            return 1;
        if(i==wholeStr.length())
            return 0;
        int counter=0;
        if(str.charAt(j)==wholeStr.charAt(i)){
            counter=getOccurence(j+1,i+1,string);
        }
        return  getOccurence(j,i+1,string)+counter;
    }

}

CodeEval - Telephone Words - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

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

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb2 = new StringBuffer();
        String line;
        while ((line = in.readLine()) != null) {
           sb=new StringBuffer();
           str=line;
           getWords(new StringBuilder());
           sb2.append(sb);
           sb2.append('\n');
        }
        System.out.print(sb2);
    }
   
    static String str;
    static StringBuffer sb;
 static void getWords(StringBuilder word){
     int index=word.length();
     if(index==7){
         if(sb.length()!=0){
             sb.append(',');
         }
         sb.append(word);
         return;
     }
     char c=str.charAt(index);
     if(c=='0' || c=='1'){
        word.append(c);
        getWords(word);
        word.deleteCharAt(word.length()-1);
     }
     else{
         int valz=c-'0'-2;
         int counter=0;
         if(valz>5)
             counter=1;
         char ca=(char) ('a'+valz*3+counter);
         word.append(ca);
         getWords(word);
         word.deleteCharAt(word.length()-1);
         char cb=(char) ('b'+valz*3+counter);
         word.append(cb);
         getWords(word);
         word.deleteCharAt(word.length()-1);
         char cc=(char) ('c'+valz*3+counter);
         word.append(cc);
         getWords(word);
         word.deleteCharAt(word.length()-1);
         if(valz==5 || valz==7){
            char cd=(char) ('d'+valz*3+counter);
            word.append(cd);
            getWords(word);
            word.deleteCharAt(word.length()-1);
         }
     }
 }

}

CodeEval - Play with DNA - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class Main {

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

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb=new StringBuffer();
        String line;
        while ((line = in.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(line);
            String pattern=st.nextToken();
            int allowedMiss=Integer.parseInt(st.nextToken());
            String str=st.nextToken();
            LinkedList<Pattern> list=new LinkedList<Pattern>();
            StringBuilder strb=new StringBuilder();
            for(int i=0;i<pattern.length()-1;i++){
                strb.append(str.charAt(i));
            }
            for(int i=pattern.length()-1;i<str.length();i++){
                 strb.append(str.charAt(i));
                 int dist=levenshteinDistance(pattern, strb.toString());
                 if(dist<=allowedMiss){
                     list.add(new Pattern(dist, strb.toString()));
                 }
                 strb.deleteCharAt(0);
            }
            Collections.sort(list);
            boolean first=true;
            while(!list.isEmpty()){
                if(!first){
                    sb.append(' ');
                }
                sb.append(list.remove().getPattern());
                first=false;
            }
            if(first){
                sb.append("No match");
            }
            sb.append('\n');
        }
       
        System.out.print(sb);
    }
   
    private static int minimum(int a, int b, int c) {
        return Math.min(Math.min(a, b), c);
    }

    public static int levenshteinDistance(String str1,String str2) {
        int[][] distance = new int[str1.length() + 1][str2.length() + 1];

        for (int i = 0; i <= str1.length(); i++)
            distance[i][0] = i;
        for (int j = 1; j <= str2.length(); j++)
            distance[0][j] = j;

        for (int i = 1; i <= str1.length(); i++)
            for (int j = 1; j <= str2.length(); j++)
                distance[i][j] = minimum(
                        distance[i - 1][j] + 1,
                        distance[i][j - 1] + 1,
                        distance[i - 1][j - 1]+ ((str1.charAt(i - 1) == str2.charAt(j - 1)) ? 0 : 1));

        return distance[str1.length()][str2.length()];   
    }

}
class Pattern implements Comparable<Pattern> {
    int score;
    String pattern;

    public Pattern(int score, String pattern) {
        this.score = score;
        this.pattern = pattern;
    }
   

    public String getPattern() {
        return pattern;
    }

    public int getScore() {
        return score;
    }

    public void setPattern(String pattern) {
        this.pattern = pattern;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public int compareTo(Pattern o) {
        if(this.score<o.getScore())
            return -1;
        if(this.score>o.getScore())
            return 1;
        return this.pattern.compareTo(o.getPattern());
    }
   
   
}

CodeEval - String Searching - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class Main {

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

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String line;
        while ((line = in.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(line,",");
            String str=st.nextToken();
            String temp=st.nextToken();
            StringBuilder stb=new StringBuilder();
            LinkedList<String> list=new LinkedList<String>();
            for(int i=0;i<temp.length();i++){
                char c=temp.charAt(i);
                if(i==0){
                    if(c!='*'){
                        stb.append(c);
                    }
                    if(i<temp.length()-1){
                        if(c=='\\'&&temp.charAt(i+1)=='*'){
                            stb.deleteCharAt(stb.length()-1);
                        }
                    }
                }else if(i== temp.length()-1){
                    if(c=='*'){
                        if(temp.charAt(i-1)=='\\'){
                           stb.append(c);
                        }
                    }else{
                        stb.append(c);
                    }
                }else{
                    if(c=='*'){
                        if(temp.charAt(i-1)=='\\'){
                           stb.append(c);
                        }else{
                            list.add(stb.toString());
                            stb=new StringBuilder();
                        }
                    }else if(c=='\\'){
                        if(temp.charAt(i+1)!='*'){
                           stb.append(c);
                        }
                    }else{
                        stb.append(c);
                    }
                }
            }
            if(stb.length()!=0){
                list.add(stb.toString());
            }
            sb.append(findThesePatterns(str, list)).append('\n');
        }
        System.out.print(sb);
    }
   
    static boolean findThesePatterns(String Str,LinkedList<String> pattern){
        LinkedList<LinkedList<Integer>> list=new LinkedList<LinkedList<Integer>>();
        LinkedList<Integer> length=new LinkedList<Integer>();
        while(!pattern.isEmpty()){
            String val=pattern.remove();
            list.add(searchForPattrern(Str,val));
            length.add(val.length());
        }
        return canBeAfter(0, -1, list, length);
    }
   
    static boolean canBeAfter(int j,int index,LinkedList<LinkedList<Integer>> list,LinkedList<Integer> length){
        if(j==length.size()){
            return true;
        }
        LinkedList<Integer> less=list.get(j);
        int lengthL=length.get(j);
        for(int val:less){
            if(val>index){
               boolean res=canBeAfter(j+1,val+lengthL,list, length);
               if(res){
                   return true;
               }
            }
        }
        return false;
    }
   
     static LinkedList<Integer> searchForPattrern(String val,String pattern){
         LinkedList<Integer> index=new LinkedList<Integer>();
         for(int i=0;i<val.length()-pattern.length()+1;i++){
             int counter=0;
             for(int j=0;j<pattern.length();j++){
                 if(val.charAt(i+j)!=pattern.charAt(j)){
                     break;
                 }
                 counter++;
             }
             if(counter==pattern.length()){
                 index.add(i);
             }
         }
         return index;
     }
}

CodeEval - Text to Number - Hard

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class Main {

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

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String line;
        HashMap<String,Integer> lessThan1000=getLessThan1000();
        while ((line = in.readLine()) != null) {
            StringTokenizer st=new StringTokenizer(line);
            String[]arr=new String[st.countTokens()];
            for(int i=0;i<arr.length;i++){
                arr[i]=st.nextToken();
            }
            sb.append(convToNum(arr, lessThan1000));
            sb.append('\n');
        }
        System.out.print(sb);
    }
  
    static int convToNum(String[]arr,HashMap<String,Integer> hm){
        int val=0;
        LinkedList<String> digit=new LinkedList<String>();
        LinkedList<String> thousand=new LinkedList<String>();
        LinkedList<String> million=new LinkedList<String>();
        int cases=0;
        boolean neg=false;
        for(int i=arr.length-1;i>-1;i--){
            if(arr[i].equals("thousand")){
                cases=1;
            }
            else if(arr[i].equals("million")){
                cases=2;
            }else{
                if(i==0){
                    if(arr[0].equals("negative")){
                        neg=true;
                        continue;
                    }
                }
                if(cases==0){
                    digit.add(arr[i]);
                }else if(cases==1){
                    thousand.add(arr[i]);
                }else{
                    million.add(arr[i]);
                }
            }
        }
        val=getVal(million, hm)*1000*1000+getVal(thousand, hm)*1000+getVal(digit, hm);
        if(neg){
            val=-val;
        }
        return val;
    }
  
    static int getVal(LinkedList<String> list,HashMap<String,Integer> hm){
        boolean first=true;
        StringBuilder sb=new StringBuilder();
        if(list.isEmpty()){
            return 0;
        }
        while(!list.isEmpty()){
            if(!first){
                sb.append(' ');
            }
            sb.append(list.removeLast());
            first=false;
        }
        return hm.get(sb.toString());
    }
  
    static HashMap<String, Integer> getLessThan1000(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        HashMap<String,Integer> digits0=initDigits0();
        HashMap<String,Integer> digits1=initDigits1();
        HashMap<String,Integer> digits2=initDigits2();
        for(String s:digits0.keySet()){
            hm.put(s,digits0.get(s));
        }
        for(String s:digits1.keySet()){
            hm.put(s,digits1.get(s));
        }
        digits0.remove("zero");
        for(String s:digits2.keySet()){
            hm.put(s,digits2.get(s));
            for(String s2:digits0.keySet()){
                hm.put(s+" "+s2,digits2.get(s)+digits0.get(s2));
            }
        }
        for(String s0:digits0.keySet()){
            hm.put(s0+" hundred",digits0.get(s0)*100);
            for(String s:digits0.keySet()){
                hm.put(s0+" hundred "+s,digits0.get(s0)*100+digits0.get(s));
            }
            for(String s:digits1.keySet()){
                hm.put(s0+" hundred "+s,digits0.get(s0)*100+digits1.get(s));
            }
            for(String s:digits2.keySet()){
                hm.put(s0+" hundred "+s,digits0.get(s0)*100+digits2.get(s));
                for(String s2:digits0.keySet()){
                    hm.put(s0+" hundred "+s+" "+s2,digits0.get(s0)*100+digits2.get(s)+digits0.get(s2));
                }
            }
        }
        return hm;
    }
  
    static HashMap<String, Integer> initDigits0(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        hm.put("zero",0);
        hm.put("one",1);
        hm.put("two",2);
        hm.put("three",3);
        hm.put("four",4);
        hm.put("five",5);
        hm.put("six",6);
        hm.put("seven",7);
        hm.put("eight",8);
        hm.put("nine",9);
        return hm;
    }
  
    static HashMap<String, Integer> initDigits1(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        hm.put("ten",10);
        hm.put("eleven",11);
        hm.put("twelve",12);
        hm.put("thirteen",13);
        hm.put("fourteen",14);
        hm.put("fifteen",15);
        hm.put("sixteen",16);
        hm.put("seventeen",17);
        hm.put("eighteen",18);
        hm.put("nineteen",19);
        return hm;
    }
  
    static HashMap<String, Integer> initDigits2(){
        HashMap<String,Integer> hm=new HashMap<String, Integer>();
        hm.put("twenty",20);
        hm.put("thirty",30);
        hm.put("forty",40);
        hm.put("fifty",50);
        hm.put("sixty",60);
        hm.put("seventy",70);
        hm.put("eighty",80);
        hm.put("ninety",90);
        return hm;
    }
  
}

UVA - 12626 - I ❤ Pizza

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#include <string.h>

int min(int x,int y){
    if(x<y)
        return x;
    return y;
}

int main()
{
    int n=0;
    scanf("%d",&n);
    while(n--){
        int M=0,A=0,R=0,G=0,I=0,T=0,i=0,z=0;
        char str[600];
        scanf("%s",str);
        z=strlen(str);
        for(i=0;i<z;i++){
            if(str[i]=='M')
                M++;
            else if(str[i]=='A')
                A++;
            else if(str[i]=='R')
                R++;
            else if(str[i]=='G')
                G++;
            else if(str[i]=='I')
                I++;
            else if(str[i]=='T')
                T++;
        }
        int answer=min(min(min(min(min(M,A/3),R/2),G),I),T);
        printf("%d\n",answer);
    }
    return 0;
}

UVA - 12592 - Slogan Learning of Princess

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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb=new  StringBuffer();
        int cases = Integer.parseInt(br.readLine());
        HashMap<String,String> hm=new HashMap<String, String>();
        for (int i = 0; i < cases; i++) {
            hm.put(br.readLine().trim(),br.readLine().trim());
        }
        cases = Integer.parseInt(br.readLine());
        for (int i = 0; i < cases; i++) {
            sb.append(hm.get(br.readLine().trim())).append("\n");
        }
        System.out.print(sb);
    }
}

UVA - 12602 - Nice Licence Plates

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


public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int cases=Integer.parseInt(br.readLine());
        for(int i=0;i<cases;i++){
            String str=br.readLine();
            int n1=(str.charAt(0)-'A')*26*26;
            n1+=(str.charAt(1)-'A')*26;
            n1+=(str.charAt(2)-'A');
            int n2=(str.charAt(4)-'0')*1000;
            n2+=(str.charAt(5)-'0')*100;
            n2+=(str.charAt(6)-'0')*10;
            n2+=(str.charAt(7)-'0');
            if(Math.abs(n1-n2)>100){
                sb.append("not nice\n");
            }else{
                sb.append("nice\n");
            }
        }
        System.out.print(sb);
    }

}

UVA - 320 - Border

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 {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int cases = Integer.parseInt(br.readLine());
        for (int i = 0; i < cases; i++) {
            sb.append("Bitmap #").append(i+1).append("\n");
            StringTokenizer st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());
            char[][] arr = new char[32][32];
            for (int j = 0; j < 32; j++) {
                for (int z = 0; z < 32; z++) {
                    arr[j][z] = '.';
                }
            }
            StringBuilder str = new StringBuilder(br.readLine());
            for (int j = 0; j < str.length(); j++) {
                 if (str.charAt(j) == 'E') {
                    x++;
                    arr[x-1][y-1] = 'X';
                   
                } else if (str.charAt(j) == 'W') {
                        x--;
                        arr[x][y] = 'X';
                       
                } else if (str.charAt(j) == 'N') {
                        y++;
                        arr[x][y-1] = 'X';
                } else if (str.charAt(j) == 'S') {
                    y--;
                    arr[x-1][y] = 'X';
                }
            }
            for (int j = 31; j >-1; j--) {
                for (int z = 0; z < 32; z++) {
                    sb.append(arr[z][j]);
                }
                sb.append("\n");
            }
            sb.append("\n");
        }
        System.out.print(sb);
    }
}