Patrick Ragi (pipo1991): January 2013

Tuesday 29 January 2013

UVA - 11565 - Simple Equations

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

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++) {
            StringTokenizer str=new StringTokenizer(br.readLine());
            int A=Integer.parseInt(str.nextToken());
            int B=Integer.parseInt(str.nextToken());
            int C=Integer.parseInt(str.nextToken());
            ArrayList<Integer> arr=new ArrayList<Integer>();
            for(int j=1;j<(B/2)+1;j++){
                if(B%j==0){
                    arr.add(j);
                    arr.add(-j);
                }
            }
            arr.add(B);
            arr.add(-B);
            Collections.sort(arr);
            boolean flag=false;
            for(int x=0;x<arr.size();x++){
                for(int y=x+1;y<arr.size();y++){
                    for(int z=y+1;z<arr.size();z++){
                        if(arr.get(x)*arr.get(y)*arr.get(z)==B){
                            if(arr.get(x)+arr.get(y)+arr.get(z)==A){
                                if((arr.get(x)*arr.get(x))+
                                        (arr.get(y)*arr.get(y))+
                                            (arr.get(z)*arr.get(z))==C){
                                    sb.append(arr.get(x)).append(" ")
                                      .append(arr.get(y)).append(" ")
                                      .append(arr.get(z)).append("\n");
                                    flag=true;
                                    break;
                                }
                            }
                        }
                    }
                    if(flag){
                        break;
                    }
                }
                if(flag){
                    break;
                }
            }
            if(!flag){
              sb.append("No solution.").append("\n");
            }
        }
        System.out.print(sb);
    }

}

UVA - 620 - Cellular Structure

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++) {
            StringBuilder str = new StringBuilder(br.readLine());
            check(str, sb);
        }
        System.out.print(sb);
    }

    static void check(StringBuilder str,StringBuffer sb){
        if (str.length() > 2) {
            if (str.charAt(0) == 'A') {
                if(str.charAt(str.length()-2)=='A' &&
                        str.charAt(str.length()-1)=='B'){
                    if(checkNotMutant(new StringBuilder(str.substring(0, str.length()-2)))){
                        sb.append("FULLY-GROWN\n");
                    }else{
                        sb.append("MUTANT\n");
                    }
                }else{
                    sb.append("MUTANT\n");
                }
            }else{
                if(str.charAt(str.length()-2)=='A' &&
                        str.charAt(str.length()-1)=='B'){
                    if(checkNotMutant(new StringBuilder(str.substring(0, str.length()-2)))){
                        sb.append("FULLY-GROWN\n");
                    }else{
                        sb.append("MUTANT\n");
                    }
                }else if(str.charAt(str.length()-1)=='A'){
                   if(checkNotMutant(new StringBuilder(str.substring(1, str.length()-1)))){
                        sb.append("MUTAGENIC\n");
                    }else{
                        sb.append("MUTANT\n");
                    }
                }else{
                    sb.append("MUTANT\n");
                }
            }
        }else{
            if (str.charAt(0) == 'A') {
                if (str.length() == 1) {
                    sb.append("SIMPLE\n");
                } else {
                    if (str.charAt(1) == 'B') {
                       sb.append("FULLY-GROWN\n");
                    } else {
                        sb.append("MUTANT\n");
                    }
                }
            }else{
                sb.append("MUTANT\n");
            }
        }
    }
    static boolean checkNotMutant(StringBuilder str) {
        if (str.length() > 2) {
            if (str.charAt(0) == 'A') {
                if(str.charAt(str.length()-2)=='A' &&
                        str.charAt(str.length()-1)=='B'){
                    return true&&checkNotMutant(new StringBuilder(str.substring(0, str.length()-2)));
                }else{
                    return false;
                }
            }else{
                if(str.charAt(str.length()-2)=='A' &&
                        str.charAt(str.length()-1)=='B'){
                    return true&&checkNotMutant(new StringBuilder(str.substring(0, str.length()-2)));
                }else if(str.charAt(str.length()-1)=='A'){
                    return true&&checkNotMutant(new StringBuilder(str.substring(1, str.length()-1)));
                }else{
                    return false;
                }
            }
        }else{
            if (str.charAt(0) == 'A') {
                if (str.length() == 1) {
                    return true;
                } else {
                    if (str.charAt(1) == 'B') {
                        return false;
                    } else {
                        return false;
                    }
                }
            }else{
                return false;
            }
        }
    }
}

