Zadatak može da se radi na mnogo načina. U nastavku je jedan način rešavanja 2. zadatka 

C++ rešenje

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

//////////////////////////////////////////////////////////////
// Funkcija za proveru pravilnosti stringa
//////////////////////////////////////////////////////////////
bool IsValidString(string s)
{
    int freq[256] = {0};

    //////////////////////////////////////////////////////////////
    // Brojanje karaktera
    //////////////////////////////////////////////////////////////
    for (char c : s)
    {
        freq[(unsigned char)c]++;
    }

    vector<int> counts;

    //////////////////////////////////////////////////////////////
    // Formiranje liste učestalosti
    //////////////////////////////////////////////////////////////
    for (int i = 0; i < 256; i++)
    {
        if (freq[i] > 0)
        {
            counts.push_back(freq[i]);
        }
    }

    //////////////////////////////////////////////////////////////
    // Sortiranje učestalosti
    //////////////////////////////////////////////////////////////
    sort(counts.begin(), counts.end());

    //////////////////////////////////////////////////////////////
    // Ako su svi jednaki
    //////////////////////////////////////////////////////////////
    if (counts.front() == counts.back())
    {
        return true;
    }

    //////////////////////////////////////////////////////////////
    // Provera uklanjanja jednog karaktera
    //////////////////////////////////////////////////////////////
    if (counts.back() - counts.front() == 1 &&
        counts[counts.size() - 1] > counts[counts.size() - 2])
    {
        return true;
    }

    //////////////////////////////////////////////////////////////
    // Primer:
    // 1 2 2 2
    //////////////////////////////////////////////////////////////
    if (counts.front() == 1 &&
        counts[1] == counts.back())
    {
        return true;
    }

    return false;
}

