Go: package main

import (
	"fmt"
	"sort"
	"strconv"
)

func main() {
	var v int
	for {
		fmt.Scan(&v)
		if v == 0 {
			break
		}
		if v%1111 == 0 {
			fmt.Print("NA")
			continue
		}
		count := 0
		for v != 6174 {
			str := ([]byte)(strconv.Itoa(v))
			sort.Slice(str, func(i, j int) bool {
				return str[i] < str[j]
			})
			s, _ := strconv.Atoi(string(str))
			sort.Slice(str, func(i, j int) bool {
				return str[i] > str[j]
			})
			l, _ := strconv.Atoi(string(str))
			v = l - s
			count++
		}
		fmt.Println(count)
	}
}

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

template<class T, class U>
T lexical_cast(U &obj){
    T ret;
    stringstream ss;
    ss << obj;
    ss >> ret;
    return ret;
}

int main(){
  while(1){
    string N, L, S;
    cin >> N;
    if(N == "0000") break;
    
    int ans = 0;
    while(1){
      if(N == "6174"){
        cout << ans << endl;
        break;
      }
      
      L = N;
      S = N;
      
      sort(L.begin(), L.end(), greater<char>());
      sort(S.begin(), S.end());
      
      if(L == S){
        cout << "NA" << endl;
        break;
      }
      
      int n = lexical_cast<int>(L) - lexical_cast<int>(S);
      N = lexical_cast<string>(n);
      
      ans++;
    }
  }
  return 0;
}

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


bool check(char data[4]){
  for(int i = 1 ; i < 4 ; i++){
    if(data[0] != data[i])return false;
  }
  return true;
}

int toInt(char data[4]){
  int ret = 0;
  for(int i = 0 ; i < 4 ; i++){
    ret += (data[i]-'0');
    ret *= 10;
  }  
  return ret/10;
}

void getNext(int a,char data[4]){
  for(int i = 0 ; i < 4 ; i++){
    data[3 - i] = a%10 + '0';
    a /= 10;
  }
}

void solve(char data[4]){

  if(check(data)){
    cout << "NA" << endl;
    return;
  }

  if(toInt(data) == 6174){
    cout << 0 << endl;
    return;
  }

  int res;
  for(res = 1 ; ; res++){
    int L,S;
    sort(data,data + 4);
    S = toInt(data);
    reverse(data,data + 4);
    L = toInt(data);
    if(L - S == 6174)break;
    getNext(L - S,data);
  }
  cout << res << endl;
}

int main(){

  char data[4];
  while(1){
    bool f = true;
    for(int i = 0 ; i < 4 ; i++){
      cin >> data[i];
      if(data[i] != '0')f = false;
    }
    if(f)break;
    solve(data);
  }
  return 0;
}

C++: // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvpii = vector<vpii>;
template<typename A> using fn = function<A>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int &n) { return n & 1; }
constexpr bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on

vi f(int x) {
  return {x % 10, x / 10 % 10, x / 100 % 10, x / 1000};
}

int g(vi x) {
  return x[0] + x[1] * 10 + x[2] * 100 + x[3] * 1000;
}

int next(int x) {
  vi v = f(x);
  vi w = v;
  sort(all(v)), sort(rall(w));
  return g(v) - g(w);
}

void solve() {
  int n;
  while (cin >> n, n) {
    vi v = f(n);
    sort(all(v));
    if (v.front() == v.back()) {
      cout << "NA" << endl;
      continue;
    }
    int c = 0;
    for (; n != 6174; c++) {
      n = next(n);
    }
    cout << c << endl;
  }
}

C++: #include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <sstream>
#include <iterator>
#include <functional>

using namespace std;

#define ALL(c) begin(c),end(c)

template<class T, class U> T lexical_cast(const U &from) {
    stringstream ss;
    ss << from;
    T to;
    ss >> to;
    return to;
}

bool same(const string &s) {
    return s[0] == s[1] && s[0] == s[2] && s[0] == s[3];
}

int main() {
    for(string S; cin >> S, S != "0000"; ) {
        if(same(S)) {
            cout << "NA" << endl;
            continue;
        }
        int ans = 0;
        while(S != "6174") {
            string L = S;
            sort(ALL(L), greater<char>());
            string SS = S;
            sort(ALL(SS));
            S = lexical_cast<string>(lexical_cast<int>(L) - lexical_cast<int>(SS));
            ans++;
        }
        cout << ans << endl;
    }
}

C++: #include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <set>
#include <sstream>

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,j) FOR(i,0,j)
#define mp std::make_pair

const int INF = 1 << 24;
const int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1}, dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};

typedef unsigned long long ull;
typedef std::pair<int,int> P;

int main(){
    std::string s;
    while(std::cin >> s, s != "0000"){
        if(s[0] == s[1] && s[0] == s[2] && s[0] == s[3]){
            std::cout << "NA" << std::endl;
        }else{
            int t = 0;
            while(s != "6174"){
                int L, S;
                std::sort(s.begin(), s.end(), std::greater<char>());
                L = std::stoi(s);
                std::sort(s.begin(), s.end());
                S = std::stoi(s);

                s = std::to_string(L-S);
                while(s.length() < 4){
                    s += "0";
                }
                t++;
            }

            std::cout << t << std::endl;
        }
    }
}

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

int main(){
  int n;
  while(cin >> n , n){
    if(n%1111 == 0){
      cout << "NA" << endl;
      continue;
    }
    int c;
    while(n != 6174){
      stringstream ss;      
      ss << n;
      string buf = ss.str();
      string strs = buf;
      string strl = buf;
      sort(strs.begin(),strs.end());
      sort(strl.begin(),strl.end(),greater<int>());
      int s = atoi(strs.c_str());
      int l = atoi(strl.c_str());
      n = l-s;
      c++;
    }
    cout << c << endl;
  }
  return 0;
}

C++: #include<iostream>
#include<algorithm>
using namespace std;
int main(){
    int n, d[4];
    while(cin >> n){
        if(n == 0)  break;
        if(n % 1111 == 0){
            cout << "NA" << endl;
        }else{
            int tmpn = n;
            for(int i = 3; i >= 0; i--){
                d[i] = tmpn%10;
                tmpn /= 10;
            }
            
            int ans = 0;
            while(n != 6174){
                ans++;
                sort(d, d+4);
                n = (1000*d[3] + 100*d[2] + 10*d[1] + d[0]) -
                        (1000*d[0] + 100*d[1] + 10*d[2] + d[3]);
                tmpn = n;
                for(int i = 3; i >= 0; i--){
                    d[i] = tmpn%10;
                    tmpn /= 10;
                }
            }
            cout << ans << endl;
        }
    }
}