Go: package main

import "fmt"
import "strconv"

func main() {
  for i := 1; i <= 9; i++ {
    for j := 1; j <= 9; j++ {
      res := i * j
      fmt.Println(strconv.Itoa(i) + "x" + strconv.Itoa(j) + "=" + strconv.Itoa(res))
    }
  }
}

C++: #include <iostream>
#include <string.h>
#include <cstdio>
#include <algorithm>
#include <vector>
#define maxnum 1000000000
using namespace std;

struct TwoTree
{
    int h, root;
    vector<TwoTree> tree;
    TwoTree() {}
    TwoTree(int x)
    {
        h = 0, root = x;
        tree.clear();
    }
    void operator =(const TwoTree &a)
    {
        h = a.h, root = a.root;
        tree = a.tree;
    }
    TwoTree addSubTree(TwoTree a)
    {
        TwoTree res = *this;
        res.h++;
        res.tree.push_back(a);
        return res;
    }
    TwoTree mergeTree(TwoTree A, TwoTree B)
    {
        if (A.root>B.root) return A.addSubTree(B);
        return A.addSubTree(B);
    }
};//螟ァ譬ケ譬?

struct TwoHeap
{
    int root;
    vector<TwoTree> tree;
    TwoHeap() {}
    TwoHeap(int x)
    {
        root = x;
        tree.clear();
        tree.push_back(TwoTree(x));
    }
    void clear()
    {
        root = -maxnum;
        tree.clear();
    }
    void push_back(TwoTree a)
    {
        tree.push_back(a);
    }
    int size()
    {
        return tree.size();
    }
    int top()
    {
        int res = -maxnum;
        for (int i = 0; i < tree.size(); i++) res = max(res, tree[i].root);
        return res;
    }
    TwoHeap mergeHeap(TwoHeap A, TwoHeap B)
    {
        TwoHeap res;
        res.clear();
        int head_A = 0, head_B = 0;
        while (head_A<A.size()||head_B<B.size())
        {
            if (head_B<B.size())
            {
                while (head_A<A.size()&&A.tree[head_A].h<B.tree[head_B].h)
                    res.push_back(A.tree[head_A]), head_A++;
            }
            else
            {
                while (head_A<A.size())
                    res.push_back(A.tree[head_A]), head_A++;
            }
            if (head_A<A.size())
            {
                while (head_B<B.size()&&A.tree[head_A].h>B.tree[head_B].h)
                    res.push_back(B.tree[head_B]), head_B++;
            }
            else
            {
                while (head_B<B.size())
                    res.push_back(B.tree[head_B]), head_B++;
            }
        }
    }
    TwoHeap add(int x)
    {
        TwoHeap A = *this;
        TwoHeap B = TwoHeap(x);
        return mergeHeap(A, B);
    }
};//螟ァ譬ケ蝣?

int main()
{

}

C++: #include<stdio.h>

int main(void){
	int printf(1x1=1,1x2=2,..9x8=72,9x9=81)

		return 0;
}

C++: #include <iostream>
int main(){for(int i=1;i<10;i++)for(int j=1;j<10;j++)printf("%dx%d=%d\n",i,j,i*j);return 0;}

C++: #include<iostream>
#include<stdio.h>
int main(){
	int a,b;
		for(a=1;a<10;a++){
			for(b=1;b<10;b++){
				std::cout<<a<<"x"<<b<<"="<<a*b<<std::endl;
				}
			}


  
      return 0;
	}

C++: #include<stdio.h>

int main(){
    for(num1=0;num1<10;num1++){
       for(num2=0;num2<10;num2++){
           printf("%dx%d=%d",num1,num2,num1*num2)
        }
    }
    return 0;
}

C++: #include <stdio.h>
int main(){
    for(int i=1;i<10;i++){
        for(int j=1;j<10;j++){
            printf("%dx%d=%d\n",i,j,i*j);
        }
    }
}

C++: #include <iostream>
using namespace std;
int main(){
int a,b,x;


	for(int j=1;j<=9;j++){
		a=j;
		for(int i=1;i<=9;i++){
		b=i;
		cout<<a<<"x"<<b<<"="<<a*b<<endl;
		
		}
	    }
}

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

int main(){
	for (int i = 1; i < 10; i++) {
		for(int j = 1; j < 10; j++) {
		cout << i << "x" << j << "=" << i*j << endl;
		}
	}
	
	return 0;
}

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