int main()
{
    //////////////////////////////////////////////////////////////
    // Unos stringa
    //////////////////////////////////////////////////////////////
    string s1;

    cout << "Unesite string: ";

    getline(cin, s1);

    //////////////////////////////////////////////////////////////
    // 2.1 ASCII niz
    //////////////////////////////////////////////////////////////
    vector<string> brojeviNiz;

    for (int i = 0; i < s1.length(); i++)
    {
        //////////////////////////////////////////////////////////////
        // ASCII vrednost
        //////////////////////////////////////////////////////////////
        int ascii = (int)s1[i];

        //////////////////////////////////////////////////////////////
        // Pretvaranje u string
        //////////////////////////////////////////////////////////////
        string broj = to_string(ascii);

        //////////////////////////////////////////////////////////////
        // Dodavanje vodećih nula
        //////////////////////////////////////////////////////////////
        while (broj.length() < 3)
        {
            broj = "0" + broj;
        }

        brojeviNiz.push_back(broj);
    }

    cout << endl;
    cout << "********** 2.1 **********" << endl;

    //////////////////////////////////////////////////////////////
    // Obrada parnih indeksa
    //////////////////////////////////////////////////////////////
    for (int i = 0; i < brojeviNiz.size(); i += 2)
    {
        string broj = brojeviNiz[i];

        //////////////////////////////////////////////////////////////
        // Cifre
        //////////////////////////////////////////////////////////////
        int a = broj[0] - '0';
        int b = broj[1] - '0';
        int c = broj[2] - '0';

        //////////////////////////////////////////////////////////////
        // Aritmetička sredina
        //////////////////////////////////////////////////////////////
        int sredina = (int)ceil((a + b + c) / 3.0);

        //////////////////////////////////////////////////////////////
        // Formiranje novog stringa
        //////////////////////////////////////////////////////////////
        string novi =
            string(1, broj[0]) +
            to_string(sredina) +
            string(1, broj[1]) +
            to_string(sredina) +
            string(1, broj[2]);

        cout << novi << endl;
    }

    //////////////////////////////////////////////////////////////
    // 2.2 Provera pravilnosti
    //////////////////////////////////////////////////////////////
    cout << endl;
    cout << "********** 2.2 **********" << endl;

    if (IsValidString(s1))
    {
        cout << "String je pravilan." << endl;
    }
    else
    {
        cout << "String nije pravilan." << endl;
    }

    //////////////////////////////////////////////////////////////
    // 2.3 Formiranje gena
    //////////////////////////////////////////////////////////////
    string s2 = "";

    for (char c : s1)
    {
        c = toupper(c);

        if (c == 'A' || c == 'C' || c == 'T' || c == 'G')
        {
            s2 += c;
        }
    }

    cout << endl;
    cout << "********** 2.3 **********" << endl;

    cout << "s2 = " << s2 << endl;

    //////////////////////////////////////////////////////////////
    // 2.4 Stabilnost gena
    //////////////////////////////////////////////////////////////
    int A = 0;
    int C = 0;
    int G = 0;
    int T = 0;

    //////////////////////////////////////////////////////////////
    // Brojanje karaktera
    //////////////////////////////////////////////////////////////
    for (char c : s2)
    {
        switch (c)
        {
            case 'A':
                A++;
                break;

            case 'C':
                C++;
                break;

            case 'G':
                G++;
                break;

            case 'T':
                T++;
                break;
        }
    }

    cout << endl;
    cout << "********** 2.4 **********" << endl;

    cout << "A = " << A << endl;
    cout << "C = " << C << endl;
    cout << "G = " << G << endl;
    cout << "T = " << T << endl;

    bool stabilan = false;

    //////////////////////////////////////////////////////////////
    // Provera stabilnosti
    //////////////////////////////////////////////////////////////
    if (s2.length() % 4 == 0)
    {
        int n = s2.length() / 4;

        if (A == n &&
            C == n &&
            G == n &&
            T == n)
        {
            stabilan = true;
        }
    }

    if (stabilan)
    {
        cout << "Gen je stabilan." << endl;
    }
    else
    {
        cout << "Gen nije stabilan." << endl;
    }

    //////////////////////////////////////////////////////////////
    // 2.5 Najkraći podniz
    //////////////////////////////////////////////////////////////
    cout << endl;
    cout << "********** 2.5 **********" << endl;

    //////////////////////////////////////////////////////////////
    // Maksimalna učestalost
    //////////////////////////////////////////////////////////////
    int maksimum = max(max(A, C), max(G, T));

    string dodatak = "";

    //////////////////////////////////////////////////////////////
    // Dodavanje nedostajućih karaktera
    //////////////////////////////////////////////////////////////
    dodatak += string(maksimum - A, 'A');
    dodatak += string(maksimum - C, 'C');
    dodatak += string(maksimum - G, 'G');
    dodatak += string(maksimum - T, 'T');

    cout << "Najkraci podniz: " << dodatak << endl;

    return 0;
}

