Freight trains

input/code.cpp: In function 'char getNthCharOption(std::string, int, char)':
input/code.cpp:545:12: warning: comparison of integer expressions of different signedness: 'int' and 'std::__cxx11::basic_string<char>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  545 |     if ( i < a.size()){
      |          ~~^~~~~~~~~~

#include <iostream>
#include <vector>
#include <functional>
#include <set>
#include <algorithm>
#include <stack>
#include <unordered_map>
#include <map>
#include <iomanip>
#include <limits>

std::tuple<int> readInt1(){
    int a;
    std::cin >> a;
    return {a};
}
std::tuple<int,int> readInt2(){
    int a, b;
    std::cin >> a >> b;
    return {a,b};
}
std::tuple<int,int,int> readInt3(){
    int a, b, c;
    std::cin >> a >> b >> c;
    return {a,b,c};
}

std::vector<int> readVecInt(int n){
    std::vector<int> arr(n);
    for (int i = 0; i < n; i++){
        int a;
        std::cin >> a;
        arr[i] = a;
    }
    return arr;
}
std::vector<std::string> readVecStr(int n){
    std::vector<std::string> arr(n);
    for (int i = 0; i < n; i++){
        std::string a;
        std::cin >> a;
        arr[i] = a;
    }
    return arr;
}

std::vector<long long> readVecLong(int n){
    std::vector<long long> arr(n);
    for (int i = 0; i < n; i++){
        long long a;
        std::cin >> a;
        arr[i] = a;
    }
    return arr;
}

std::vector<std::tuple<int,int>> readVecTup2(int n){
    std::vector<std::tuple<int,int>> arr(n);
    for (int i = 0; i < n; i++){
        int a, b;
        std::cin >> a;
        std::cin >> b;
        arr[i] = {a,b};
    }
    return arr;
}

std::vector<std::tuple<int,int,int>> readVecTup3(int n){
    std::vector<std::tuple<int,int,int>> arr(n);
    for (int i = 0; i < n; i++){
        int a, b, c;
        std::cin >> a;
        std::cin >> b;
        std::cin >> c;
        arr[i] = {a,b,c};
    }
    return arr;
}
std::vector<std::tuple<int,int,int,int>> readVecTup4(int n){
    std::vector<std::tuple<int,int,int,int>> arr(n);
    for (int i = 0; i < n; i++){
        int a, b, c,d;
        std::cin >> a;
        std::cin >> b;
        std::cin >> c;
        std::cin >> d;
        arr[i] = {a,b,c,d};
    }
    return arr;
}

void printNewLine(){std::cout << "\n";}
template<typename T, typename... Ts>
std::tuple<Ts...> tail(std::tuple<T,Ts...> as){
    return std::apply([](T &a, Ts... b){return std::make_tuple(b...);},as);
}

template<typename T>
void print(T a){std::cout << std::setprecision(19) << a;}
template<typename... T>
void println(T... a);

template<typename T, typename Ts>
void print(std::tuple<T,Ts> a){
    print(std::get<0>(a));
    print(" ");
    print(std::get<1>(a));
}

template<typename T, typename... Ts>
void print(std::tuple<T,Ts...> a){
    print(std::get<0>(a));
    print(" ");
    print(tail(a));
}



template<typename T>
void print(const std::vector<T> &arr, int width = -1){
    if (width == -1) width = arr.size();
    for (int i = 0; i < (int)arr.size(); i++){
        if ((i%width) == width-1 && i != (int)arr.size()-1){
            print(" ");
            println(arr[i]);
        }else if ((i%width) == 0){        
            print(arr[i]);
        }else {
            print(" ");
            print(arr[i]);
        }
    }    
}
template<typename... T>
void println(T... a){print(a...);printNewLine();}



template<typename T>
void sorted(std::vector<T> &arr){
    std::sort(arr.begin(),arr.end(),[](const T &a, const T &b){ return a < b; });
}


template<typename T>
std::set<T> toSet(const std::vector<T> &vec){
    std::set<T> c;
    for (T a : vec){ c.emplace(a);}
    return c;
}