Monday 28 January 2013

UVA - 902 - Password Search

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

public class Main {

public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        StringBuffer sb = new StringBuffer();
        while(sc.hasNext()){
            int n=sc.nextInt();
            String str=sc.next();
            HashMap<String,Integer> hm=new HashMap<String, Integer>();
            String max="";
            int freq=-1;
            for(int i=0;i<str.length()-n;i++){
                StringBuilder temp=new StringBuilder();
                for(int j=i;j<i+n;j++){
                    temp.append(str.charAt(j));
                }
                if(hm.containsKey(temp.toString())){
                    int tempf=hm.get(temp.toString())+1;
                    hm.put(temp.toString(), tempf);
                    if(tempf>freq){
                        max=temp.toString();
                        freq=tempf;
                    }
                }else{
                    hm.put(temp.toString(), 1);
                }
            }
            sb.append(max).append("\n");
        }
        System.out.print(sb);
    }

}

UVA - 11588 - Image Coding

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

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 l=1;l<cases+1;l++){
            StringTokenizer st=new StringTokenizer(br.readLine());
            int x=Integer.parseInt(st.nextToken()),
                y=Integer.parseInt(st.nextToken()),
                c=Integer.parseInt(st.nextToken()),
                o=Integer.parseInt(st.nextToken());
            int []arr=new int[26];
            for(int i=0;i<x;i++){
                StringBuilder str=new StringBuilder(br.readLine());
                for(int j=0;j<y;j++){
                    arr[str.charAt(j)-65]++;
                }
            }
            Arrays.sort(arr);
            int totalCost=arr[25]*c;
            int counter=arr[25];
            for(int j=24;j>-1;j--){
                if(arr[j]!=arr[j+1]){
                    break;
                }
                totalCost+=arr[j]*c;
                counter+=arr[j];
            }
            totalCost+=((x*y)-counter)*o;
            String s=String.format("Case %d: %d\n",l,totalCost);
            sb.append(s);
        }
        System.out.print(sb);
    }

}

UVA - 10365 - Blocks

UVA - 10487 - Closest Sums

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

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=1;
        while (true) {
            int n = Integer.parseInt(br.readLine());
            if (n == 0) {
                break;
            }
            sb.append("Case ").append(cases).append(":\n");
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = Integer.parseInt(br.readLine());
            }
            ArrayList<Integer> sum=new ArrayList<Integer>(n*n);
            for (int i = 0; i < n; i++) {
               for (int j = i; j < n; j++) {
                   if(i!=j){
                       sum.add(arr[i]+arr[j]);
                   }
                }
            }
            Collections.sort(sum);
            int m = Integer.parseInt(br.readLine());
            for(int i = 0; i < m; i++){
                int q=Integer.parseInt(br.readLine());
                int min=Integer.MAX_VALUE,ans=-1;
                for(int j=0;j<sum.size();j++){
                    int dif=Math.abs(q-sum.get(j));
                    if(dif<min){
                        min=dif;
                        ans=sum.get(j);
                    }
                }
                sb.append("Closest sum to ").append(q).append(" is ").append(ans).append(".\n");
            }
            cases++;
        }
        System.out.print(sb);
    }
}

Friday 25 January 2013

UVA - 477 - Points in Figures: Rectangles and Circles

