#include<bits/stdc++.h>
#define len(s) (int)s.size()
#define forn(i, n) for (int i = 0; i < int(n); i++)
using namespace std;
int ans = 0;
bool ok = true;

void Find(int a, int b, string &t, vector<string>&str, vector<pair<int, int>>&match){
    int Max = 0, id = -1, pos = -1;
    for(int i = a; i <= b; i++){
        for(int j = 0; j < len(str); j++){
            string s = str[j];
            if(i + len(s) > len(t) || i + len(s) <= b)continue;
            if(t.substr(i, len(s)) == s) {
                if(i + len(s) > Max){
                    Max = i + len(s);
                    id = j;
                    pos = i;
                }
            }
        }
    }
    if(id == -1) {
        ok = false; return;
    }
    else {
        match.emplace_back(id, pos);
        ans++;
        if(Max == len(t)) return;
        else Find(max(pos + 1, b +1), Max, t, str, match);
    }
}

void solve(){
    ans = 0;
    ok = true;
    string t;
    cin >> t;
    int n;
    cin >> n;

    vector<string>s(n);
    vector<pair<int, int>>match;

    forn(i, n) {
        cin >> s[i];
    }

    Find(0, 0, t, s, match);
    if(!ok) cout << "-1\n";
    else{
        cout << ans << endl;
        for(auto &p : match) cout << p.first + 1 << ' ' << p.second + 1 << endl;
    }
}

int main(){
    int q;
    cin >> q;
    while(q--){
        solve();
    }
    return 0;
}

Convert all the times hi mi to minutes. This can be done by multiplying the hour time by 60 and adding that to the minute time. Then calculate the minimum of the differences from the start time to each of the alarms. If the difference is negative, add 24*60 to it. Now that we've got the smallest distance in minutes, divide it by 60 to get the number of hours and take it modulo 60 to get the number of minutes.

166513127

I just used a map and filled it up with all the values in the array beforehand. Then I kept removing a larger and larger prefix of elements until eventually all the resulting elements were unique.

166516865

Recursion/Bitmasks Brute force. For each of the digits from 1-9, you have 2 choices: use it, or not. Just get all the 2^9 numbers and find the smallest one that works. This can be done by sorting the digits from smallest to largest and using that as your answer

166525073

To solve this problem I kept repeating the following process until all the elements were colored, or no more elements could be colored. Start from the first uncolored element and go down all the way to the first element. Then brute force all the possible input strings that can fit at that position and count the number of new elements that can be colored. If no new elements can be colored, then it's impossible to color everything. Otherwise, use the one that gave you the most new elements, mark those as visited, and move on to the element right after the end of that string.

166548769

My approach for this problem was quite messy but it surprisingly worked. There are 3 cases. Case 1: Only numbers that end with 0's and 5's are in the input. 2: Only numbers that end with 1's, 2's, 3's, 4's, 6's, 7's, 8's, and 9's. 3: A mix of both. It can be proven that there is no answer in Case 3. For Case 1: Just add 5's to all the numbers with a units digit of 5 and check if they are all equal. For Case 2, what I did is I first added 1's to all the numbers with unit's digit of 1. I did the same for numbers with unit's digits of 3, 7, and 9. This will then convert all the numbers to having unit's digits of 2, 4, 8, and 6, Then keep adding 20 to all the numbers until they are all less than 20 away from each other. 20 is special because it preserves the units digit and can be added using the operations. Now if there are multiple numbers that have the same unit's digit after adding 20, then there's no solution because it's impossible to ever make them equal. Now we just have (0-1) numbers with unit's digit 2, (0-1) numbers with unit's digit 4, (0-1) numbers with unit's digit 6, and (0-1) numbers with digit 8. Now for all 16 pairs, just check if it's possible to go from the smaller number to the larger number. This means that it is possible for them all to converge to a single value. This solution is really an overcomplicated version of most solutions, and the code is really messy and inefficent.

166575249

#include<bits/stdc++.h>
#define len(s) (int)s.size()
#define forn(i, n) for (int i = 0; i < int(n); i++)
using namespace std; 
int ans = 0; 
bool ok = true;