template<typename T, typename N>
std::vector<N> map(const std::vector<T> &a, const std::function<N(T)> &transform){
    std::vector<N> b(a.size());
    int i = 0;
    for (T x : a){
        b[i] = transform(x);
        i++;
    }
    return b;
}

template<typename N, typename M, typename R>
std::vector<R> zip(const std::vector<N> &a, const  std::vector<M> &b, const std::function<R(N,M)> &transform){
    int n = std::min(a.size(),b.size());
    std::vector<R> res(n);
    for (int i = 0; i < n; i++){
        res[i] = transform(a[i],b[i]);
    }
    return res;
}

template<typename T, typename N>
std::vector<N> convertVec(const std::vector<T> &a){
    std::vector<N> b(a.size());
    int i = 0;
    for (T x : a){
        b[i] = x;
        i++;
    }
    return b;
}
template<typename T>
std::vector<T> reverse(const std::vector<T> &a){
    std::vector<T> b(a.size());
    int i = 0;
    for (T x : a){
        b[a.size()-1-i] = x;
        i++;
    }
    return b;
}



template<typename T, typename R>
R reduce(const std::vector<T> &arr, R init, const std::function<R(const R,const T)> &transform){
    R current = init;
    for (int idx = 0; idx < (int)arr.size(); idx++){
        current = transform(current,arr[idx]);
    };
    return current;
}
template<typename T>
T max(const std::vector<T> &arr){return reduce(arr, arr[0], static_cast<std::function<T(const T,const T)>>(static_cast<const T& (*)(const T&, const T&)>(std::max<T>)));}
template<typename T>
T min(const std::vector<T> &arr){return reduce(arr, arr[0], static_cast<std::function<T(const T,const T)>>(static_cast<const T& (*)(const T&, const T&)>(std::min<T>)));}

template<typename T>
std::function<T(const T,const T)> add(){return [](T a,T b){return a+b;};}
template<typename T>
std::function<T(const T,const T)> modAdd(T mod){return [mod](T a,T b){return (((a+b)%mod)+mod)%mod;};}
template<typename T, typename R>
std::function<R(const R,const T)> mulAdd(R mul){return [mul](R a,T b){return a+b*mul;};}
template<typename T>
T sum(const std::vector<T> &arr){return reduce(arr, 0, add<T>());}
template<typename T>
T avg(const std::vector<T> &arr){return reduce(arr, 0.0, mulAdd<double,T>(1.0/arr.size()));}

template<typename T>
T binarySearch(T min, T max, const std::function<bool(T)> &leq){
    if (min == max) return max;
    T guess = (min+max)/2;
    if (leq(guess)){
        return binarySearch(min,guess,leq);
    }else{
        return binarySearch(guess+1,max,leq);
    }
}

template<typename T>
T binarySearchDecending(T min, T max, const std::function<bool(T)> &leq){
    std::function<bool(T)> gt = [leq](T x){
        return !leq(x);
    };
    return binarySearch(min,max+1, gt)-1;
}

template<typename T>
std::vector<T> cloneVec(std::vector<T> a){return a;}

template<typename T>
std::vector<T> padding(const std::vector<T> &initial, T num, int start, int end){
    std::vector<T> arr(start+initial.size()+end);
    for (int i = 0; i < start; i++){
        arr[i] = num;
    }
    for (int i = 0; i < (int)initial.size(); i++){
        arr[start+i] = initial[i];
    }
    for (int i = 0; i < end; i++){
        arr[start+initial.size()+i] = num;
    }
    return arr;
}

template<typename T>
int findMax(int start, int end, const std::function<T(int)> &maxHeuristic){
    T initialGuess = maxHeuristic(start);
    int index = start;
    for (int i = start; i <= end; i++){
        if (initialGuess < maxHeuristic(i)){
            initialGuess = maxHeuristic(i);
            index = i;
        }
    }
    return index;
}

template<typename T>
void operateOnMax(int start, int end, const std::function<T(int)> &maxHeuristic, const std::function<void(int)> &found){
    found(findMax(start,end,maxHeuristic));
}