import java.io.BufferedReader;
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 IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String m = "";
        LinkedList<Rectangle> listrec=new LinkedList<Rectangle>();
        LinkedList<Circle> listcirc=new LinkedList<Circle>();
        LinkedList<Integer> typ=new LinkedList<Integer>();
        while(true){
                m=br.readLine();
                if("*".equals(m))
                    break;
                StringTokenizer st=new StringTokenizer(m);
                String type=st.nextToken();
                if(type.charAt(0)=='r'){
                    listrec.add(new Rectangle(Double.parseDouble(st.nextToken()),
                                Double.parseDouble(st.nextToken()),
                                Double.parseDouble(st.nextToken()),
                                Double.parseDouble(st.nextToken())));
                    typ.add(0);
                }else{
                    listcirc.add(new Circle(Double.parseDouble(st.nextToken()),
                            Double.parseDouble(st.nextToken()),
                            Double.parseDouble(st.nextToken())));
                    typ.add(1);
                }
        }
        Rectangle[]rects=new Rectangle[listrec.size()];
        for(int i=0;i<rects.length;i++){
            rects[i]=listrec.remove();
        }
        Circle[]circs=new Circle[listcirc.size()];
        for(int i=0;i<circs.length;i++){
            circs[i]=listcirc.remove();
        }
        int[]types=new int[typ.size()];
        for(int i=0;i<types.length;i++){
            types[i]=typ.remove();
        }
        int cases=1;
        while(true){
            Double x,y;
            StringTokenizer st=new StringTokenizer(br.readLine());
            x=Double.parseDouble(st.nextToken());
            y=Double.parseDouble(st.nextToken());
            if(x==9999.9 &&y==9999.9){
                break;
            }
            Point p=new Point(x, y);
            boolean flag=false;
            for(int i=0,j=0,z=0;i<types.length;i++){
                if(types[i]==0){
                    if(pointInRect(p, rects[j])){
                        String str=String.format("Point %d is contained in figure %d\n", cases,(i+1));
                        sb.append(str);
                        flag=true;
                    }
                    j++;
                }else{
                   if(pointInCircle(p, circs[z])){
                        String str=String.format("Point %d is contained in figure %d\n", cases,(i+1));
                        sb.append(str);
                        flag=true;
                    }
                    z++;
                }
            }
            if(!flag){
                String str=String.format("Point %d is not contained in any figure\n", cases);
                sb.append(str);
            }
            cases++;
        }
        System.out.print(sb);
    }

    static boolean pointInRect(Point p,Rectangle x){
        return x.getX1()<p.getX()&&x.getX2()>p.getX()
                &&x.getY1()<p.getY()&&x.getY2()>p.getY();
    }

    static boolean pointInCircle(Point p,Circle x){
       double tempX=(p.getX()-x.getCenterX());
       tempX*=tempX;
       double tempY=(p.getY()-x.getCenterY());
       tempY*=tempY;
       return (x.getRadius()>Math.abs(Math.sqrt(tempX+tempY)));
    }

}
class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

}
class Rectangle{
    private double x1;
    private double y1;
    private double x2;
    private double y2;

    public Rectangle(double x1, double y1, double x2, double y2) {
        this.x1 = Math.min(x1, x2);
        this.y1 = Math.min(y1, y2);
        this.x2 = Math.max(x1, x2);
        this.y2 = Math.max(y1, y2);
    }

    public double getX1() {
        return x1;
    }

    public void setX1(double x1) {
        this.x1 = x1;
    }

    public double getX2() {
        return x2;
    }

    public void setX2(double x2) {
        this.x2 = x2;
    }

    public double getY1() {
        return y1;
    }

    public void setY1(double y1) {
        this.y1 = y1;
    }

    public double getY2() {
        return y2;
    }

    public void setY2(double y2) {
        this.y2 = y2;
    }

    public double getWidth(){
        return x2-x1;
    }

    public double getHeight(){
        return y2-y1;
    }

    public double getArea(){
        return getWidth()*getHeight();
    }

