Go: package main

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

func sliceAtoi(sa []string) ([]int, error) {
	si := make([]int, 0, len(sa))
	for _, a := range sa {
		i, err := strconv.Atoi(a)
		if err != nil {
			return si, err
		}
		si = append(si, i)
	}
	return si, nil
}

func getDigits(ary []int) (digits int) {
	sum := 0
	for _, v := range ary {
		sum += v
	}

	for sum != 0 {
		sum /= 10
		digits++
	}
	return
}

func getsTwoNumAsArray() (nums [][]int) {
	scanner := bufio.NewScanner(os.Stdin)

	for scanner.Scan() {
		str := scanner.Text()
		if str == "" {
			break
		}

		ary, _ := sliceAtoi(strings.Split(str, " "))
		nums = append(nums, ary)
	}

	return
}

func main() {
	ary := getsTwoNumAsArray()

	for _, v := range ary {
		fmt.Println(getDigits(v))
	}
}

C++: #include <iostream>
#include <math.h>

using namespace std;

int main()
{
    int a;
    int b;
    int c;

    cin >> a;
    cin >> b;

    c = ceil (log10(a+b));

    cout << c << " digit" <<endl;



    return 0;
}

C++: #include "stdio.h"

int main(){
	int a=0,b=0,c=0,count=0,i;
	for(i=0;i<=2;i++){
	scanf("%d %d",&a,&b);
	c = a + b;
	while(c > 0){
		c = c/10;
		count++;
	}
	printf("%d\n",count);
	count = 0;
	}
}

C++: #include <stdio.h>
#include<string.h>
/*
int length(const char c[])
{
    int len=0;
    while(c[len])   len++;

    return len;
}
*/
int main(void)
{
    int i=0,n=3,sum,len;
    int a,b;
    char c[10];

    scanf("%d %d",&a,&b);

    for(i=0;i<n;i++){   
        sum=a+b;
        sprintf(c,"%d",sum);
        len=strlen(c);
        printf("%d\n",len);
        scanf("%d %d",&a,&b);
    }

    return 0;

}

C++: # coding: utf-8
import sys
import math

numbers = []
for line in sys.stdin:
    numbers.append(line.split())

for i in range(len(numbers)):
    sum = int(numbers[i][0]) + int(numbers[i][1])
    print int(math.log10(float(sum))) + 1

C++: #include<stdio.h>
main(){
int x,y;
while(scanf("%d %d",&x,&y)!=EOF){
printf("%d\n",(x+y)%10);
}
}

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


int main(){

int i,d,n1,n2,sum,c;

int a,b;

while(cin >> n1 >> n2){
    if(n1 == -1 or n2 == -1)  break;
   while(n1 < 0 or n1 > 1000000 or n2 < 0 or n2 > 1000000){
      cin >> n1 >> n2;
   }
   if(n1 >= 0 and n1 <= 1000000 and n2 >= 0 and n2 <= 1000000){
       a=n1;
       b=n2;
       c=0;
       sum=a+b;
       while((sum/10)!=0){
           c++;
           sum=sum/10;
        }
       cout << c+1 << "\n";
   }
}
return 0;
}

C++: #include<iostream>
#include<cmath>
using namespace std;
int main()
{
    int a,b;
    for(int i=1;i>0;)
    {
        cin>>a>>b;
        cout<<(int)log10(a+b)+1<<endl;
    }
    return 0;
}

C++: fn main(){
    loop{
        let mut buf = String::new();
        let _ = io::stdin().read_line(&mut buf);
        if buf == "" { break; }
        let v: Vec<_> = buf.split_whitespace().collect();
        let a: i32 = v[0].parse().unwrap();
        let b: i32 = v[1].parse().unwrap();
        println!("{}", (a + b).to_string().len());
    
    }

}
    

// --- template ---
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
 
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);

C++: #include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include <climits>
#include <algorithm>
#include <map>
using namespace std;

int main() {
    int a, b;
    while (cin >> a >> b) {
        int c = a + b;
        int res = 0;
        if (c == 0) {
            cout << 1 << endl;
            continue;
        }
        while (c) {
            c /= 10;
            res ++;
        }
        cout << res << endl;
    }
    return 0;
}

C++: using System;

class main(){
public static void Main(String[] a){
string[] s=new string[200];
for(int i;i<200;i++){
s[i]=Console.ReadLine();
}

string[] s1=new string[2];
long a,b.d,dk;

foreach(sa in s){
if(IsNullOrEmpty(sa))continue;
s1=sa.Split(' ');

a=long.Parse(s1[0]);
b=long.Parse(s1[1]);
d=a+b;
dk=(string)d.Length;
Console.WriteLine(dk);
}

}}

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

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

C++: #include <iostream>

using namespace std;

void solve()
{
	int a, b;
	while(cin >> a >> b)
	{
		int sum = a + b;
		int ans = 0;
		while(sum)
		{
			sum /= 10;
			++ans;
		}
		cout << ans << endl;
	}
}

int main()
{
	solve();
	return(0);
}

C++: #include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
#include <sstream>
using namespace std;

// Digit Number(0002)
int main()
{
	int a, b;
	while (cin >> a >> b) {
		stringstream ss;
		ss << a + b;

		cout << ss.str().length() << endl;
	}

	return 0;
}

C++: #include <iostream>

using namespace std;

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

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

int main(){
	int a,b;
	while (std::cin >> a >> b)
		std::cout << static_cast<int>(log10(a + b)) + 1 << std::endl;
	system("pause");
	return 0;
}

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

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

C++: #include <cstdio>
#include <cmath>
#define LOOP(index,times) for(int index=0;index<times;index++)
using namespace std;

int main(){

int a,b;

while(scanf("%d %d",&a,&b) != EOF){

printf("%d\n",int(log10(a+b))+1);

}
return 0;		
}

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

int main(){
	int a,b,c;
	int ans;
	int cnt=-1;
	
	while(cin>>a>>b){
		cnt++;
		//-----test-----
		if(a<1172) break;
		
		//--------------
		c=a+b;
		ans=1;
		while(10<=c){
			c/=10;
			ans++;
		}
		cout<<ans<<endl;
	}
	
	return 0;
}

C++: #include <iostream>

int main()
{
        int a ,b, c;
        while(std::cin >> a >> b)
        {
                a += b;
                b = 0;
                do
                {
                        b++;
                }while(a /= 10);
                std::cout << b << std::endl;
        }
        return 0;
}

C++: #include<stdio.h>
#include<math.h>

int main(){

	int a = 0;
	int b = 0;
	int c = 0;
	int i = 0;

	scanf_s("%d", &a);
	scanf_s("%d", &b);

	c = a + b;

	for (i = 0; c != 0; i++)
	{
		c /= 10;
	}

	printf("%d\n",i);

	return 0;
}