template<typename T>
void stackOperate(T init, const std::function<std::vector<T>(T)> operate){
    std::stack<T> stack;
    stack.push(init);
    while (!stack.empty()){
        T next = stack.top();
        stack.pop();
        std::vector<T> nextSteps = operate(next);
        for (T a : nextSteps){
            stack.push(a);
        }
    }
}
template<typename T>
void stackOperate(std::vector<T> init, const std::function<std::vector<T>(T)> operate){
    std::stack<T> stack;
    for (auto x : init){
        stack.push(x);
    }
    while (!stack.empty()){
        T next = stack.top();
        stack.pop();
        std::vector<T> nextSteps = operate(next);
        for (T a : nextSteps){
            stack.push(a);
        }
    }
}
#include <queue>

template<typename T>
void queueOperate(T init, const std::function<std::vector<T>(T)> operate){
    std::queue<T> que;
    
    que.push(init);
    while (!que.empty()){
        T next = que.front();
        que.pop();
        std::vector<T> nextSteps = operate(next);
        for (T a : nextSteps){
            que.push(a);
        }
    }
}

template<typename T>
void queueOperate(std::vector<T> init, const std::function<std::vector<T>(T)> operate){
    std::queue<T> que;
    for (auto x : init){
        que.push(x);
    }
    while (!que.empty()){
        T next = que.front();
        que.pop();
        std::vector<T> nextSteps = operate(next);
        for (T a : nextSteps){
            que.push(a);
        }
    }
}

template<typename T>
void recursiveVectorSplit(int start, int end, int distl, int distr, const std::function<T(int)> &maxHeuristic, const std::function<void(int)> &found){
    if (start == end){
        return found(start);
    }else if (end < start){
        return;
    }
    std::tuple<int,int> range = {start,end};
    std::function<std::vector<std::tuple<int,int>>(std::tuple<int,int>)> splitter = [distl, distr,&maxHeuristic,&found](std::tuple<int,int> range){
        auto [start,end] = range;
        int idx = findMax(start, end, maxHeuristic);
        found(idx);
        std::vector<std::tuple<int,int>> next;
        if (idx+distl+1 <= end){
            next.push_back({idx+distl+1,end});
        }
        if (start <= idx-distr-1){
            next.push_back({start, idx-distr-1});
        }
        return next;
    };
    stackOperate(range,splitter);
}


template<typename T>
std::vector<T> dynamicallyComputableList(int n, std::function<T(std::vector<T>&,int)> next){
    std::vector<T> arr(n);
    for (int i = 0; i < n; i++){
        arr[i] = next(arr,i);
    }
    return arr;
}
template<typename T>
int indexOfBinarySearch(const std::vector<T> &arr, const T &find){
    return binarySearch(0,(int)arr.size()-1,(std::function<bool(int)>)[&arr, &find](int guess){return find <= arr[guess];});
}

template<typename T>
std::unordered_map<T, int> indexCompress(const std::vector<T> &arr){
    std::unordered_map<T, int> compressed;
    int i = 0;
    for (T x : arr){
        if (compressed.find(x) != compressed.end()) compressed[x] = i++;
    }
    return compressed;
}   


template<typename T>
std::tuple<T, std::vector<int>> shortestPath(const std::vector<std::tuple<int, int, T>> &edgesMessy, int start, int goal){
    std::vector<std::tuple<int, int, T>> edges = edgesMessy;
    for (auto e : edgesMessy){
        auto [a,b,t] = e;
        edges.push_back({b,a,t});
    }
    shortestPathDirected(edges, start, goal);
}