C# rešenje

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    //////////////////////////////////////////////////////////////
    // Provera pravilnosti stringa
    //////////////////////////////////////////////////////////////
    static bool IsValidString(string s)
    {
        Dictionary<char, int> freq =
            new Dictionary<char, int>();

        //////////////////////////////////////////////////////////////
        // Brojanje karaktera
        //////////////////////////////////////////////////////////////
        foreach (char c in s)
        {
            if (!freq.ContainsKey(c))
            {
                freq[c] = 0;
            }

            freq[c]++;
        }

        List<int> counts =
            freq.Values.ToList();

        counts.Sort();

        //////////////////////////////////////////////////////////////
        // Svi jednaki
        //////////////////////////////////////////////////////////////
        if (counts.First() == counts.Last())
        {
            return true;
        }

        //////////////////////////////////////////////////////////////
        // Razlika 1
        //////////////////////////////////////////////////////////////
        if (counts.Last() - counts.First() == 1 &&
            counts[counts.Count - 1] >
            counts[counts.Count - 2])
        {
            return true;
        }

        //////////////////////////////////////////////////////////////
        // Primer:
        // 1 2 2 2
        //////////////////////////////////////////////////////////////
        if (counts.First() == 1 &&
            counts[1] == counts.Last())
        {
            return true;
        }

        return false;
    }

    static void Main()
    {
        //////////////////////////////////////////////////////////////
        // Unos stringa
        //////////////////////////////////////////////////////////////
        Console.Write("Unesite string: ");

        string s1 = Console.ReadLine();

        //////////////////////////////////////////////////////////////
        // 2.1 ASCII niz
        //////////////////////////////////////////////////////////////
        List<string> brojeviNiz =
            new List<string>();

        foreach (char c in s1)
        {
            //////////////////////////////////////////////////////////////
            // ASCII zapis
            //////////////////////////////////////////////////////////////
            string broj =
                ((int)c).ToString("D3");

            brojeviNiz.Add(broj);
        }

        Console.WriteLine();
        Console.WriteLine("********** 2.1 **********");

        //////////////////////////////////////////////////////////////
        // Obrada parnih indeksa
        //////////////////////////////////////////////////////////////
        for (int i = 0; i < brojeviNiz.Count; i += 2)
        {
            string broj = brojeviNiz[i];

            int a = broj[0] - '0';
            int b = broj[1] - '0';
            int c = broj[2] - '0';

            //////////////////////////////////////////////////////////////
            // Sredina
            //////////////////////////////////////////////////////////////
            int sr =
                (int)Math.Ceiling(
                    (a + b + c) / 3.0
                );

            //////////////////////////////////////////////////////////////
            // Novi string
            //////////////////////////////////////////////////////////////
            string novi =
                broj[0] +
                sr.ToString() +
                broj[1] +
                sr.ToString() +
                broj[2];

            Console.WriteLine(novi);
        }

        //////////////////////////////////////////////////////////////
        // 2.2
        //////////////////////////////////////////////////////////////
        Console.WriteLine();
        Console.WriteLine("********** 2.2 **********");

        if (IsValidString(s1))
        {
            Console.WriteLine(
                "String je pravilan."
            );
        }
        else
        {
            Console.WriteLine(
                "String nije pravilan."
            );
        }

        //////////////////////////////////////////////////////////////
        // 2.3 Formiranje gena
        //////////////////////////////////////////////////////////////
        string s2 = "";

        foreach (char c in s1)
        {
            char veliko =
                Char.ToUpper(c);

            if (veliko == 'A' ||
                veliko == 'C' ||
                veliko == 'G' ||
                veliko == 'T')
            {
                s2 += veliko;
            }
        }

        Console.WriteLine();
        Console.WriteLine("********** 2.3 **********");

        Console.WriteLine("s2 = " + s2);

        //////////////////////////////////////////////////////////////
        // 2.4 Stabilnost gena
        //////////////////////////////////////////////////////////////
        int A = 0;
        int C = 0;
        int G = 0;
        int T = 0;

        foreach (char c in s2)
        {
            switch (c)
            {
                case 'A':
                    A++;
                    break;

                case 'C':
                    C++;
                    break;

                case 'G':
                    G++;
                    break;

                case 'T':
                    T++;
                    break;
            }
        }

        Console.WriteLine();
        Console.WriteLine("********** 2.4 **********");

        Console.WriteLine("A = " + A);
        Console.WriteLine("C = " + C);
        Console.WriteLine("G = " + G);
        Console.WriteLine("T = " + T);

        bool stabilan = false;

        if (s2.Length % 4 == 0)
        {
            int n = s2.Length / 4;

            if (A == n &&
                C == n &&
                G == n &&
                T == n)
            {
                stabilan = true;
            }
        }

        if (stabilan)
        {
            Console.WriteLine(
                "Gen je stabilan."
            );
        }
        else
        {
            Console.WriteLine(
                "Gen nije stabilan."
            );
        }

        //////////////////////////////////////////////////////////////
        // 2.5 Najkraći podniz
        //////////////////////////////////////////////////////////////
        Console.WriteLine();
        Console.WriteLine("********** 2.5 **********");

        int maksimum =
            Math.Max(
                Math.Max(A, C),
                Math.Max(G, T)
            );

        string dodatak = "";

        dodatak += new string('A', maksimum - A);
        dodatak += new string('C', maksimum - C);
        dodatak += new string('G', maksimum - G);
        dodatak += new string('T', maksimum - T);

        Console.WriteLine(
            "Najkraci podniz: " + dodatak
        );
    }
}

