Created application for the change pattern AAAA AAAB AABA AABB ect

[Tony Evans]

Hi hope this is the correct thread.

Created an application for the changing a pattern given a pattern AAAA and a char B
Will end up with BBBB following making one change at a time i.e AAAB AABA AABB ABAA.

It works but I guess there is a faster or a recursive way of doing it.

Anyway just review this. This is not for college or unie. As we move more and more towards framwork I want to try and keep my basic coding skills as sharp as I can.




Main application

public class BineryPattern {

	public void runBineryPatterns(String pattern, char ch){
		System.out.println("start");
		char [] charPattern = pattern.toCharArray();
		CharContainer [] container = setPattern(charPattern,ch);
   	 	printPattern(container);
		int check = 0;
         while(true){
        	 updatePattern(container);
        	 printPattern(container);
        	 if(checkComplete(container,ch)){
            	 printPattern(container);
        		 break;
        	 }
         }
	}
	
	private CharContainer [] setPattern(char [] charPattern, char newCh){
		char ch = charPattern[0];
		CharContainer container = null;
		
		
		CharContainer [] containerArray = new CharContainer[charPattern.length];
		for(int index=0; index < charPattern.length; index++){
			container = new CharContainer();
			container.setCh(ch);
			container.setswopCh(newCh);
			container.setChangeCount(1);
			containerArray[index] = container;
		}
		int length = containerArray.length-1;
		
		int count = 1;
		for(int index=length; index >= 0; index--){
			container = containerArray[index];
			container.setChange(count);
			containerArray[index] = container;
			count = count*2;
		}
		return containerArray; 
	}
	
	private boolean checkComplete(CharContainer [] containerArray, char ch){
		CharContainer container = null;
		for(int index=0; index < containerArray.length; index++){
			container = containerArray[index];
			if(ch != container.getCh()){
				return false;
			}
		}
		return true;
	}
	
	private void updatePattern(CharContainer [] containerArray){
		CharContainer container = null;
		for(int index=0; index < containerArray.length; index++){
			container = containerArray[index];
			if(container.getChange() == container.getChangeCount()){
				container = swop(container);
				container.setChangeCount(1);
			} else {
				int count = container.getChangeCount() +1;
				container.setChangeCount(count);
			}
			containerArray[index] = container;
		}
	}
	
	private CharContainer swop(CharContainer container){
		char temp = container.getCh();
		container.setCh(container.getSwopCh());
		container.setswopCh(temp);
		return container;
	}
	
	private void printPattern(CharContainer [] containerArray){
		CharContainer container = null;
		for(int index=0; index < containerArray.length; index++){
           container = containerArray[index];
           System.out.print(container.getCh());
		}
		System.out.println();
	}

The object container

public class CharContainer {
	char ch = ' ' ;
	char swopCh = ' ';
	int change = 0;
	int changeCount = 0;
	
	
	public void setCh(char ch){
		this.ch = ch;
	}
	
	public char getCh(){
		return ch;
	}
	
	public void setswopCh(char swopCh){
		this.swopCh = swopCh;
	}
	
	public char getSwopCh(){
		return swopCh;
	}
	
	public void setChange(int change){
		this.change = change;
	}
	
	public int getChange(){
		return change;
	}
	
	public void setChangeCount(int changeCount){
		this.changeCount = changeCount;
	}
	
	public int getChangeCount(){
		return changeCount;
	}
}

[fred rosenberger]

isn't this really just counting in binary? let 0 = A and 1 = B.

0000
0001
0010
0011
0100
0101
0110
0111
etc

you could just count from 0 to 15, use a mask to check each bit, and print the associated character.