    public double getPeri(){
        return 2*(getWidth()+getHeight());
    }
}class Circle{
    private double centerX;
    private double centerY;
    private double radius;

    public Circle(double centerX, double centerY, double radius) {
        this.centerX = centerX;
        this.centerY = centerY;
        this.radius = radius;
    }

    public double getCenterX() {
        return centerX;
    }

    public void setCenterX(double centerX) {
        this.centerX = centerX;
    }

    public double getCenterY() {
        return centerY;
    }

    public void setCenterY(double centerY) {
        this.centerY = centerY;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

}

UVA - 232 - Crossword Answers

import java.io.BufferedReader;
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 IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        int cases=1;
        while(true){
           StringTokenizer st=new StringTokenizer(br.readLine());
           int n=Integer.parseInt(st.nextToken());
           if(n==0)
               break;
           if(cases>1){
               sb.append("\n");
           }
           sb.append(String.format("puzzle #%d:\n", cases));
           int m=Integer.parseInt(st.nextToken());
           char[][]arr=new char[n][m];
           char[][]pos=new char[n][m];
           for(int i=0;i<n;i++){
               arr[i]=br.readLine().toCharArray();
           }
           for(int i=0;i<n;i++){
               boolean flag=true;
              for(int j=0;j<m;j++){
                  if(arr[i][j]=='*'){
                      flag=true;
                  }else{
                      if(flag){
                         flag=false;
                         pos[i][j]='n';
                      }
                  }
              }
           }
           for(int i=0;i<m;i++){
               boolean flag=true;
              for(int j=0;j<n;j++){
                  if(arr[j][i]=='*'){
                      flag=true;
                  }else{
                      if(flag){
                         flag=false;
                         pos[j][i]='n';
                      }
                  }
              }
           }
           int[][]posX=new int[n][m];
           for(int i=0,p=1;i<n;i++){
              for(int j=0;j<m;j++){
                  if(pos[i][j]=='n'){
                      posX[i][j]=p++;
                  }
              }
           }
           LinkedList<String> list=new LinkedList<String>();
           sb.append("Across\n");
           for(int i=0;i<n;i++){
               boolean flag=true;
               StringBuilder temp=new StringBuilder();
              for(int j=0;j<m;j++){
                  if(arr[i][j]=='*'){
                      if(!flag){
                          list.add(temp.toString());
                          temp=new StringBuilder();
                      }
                      flag=true;
                  }else{
                      if(flag){
                         String str=String.format("%3d.", posX[i][j]) ;
                         temp.append(str);
                         flag=false;
                      }
                      temp.append(arr[i][j]);
                  }
              }
              if(!flag){
                list.add(temp.toString());
                temp=new StringBuilder();
              }
           }
           Collections.sort(list);
           while(!list.isEmpty()){
               sb.append(list.remove()).append("\n");
           }
           sb.append("Down\n");
           LinkedList<String> list2=new LinkedList<String>();
           for(int i=0;i<m;i++){
               boolean flag=true;
               StringBuilder temp=new StringBuilder();
              for(int j=0;j<n;j++){
                  if(arr[j][i]=='*'){
                      if(!flag){
                          list2.add(temp.toString());
                          temp=new StringBuilder();
                      }
                      flag=true;
                  }else{
                      if(flag){
                         String str=String.format("%3d.", posX[j][i]) ;
                         temp.append(str);
                         flag=false;
                      }
                      temp.append(arr[j][i]);
                  }
              }
              if(!flag){
                list2.add(temp.toString());
                temp=new StringBuilder();
              }
           }
           Collections.sort(list2);
           while(!list2.isEmpty()){
               sb.append(list2.remove()).append("\n");
           }
           cases++;
        }
        System.out.print(sb);
    }
}

Wednesday 23 January 2013

UVA - 476 - Points in Figures: Rectangles

UVA - 10125 – Sumsets

//Data Set is weak ...
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String m = "";
        while (true) {
            int n = Integer.parseInt(br.readLine());
            if (n == 0) {
                break;
            }
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = Integer.parseInt(br.readLine().trim());
            }
            Arrays.sort(arr);
            boolean flag = false;
            long max = Integer.MIN_VALUE;
            for (int i = n - 1; i > -1; i--) {
                for (int j = 0; j < n; j++) {
                    if (arr[i] == arr[j]) {
                        continue;
                    }
                    for (int z = j + 1; z < n; z++) {
                        if (arr[z] == arr[i]) {
                            continue;
                        }
                        for (int k = z + 1; k < n; k++) {
                            if (arr[k] == arr[i]) {
                                continue;
                            }
                            if (arr[i] == (arr[j] + arr[k] + arr[z])) {
                                sb.append(arr[i]).append("\n");
                                flag = true;
                                break;
                            }
                        }
                        if (flag) {
                            break;
                        }
                    }
                    if (flag) {
                        break;
                    }
                }
                if (flag) {
                    break;
                }
            }
            if (!flag) {
                sb.append("no solution\n");
            }
        }
        System.out.print(sb);
    }
}

Tuesday 22 January 2013

UVA - 10891 - Game of Sum

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));
        StringBuffer sb = new StringBuffer();
        String m="";
        while(true){
            int n=Integer.parseInt(br.readLine());
            if(n==0){
                break;
            }
            StringTokenizer str=new StringTokenizer(br.readLine());
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=Integer.parseInt(str.nextToken());
            }
            long[][]dp=new long[n][n];
            for(int i=0;i<n;i++){
               for(int j=0;j<n;j++){
                   dp[i][j]=Long.MIN_VALUE;
                }
            }
            sb.append(maxSum(0, n-1, arr, dp)).append("\n");
        }
        System.out.print(sb);
    }

    static long maxSum(int i,int j,int[] arr,long[][]dp){
        if(i==j)
            return arr[i];
        if(dp[i][j]>Long.MIN_VALUE){
            return dp[i][j];
        }
        long sum=0;
        long value=Long.MIN_VALUE;
        for(int k=i;k<j;k++){
            sum+=arr[k];
            value=Math.max(value,sum-maxSum(k+1, j, arr, dp));
        }
        value=Math.max(value,sum+arr[j]);
        sum=0;
        for(int k=j;k>i;k--){
            sum+=arr[k];
            value=Math.max(value,sum-maxSum(i, k-1, arr, dp));
        }
        dp[i][j]=Math.max(value,sum+arr[i]);
        return dp[i][j];
    }
}

