无法替换上班

Question

I am making a program that will help me convert DFA to a regular expression using an algorithm we learned at the course. CODE:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Collections;
import java.util.regex.Pattern;
import java.util.Arrays;
import java.io.*;

public class DFK {
    static ArrayList<Path> done = new ArrayList<Path>();

    public static void print() {
        for(Path i: done) {
            System.out.println("NOT REPLACED: "+ i);
            if(i.isConverted()) {
                System.out.println("WITH REPLACE: "+ i.getConverted()+"\n");
            } else
                System.out.print("\n");
        }
    }

    public static void develop() {
        if(done.get(0).getKP1() > 0) {
            DFK.add(new Path(done.get(0).getP(), done.get(0).getQ(), done.get(0).getK()));
            DFK.add(new Path(done.get(0).getP(), done.get(0).getKP1(), done.get(0).getK()));
            DFK.add(new Path(done.get(0).getKP1(), done.get(0).getKP1(), done.get(0).getK()));
            DFK.add(new Path(done.get(0).getKP1(), done.get(0).getQ(), done.get(0).getK()));
        }
    }

    public static void add(Path x) {
            boolean exists = (done.indexOf(x)==-1 ? false : true);
            if(exists == false) {
                done.add(x);
                if(x.getKP1() >= 2) {
                    DFK.add(new Path(x.getP(), x.getQ(), x.getK()));
                    DFK.add(new Path(x.getP(), x.getKP1(), x.getK()));
                    DFK.add(new Path(x.getKP1(), x.getKP1(), x.getK()));
                    DFK.add(new Path(x.getKP1(), x.getQ(), x.getK()));
                }
            }
    }

    public static void main(String argv[]) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        int p = 0, q = 0, kp1 = 0;
        Scanner in = new Scanner(System.in);
        System.out.print("p = ");p = in.nextInt();
        System.out.print("q = ");q = in.nextInt();
        System.out.print("k+1 = ");kp1 = in.nextInt();

        System.out.print("\n");
        String rkzero[][] = new String[q][q];
        for(int i=0; i<q ; i++) {
            for(int j=0; j<q ; j++) {
                System.out.print(String.format("r(%d,%d,0): ", i+1, j+1));
                rkzero[i][j]=input.readLine();
            }
        }

        done.add(new Path(p, q, kp1));
        DFK.develop();
        Collections.sort(done);

        for(int z=0; z<q ; z++) {
            for(int j=0; j<q ; j++) {
                for(Path i: done)
                    if(i.getKP1()==1) {
                        String reg = String.format("r(%d,%d,0)",z+1,j+1); //
                        i.setConverted(i.toString().replace( reg , rkzero[z][j])); //HERE IS THE PROBLEM I THINK
                }
            }
        }
        System.out.print("\n");
        DFK.print();
    }
}

class Path implements Comparable<Path> {
    int p,q,kplus1,k;
    String converted = null;

    public int getP() {
        return p;
    }

    public int getQ() {
        return q;
    }

    public int getKP1() {
        return kplus1;
    }

    public int getK() {
        return k;
    }

    public Path(int a, int b, int c) {
        super();
        p = a;
        q = b;
        kplus1 = c;
        k = c-1;
    }

    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }

        if (!Path.class.isAssignableFrom(obj.getClass())) {
            return false;
        }

        final Path other = (Path) obj;
        if(other.p == this.p && other.q == this.q && other.kplus1 == this.kplus1)
            return true;
        return false;
    }

    public int compareTo(Path other) {
        return other.kplus1-kplus1;
    }

    public String toString() {
        return String.format("r(%d,%d,%d)=r(%d,%d,%d)+r(%d,%d,%d)r(%d,%d,%d)*r(%d,%d,%d)",p,q,kplus1,p,q,k,p,kplus1,k,kplus1,kplus1,k,kplus1,q,k);
    }

    public void setConverted(String x) {
        converted = new String(x);
    }

    public String getConverted() {
        return converted;
    }

    public boolean isConverted() {
        if(converted == null)
            return false;
        return true;
    }
}

CURRENT OUTPUT:

p = 1
q = 2
k+1 = 2

r(1,1,0): 0
r(1,2,0): 1
r(2,1,0): 1
r(2,2,0): 0

NOT REPLACED: r(1,2,2)=r(1,2,1)+r(1,2,1)r(2,2,1)*r(2,2,1)

NOT REPLACED: r(1,2,1)=r(1,2,0)+r(1,1,0)r(1,1,0)*r(1,2,0)
WITH REPLACE: r(1,2,1)=r(1,2,0)+r(1,1,0)r(1,1,0)*r(1,2,0)

NOT REPLACED: r(2,2,1)=r(2,2,0)+r(2,1,0)r(1,1,0)*r(1,2,0)
WITH REPLACE: r(2,2,1)=0+r(2,1,0)r(1,1,0)*r(1,2,0)

WANTED OUTPUT:

p = 1
q = 2
k+1 = 2

r(1,1,0): 0
r(1,2,0): 1
r(2,1,0): 1
r(2,2,0): 0

NOT REPLACED: r(1,2,2)=r(1,2,1)+r(1,2,1)r(2,2,1)*r(2,2,1)

NOT REPLACED: r(1,2,1)=r(1,2,0)+r(1,1,0)r(1,1,0)*r(1,2,0)
WITH REPLACE: r(1,2,1)=1+00*1

NOT REPLACED: r(2,2,1)=r(2,2,0)+r(2,1,0)r(1,1,0)*r(1,2,0)
WITH REPLACE: r(2,2,1)=0+10*1

As you can see it only replaces r(2,2,0) with 0 , and nothing else and I cant find out why. I replicated the problem in a previous question, but it turned out there was a non-ascii comma in my code there which caused the issue, but here I can't find it.

I used grep --color='auto' -P -n "[^\\x00-\\x7F]" DFK.java and it didn't find any non ascii characters, so I hope it's not the same problem.

The program should iterate over all Paths that have kplus1 = 1 and replace all r(i,j,0) with strings I have previously entered. Keep in mind, it is not finished yet.

Answer 1

The mistake is I was using toString to get the string in which I replace things, and so I replace one string and for the next replacement I use the original string again and thus throwing away the last replacement and so on.

So the solution is to make converted initialize as the same string as toString() inside constructor:

converted = String.format("r(%d,%d,%d)=r(%d,%d,%d)+r(%d,%d,%d)r(%d,%d,%d)*r(%d,%d,%d)",p,q,kplus1,p,q,k,p,kplus1,k,kplus1,kplus1,k,kplus1,q,k);

and then in main use:

i.setConverted( i.getConverted().replace(reg, rkzero[z][j]) );

so I save the intermediate solution in converted.