int main(){
	for(int i = 1; i < 10; i++){
		for(int j = 1; j < 10; j++){
			cout << i << "x" << j << "=" << i*j << endl;
		}
	}
	return 0;
}

C++: #include <stdio.h>

int main(void) {
  for(int i=1; i<10; i++)
    for(int j=1; j<10; j++)
      printf("%dx%d=%d\n", i, j, i*j);
  return 0;
}

C++: #include <iostream>
int main()
{
  std::cout << "Hello World" << "\n";
}

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

int main(){
  for(int i=0; i<10;++i){
    for(int j=0; j<10; ++j){
      cout << i << "x" << j << "=" << i*j << endl;
    }
  }
 
  return 0;
}

C++: 
#include<stdio.h>

int main(){
    int a,b;
 for(a = 1; a < 10; a++)
   {
   for(b = 1;b < 10;b++)
     {
      printf("%d", a);
    printf("x");
  printf("%d", b);
    printf("=");
      printf("%d\n", a*b);
     };
   };
    return 0;
}

C++: #include<stdio.h>
int i=1,j;int main(){for(;i<10;i++)for(j=1;j<10;j++)printf("%dx%d=%d\n",i,j,i*j);}

C++: #include<cstdio>
#include<cstring>
#include<cstdlib>

int main()
{
	int i, j;
	for(i = 1; i <= 9; i++)
	{
		for(j = 1; j <= 9; j++)
		{
			printf("%d*%d=%d\n",i,j,i*j);
		}
	}
return 0;
}

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

int main(void){

	for(int i=1; i<=9; i++){
		for(int j=1; j<=9; j++){
			cout<< i << "??" << j << "=" << i*j <<endl;
		}
	}


    return 0;
}

C++: // compile in C++11. use -std=c++11.
#include <iostream>
#include <iomanip>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <bitset>
#include <utility>
#include <numeric>
#include <algorithm>
#include <functional>
#include <complex>
#include <string>
#include <sstream>

#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cstring>

// this require C++11
#include <unordered_set>
#include <unordered_map>

using namespace std;

#define all(c) c.begin(),c.end()
#define repeat(i,n) for(int i=0;i<(int)n;i++)
#define debug(x) #x << "=" << (x)

typedef long long ll;
typedef vector<int> vi;

template<typename T>
ostream& operator<<(ostream& os,const vector<T>& val){
    os << "[ ";
    for(typename vector<T>::const_iterator it=val.begin();
        it != val.end();++it){
        os << *it << " ";
    }
    os << "]";
    return os;
}

template<typename T,typename IT>
struct Indexer{
    struct iterator{
        typedef IT inner_iterator;
        typedef typename iterator_traits<inner_iterator>::reference inner_reference;
        struct reference : pair<size_t,inner_reference>{
            reference(size_t s,inner_reference i) :
                pair<size_t,inner_reference>(s,i) {}
            const size_t& index = (*this).first;
            const inner_reference& value = (*this).second;
        };

        iterator(inner_iterator i) : pos(0),it(i) {}
        reference operator*() const {
            return reference(pos,*it);
        }
        iterator& operator++(){
            ++pos;++it;
            return *this;
        }
        iterator operator++(int){
            iterator tmp(*this);
            ++(*this);
            return tmp;
        }
        bool operator==(const iterator& rhs) const{
            return it == rhs.it;
        }
        bool operator!=(const iterator& rhs) const{
            return !(*this == rhs);
        }
    private:
        size_t pos;
        inner_iterator it;
    };

    Indexer(T& t): container(t) {};
    iterator begin() const{
        return iterator(container.begin());
    }
    iterator end() const{
        return iterator(container.end());
    }

private:
    T& container;
};

template<typename T>
Indexer<T,typename T::iterator> enumerate(T& t){
    return Indexer<T,typename T::iterator>(t);
}
// value will be readonly.
template<typename T>
Indexer<T,typename T::const_iterator> const_enumerate(T& t){
    return Indexer<T,typename T::const_iterator>(t);
}

template<typename T>
T input(){
    T tmp;
    cin >> tmp;
    return tmp;
}

int main(){

    return 0;
}

C++: #include<iostream>
using namespace std;
int main()
{
	int line=1,column=1;
	for (line=1;line<=9;line++)
		{
			for(column=1;column<=line;column++)
				{cout<<column<<"*"<<line<<"="<<column*line<<endl;
				}
		}
	return 0;
}

C++: #include <stdio.h>