UVA - 160 - Factors and Factorials

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 {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String m="";
        int[][]arr=new int[101][100];
        for(int i=2;i<arr.length;i++){
            System.arraycopy(arr[i-1], 2, arr[i], 2, 100 - 2);
            LinkedList<Integer> list=primeFactors(i);
            while(!list.isEmpty()){
                int temp=list.remove();
                arr[i][temp]++;
            }
        }
        while(true){
            int x=Integer.parseInt(br.readLine());
            if(x==0){
                break;
            }
            String str=String.format("%3d! =", x);
            sb.append(str);
            int counter=0;
            boolean flag=false;
            for(int i=2;i<100;i++){
                if(arr[x][i]>0){
                    if(flag){
                       sb.append("      ");
                       flag=false;
                    }
                    str=String.format("%3d", arr[x][i]);
                    sb.append(str);
                    counter++;
                    if(counter%15==0){
                        sb.append("\n");
                        flag=true;
                    }
                }
            }
            if(!flag){
                sb.append("\n");
            }
        }
        System.out.print(sb);
    }

    static LinkedList<Integer> primeFactors(int x){
        LinkedList<Integer> list=new LinkedList<Integer>();
        if(x<0){
            list.add(-1);
        }
        int temp=Math.abs(x);
        boolean notprime=false,entered=false;
        while(temp>1 &&!notprime){
            entered=false;
            for(int i=2;i<Math.sqrt(temp)+1;i++){
                if(temp%i==0){
                    list.add(i);
                    temp/=i;
                    notprime=false;
                    entered=true;
                    break;
                }
            }
            if(!entered)
                 notprime=true;
        }
        if(notprime){
                list.add(temp);
            }
        return list;
    }
}

Monday 21 January 2013

UVA - 11340 - Newspaper

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

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());
        String m="";
        for(int i=0;i<cases;i++){
            int n=Integer.parseInt(br.readLine());
            HashMap<Character,Integer> hm=new HashMap<Character, Integer>();
            for(int j=0;j<n;j++){
                StringTokenizer str=new StringTokenizer(br.readLine());
                hm.put(str.nextToken().charAt(0), Integer.parseInt(str.nextToken()));
            }
            long sum=0;
            n=Integer.parseInt(br.readLine());
            for(int j=0;j<n;j++){
                m=br.readLine();
                for(int z=0;z<m.length();z++){
                    if(hm.containsKey(m.charAt(z))){
                        sum+=hm.get(m.charAt(z));
                    }
                }

            }
            String temp=sum%100+"";
            if(temp.length()<2){
                temp="0"+temp;
            }
            sb.append(sum/100).append(".").append(temp).append("$\n");
        }
        System.out.print(sb);
    }
}

Thursday 17 January 2013

UVA - 10633 - Rare Easy Problem

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 {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer("");
        while(true){
            BigInteger x=new BigInteger(br.readLine());
            if(x.compareTo(BigInteger.ZERO)==0){
                break;
            }
            BigInteger temp=x.multiply(BigInteger.valueOf(10)).divide(BigInteger.valueOf(9));
            boolean flag=false;
            for(BigInteger i=temp.subtract(BigInteger.valueOf(10));
                    i.compareTo(temp.add(BigInteger.valueOf(11)))==-1;
                    i=i.add(BigInteger.ONE)){
                BigInteger maybe=i.divide(BigInteger.valueOf(10));
                maybe=i.subtract(maybe);
                if(x.compareTo(maybe)==0){
                    if(flag)
                        sb.append(" ");
                    sb.append(i);
                    flag=true;
                }
            }
            sb.append("\n");
        }
        System.out.print(sb);
    }
}

Patrick Ragi (pipo1991)

Pages