A more "creative answers" with slightly changed input of your scores and assuming that you enter the scores for each student in always the same order (fixed list of student names) bring me to this solution:

While entering the scores for a new subsubsection with scoreN{{4.5,5,2.5,3.3}} a new line in an external file is written where I store the generated table. At the same time a line in a datatool table is generated. When all subsubsection area finished (a date/subsection) is finished the Sub Avg values are calculate using DTLmeanforcolumn and again a line in the generated tab is written and a line in a secund datatool tab is wirtten to store the Suv Avg values. After all dates are finished the last line of the generated tab is written usin the TotalAvg tab to calculate the total averages. At the end of the document the generated external file is simply included by input{tmpFile.tex}.

For sure the code could be further optimized but it seams to work. Btw., I force to add a zero for students which did not submit a solution and I also plot an image for this case. The idea for this was that there will be students having submitted a solution but got zero points for it - so I want to see the solution when I click the link in the table.

documentclass[demo,12pt]{article}
usepackage{xcolor}
usepackage{graphicx}
usepackage[labelformat=empty]{caption}
usepackage{longtable}
usepackage{array}
usepackage{capt-of}

letoldsubsectionsubsection
renewcommand{subsection}[2][]{defsx{#2}oldsubsection[#1]{#2}}

usepackage{tikz} % for foreach, pfgmath...
usepackage{ifthen}

usepackage{datatool}

%workaround for unmatching pairs of braces within immediate
usepackage{newverbs}
Verbdefleftb|{|
Verbdefrightb|}|

%list of student names
defStudentNames{{"A10","X02","P33","X04"}}
defStudentNamesS{A10,X02,P33,X04}

%a temp file to store the generated tab
newwritemytmpfile
immediateopenoutmytmpfile=tmpFile.tex

%probelm number counter 
newcounter{NoCounter}
setcounter{NoCounter}{1}

% #1 list of scores
newcommandscoreN[1]{%
    ifthenelse{equal{theNoCounter}{1}}{
        immediatewritemytmpfile{sxunexpanded{ & hyperlink}{sx:theNoCounter}{theNoCounter}}
    }{
        immediatewritemytmpfile{unexpanded{ & hyperlink}{sx:theNoCounter}{theNoCounter}}
    }
    
    dtlexpandnewvalue
    DTLnewrow{SubAvgTab}
    foreach x [count=xi from 0] in #1 {
        begin{center}
        includegraphics{sx/x-arabic{subsubsection}}
        pgfmathsetmacro{StudentName}{StudentNames[xi]}
        captionof{figure}{StudentName: x}hypertarget{sx-StudentName-theNoCounter}{}
        end{center}
        
        pgfmathsetmacro{StudentName}{StudentNames[xi]} % id do not know why i have to repeat this here (but without the StudentName definition is not known)
        ifthenelse{equal{x}{0}}{
            immediatewritemytmpfile{
                unexpanded{ & fcolorbox{black}{yellow}}
                leftbunexpanded{hyperlink}
                {sx-StudentName-theNoCounter}{0}
                rightb}
        }{
            immediatewritemytmpfile{unexpanded{ & hyperlink}{sx-StudentName-theNoCounter}{x}}
        }
        DTLnewdbentry{SubAvgTab}{StudentName}{x}
    }
    immediatewritemytmpfile{unexpanded{hline}}
    stepcounter{NoCounter}
}

newcommandfinishDate{%
    %set problem number counter back
    setcounter{NoCounter}{1}
    
    dtlexpandnewvalue
    DTLnewrow{TotalAvgTab}
    immediatewritemytmpfile{Sub Avgunexpanded{ & }}
    %calc average for each column in SubAvgTab and write them to the tmp file
    foreach x in StudentNamesS {
        DTLmeanforcolumn{SubAvgTab}{x}{menaX}
        immediatewritemytmpfile{unexpanded{ & pgfmathprintnumber[fixed,precision=2]}{menaX}}
        DTLnewdbentry{TotalAvgTab}{x}{menaX}
    }
    immediatewritemytmpfile{unexpanded{hlinehline}}
    %clear SubAvgTab
    DTLcleardb{SubAvgTab}
}

newcommandfinishTotal{%
    immediatewritemytmpfile{unexpanded{hlinehline}Total Avgunexpanded{ & }}
    %calc average for each column in SubAvgTab
    foreach x in StudentNamesS {
        DTLmeanforcolumn{TotalAvgTab}{x}{menaX}
        immediatewritemytmpfile{unexpanded{ & pgfmathprintnumber[fixed,precision=2]}{menaX}}
    }
    immediatewritemytmpfile{unexpanded{hlinehline}}
}

usepackage{pdflscape}
usepackage[colorlinks]{hyperref}

begin{document}
DTLnewdb{SubAvgTab}
DTLnewdb{TotalAvgTab}

section{Solving With Factorization Method}

subsection{2020-07-16}

subsubsection{Simple}hypertarget{sx:theNoCounter}{}
scoreN{{4.5,5,2.5,3.3}}

subsubsection{Intermediate}hypertarget{sx:theNoCounter}{}
scoreN{{2,2,0,2.3}}

subsubsection{Advanced}hypertarget{sx:theNoCounter}{}
scoreN{{1,2,3,4}}

finishDate
subsection{2020-07-23}

subsubsection{Simple}hypertarget{sx:theNoCounter}{}
scoreN{{2.5,4,3.5,4}}

subsubsection{Intermediate}hypertarget{sx:theNoCounter}{}
scoreN{{0,4,3,3}}

finishDate

section{Generated Cumulative Score Table}
finishTotal
immediatecloseoutmytmpfile % write the tmp file

begin{landscape}
begin{longtable}{|m{20mm}|m{5mm}|*4{m{10mm}|}}hline
Deadline        & No. & A10     & X02   & P33       & X04 hlinehline
input{tmpFile.tex}
end{longtable}
end{landscape}

end{document}

About this solution

• This solution is implemented with Lua. Therefore, the compiler must be LuaTeX.

• Basically, a table object called student_info in Lua keeps tracks of all student information. For example, if one writes:

  subsection{2020-07-16}
  subsubsection{Simple}
  score{A10}{4.5}
  

  Then the value of student_info["2020-07-16"]["Simple"]["A10"] is 4.5. Most of the code is in charge of transforming and formatting this table for output.

• The table is constructed with generate_tex_table() function. Every time the document is compiled, the constructed table is saved to jobname.mytable. The table can be shown by using printtable command, which essentially reads jobname.mytable.

  % update the table when document finishes
  makeatletter
  AtEndDocument{
    directlua{
        out = io.open("jobname.mytable", "w")
        out:write(generate_tex_table())
        io.close(out)
    }
  }
  makeatother
  % try to retrieve the table generated from last run
  newcommand{printtable}{
    InputIfFileExists{jobname.mytable}
  }
  

• A set of format_ functions controls how data are formatted in the output.

Source

documentclass{article}
usepackage{array}
usepackage{newtxtext, newtxmath}
usepackage{expl3}
usepackage{luacode}
usepackage{xcolor}
usepackage{longtable}
usepackage{float}
usepackage{graphicx}
usepackage{datetime2}
usepackage[colorlinks]{hyperref}

begin{document}

directlua{
    % debug only
    % https://github.com/kikito/inspect.lua
    % inspect = require('inspect')
    
    subsection_name = ''
    subsubsection_name = ''
}

begin{luacode*}
    student_info = {}
    
    function table_get(tb, key, default)
        if (tb[key] == nil) then
            tb[key] = default
        end
        return tb[key]
    end
    
    function get_table_size(t)
        local count = 0
        for _, __ in pairs(t) do
            count = count + 1
        end
        return count
    end
    
    -- using `get_table_size` to track the order of occurrence
    function append_student_info(name, score)
        local subsec_tb = table_get(student_info, subsection_name, {{}, get_table_size(student_info)})
        local subsubsec_tb = table_get(subsec_tb[1], subsubsection_name, {{}, get_table_size(subsec_tb[1])})
        subsubsec_tb[1][name] = tonumber(score)
    end
    
    -- sort keys by occurrence order
    function get_sorted_keys(tb)
        local arr = {}
        for key, val in pairs(tb) do
            local seq = val[2]
            arr[seq + 1] = key
        end
        return arr
    end
    
    function _get_all_student_name(tb, set)
        for key, val in pairs(tb) do
            if (type(val) == "table") then
                if (type(val[1]) == "table") then
                    _get_all_student_name(val[1], set)
                end
            elseif (type(val) == "number") then
                set[key] = true
            end
        end
    end
    
    -- get all student names in sorted order
    function get_all_student_name(tb)
        local set = {}
        _get_all_student_name(tb, set)
        
        local lst = {}
        for key, val in pairs(set) do
            table.insert(lst, key)
        end
        
        table.sort(lst)
        return lst
    end
    
    -- get tex label of something
    function get_label(l)
        return table.concat(l, "-")
    end
    
    -- format a score
    function format_score(ops)
        local score = ops[1]
        
        local no_img = false
        if (score == nil) then
            no_img = true
            score = 0.0
        end
        
        
        local num_str = string.format("%2.2f", score)
        local tex_str = ""
        
        if (math.abs(score) < 0.01) then
            tex_str = string.format("fcolorbox{black}{yellow}{%s}", num_str)
        else
            tex_str = num_str
        end
        
        if no_img or ops["no_link"] then
            return tex_str
        else
            local label = get_label{"fig", ops[2], ops[3], ops[4]}
            return [[def@linkcolor{red}]] .. string.format("hyperref[%s]{%s}", label, tex_str)
        end
    end
    
    function format_deadline(ops)
        local label = get_label{"subsec", ops[1]}
        return [[def@linkcolor{blue}]] .. string.format("hyperref[%s]{%s}", label, ops[1])
    end
    
    function format_no(ops)
        local label = get_label{"subsubsec", ops[2], ops[3]}
        return [[def@linkcolor{green}]] .. string.format("hyperref[%s]{%s}", label, ops[1])
    end
    
    function get_sub_average(subsec_name, student_name, subsubsec_names)
        local sum = 0.0
        local count = 0
        local tb = student_info[subsec_name][1]
        for ind, subsubsec_name in pairs(subsubsec_names) do
            local score = tb[subsubsec_name][1][student_name]
            if (score ~= nil) then
                sum = sum + score
            end
            count = count + 1
        end
        return sum / count
    end
    
    function get_total_average(student_name, subsec_names)
        local sum = 0.0
        local count = 0
        
        for _, subsec_name in pairs(subsec_names) do
            local subsec_tb = student_info[subsec_name]
            local subsubsec_names = get_sorted_keys(subsec_tb[1])
            for ind, subsubsec_name in pairs(subsubsec_names) do
                local score = subsec_tb[1][subsubsec_name][1][student_name]
                if (score ~= nil) then
                    sum = sum + score
                end
                count = count + 1
            end
        end
        
        return sum / count
        
    end
    
    function generate_tex_table()
        local student_names = get_all_student_name(student_info)
        
        local rows = {}
        
        local row = {"Deadline", "No."}
        for _, student_name in pairs(student_names) do
            table.insert(row, student_name)
        end
        table.insert(rows, row)
        
        local subsec_names = get_sorted_keys(student_info)
        for _, subsec_name in pairs(subsec_names) do
            local subsec_tb = student_info[subsec_name]
            local subsubsec_names = get_sorted_keys(subsec_tb[1])
            
            for ind, subsubsec_name in pairs(subsubsec_names) do
                local row = nil
                if (ind == 1) then
                    row = {format_deadline{subsec_name}, format_no{ind, subsec_name, subsubsec_name}}
                else
                    row = {'', format_no{ind, subsec_name, subsubsec_name}}
                end
                
                local subsubsec_tb = subsec_tb[1][subsubsec_name]
                for _, student_name in pairs(student_names) do
                    table.insert(row, format_score{subsubsec_tb[1][student_name], subsec_name, subsubsec_name, student_name})
                end
                
                table.insert(rows, row)
            end
            
            local row = {"Sub Avg", ""}
            for _, student_name in pairs(student_names) do
                table.insert(row, format_score{get_sub_average(subsec_name, student_name, subsubsec_names), no_link=true})
            end
            table.insert(rows, row)
        end
        
        row = {"Total Avg", ""}
        for _, student_name in pairs(student_names) do
            table.insert(row, format_score{get_total_average(student_name, subsec_names), no_link=true})
        end
        table.insert(rows, row)
        
        
        -- construct tex string
        local n_cols = get_table_size(rows[1])
        local table_fmt_tmp = {"m{20mm}", "m{5mm}"}
        for i = 3,n_cols do
            table.insert(table_fmt_tmp, "m{10mm}")
        end
        local table_fmt = "|" .. table.concat(table_fmt_tmp, "|") .. "|"
        local tex_str = "makeatletternbegin{longtable}{" .. table_fmt .. "} hline n"
        
        for _, row in pairs(rows) do
            local row_str = table.concat(row, " & ") .. "\ hline n"
            tex_str = tex_str .. row_str
        end
        
        tex_str = tex_str .. "end{longtable}nmakeatothern"
        
        return tex_str
    end
    
end{luacode*}


newcommand{score}[2]{
    directlua{append_student_info("luaescapestring{#1}", "luaescapestring{#2}")}
    defimgfilename{directlua{tex.print(subsection_name)}/#1-arabic{subsubsection}}
    IfFileExists{imgfilename}{
        begin{figure}[H]
            centering
            includegraphics{imgfilename}
            caption{#1: #2}
            label{directlua{tex.print(get_label{"fig", subsection_name, subsubsection_name, "luaescapestring{#1}"})}}
        end{figure}
    }{
        % this is for testing
        % maybe raise error if not found?
        begin{figure}[H]
            centering
            includegraphics[width=0.4linewidth]{example-image}
            caption{#1: #2}
            label{directlua{tex.print(get_label{"fig", subsection_name, subsubsection_name, "luaescapestring{#1}"})}}
        end{figure}
    }
}

% reset section commands
letoldsubsectionsubsection
letoldsubsubsectionsubsubsection


renewcommand{subsection}[2][]{
    directlua{
        subsection_name="luaescapestring{#2}"
        local subsec_tb = table_get(student_info, subsection_name, {{}, get_table_size(student_info)})
    }
    oldsubsection[#1]{#2}
    label{directlua{tex.print(get_label{"subsec", subsection_name})}}
}
renewcommand{subsubsection}[2][]{
    directlua{
        subsubsection_name="luaescapestring{#2}"
        local subsec_tb = table_get(student_info, subsection_name, {{}, get_table_size(student_info)})
        local subsubsec_tb = table_get(subsec_tb[1], subsubsection_name, {{}, get_table_size(subsec_tb[1])})
    }
    oldsubsubsection[#1]{#2}
    label{directlua{tex.print(get_label{"subsubsec", subsection_name, subsubsection_name})}}
}


% update the table when document finishes
makeatletter
AtEndDocument{
    directlua{
        out = io.open("jobname.mytable", "w")
        out:write(generate_tex_table())
        io.close(out)
    }
}
makeatother
% try to retrieve the table generated from last run
newcommand{printtable}{
    InputIfFileExists{jobname.mytable}
}


printtable


section{Solving With Factorization Method}

subsection{2020-07-16}

subsubsection{Simple}
score{A10}{4.5}
score{X02}{5}
score{P33}{2.5}
score{X04}{3.3}

subsubsection{Intermediate}
score{A10}{2}
score{X02}{2}
% If, for example, P33 does not submit the solution
%  he should  get zero automatically.
% His score cell  on the cumulative table with
% missing homework must be highlighted with a unique color. 
score{X04}{2.3}


subsubsection{Advanced}
score{A10}{1}
score{X02}{2}
score{P33}{3}
score{X04}{4}


subsection{2020-07-18}

subsubsection{Simple}
score{A10}{2}
score{X02}{4.3}
score{P33}{0}
score{X04}{6.5}

subsubsection{Intermediate}
score{A10}{3}
score{X02}{4}
score{P33}{2}
score{X04}{5}


subsubsection{Advanced}
score{A10}{4}
score{X02}{5}
score{P33}{2}
score{X04}{1}

subsubsection{Impossible}


DTMNow

end{document}

The table

(The design is inspired muzimuzhi Z's answer. By looking at his solution, I can't help but admire how good his LaTeX programming skills are...It is beautiful and he absolutely deserves the reward. My only concern is about the precision of LaTeX3's floating point arithmetic though. However, for this kind of application, it should be fine.)

My thoughts

I was really fanatic about LaTeX programming a while ago, and I implemented a bunch of algorithms in LaTeX. However, when my passion begin to fade away, I started to contemplate: "do I really need to implement this/that in LaTeX"? The problem of LaTeX is that it is just not designed for generic programming. Yes, it is Turing complete, but the workload to implement simple algorithms in LaTeX can be huge.

In your specific case, you are trying to apply simple data processing and file management with LaTeX directly. I tried to avoid LaTeX3 by using Lua, but it turned out that Lua is not the best language for these purposes either: you may notice that I need to write explicit loop blocks for aggregating arrays, which is a one-liner in Python. In fact, the entire Lua code almost has nothing to do with LaTeX. That is to say, it can be written in any language.

If I were you, this is probably what I would do:

1. Save students' information in an CSV file (you can work with Microsoft Excel).
2. Use Python's pandas, numpy to process data and os.path to manage files.
3. Construct the TeX source in Python. It should be fairly easy with the help of Python's powerful string library and pylatex.
4. Save TeX source to a file and use subprocess.run to call TeX executables to compile the file.

If efficiency is the key, I think this approach can save a lot of time and the outcome will be much more customizable compared to pure LaTeX/LuaTeX solution. Nevertheless, I still had a lot of fun writing the code above. Hope you like my alternative solution ?

Using Python to generate LaTeX source

In this case, students information can be stored in a CSV file (supposed it is saved as Book1.csv).

Student,2020-07-15/Basic,2020-07-15/Intermediate,2020-07-15/Advanced,2020-07-18/Basic,2020-07-18/Intermediate,2020-07-18/Advanced,2020-07-18/Impossible
Lorem Ipsum,4.43,2.39,4.90,4.19,2.42,4.61,
Dolor Sit,3.03,4.13,3.18,4.58,3.97,1.12,
Amet Consectetuer,4.05,,,4.75,4.36,4.36,
Adipiscing Elit,1.80,3.03,1.55,4.50,2.69,3.68,
Aenean Commodo,3.99,4.55,4.37,,4.17,0.00,

Then, I can use the following Python code to generate TeX source.

import pandas
import numpy as np
from collections import OrderedDict
import re
import os

# to imitate dict's get() method for ordered dict
def od_get(od, key, default):
    if key in od:
        return od[key]
    od[key] = default
    return od[key]

class CSV2TeX:

    def __init__(self, csv_filename, **kwargs):
        self.df = pandas.read_csv(csv_filename)
        self.df_arr = self.df.iloc[:, 1:].to_numpy()
        self.section_title = kwargs.get('section_title', '')

        self._parse_header()
        # get all student names
        self.all_students = self.df.iloc[:, 0].tolist()

        # global variables to expedite formatting
        self.date = ''
        self.description = ''
        self.student = ''
        self.question_id = 0
        self.score = np.NaN
        self.score_no_link = False

    # parse headers - the mapping result in the index of a header item
    def _parse_header(self):
        self.header_info = OrderedDict()
        for ind, header_str in enumerate(self.df.columns.values):
            if ind == 0: continue
            date, description = header_str.split('/')
            od_get(self.header_info, date, OrderedDict())[description] = ind - 1

    def _get_label(self, *args):
        return re.sub(r's', '-', '-'.join(args)).lower()

    def format_date(self):
        label = self._get_label('subsec', self.date)
        return r'def@linkcolor{blue}hyperref[%s]{%s}' % (label, self.date)

    def format_question_id(self):
        label = self._get_label('subsubsec', self.date, self.description)
        return r'def@linkcolor{green}hyperref[%s]{%s}' % (label, self.question_id + 1)

    def format_score(self):
        score = self.score
        no_link = self.score_no_link
        score_fmt = '{:.2f}'
        if np.isnan(score):
            no_link = True
            score = 0.0
            score_s = r'fcolorbox{black}{yellow}{%s}' % (score_fmt.format(score),)
        else:
            score_s = score_fmt.format(score)


        if no_link:
            return score_s

        label = self._get_label('figure', self.date, self.description, self.student)
        return r'def@linkcolor{red}hyperref[%s]{%s}' % (label, score_s)

    def format_figure(self):
        label = self._get_label('figure', self.date, self.description, self.student)
        # TODO: change image_path for actual application
        image_path = 'example-image'
        #image_path = os.path.join(self.date, self.student + repr(self.question_id))
        caption = '{}: {}'.format(self.student, self.score)
        return r'''
begin{figure}[H]
centering
includegraphics[width=0.5linewidth]{%s}
caption{%s}
label{%s}
end{figure}''' % (image_path, caption, label)

    def format_section(self):
        return r'section{%s}' % (self.section_title,)

    def format_subsection(self):
        label = self._get_label('subsec', self.date)
        return r'subsection{%s}label{%s}' % (self.date, label)

    def format_subsubsection(self):
        label = self._get_label('subsubsec', self.date, self.description)
        return r'subsubsection{%s}label{%s}' % (self.description, label)

    def convert(self):
        rows1 = []  # the table
        rows2 = []  # figures

        rows1.append(['Deadline', 'No.'] + self.all_students)

        # generate the table
        for date, descriptions in self.header_info.items():
            self.date = date
            rows2.append(self.format_subsection())

            all_col_inds = []
            for q_ind, (description, col_ind) in enumerate(descriptions.items()):
                all_col_inds.append(col_ind)
                self.question_id = q_ind
                self.description = description
                rows2.append(self.format_subsubsection())

                if q_ind == 0:
                    row = [self.format_date(), self.format_question_id()]
                else:
                    row = ['', self.format_question_id()]

                for s_ind, student in enumerate(self.all_students):
                    self.student = student
                    self.score = self.df_arr[s_ind, col_ind]
                    row.append(self.format_score())
                    if not np.isnan(self.score):
                        rows2.append(self.format_figure())

                rows1.append(row)

            row = ['Sub Avg', '']
            # compute sub avg for each student
            self.score_no_link = True
            for s_ind, student in enumerate(self.all_students):
                student_cols = np.take(self.df_arr[s_ind, ...], all_col_inds)
                student_cols[np.isnan(student_cols)] = 0.0
                self.score = np.mean(student_cols)
                row.append(self.format_score())
            self.score_no_link = False
            rows1.append(row)

        # compute total avg for each student
        row = ['Total Avg', '']
        self.score_no_link = True
        for s_ind, student in enumerate(self.all_students):
            student_row = self.df_arr[s_ind, ...]
            student_row[np.isnan(student_row)] = 0.0
            self.score = np.mean(student_row)
            row.append(self.format_score())
        self.score_no_link = False
        rows1.append(row)

        # find the longest cell for pretty printing
        longest_len = max(map(lambda x : max(map(len, x)), rows1))
        fmt_str = '{:<%d}' % longest_len

        # generate tex table
        tex_table_fmt = '|' + '|'.join(['l'] * len(rows1[0])) + '|'
        row1_str = 'begin{longtable}{%s}nhlinen' % tex_table_fmt
        for row in rows1:
            row_str = ' & '.join(map(lambda x : fmt_str.format(x), row)) + r' hline ' + 'n'
            row1_str += row_str
        row1_str += 'end{longtable}'

        row1_all = [self.format_section(), r'makeatletter', row1_str, r'makeatother', 'n']

        return 'nn'.join(row1_all) + 'nn'.join(rows2)

with open('my_table.tex', 'w') as outfile:
    outfile.write(CSV2TeX('Book1.csv', section_title='Math').convert())

The code above stores the LaTeX source into my_table.tex (the file is too long for this answer, you can peek at it from here). Now, I can compile the following document to get desired output. Of course, it is possible to fully automate this by using subprocess.

documentclass{article}
usepackage{array}
usepackage{newtxtext, newtxmath}
usepackage{luacode}
usepackage{xcolor}
usepackage{longtable}
usepackage{float}
usepackage{graphicx}
usepackage{datetime2}
usepackage[colorlinks]{hyperref}

begin{document}

input{my_table.tex}

end{document}