Python rešenje

import math

##############################################################
# Funkcija za proveru pravilnosti stringa
##############################################################
def is_valid_string(s):

    freq = {}

    ##############################################################
    # Brojanje karaktera
    ##############################################################
    for c in s:

        if c not in freq:
            freq[c] = 0

        freq[c] += 1

    ##############################################################
    # Lista učestalosti
    ##############################################################
    counts = list(freq.values())

    counts.sort()

    ##############################################################
    # Ako su svi jednaki
    ##############################################################
    if counts[0] == counts[-1]:
        return True

    ##############################################################
    # Razlika 1
    ##############################################################
    if (
        counts[-1] - counts[0] == 1
        and
        counts[-1] > counts[-2]
    ):
        return True

    ##############################################################
    # Primer:
    # 1 2 2 2
    ##############################################################
    if (
        counts[0] == 1
        and
        counts[1] == counts[-1]
    ):
        return True

    return False


##############################################################
# Unos stringa
##############################################################
s1 = input("Unesite string: ")

##############################################################
# 2.1 ASCII niz
##############################################################
brojevi_niz = []

for c in s1:

    ##############################################################
    # ASCII vrednost
    ##############################################################
    broj = str(ord(c))

    ##############################################################
    # Dodavanje vodećih nula
    ##############################################################
    while len(broj) < 3:
        broj = "0" + broj

    brojevi_niz.append(broj)

print()
print("********** 2.1 **********")

##############################################################
# Obrada parnih indeksa
##############################################################
for i in range(0, len(brojevi_niz), 2):

    broj = brojevi_niz[i]

    ##############################################################
    # Cifre
    ##############################################################
    a = int(broj[0])
    b = int(broj[1])
    c = int(broj[2])

    ##############################################################
    # Aritmetička sredina
    ##############################################################
    sredina = math.ceil((a + b + c) / 3)

    ##############################################################
    # Novi string
    ##############################################################
    novi = (
        broj[0]
        + str(sredina)
        + broj[1]
        + str(sredina)
        + broj[2]
    )

    print(novi)

##############################################################
# 2.2 Provera pravilnosti
##############################################################
print()
print("********** 2.2 **********")

if is_valid_string(s1):
    print("String je pravilan.")
else:
    print("String nije pravilan.")

##############################################################
# 2.3 Formiranje gena
##############################################################
s2 = ""

for c in s1:

    c = c.upper()

    if c in ['A', 'C', 'G', 'T']:
        s2 += c

print()
print("********** 2.3 **********")

print("s2 =", s2)

##############################################################
# 2.4 Stabilnost gena
##############################################################
A = s2.count('A')
C = s2.count('C')
G = s2.count('G')
T = s2.count('T')

print()
print("********** 2.4 **********")

print("A =", A)
print("C =", C)
print("G =", G)
print("T =", T)

stabilan = False

##############################################################
# Provera stabilnosti
##############################################################
if len(s2) % 4 == 0:

    n = len(s2) // 4

    if (
        A == n
        and
        C == n
        and
        G == n
        and
        T == n
    ):
        stabilan = True

if stabilan:
    print("Gen je stabilan.")
else:
    print("Gen nije stabilan.")

##############################################################
# 2.5 Najkraći podniz
##############################################################
print()
print("********** 2.5 **********")

maksimum = max(A, C, G, T)

dodatak = ""

dodatak += "A" * (maksimum - A)
dodatak += "C" * (maksimum - C)
dodatak += "G" * (maksimum - G)
dodatak += "T" * (maksimum - T)

print("Najkraci podniz:", dodatak)