Go: package main
import "fmt"
func main(){
    for i:=1;i<10;i++{
        for j:=1;j<10;j++{
            fmt.Print(i)
            fmt.Print("x")
            fmt.Print(j)
            fmt.Print("=")
            fmt.Println(i*j)
        }
    }
}

C++: //#define _GRIBCXX_DEBUG
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;


// ?????¬???????????¬??????
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion

#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion


// Effective std
#pragma region ESTD
template<typename C, typename T>
constexpr int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F>
constexpr int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T, typename U>
constexpr void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U>
constexpr void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C>
constexpr void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred>
constexpr void sort(C& c, Pred p) { sort(ALL(c), p); }
template<typename C>
constexpr void reverse(C& c) { reverse(ALL(c)); }
#pragma endregion


// ?´???°
#pragma region PRIME
bool is_prime(unsigned n) {
  switch(n) {
    case 0:
    case 1: return false;
    case 2: return true;
  }
  if (n%2==0) return false;
  for (unsigned i=3; i*i<=n; i+=2)
    if (n%i==0) return false;
  return true;
}
#pragma endregion


// ??§??????/?°?????????????
#pragma region TRANSFORM
void mutal_tr(string &s) {
  for(int i=s.size(); i--;) {
    if(islower(s[i])) s[i] = toupper(s[i]);
    else if (isupper(s[i])) s[i] = tolower(s[i]);
  }
}
void to_upper(string &s) { for(int i=s.size(); i--;) s[i] = toupper(s[i]); }
void to_lower(string &s) { for(int i=s.size(); i--;) s[i] = tolower(s[i]); }
#pragma endregion


// ??????
#pragma region SET
template<class T>
set<T> intersection(const set<T>& sa, const set<T>& sb) {
  set<T> ret;
  for(T a : sa) if(sb.find(a) != sb.end()) ret.insert(a);
  return ret;
}
#pragma endregion

// Union Find
#pragma region UF
struct UnionFind {
  vector<int> data;
  UnionFind(int size) : data(size, -1) {}
  bool union_set(int x, int y) {
    x = root(x); y = root(y);
    if(x!=y) {
      if(data[y] < data[x]) swap(x, y);
      data[x] += data[y]; data[y] = x;
    }
    return x != y;
  }
  bool find_set(int x, int y) { return root(x) == root(y); }
  int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
  int size(int x) { return -data[root(x)]; }
};
#pragma endregion


// ?????°
#pragma region CONST_VAL
#define PI (2*acos(0.0))
#define EPS (1e-9)
#define MOD (int)(1e9+7)
#pragma endregion

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

C++: #include<bits/stdc++.h>
using namespace std;
int main(){
	for (int i=1;i<=9;i++){
		for (int j=1;j<=9;j++){
			cout << i << 'x' << j << '=' << i*j << endl;
		}
	}
	return 0;
}

C++: #include <iostream>
int main(){
	int a,b,c;
		for(a=1;a<10;++a){
			for(b=1;b<10;++b){
				c=a*b;
				std::cout<<c<<std::endl;
				}
		}
		
	 return 0;
	}

C++: #include <iostream>
using namespace std;
int main()
{
for(int a=1;a<=9;a++)
{for(int b=1;b<=9;b++)
{cout << a << "x" << b << "=" << a*b << 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++)
			printf("%dx%d=%d\n",i,j,i*j);
	}
    return 0;
}

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

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

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

int main() {

    for(int i = 1;i <= 9;i++){
        for(int j = 1;j <= 9;j++){
            cout << i << "x" << j << "=" << i*j << "\n";
        }
    }
    
return 0;
}

C++: //include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <fstream>
#include <boost/multiprecision/cpp_int.hpp>

using namespace std;

//conversion
//------------------------------------------
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}

//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}

//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long, long> PLL;
typedef long long LL;
typedef boost::multiprecision::cpp_int bigint;
//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())

//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

//constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI  = acos(-1.0);

//clear memory
#define CLR(a) memset((a), 0 ,sizeof(a))
typedef boost::multiprecision::cpp_int bigint;




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

C++: #include<iostream>

using namespace std;

int main(){
	int i,j;

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

	return 0;
}

C++: #include <iostream>

using namespace std;

int main()
{
  int n[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  for (auto &n1 : n)
    for (auto &n2 : n)
      cout << n1 << "x" << n2 << "=" << n1 * n2 << endl;
  return 0;
}

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

using namespace std;

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

C++: #include<stdio.h>
int a, b;int main(){for(a=1;a<=9;a++)for(b=1;b<=9;b++)printf("%dx%d=%d\n",a,b,a*b);return 0;}

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

int main(void)
{
    int i, j;

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

    return 0;
}

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

C++: - submit, private