Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	for sc.Scan() {
		str := strings.Split(sc.Text(), " ")
		if len(str) != 2 {
			return
		}
		a, err1 := strconv.ParseInt(str[0], 10, 64)
		b, err2 := strconv.ParseInt(str[1], 10, 64)
		if err1 != nil || err2 != nil {
			return
		}
		a += b
		for b = 0; a > 0; a /= 10 {
			b++
		}
		fmt.Println(b)
	}
}

C++: #include <iostream>
#include <string>
using namespace std;

int main () {
	int a, b;
	while (cin >> a >> b) {
		cout << to_string(a + b).size() << endl;
	}
	return 0;
}

C++: 
#include <iostream>

using namespace std;

int main(){
      long int a,b,sum;
int i,j;
while(cin>>a>>b)
    {
    sum=a+b;
    for(j=0;sum>0;j++)
    {
        sum=sum/10;
        }
    cout<<j<<endl;
        }
    system("PAUSE");
    return 0;
}

C++: #include<bits/stdc++.h>
#include<cstdio>
#include<sstream>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<algorithm>
#include<set>
#include<queue>
#include<stack>
#include<list>
#include<iostream>
#include<fstream>
#include<numeric>
#include<string>
#include<vector>
#include<cstring>
#include<map>
#include<iterator>

using namespace std;
#define EPS 1e-9
#define MAX 505
#define pb push_back
#define mp make_pair
#define ins insert
#define fi first
#define se second
#define pi acos(-1.0)
#define mod 100000007
#define inf 2147483647
#define ll long long int
#define sss stringstream
#define oss ostringstream
#define iss istringstream
#define llu long long unsigned

#define _sq(a) (a)*(a)
#define sz(a) ((int)a.size())
#define gcd(a,b)    __gcd(a,b)
#define lcm(a,b) ((a)*((b)/gcd(a,b)))
#define _max3(a,b,c) max(a, max(b,c))
#define _min3(a,b,c) min(a, min(b,c))
#define FOR(i, n) for(i=0; i<(int)n; i++)
#define FOR1(i, n) for(i=1; i<=(int)n; i++)
#define mem(a) memset(a, 0, sizeof(a))
#define _set(a) memset(a,-1,sizeof(a))
#define FORI(i, a, b) for(i=a; i>=(int)b; i--)
#define FORab(i, a, b) for(i=a; i<=(int)b; i++)
#define popcount(n) __builtin_popcount(n)
#define popcountl(n) __builtin_popcountll(n)
#define sort_rev(a) sort(a.rbegin(), a.rend())
#define sort_all(a) sort(a.begin(), a.end())
#define dis_twopoints(x1,y1,x2,y2) sqrt(_sq(x1-x2) + _sq(y1-y2))
#define foreach(i,n) for(__typeof((n).begin())i =(n).begin();i!=(n).end();i++)

//If Long Long (mask & (1LL << k))
#define check(mask, k) (mask & (1 << k))
#define set1(mask, k) (mask | (1 << k))
#define set0(mask ,k) (mask & (~(1<<k)))

#define SD(a) scanf("%d",&a)
#define SLF(a) scanf("%lf",&a)
#define SC(a) scanf("%c",&a)
#define SS(a) scanf("%s",a)
#define SLLD(a) scanf("%lld", &a)
#define Si64(a) scanf("%I64d", &a)

#define READ(f) freopen(f, "r", stdin)
#define WRITE(f) freopen(f, "w", stdout)
int f[60];
int main()
{
    int a,b,s,t;
    while(cin>>a>>b)
    {
        t=1;
        int n=10;
        s=a+b;
        while(s/n)
        {
            t++;
            n=n*10;

        }
        cout<<t<<endl;
    }
    return 0;
}

C++: #include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
    int a,b=0;
    
    while (cin >> a >> b){
        a += b;
    for (b=1; a>=10; b++) {
        a /= 10;
    }
        cout << b << endl;
    }
}

C++: #include <bits/stdc++.h>
#define REP(i,n) for(int i = 0; i < n; i++)
using namespace std;

int main() {
  int a, b;
  while(scanf("%d %d", &a, &b) != EOF) {
    a += b;
    b = 0;
    while(a != 0) {
      a /= 10;
      b++;
    }
    printf("%d\n", b);
  }
  return 0;
}

C++: #include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main(void){
	long long n , i , j , k ;
	while(1){
		cin >> j >> k ;
		int x = j+k;
		stringstream str;
		str << x ;
		string st = str.str();
		cout << st.size() << endl;
	}
}

C++: #include <iostream>
#include <vector>

#ifndef EOF
#define EOF (-1)
#endif

