Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	for scanner.Scan() {
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		arr := make([]int, n)
		for i := 0; i < n; i++ {
			scanner.Scan()
			arr[i], _ = strconv.Atoi(scanner.Text())
		}
		cnt := 0
		for i := n-1; i  > 0; i-- {
			for j := 0; j < i; j++ {
				if arr[j] > arr[j+1] {
					// log.Println(arr)
					cnt++
					arr[j], arr[j+1] = arr[j+1], arr[j]
				}
			}
		}
		// log.Println(arr)
		fmt.Println(cnt)
	}
}

C++: #include <iostream>
using namespace std;
int main(){
  int n;
  int a[1000];
  while( cin >> n,n){
    for(int i = 0 ; i < n ; i++ )cin >> a[i];
    int ans = 0;
    for(int i = n-1 ; i >= 0 ; i-- ){
      for(int j = 0 ; j < n - 1 ; j++  ){
	if(a[j] > a[j + 1]){
	  swap(a[j],a[j + 1]);
	  ans++; 
	}
      }
    }
    cout << ans << endl;
  }  
  return 0;
}

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

int array[MAX];

int bubble_sort(int n, int array[]){
    int tmp,cnt = 0;
    
    for(int i = n - 1 ; i > 0 ; i--){
        for(int j = 0 ; j < i ; j++){
            if(array[j+1] < array[j]){
                tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
                cnt++;
            }
        }
            
    }

    return cnt;
}


int main(){
    int n,array[MAX];
    
    while(1){
        cin >> n;
        if(n == 0) break;
        
        for(int i = 0 ; i < n ; i++) cin >> array[i];
        
        int ans = 0;
        ans = bubble_sort(n,array);
       
        cout << ans << endl;
    }

    return 0;
}

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

int bit[MAX_N + 1],a[MAX_N + 1],n;

int sum(int);
void add(int,int);

int main(void){
  
  while(cin >> n,n){
    int ans=0;
    for(int i=0;i<n;i++)cin >> a[i];
    
    for(int j=0;j<n;j++){
      ans += j - sum(a[j]);
      add(a[j],1);
    }
    printf("%d\n",ans);
  }
}

int sum(int i){
  int s=0;
  while(i > 0){
    s += bit[i];
    i -= i & -i;
  }
  return s;
}

void add(int i,int x){
  while(i <= n){
    bit[i] += x;
    i += i & -i;
  }
}

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

using namespace std;

int main (int argc, char const* argv[])
{
	int n;
	cin >> n;
	while(n)
	{
		vector<int> ary = vector<int>(n);
		for (unsigned int i = 0; i < n; i += 1)
		{
			cin >> ary[i];
		}
		int s = 0;
		for(int i = 0;i < n;i++)
		{
			for(int j = 1;j < (n-i);j++)
			{
				if(ary[j-1] > ary[j])
				{
					int tmp = ary[j-1];
					ary[j-1] = ary[j];
					ary[j] = tmp;
					s++;
				}
			}
		}
		cout << s << endl;
		cin >> n;
	}
	return 0;
}

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

void sort_count(int n, int *a, int *b, long long &count) {
  if(n <= 1) return;
  int m0 = n/2;
  int m1 = n-m0;
  sort_count(m0, a, b, count);
  sort_count(m1, a+m0, b+m0, count);
  int i = 0, j = 0;
  while(i < m0 || j < m1) {
    int ai = i < m0 ? a[i] : INT_MAX;
    int aj = j < m1 ? a[m0+j] : INT_MAX;
    if(ai <= aj) {
      b[i++ + j] = ai;
    } else {
      b[i + j++] = aj;
      count += m0 - i;
    }
  }
  copy(b, b+n, a);
}

int main() {
  for(int tci = 0; ; tci++) {
    int N; scanf("%d", &N);
    if(!N) break;
    int *a = new int[N];
    int *b = new int[N];
    for(int i = 0; i < N; i++) scanf("%d", a+i);
    long long count = 0;
    sort_count(N, a, b, count);
    printf("%lld\n", count);
    delete[] b;
    delete[] a;
  }
  return 0;
}

