Modern systems suffer system faults in both hardware and software. Requirement degradation is a widely applied redundant-design approach to deal with system fault by degrading or disabling (non-critical) requirements. However, due to the environment's unpredictability, it is unrealistic for engineers to prepare such redundant designs for unforeseen and unknown faults in advance. Requirement-aware self-adaptive systems have been investigated to address this challenge. Specifically, such a system can autonomously analyze which requirements are guaranteeable so that the requirement degradation can be determined automatically to satisfy the maximal requirements. The previous work has proposed an algorithm to recognize the guaranteeable requirements by analyzing a two-player game between the environment and the system. However, such an algorithm is not designed for the system fault, and the entire game must be re-analyzed from scratch, making it inefficient for runtime adaptation. In this paper, we propose an efficient difference analysis algorithm that reuses the previous analysis result to reduce the runtime computational overhead. Specifically, it carefully specifies which part of the result is reusable and only re-analyzes the part that may be affected. We evaluated the algorithm's effectiveness with four case studies, and the results indicate that an average of 46.5% computational time is reduced.