template<typename T>
std::tuple<T, std::vector<int>> shortestPathDirected(const std::vector<std::tuple<int, int, T>> &edges, int start, int goal){
    //assumes all are between 0 <= n < c*(number of vertexies), where c is reasonably small constant.  
    int n = 0;
    for (auto& [s,g,c] : edges){
        n = std::max(n,s);
        n = std::max(n,g);
    }
    int mappedStart = start;
    int mappedEnd   = goal; 
    n += 1;
    std::vector<T> distance(n);
    //std::vector<int> path(n);
    for (int i = 0; i < n; i++) distance[i] = std::numeric_limits<T>::max()/4;
    //for (int i = 0; i < n; i++) path[i] = i;
    distance[mappedStart] = 0;
    for (int i = 1; i <= n; i++) {
        bool changed = false;
        for (auto e : edges) {
            auto [a, b, w] = e;
            if (!changed) {changed = (distance[b] != std::min(distance[b], distance[a]+w));}
            if (distance[a]+w < distance[b]){
                distance[b] = distance[a]+w;
                //path[b] = a;
            }
        }
        if (!changed) break;
        if (changed && i == n){
            // handle inifnite loop This could be made to find the infinite loop instead.
            //exit(1);
            return std::tuple((T)0,(std::vector<int>){});
        }
    }
    return std::tuple(distance[mappedEnd],(std::vector<int>){});
    std::vector<int> fullPath = {goal};
    while (fullPath[fullPath.size()-1] != start){
        //fullPath.push_back(path[fullPath[fullPath.size()-1]]);
    }
    return std::tuple(distance[mappedEnd],reverse(fullPath));
}






template<typename T>
std::vector<T> distanceTable(const std::vector<T> &init, const  std::function<T(T,T)> &distance){
    int n = init.size();
    std::vector<T> table(n*n);
    for (int i = 0; i < n; i++){
        table[i+n*i] = init[i];
        for (int j = i-1; j >= 0; j--){
            table[j+n*i] = distance(init[j],table[j+1+n*i]);
        }
        for (int j = i+1; j < n; j++){
            table[j+n*i] = distance(table[j-1+n*i],init[j]);
        }
    }
    return table;
}

void particles(){
    auto [n] = readInt1();
    auto arr = readVecLong(n);
    std::vector<long long> table = distanceTable(arr,add<long long>());
    print(table,n);
    //println(cost[n*n-1]);
}
template<typename T>
std::vector<T> range(const std::vector<T> &a, int from, int to){
    std::vector<T> b;
    for (int i = from; i <= to; i++){
        b.push_back(a[i]);
    }
    return b;
}

template<typename T>
bool forall(const std::vector<T> &a, std::function<bool(T)> &test){
    bool res = true;
    for (auto v : a){
        res = res & test(v);
    }
    return res;
}
/*
std::vector<int> dynamicUpdater(std::vector<std::tuple<int,int>> get, std::function<int(std::unordered_map<std::tuple<int,int>, int>&,std::tuple<int,int>)> eval, std::function<std::vector<std::tuple<int,int>>(std::tuple<int,int>)> needs){
    std::map<std::tuple<int,int>, int> results;
    std::stack<std::tuple<int,int>> toDo;
    for (auto val : get){
        toDo.push(val);
    }
    std::function<bool(std::tuple<int,int>)> has = [&results](std::tuple<int,int> &value){
        return results.find(value) != results.end();
    };
    while (toDo.size() != 0){
        auto next = toDo.top();
        toDo.pop();
        if (results.find(next) != results.end()){

        } else if (forall(needs(next))){
            results[next] = eval(results,next);
        } else {
            for (auto val : needs(next)){
                toDo.push(val);
            }
        }
    }
    std::function<int(std::tuple<int,int>)> resultMap = [&results](std::tuple<int,int> &value){
        return results[value];
    };
    return map(get,resultMap);
}*/
/*

template<typename T, typename R>
std::vector<R> dynamicUpdater(std::vector<T> get, std::function<R(std::unordered_map<T, R>&,T)> eval, std::function<std::vector<T>(T)> needs){
    std::map<T, R> results;
    std::stack<T> toDo;
    for (auto val : get){
        toDo.push(val);
    }
    std::function<bool(T)> has = [&results](T &value){
        return results.find(value) != results.end();
    };
    while (toDo.size() != 0){
        auto next = toDo.top();
        toDo.pop();
        if (results.find(next) != results.end()){

        } else if (forall(needs(next))){
            results[next] = eval(results,next);
        } else {
            for (auto val : needs(next)){
                toDo.push(val);
            }
        }
    }
    std::function<R(T)> resultMap = [&results](T &value){
        return results[value];
    };
    return map(get,resultMap);
}
*/




char getNthCharOption(std::string a, int i,char opt){
    if ( i < a.size()){
        return a[i];
    } else {
        return opt;
    }
}