void Find(int a, int b, string &t, vector&str, vector<pair<int, int>>&match)
{ 
    int Max = 0, id = -1, pos = -1; 
    for(int i = a; i <= b; i++)
    { 
        for(int j = 0; j < len(str); j++)
        { 
            string s = str[j]; 
            if (i + len(s) > len(t) || i + len(s) <= b) continue; 
            if (t.substr(i, len(s)) == s) 
            { 
                if (i + len(s) > Max){ 
                    Max = i + len(s); id = j; pos = i; 
                } 
            } 
        } 
        if(id == -1) { ok = false; return; } 
        else
        { 
            match.emplace_back(id, pos); 
            ans++; 
            if (Max == len(t)) return; 
            else Find(max(pos + 1, b +1), Max, t, str, match); 
        } 
    }

void solve()
{ 
    ans = 0; ok = true;

    string t;
    cin >> t;
    int n;
    cin >> n;

    vector<string>s(n);
    vector<pair<int, int>>match;

    forn(i, n) {
        cin >> s[i];
    }

    Find(0, 0, t, s, match);
    if(!ok) cout << "-1\n";
    else{
        cout << ans << endl;
        for(auto &p : match) cout << p.first + 1 << ' ' << p.second + 1 << endl;
    }
}

int main(){ 
    int q; 
    cin >> q; 
    while(q--){ 
        solve(); 
    } 
    return 0; 
}

#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>  
#include <complex>
#include <queue>
#include <set>
#include <unordered_set>
#include <list>
#include <chrono>
#include <random>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <stack>
#include <iomanip>
#include <fstream>
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef pair<int,int> p32;
typedef pair<ll,ll> p64;
typedef pair<double,double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int> > vv32;
typedef vector<vector<ll> > vv64;
typedef vector<vector<p64> > vvp64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
double eps = 1e-12;
#define forn(i,e) for(ll i = 0; i < e; i++)
#define forsn(i,s,e) for(ll i = s; i < e; i++)
#define rforn(i,s) for(ll i = s; i >= 0; i--)
#define rforsn(i,s,e) for(ll i = s; i >= e; i--)
#define ln "\n"
#define dbg(x) cout<<#x<<" = "<<x<<ln
#define umap unordered_map
#define uset unordered_set
#define mp make_pair
#define pb push_back
#define ppb pop_back
#define fi first
#define se second
#define INF 2e18
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend
#define sz(x) ((ll)(x).size())
#define max3(a,b,c) max(max((a),(b)),(c))
#define max4(a,b,c,d) max(max((a),(b)),max((c),(d)))
#define min3(a,b,c) min(min((a),(b)),(c))
#define min4(a,b,c,d) min(min((a),(b)),min((c),(d)))

template<class T>
void swp(T&a,T&b)
{
    T temp=a;
a=b;
b=temp;
}


// Useful Funcs

// smallest prime divisor
// int smp[100001]={0};
// void calcPrimes(){
//     forn(i,100001){
//         smp[i]=i;
//     }
//     ll ct=2;
//     while(ct*ct<100001){
//         if(smp[ct]==ct){
//             for(ll j=ct*ct;j<100001;j+=ct){smp[j]=ct;}}
//         ct+=1;
//     }
// }


ll ceil_div(ll a, ll b) {return a % b == 0 ? a / b : a / b + 1;}

// Recursive function to calculate gcd
long long gcd(long long a, long long b){
    if(b==0)
        return a;
    return gcd(b,a%b);
}

/* Iterative Function to calculate (x^y)%p in O(log y) */
long long modex(long long x, unsigned int y, long long p)
{
    long long res = 1;     // Initialize result
    x = x % p; // Update x if it is more than or
                // equal to p
    if (x == 0) return 0; // In case x is divisible by p;
    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;
        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

int binarySearch(int arr[], int l, int r, int x)
{
    if (r >= l) {
        int mid = l + (r - l) / 2;

        // If the element is present at the middle
        // itself
        if (arr[mid] == x)
            return mid;

        // If element is smaller than mid, then
        // it can only be present in left subarray
        if (arr[mid] > x)
            return binarySearch(arr, l, mid - 1, x);

        // Else the element can only be present
        // in right subarray
        return binarySearch(arr, mid + 1, r, x);
    }

    // We reach here when element is not
    // present in array
    return -1;
}

// STL binary search functions
// binary_search(start_ptr, end_ptr, num)
    // returns true if element present,
    // otherwise returns false.

// upper_bound(start_ptr, end_ptr, num)
    // returns the first index having value
    // greater than num.
    // If there is no such index, then returns
    // length of array.

// lower_bound(start_ptr, end_ptr, num)
    // returns the fiirst index having value
    // not less than num

// Subtract v.begin() or a(in case of array) to get index.

// Pointers
// for array->  a, a+x
// for vector-> v.begin(), v.begin()+x, v.end()
 


const ll MOD = 998244353;
const ll mod = 1e9+7;

void solve(){
    string t;
    cin>>t;
    ll n;
    cin>>n;
    vector<string> s(n);
    forn(i,n) cin>>s[i];

    ll m = sz(t);
    v64 c(m);
    ll ans = 0;
    vp64 ansl;
    for(ll cv=10;cv>=1;--cv){
        forn(i,m){
            forn(j,n){
                if(sz(s[j])>=cv && m-i>=sz(s[j])){
                    ll cov = 0;
                    bool b=true;
                    forn(k,sz(s[j])){
                        if(s[j][k]!=t[i+k]){
                            b=false;
                            break;
                        }
                        else{
                            if(!c[i+k]) cov++;
                        }
                    }
                    if(b && cov==cv){
                        ans++;
                        ansl.pb({j+1,i+1});
                        forn(k,sz(s[j])){
                            c[i+k]=1;
                        }
                    }
                }
            }
        }
    }
    bool b=true;
    forn(i,sz(t)){
        if(!c[i]){
            b=false;
            break;
        }
    }
    if(b){
        cout<<ans<<"\n";
        for(auto z:ansl){
            cout<<z.fi<<" "<<z.se<<"\n";
        }
    }
    else{
        cout<<-1<<"\n";
    }
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
    fast_cin();
    ll t;
    cin >> t;
    for(int it=1;it<=t;it++) {
        solve();
    }
    return 0;
}