int main() {
    std::vector<int> digits;
    int a, b;
    while (scanf("%d %d", &a, &b) != EOF)
    {
        int sum = a + b;
        int t = sum / 10;
        int digit = 1;
        while (t > 0) {
            digit++;
            t = t / 10;
        }
        digits.push_back(digit);
    }

    for (int i = 0; i < digits.size(); i++) {
        std::cout << digits[i] << std::endl;
    }

    return 0;
}

C++: #include<iostream>
using namespace std;
#define N 200

int main()
{
int a=0,b=0,n[N],kaisu=0;

do{
 n[kaisu]=1;
 cin>>a>>b;
 if(a>=0 && b>=0 && a<=1000000 && b<=1000000)
 	{
	 a = a+b;
	 while(a>=10)
	 	{
		 a = a/10;
		 n[kaisu] += 1;
	 	}
 	}
 	cout<<n[kaisu]<<endl;
 	kaisu++;
 	
 	}while(kaisu<N);


}

C++: #include <iostream>

using namespace std;

int numarray[400];
int i=0;

int main(){
while(cin>>numarray[i]) {
	//cout<<numarray[i]<<endl;
	i++;
}

for (int j=0;j<i;j=j+2){
	//cout<<numarray[j]<<"+"<<numarray[j+1]<<"=";
	cout<<numarray[j]+numarray[j+1]<<endl;
}

	return 0;
}

C++: #include <iostream>
using namespace std;

int digit(int n){
    int digit=0;
    while(n>0){
        digit+=1;
        n=n/10;
    }
    return digit;
}

int main(void){
    int a,b;
    while(cin>>a>>b){
        cout<<digit(a+b)<<endl;
    }
    return 0;
}

C++: #include<iostream>
#include<string>

using namespace std;

int main() {
	string s;
	for (int a, b; cin >> a >> b;) {
		s=to_string(a + b);
		cout << s.size() << endl;
	}
	return 0;
}

C++: #include <bits/stdc++.h>

using namespace std;

int main(){
	int a,b;
while (cin>>a>>b){
	int n=a+b;
	if(n==1000000){
		cout<<7<<endl;
	}
	else if (n>99999){	
	cout<<6<<endl;
}
	else if(n>9999){
		cout<<5<<endl;
	}
		else if(n>999){
		cout<<4<<endl;
	}
		else if(n>99){
		cout<<3<<endl;
		}
		else if(n>9){
		cout<<2<<endl;
	}
	else{ 
	cout<<1<<endl;
	}
	}
}

C++: 
fn main() {
        let n = readln();
        let mut c:f32 = 100000.0;

        for _i in 0..n {
            c=c+c*0.05;
            if c%1000.0!=0.0{
                c=(((c/1000.0) as i32) as f32)*1000.0+1000.0;
            }
        }
        println!("{:.0}",c);
}
     
    // --- template ---
    #[allow(unused_imports)]
    use std::cmp::{max, min};
    #[allow(unused_imports)]
    use std::collections::{HashMap, HashSet, VecDeque};
     
    pub trait FromLn {
        fn fromln(s: &str) -> Self;
    }
    pub fn readln<T: FromLn>() -> T {
        let mut buf = String::new();
        let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
        T::fromln(buf.trim())
    }
    pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
        let mut vs = vec![];
        for _ in 0..n {
            vs.push(readln());
        }
        vs
    }
    macro_rules! fromln_primitives {
        ($($t:ty),*) => { $(
            impl FromLn for $t {
                fn fromln(s: &str) -> $t {
                    s.parse().unwrap()
                }
            }
        )* }
    }
    fromln_primitives!(
        String,
        bool,
        f32,
        f64,
        isize,
        i8,
        i16,
        i32,
        i64,
        usize,
        u8,
        u16,
        u32,
        u64
    );
    impl<T> FromLn for Vec<T>
    where
        T: FromLn,
    {
        fn fromln(s: &str) -> Vec<T> {
            s.split_whitespace().map(T::fromln).collect()
        }
    }
    impl FromLn for Vec<char> {
        fn fromln(s: &str) -> Vec<char> {
            s.chars().collect()
        }
    }
    macro_rules! fromln_tuple {
        ($($t:ident),*) => {
            impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {
                fn fromln(s: &str) -> ($($t),*) {
                    let mut it = s.split_whitespace();
                    let t = ($($t::fromln(it.next().unwrap())),*);
                    assert_eq!(it.next(), None);
                    t
                }
            }
        }
    }
fromln_tuple!(A, B);
fromln_tuple!(A, B, C);
fromln_tuple!(A, B, C, D);
fromln_tuple!(A, B, C, D, E);
fromln_tuple!(A, B, C, D, E, F);