C++: #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 <queue>
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 long long LL;

//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))

//debug
#define dump(x)  cerr << #x << '=' << (x) << endl;
#define debug(x) cerr << #x << '=' << (x) << '('<<'L' << __LINE__ << ')' << ' ' << __FILE__ << endl;



/*
BIT bit indexed tree


ーーーー何ができるか
列
a1,a2,a3,a4,....,anがあり
始めは全てのai=0とする。

これに対して

1、iとxが与えられたときai+=xとする
2、iが与えられたときa0からaiまでの和を計算する

が効率的に実現できるデータ構造


[a,b]までの和は
(1~b)までの和から
(1~(a-1))までの和を引けば求められる（累積和の考え）
のでこれは結構実用的


*/

namespace BIT {


	VI bit(114514 + 1);//[1,n]
	int n;

	void init(int n_) {
		bit.resize(n_+1);
		n = n_;

		REP(i, SZ(bit)) { bit[i] = 0; }
	}

	//iまでの和を求めるためにはiから初めて0に到達するまでiから最下位bitを取り除きながら場所iに格納されている値を足していく
	int sum(int i) {
		int s = 0;
		while (i > 0) {
			s += bit[i];
			i -= i & -i;//最下位bitを減算する
		}
		return s;
	}

	//bit[i]の値をxに書き換える。
	// iからはじめて、iの最下位ビットを加算しながら場所iの値にxを加えていく
	void add(int i, int x) {
		while (i <= n) {
			bit[i] += x;
			i += i&-i;//最下位bitを足す
		}
	}




}



//バブルソートの交換回数を求める
/*
バブルソートの交換回数は，各要素 a[k] について，それより左側にある要素のうち a[k] より大きなものの数を c[k] とすれば Σ c[k] で与えられる



*/
int main() {
	
	int N = 4;
	VI a(4);

	REP(ii, 20) {

		cin >> N;
		if (N == 0) { 
			return 0;
		}
		a.resize(N);

		REP(i, N) { cin >> a[i]; }

		BIT::init(N);

		LL ans = 0LL;

		REP(j, N) {
			//debug(j - BIT::sum(a[j]));
			ans += j - BIT::sum(a[j]);
			BIT::add(a[j], 1);
		}
		cerr << "ans" << endl;
		cout << ans << endl;

	}
}

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

using namespace std;

int bubble(int n, int bubble[], int count);

int main(void)
{
	int ans, n;
	while(cin >> n, n){
		int num[100];
		for(int i = 0; i < n; i++){
			cin >> num[i];
		}
		ans = bubble(n, num, 0);
		cout << ans << endl;
	}
	
	return 0;
}

int bubble(int n, int bubble[], int count)
{
	int temp = n;
	for(int ii = 0; ii < n; ii++){
		for(int i = 0; i < temp-1; i++){
			if(bubble[i] > bubble[i+1]){
				count++;
				int temp;
				temp = bubble[i];
				bubble[i] = bubble[i+1];
				bubble[i+1] = temp;
			}
		}
		temp--;
	}
	
	return count;
}

C++: #include<iostream>
#include<algorithm>
using namespace std;
void sort(int A[], int C, int N){
	int c=0;
	for(int i=0;i<N-1;i++){
		if(A[i]>A[i+1]){
			swap(A[i],A[i+1]);
			c++;
		}
	}
	if(c==0) cout << C << endl;
	else{
		C+=c;
		sort(A,C,N);
	}
}

int main(){
	int n;
	while(cin >> n,n){
		int a[n],count=0;
		for(int i=0;i<n;i++) cin >> a[i];
		sort(a,count,n);
	}
}

C++: #include <iostream>
using namespace std;
int a[100];
int main(){
    int n;
    while(cin>>n && n){
        int ans=0;
        for(int i=0;i<n;i++){
            cin>>a[i];
            for(int j=0;j<i;j++){
                if(a[j]>a[i])ans++;
            }
        }
        cout << ans << endl;
    }
}