typedef std::tuple<char,char,char,char,char,char,char,char,char,char,std::string> tup11; 
int main() {
    auto [n] = readInt1();
    auto arr = readVecStr(n);
    std::function<tup11(std::string)> func = [](std::string a){
        
        return (tup11){
            getNthCharOption(a,0,(char)125),
            getNthCharOption(a,1,(char)125),
            getNthCharOption(a,2,(char)125),
            getNthCharOption(a,3,(char)125),
            getNthCharOption(a,4,(char)125),
            getNthCharOption(a,5,(char)125),
            getNthCharOption(a,6,(char)125),
            getNthCharOption(a,7,(char)125),
            getNthCharOption(a,8,(char)125),
            getNthCharOption(a,9,(char)125),
            a};
    };
    std::vector<tup11> arrtup = map(arr,func);
    sorted(arrtup);
    for (int i = 0; i < n; i++){
        print(std::get<10>(arrtup[i]));
    }
    printNewLine();
    //std::vector<std::vector<int>> a;
    //for (int i = 0; i < 5; i++){
    //    std::vector<int> b = {1,2,3};
    //    a.push_back(b);
    //}
    //println(a,1);
    //marioKart2();
    //particles();
    //boxStacking();
    //ConcurrentContests();


    return 0;
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: ACCEPTED

Test 14

Verdict: ACCEPTED

Test 15

Verdict: ACCEPTED

Test 16

Verdict: ACCEPTED

Test 17

Verdict: ACCEPTED

Test 18

Verdict: ACCEPTED

Test 19

Verdict: ACCEPTED

Test 20

Verdict: ACCEPTED

Test 21

Verdict: WRONG ANSWER

Test 22

Verdict: ACCEPTED

Test 23

Verdict: ACCEPTED

Test 24

Verdict: WRONG ANSWER

Test 25

Verdict: ACCEPTED

Test 26

Verdict: ACCEPTED

Test 27

Verdict: ACCEPTED

Test 28

Verdict: ACCEPTED

Test 29

Verdict: WRONG ANSWER

Test 30

Verdict: WRONG ANSWER

Test 31

Verdict: WRONG ANSWER

Test 32

Verdict: WRONG ANSWER

Test 33

Verdict: WRONG ANSWER

Test 34

Verdict: WRONG ANSWER

Test 35

Verdict: WRONG ANSWER

Test 36

Verdict: WRONG ANSWER

Test 37

Verdict: WRONG ANSWER

Test 38

Verdict: WRONG ANSWER

Test 39

Verdict: WRONG ANSWER

Test 40

Verdict: WRONG ANSWER

Test 41

Verdict: WRONG ANSWER

Test 42

Verdict: WRONG ANSWER

Test 43

Verdict: WRONG ANSWER

Test 44

Verdict: WRONG ANSWER

Test 45

Verdict: WRONG ANSWER

Test 46

Verdict: WRONG ANSWER

Test 47

Verdict: WRONG ANSWER

Test 48

Verdict: WRONG ANSWER

Test 49

Verdict: WRONG ANSWER

Test 50

Verdict: WRONG ANSWER

Test 51

Verdict: WRONG ANSWER

Test 52

Verdict: WRONG ANSWER

Test 53

Verdict: WRONG ANSWER

Test 54

Verdict: WRONG ANSWER

Test 55

Verdict: WRONG ANSWER

Test 56

Verdict: WRONG ANSWER

Test 57

Verdict: WRONG ANSWER

Test 58

Verdict: WRONG ANSWER

Test 59

Verdict: WRONG ANSWER

Test 60

Verdict: WRONG ANSWER

Test 61

Verdict: WRONG ANSWER

Test 62

Verdict: WRONG ANSWER

Test 63

Verdict: WRONG ANSWER

Test 64

Verdict: WRONG ANSWER

Test 65

Verdict: WRONG ANSWER

Test 66

Verdict: WRONG ANSWER

Test 67

Verdict: WRONG ANSWER

Test 68

Verdict: WRONG ANSWER

Test 69

Verdict: WRONG ANSWER

Test 70

Verdict: WRONG ANSWER

Test 71

Verdict: WRONG ANSWER