algorithm primary arithmetic - andstudy/forge GitHub Wiki

  import java.io.IOException;
  
  class Main implements Runnable{
      static String ReadLn(int maxLength){  // utility function to read from stdin,
                                            // Provided by Programming-challenges, edit for style only
          byte line[] = new byte [maxLength];
          int length = 0;
          int input = -1;
          try{
              while (length < maxLength){//Read untill maxlength
                  input = System.in.read();
                  if ((input < 0) || (input == '\n')) break; //or untill end of line ninput
                  line [length++] += input;
              }
  
              if ((input < 0) && (length == 0)) return null;  // eof
              return new String(line, 0, length);
          }catch (IOException e){
              return null;
          }
      }
  
      public static void main(String args[])  // entry point from OS
      {
          Main myWork = new Main();  // Construct the bootloader
          myWork.run();            // execute
      }
  
      public void run() {
      	String line = null;
      	Adder adder = new Adder();
      	while((line = ReadLn(22).trim()) != null){
      		if(line.equals("0 0")){
      			break;
      		}
      		String [] nums = line.split(" ");
      		if(nums.length != 2){
      			break;
      		}
      		int carryCount = adder.getCarryCount(nums[0], nums[1]);
      		if(carryCount == 0){
      			System.out.println("No carry operation.");
      		} else if(carryCount==1){
      			System.out.println(carryCount+" carry operation.");
      		}else{
      			System.out.println(carryCount+" carry operations.");
      		}
      	}
      }
  }
  
  
  class Adder {
  
  	public boolean isMakeCarry(int i, int j,boolean hasCarry) {
  		int carray = hasCarry?1:0;
  		return i+j+carray>=10;
  	}
  
  	public int getCarryCount(String adder, String addend) {
  		int maxLen = Math.max(adder.length(), addend.length());
  		boolean hasCarry = false;
  		int carryCount = 0;
  		for(int index=0;index<maxLen;index++){
  			int a = getValueByPos(adder, index);
  			int b = getValueByPos(addend, index);
  			hasCarry = isMakeCarry(a, b, hasCarry);
  			if(hasCarry){
  				carryCount++;
  			}
  		}
  		return carryCount;
  	}
  	public int getValueByPos(String value,int pos){
  		if(value.length() <= pos)
  			return 0;
  		int cutPos = value.length()-pos-1;
  		return Integer.parseInt( value.substring( cutPos,cutPos+1) );
  	}
  
  }

  import junit.framework.TestCase;
  
  
  public class AdderTest extends TestCase {
  	public void testIsMakeCarry(){
  		Adder adder = new Adder();
  		assertTrue(adder.isMakeCarry(5,5,false));
  		assertTrue(adder.isMakeCarry(5,4,true));
  		assertTrue(adder.isMakeCarry(5,6,false));
  		assertFalse(adder.isMakeCarry(5,3,false));
  	}
  	
  	public void testValuePos(){
  		Adder adder = new Adder();
  		assertEquals(1, adder.getValueByPos("1234", 3));
  		assertEquals(4, adder.getValueByPos("1234", 0));
  	}
  	
  	public void testGetCarryCount(){
  		Adder adder = new Adder();
  		assertEquals(0, adder.getCarryCount("123","456"));
  		assertEquals(3, adder.getCarryCount("555","555"));
  		assertEquals(2, adder.getCarryCount("55","555"));
  		assertEquals(1, adder.getCarryCount("123" ,"594"));
  		assertEquals(0, adder.getCarryCount("0","0"));
  	}
  	
  	
  }

  public class PrimaryMain {
  	
  	int[] firNum = new int[10];
  	int[] secNum = new int[10];
  	
  	public boolean parseInput(String fir, String sec) {
  
  		if(fir.length() > 10 || sec.length() > 10)
  			return false;
  		
  		char[] temp = fir.toCharArray();
  		for(int i=temp.length-1, j=0 ; i>=0 ; i-- , j++)		{
  			firNum[i] = Integer.parseInt(String.valueOf(temp[j]));
  		}
  		
  		char[] temp2= sec.toCharArray();
  		for(int i=temp2.length-1, j=0 ; i>=0 ; i-- , j++)		{
  			secNum[i] = Integer.parseInt(String.valueOf(temp2[j]));
  		}
  				
  		return true;	
  	}
  
  	public int addOneDigit(int fir, int sec, int carry) {
  		
  		if( fir + sec + carry > 9)
  			return 1;
  		else
  			return 0;
  	}
  	
  	public void initNumbers(String in) {
  		String[] input = in.split(" ");
  		
  		if(input.length > 2)
  			return;
  				
  		parseInput(input[0],input[1]);
  		
  	}
  
  	public int sumCarryCount() {
  		
  		int sumCarry = 0;
  		int carry = 0;
  				
  		for(int i=0; i < firNum.length ; i++) {
  			carry = addOneDigit(firNum[i],secNum[i],carry);
  			
  			if( carry == 1)
  				sumCarry++;
  			
  			if( firNum[i] == 0 && secNum[i] == 0)
  				break;
  		}
  		
  		return sumCarry;
  	}
  
  }

  import static org.junit.Assert.*;
  import java.util.Arrays;
  import org.junit.Test;
  
  
  public class PrimaryMainTest {
  	
  	PrimaryMain pri = new PrimaryMain();
  
  	@Test
  	public void testSumCarryCount() {
  		pri.initNumbers("123 456");
  		assertEquals(0,pri.sumCarryCount());
  		
  		pri.initNumbers("555 555");
  		assertEquals(3,pri.sumCarryCount());
  
  		pri.initNumbers("123 594");
  		assertEquals(1,pri.sumCarryCount());
  
  		pri.initNumbers("146 554");
  		assertEquals(2,pri.sumCarryCount());
  	}
  
  	@Test
  	public void testParseInput() {
  		pri.parseInput("15","4");
  		assertTrue(Arrays.equals(pri.firNum,new int[] {5,1,0,0,0,0,0,0,0,0}));
  		assertTrue(Arrays.equals(pri.secNum,new int[] {4,0,0,0,0,0,0,0,0,0}));
  		
  		pri.parseInput("123","456");
  		assertTrue(Arrays.equals(pri.firNum,new int[] {3,2,1,0,0,0,0,0,0,0}));
  		assertTrue(Arrays.equals(pri.secNum,new int[] {6,5,4,0,0,0,0,0,0,0}));
  		
  	}
  	
  	@Test
  	public void testAddOneDigit() {
  		assertEquals(0,pri.addOneDigit(4,5,0));
  		assertEquals(1,pri.addOneDigit(5,5,0));
  		assertEquals(1,pri.addOneDigit(4,5,1));
  		assertEquals(0,pri.addOneDigit(1,2,1));
  	}
  	
  	
  }

  /* @JUDGE_ID:parkpd 10038 C "test" */
  
  /* @BEGIN_OF_SOURCE_CODE */
  
  #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
  #define _CRT_SECURE_NO_DEPRECATE 1 
  
  #include <stdlib.h>
  #include <iostream>
  #include <vector>
  #include <set>
  #include <deque>
  #include <strstream>
  #include <algorithm>
  
  using namespace std;
  
  //#define _UNIT_TEST
  
  #ifdef _UNIT_TEST
  
  #include "../../UnitTest++/src/UnitTest++.h"
  
  int main()
  {
  	UnitTest::RunAllTests();
  
  	char temp;
  	cin >> temp;
  
  	return 0;
  }
  
  #endif
  
  class CPrimaryArithmetic 
  {
  public:
  	static int GetCarryCount(int left, int right);
  	static void GetInts(int num, vector<int>& nums);
  };
  
  int CPrimaryArithmetic::GetCarryCount( int left, int right )
  {
  	vector<int> lefts;
  	vector<int> rights;
  	GetInts(left, lefts);
  	GetInts(right, rights);
  
  	int carryCount = 0;
  	int additionalCarry = 0;
  	for (int i = 9; i >= 0; --i)
  	{
  		if (10 <= lefts[i] + rights[i] + additionalCarry)
  		{
  			carryCount++;
  			additionalCarry = 1;
  		}
  	}
  
  	return carryCount;
  }
  
  // string 으로 하는 거랑 속도 비교해 볼 것.
  void CPrimaryArithmetic::GetInts( int num, vector<int>& nums )
  {
  	nums = vector<int>(10, 0);
  
  	int index = 9;
  	while (10 <= num)
  	{
  		nums[index] = (num % 10);
  		num /= 10;
  		--index;
  	}
  
  	nums[index] = num;
  }
  
  #ifndef _UNIT_TEST
  
  int main()
  {
  	vector<pair<int, int> > testNums;
  
  	while(1)
  	{
  		int left, right;
  		cin >> left >> right;
  		if ((0 == left) && (0 == right))
  		{
  			break;
  		}
  
  		testNums.push_back(make_pair<int, int>(left, right));
  	}
  
  	int count = (int)testNums.size();
  	for (int i = 0; i < count; ++i)
  	{
  		int carryCount = CPrimaryArithmetic::GetCarryCount(testNums[i].first, testNums[i].second);
  		if (0 == carryCount)
  		{
  			cout << "No carry operation.\n";
  		}
  		else if (1 == carryCount)
  		{
  			cout << "1 carry operation.\n";
  		}
  		else
  		{
  			cout << carryCount << " carry operations\n";
  		}
  	}
  
  	return 0;
  }
  
  #else
  
  struct FixturePrimaryArithmetic : public CPrimaryArithmetic
  {
  	vector<int> nums;
  };
  
  TEST_FIXTURE(FixturePrimaryArithmetic, GetInts)
  {
  	int expect[] = {0, 0, 0, 0, 0, 1, 2, 3, 4, 5};
  	GetInts(12345, nums);
  	CHECK_ARRAY_EQUAL(expect, nums, 10);
  }
  
  TEST_FIXTURE(FixturePrimaryArithmetic, GetCarryCount)
  {
  	CHECK_EQUAL(0, GetCarryCount(1, 1));
  	CHECK_EQUAL(1, GetCarryCount(2, 9));
  	CHECK_EQUAL(9, GetCarryCount(999999999, 1));
  
  	CHECK_EQUAL(0, GetCarryCount(123, 456));
  	CHECK_EQUAL(3, GetCarryCount(555, 555));
  	CHECK_EQUAL(1, GetCarryCount(123, 594));
  	CHECK_EQUAL(0, GetCarryCount(123, 0));
  
  	CHECK_EQUAL(1, GetCarryCount(4821, 311));
  	CHECK_EQUAL(3, GetCarryCount(999, 1));
  	CHECK_EQUAL(4, GetCarryCount(99099, 1001));
  }
  
  #endif
  
  /* @END_OF_SOURCE_CODE */