step

package-lock.json

@@ -5,30 +5,30 @@
   "requires": true,
   "dependencies": {
     "@babel/helper-string-parser": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
-      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA=="
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="
     },
     "@babel/helper-validator-identifier": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
-      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ=="
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="
     },
     "@babel/parser": {
-      "version": "7.27.0",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.0.tgz",
-      "integrity": "sha512-iaepho73/2Pz7w2eMS0Q5f83+0RKI7i4xmiYeBmDzfRVbQtTOG7Ts0S4HzJVsTMGI9keU8rNfuZr8DKfSt7Yyg==",
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.2.tgz",
+      "integrity": "sha512-QYLs8299NA7WM/bZAdp+CviYYkVoYXlDW2rzliy3chxd1PQjej7JORuMJDJXJUb9g0TT+B99EwaVLKmX+sPXWw==",
       "requires": {
-        "@babel/types": "^7.27.0"
+        "@babel/types": "^7.27.1"
       }
     },
     "@babel/types": {
-      "version": "7.27.0",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.0.tgz",
-      "integrity": "sha512-H45s8fVLYjbhFH62dIJ3WtmJ6RSPt/3DRO0ZcT2SUiYiQyz3BLVb9ADEnLl91m74aQPS3AzzeajZHYOalWe3bg==",
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.1.tgz",
+      "integrity": "sha512-+EzkxvLNfiUeKMgy/3luqfsCWFRXLb7U6wNQTk60tovuckwB15B191tJWvpp4HjiQWdJkCxO3Wbvc6jlk3Xb2Q==",
       "requires": {
-        "@babel/helper-string-parser": "^7.25.9",
-        "@babel/helper-validator-identifier": "^7.25.9"
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1"
       }
     },
     "@types/q": {
@@ -331,9 +331,9 @@
       },
       "dependencies": {
         "bn.js": {
-          "version": "4.12.1",
-          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
-          "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
+          "version": "4.12.2",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+          "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==",
           "dev": true
         }
       }
@@ -1435,9 +1435,9 @@
       "dev": true
     },
     "bn.js": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz",
-      "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==",
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.2.tgz",
+      "integrity": "sha512-v2YAxEmKaBLahNwE1mjp4WON6huMNeuDvagFZW+ASCuA/ku0bXR9hSMw0XpiqMoA3+rmnyck/tPRSFQkoC9Cuw==",
       "dev": true
     },
     "body-parser": {
@@ -1818,15 +1818,15 @@
       }
     },
     "caniuse-db": {
-      "version": "1.0.30001713",
-      "resolved": "https://registry.npmjs.org/caniuse-db/-/caniuse-db-1.0.30001713.tgz",
-      "integrity": "sha512-ntidesNHgjVfKsLZfDXGCG4msGZh9JNW2qiNPd9bDy6dWCEct3XDTBSEVDPb55uhi0elQv7/Yk9HEhs4FDb32Q==",
+      "version": "1.0.30001717",
+      "resolved": "https://registry.npmjs.org/caniuse-db/-/caniuse-db-1.0.30001717.tgz",
+      "integrity": "sha512-V0sTnN19lYOQrM19FYGDmITrIH5Gck9dI005H9dVhIE9MEYZIWMBjKdwCeTSqhCf65H6n+ZMRiMz/4j5jq57Iw==",
       "dev": true
     },
     "caniuse-lite": {
-      "version": "1.0.30001713",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001713.tgz",
-      "integrity": "sha512-wCIWIg+A4Xr7NfhTuHdX+/FKh3+Op3LBbSp2N5Pfx6T/LhdQy3GTyoTg48BReaW/MyMNZAkTadsBtai3ldWK0Q==",
+      "version": "1.0.30001717",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001717.tgz",
+      "integrity": "sha512-auPpttCq6BDEG8ZAuHJIplGw6GODhjw+/11e7IjpnYCxZcW/ONgPs0KVBJ0d1bY3e2+7PRe5RCLyP+PfwVgkYw==",
       "dev": true
     },
     "caseless": {
@@ -2422,9 +2422,9 @@
       },
       "dependencies": {
         "bn.js": {
-          "version": "4.12.1",
-          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
-          "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
+          "version": "4.12.2",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+          "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==",
           "dev": true
         }
       }
@@ -2807,15 +2807,15 @@
       },
       "dependencies": {
         "browserslist": {
-          "version": "4.24.4",
-          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz",
-          "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==",
+          "version": "4.24.5",
+          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.5.tgz",
+          "integrity": "sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==",
           "dev": true,
           "requires": {
-            "caniuse-lite": "^1.0.30001688",
-            "electron-to-chromium": "^1.5.73",
+            "caniuse-lite": "^1.0.30001716",
+            "electron-to-chromium": "^1.5.149",
             "node-releases": "^2.0.19",
-            "update-browserslist-db": "^1.1.1"
+            "update-browserslist-db": "^1.1.3"
           }
         },
         "caniuse-api": {
@@ -3689,9 +3689,9 @@
       },
       "dependencies": {
         "bn.js": {
-          "version": "4.12.1",
-          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
-          "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
+          "version": "4.12.2",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+          "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==",
           "dev": true
         }
       }
@@ -16807,9 +16807,9 @@
       "dev": true
     },
     "electron-to-chromium": {
-      "version": "1.5.137",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.137.tgz",
-      "integrity": "sha512-/QSJaU2JyIuTbbABAo/crOs+SuAZLS+fVVS10PVrIT9hrRkmZl8Hb0xPSkKRUUWHQtYzXHpQUW3Dy5hwMzGZkA==",
+      "version": "1.5.151",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.151.tgz",
+      "integrity": "sha512-Rl6uugut2l9sLojjS4H4SAr3A4IgACMLgpuEMPYCVcKydzfyPrn5absNRju38IhQOf/NwjJY8OGWjlteqYeBCA==",
       "dev": true
     },
     "element-ui": {
@@ -16841,9 +16841,9 @@
       },
       "dependencies": {
         "bn.js": {
-          "version": "4.12.1",
-          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
-          "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
+          "version": "4.12.2",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+          "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==",
           "dev": true
         }
       }
@@ -19578,9 +19578,9 @@
       },
       "dependencies": {
         "bn.js": {
-          "version": "4.12.1",
-          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
-          "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
+          "version": "4.12.2",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+          "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==",
           "dev": true
         }
       }
@@ -20597,9 +20597,9 @@
       }
     },
     "portfinder": {
-      "version": "1.0.36",
-      "resolved": "https://registry.npmjs.org/portfinder/-/portfinder-1.0.36.tgz",
-      "integrity": "sha512-gMKUzCoP+feA7t45moaSx7UniU7PgGN3hA8acAB+3Qn7/js0/lJ07fYZlxt9riE9S3myyxDCyAFzSrLlta0c9g==",
+      "version": "1.0.37",
+      "resolved": "https://registry.npmjs.org/portfinder/-/portfinder-1.0.37.tgz",
+      "integrity": "sha512-yuGIEjDAYnnOex9ddMnKZEMFE0CcGo6zbfzDklkmT1m5z734ss6JMzN9rNB3+RR7iS+F10D4/BVIaXOyh8PQKw==",
       "dev": true,
       "requires": {
         "async": "^3.2.6",
@@ -22221,15 +22221,15 @@
       },
       "dependencies": {
         "browserslist": {
-          "version": "4.24.4",
-          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz",
-          "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==",
+          "version": "4.24.5",
+          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.5.tgz",
+          "integrity": "sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==",
           "dev": true,
           "requires": {
-            "caniuse-lite": "^1.0.30001688",
-            "electron-to-chromium": "^1.5.73",
+            "caniuse-lite": "^1.0.30001716",
+            "electron-to-chromium": "^1.5.149",
             "node-releases": "^2.0.19",
-            "update-browserslist-db": "^1.1.1"
+            "update-browserslist-db": "^1.1.3"
           }
         },
         "picocolors": {
@@ -22951,9 +22951,9 @@
       },
       "dependencies": {
         "bn.js": {
-          "version": "4.12.1",
-          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
-          "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
+          "version": "4.12.2",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+          "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==",
           "dev": true
         }
       }
@@ -24555,15 +24555,15 @@
       },
       "dependencies": {
         "browserslist": {
-          "version": "4.24.4",
-          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz",
-          "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==",
+          "version": "4.24.5",
+          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.5.tgz",
+          "integrity": "sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==",
           "dev": true,
           "requires": {
-            "caniuse-lite": "^1.0.30001688",
-            "electron-to-chromium": "^1.5.73",
+            "caniuse-lite": "^1.0.30001716",
+            "electron-to-chromium": "^1.5.149",
             "node-releases": "^2.0.19",
-            "update-browserslist-db": "^1.1.1"
+            "update-browserslist-db": "^1.1.3"
           }
         },
         "picocolors": {

src/components/question-info.vue

@@ -22,8 +22,8 @@
       </div>
 
       <el-dialog title="答题卡" :visible.sync="openAnswerFlag" width="30%">
-        <template v-for="(question, index) in questionAnswerDataList">
-          <el-button :key="++index" size="medium" @click="selectQuestion(index)" circle>{{index}}</el-button>
+        <template >
+          <el-button v-for="(question, index) in questionAnswerDataList" :key="++index" size="medium" @click="selectQuestion(index)" circle>{{index}}</el-button>
         </template>
       </el-dialog>
 
@@ -186,17 +186,18 @@
               </div>
             </el-step>
           </el-steps>
-          <div>
+          <!-- <div>
             <el-button icon="el-icon-discover" size="small" type="success">AI助手</el-button>
-          </div>
+          </div> -->
+          <br/>
           <el-col :span="24" v-if="active==0">
             <el-form-item class="cust-label">
 
-              <el-input type="textarea" class="custom-height" v-model="form.p" placeholder="`根据目标准确地描述问题。要求：
+              <el-input type="textarea" class="custom-height" v-model="form.p" placeholder="根据目标准确地描述问题。要求：
 1.功能描述准确。问题需求描述与目标一致，无偏差或遗漏。
 2.术语表达规范。正确使用数据结构与算法的专业术语，避免口语化表达，符合计算机学科表述规范。
 3.上下文抽象。能剔除无关背景信息，保留与问题相关的关键上下文，对复杂问题进行抽象精炼表达。
-4.接口定义清晰。输入/输出参数类型、范围、约束条件明确定义，函数/方法接口设计符合模块化原则。`"></el-input>
+4.接口定义清晰。输入/输出参数类型、范围、约束条件明确定义，函数/方法接口设计符合模块化原则。"></el-input>
             </el-form-item>
           </el-col>
 
@@ -242,7 +243,7 @@
             @click="()=>{active--}">上一步</el-button>
           <el-button icon="el-icon-arrow-right" size="small" type="primary" plain v-if="active<4"
             @click="onNext">下一步</el-button>
-          <el-button type="primary" @click="dialogVisible = false" size="small" v-if="active==4">提交</el-button>
+          <el-button type="primary" @click="onNext" size="small" v-if="active==4" >提交</el-button>
           <el-button @click="dialogVisible = false" size="small">取 消</el-button>
         </span>
       </el-dialog>
@@ -260,10 +261,9 @@
             <el-timeline-item v-for="(item,index) in aiTestItem" :timestamp="item.time" placement="top" :key="index">
               <el-card>
                 <h3>{{ item.title }}</h3>
-                <p style="color:blue;font-weight: bold;">达成度:{{item.process}}</p>
-                <br>
-                <p style="color:  blue;font-weight: bold;">AI解析:</p>
-                <p v-html="item.content"></p>
+                <p style="color:blue;font-weight: bold;">{{item.process}}</p>
+                <br> 
+                <p   v-html="item.content"></p>
               </el-card>
             </el-timeline-item>
           </el-timeline>
@@ -272,68 +272,25 @@
         <span slot="footer" class="dialog-footer" v-if="aiTestClass=='el-icon-reading'">
           <el-button icon="el-icon-arrow-right" size="small" type="primary" plain v-if="active<4"
             @click="()=>{active++;dialogResultVisible = false;}">下一步</el-button>
-          <!-- <el-button type="primary" @click="dialogVisible = false" size="small" v-if="active==4">提交</el-button> -->
-          <el-button @click="dialogResultVisible = false" size="small">修改评估方案</el-button>
+            <!-- <el-button icon="el-icon-arrow-right" size="small" type="primary" plain v-else-if="active==4"
+            @click="()=>{active++;dialogResultVisible = false;}">提交</el-button> -->
+          <el-button type="primary" @click="()=>{dialogResultVisible = false;dialogVisible = false}" size="small" v-else-if="active==4">提交</el-button>
+          <el-button @click="dialogResultVisible = false" size="small">修改</el-button>
           <el-button @click="()=>{dialogResultVisible = false; active=0;}" size="small">重新答题</el-button>
         </span>
       </el-dialog>
     </template>
-  </div>
-  </div>
-  </div>
+  </div> 
 </template>
 
 <script>
 import { getDictValueByType } from '../api/dict'
-let thisPage = null
 
-let items = [
-  "P(描述问题)",
-  "S(拆解问题)",
-  "R(结果)",
-]
-
-let evalItems = [];
-evalItems.push({c:"<div><strong>功能描述准确（5/5）：</strong>汉诺塔问题是给定三根柱子（通常设为源柱 A、辅助柱 B、目标柱 C）和若干个大小不同的圆盘，初始时圆盘按从大到小顺序叠放在源柱 A 上。要求将所有圆盘从源柱 A 借助辅助柱 B 移动到目标柱 C 上，并且在移动过程中，每次只能移动一个圆盘，且任何时刻大圆盘不能放在小圆盘上面。目标是通过算法实现对圆盘移动过程的模拟并输出每一步的移动操作。</div>" +
-  "<div><strong>术语表达规范（4/5）：</strong> 在描述中准确使用了 “柱子”“圆盘”“递归”（在后续解决中会用到递归思想）等专业术语，无口语化表达，符合计算机学科对于这类逻辑问题的表述规范。比如描述移动规则 “每次只能移动一个圆盘，且任何时刻大圆盘不能放在小圆盘上面。</div>" +
-  "<div><strong>上下文抽象（4/5）：</strong> 剔除了如汉诺塔问题的起源等无关背景信息，保留了核心要素：三根柱子（源柱、辅助柱、目标柱）、若干圆盘、移动规则（每次移动一个圆盘，大圆盘不能在小圆盘上面）以及最终要达成的目标（将圆盘从源柱移动到目标柱），对问题进行了抽象精炼表达。</div>" +
-  "<div><strong>接口定义清晰（4/5）：</strong> 输入：圆盘的数量 n（n 为正整数，表示圆盘的个数），源柱标识（如字符 'A' 表示源柱），辅助柱标识（如字符 'B' 表示辅助柱），目标柱标识（如字符 'C' 表示目标柱）。</div>" +
-  "输出：每一步圆盘的移动操作，例如 “将圆盘从 A 柱移动到 C 柱”。<br/>" +
-  "约束条件：圆盘数量 n >= 1，柱子标识为合法的字符表示（如 'A'、'B'、'C'） ，函数设计符合模块化原则，将移动操作封装成一个函数便于调用和复用。</div>",p:"(17/20)"})
-
-evalItems.push({c:"<div><strong>拆解维度合理（4/5）：</strong> 汉诺塔问题是一个递归结构的问题，可按流程进行拆解。" +
-  "<br/>首先，考虑递归终止条件，当只有一个圆盘时，直接将其从源柱移动到目标柱。" +
-  "<br/>然后，对于多个圆盘的情况，可将其分解为三个子问题：\n" +
-  "<br/>&nbsp;&nbsp;把 n-1 个圆盘从源柱借助目标柱移动到辅助柱。\n" +
-  "<br/>&nbsp;&nbsp;把第 n 个（最大的）圆盘从源柱移动到目标柱。\n" +
-  "<br/>&nbsp;&nbsp;把 n-1 个圆盘从辅助柱借助源柱移动到目标柱。\n" +
-  "<br/>这种拆解方式符合递归问题的解决思路，将复杂问题逐步简化为更小的相同子问题。</div>" +
-  "<div><strong>逻辑结构完整（3/5）：</strong> 上述拆解覆盖了汉诺塔问题的所有关键部分。递归终止条件（只有一个圆盘时直接移动）明确，移动过程包含了对多个圆盘情况的处理，通过递归调用实现了整体的移动逻辑，涵盖了将圆盘从源柱借助辅助柱移动到目标柱的整个过程。</div>" +
-  "<div><strong>颗粒度适中（3/5）：</strong>" +
-  "将汉诺塔问题拆解为递归终止条件和递归步骤两部分，对于已知递归概念的人来说，这种拆解符合认知逻辑。对于未认知递归的人来说，递归终止条件和递归步骤都是单一性问题，可以分别理解和掌握，颗粒度较为合适。",p:"(10/15)"});
-
-evalItems.push({c:"<div><pre>public class Hanoi {\n" +
-  "    public static void hanoi(int n, char source, char auxiliary, char target) {\n" +
-  "        if (n == 1) {\n" +
-  "            System.out.println(\"将圆盘从 \" + source + \" 柱移动到 \" + target + \" 柱\");\n" +
-  "            return;\n" +
-  "        }\n" +
-  "        hanoi(n - 1, source, target, auxiliary);\n" +
-  "        System.out.println(\"将圆盘从 \" + source + \" 柱移动到 \" + target + \" 柱\");\n" +
-  "        hanoi(n - 1, auxiliary, source, target);\n" +
-  "    }\n" +
-  "\n" +
-  "    public static void main(String[] args) {\n" +
-  "        int n = 3;\n" +
-  "        hanoi(n, 'A', 'B', 'C');\n" +
-  "    }\n" +
-  "} \n" +
-  "\n" +
-  "# 测试\n" +
-  "n = 3\n" +
-  "hanoi(n, 'A', 'B', 'C')\n" +
-  "以上代码通过递归函数 hanoi 实现了汉诺塔问题的求解，输出了每一步圆盘的移动操作，是最终可执行的代码，满足有效性要求。</pre></div>",p:"(75/100)"});
+import { mockAI,steps } from '../mock/gpsren';
+let thisPage = null
 
+let stepMapToCnt = {}
+ 
 export default {
   name: 'question-info',
   props: {
@@ -424,38 +381,42 @@ export default {
   methods: {
 
     onNext() {
-      if (this.active == 3) {
+      //下一步，即时AI评价
+
+     
         //弹出AI验证界面
         this.aiTestItem.length = 0
         this.dialogResultVisible = true
         this.aiTestClass = "el-icon-loading"
         let i = 0
 
+        let step = steps[this.active]
+        stepMapToCnt[step] = stepMapToCnt[step] || 0
+        
         let run = () => {
           let st = setTimeout(() => {
             let ts =  new Date().toLocaleString()
             let p = Math.floor(50 + Math.random() * 40)
+            let data = mockAI[step][stepMapToCnt[step]]
             this.aiTestItem.push({
-              title: items[i],
-              process: evalItems[i].p,
-              content: evalItems[i].c,
+              title: data.title,
+              process: data.aires.p,
+              content: data.aires.c,
               time: ts
             })
-
-            if(i<2) {
-              run()
-            }  else {
-              this.aiTestClass = "el-icon-reading"
+            this.aiTestClass = "el-icon-reading"
+            stepMapToCnt[step]++
+            if(stepMapToCnt[step]>1){
+              stepMapToCnt[step] = 1
             }
-            i++
           }, 2000)
         }
 
         run()
-
-      } else {
-        this.active++
-      }
+      // if (this.active == 3) {
+      // } else {
+      //   this.active++
+      // }
     },
 
     changeQuestionIndex(index) {
@@ -740,4 +701,22 @@ export default {
     color: skyblue;
   }
 }
+
+
+.typing-effect {
+  overflow: hidden; /* 确保超出部分的内容不显示 */
+  border-right: .15em solid orange; /* 光标效果 */
+  white-space: nowrap; /* 防止文本换行 */
+  animation: typing 3s steps(20, end), blink-caret .75s step-end infinite;
+}
+ 
+@keyframes typing {
+  from { width: 0 }
+  to { width: 100% }
+}
+ 
+@keyframes blink-caret {
+  from, to { border-color: transparent }
+  50% { border-color: orange }
+}
 </style>

src/mock/gpsren.js

@@ -0,0 +1,200 @@
+const steps = ["P", "S", "R", "E", "N"]
+const mockAI = {
+    "P": [{
+
+        //第一次回答
+        "title": "P(描述问题)",
+        "prompt": "",
+
+        //这个回答不够专业的得分
+        "aires": {
+            "c": `<p style=\"color:  blue;font-weight: bold;\">AI解析:</p><div><strong>功能描述不准确（0/5）：</strong>汉诺塔本质上是一个经典的递归算法问题，而非 “心理学实验研究问题”。汉诺塔主要是通过递归方法，实现将n个大小不同且有特定放置规则（大盘在下、小盘在上）的圆盘从起始柱借助中间柱移动到目标柱，每次只能移动一个圆盘且大盘不能放在小盘上面。原描述中 “主要是解决的是三个柱子排序的问题” 表述不准确，它不是简单的柱子排序，而是圆盘的移动操作。
+                    <div><strong>术语表达不规范（1/5）：</strong>没有正确使用数据结构与算法的专业术语，整体表述较为口语化。应准确使用如 “递归”“输入参数”“输出参数” 等专业术语来描述问题。
+                    <div><strong>上下文抽象不足（1/5）：</strong> 没有剔除无关背景信息（“汉诺塔是一个心理学实验研究问题” 属于错误且无关的信息），也没有对问题进行很好的抽象精炼表达。应突出汉诺塔问题中圆盘移动的核心内容，如圆盘数量、移动规则等关键信息。
+                    <div><strong>接口定义不清晰（2/5）：</strong>“输入 3 个柱子的盘子数量，输出符合汉诺塔要求的程序”，没有明确定义输入参数的类型、范围、约束条件，也没有说明输出的具体格式要求（如输出移动步骤等），不符合模块化原则。应该清晰地定义输入的圆盘数量（整数且大于等于 1）、各柱子的标识（字符串且互不相同），输出是通过打印操作输出圆盘的移动步骤等内容。
+                    <div>综上，需要对上述内容进行整体的修改和完善，使其功能描述准确、术语表达规范、上下文抽象精炼、接口定义清晰</div>`,
+            "p": "达成度:(4/20)"
+        }
+    }, {
+
+        //第二次回答
+        "title": "P(描述问题)",
+        "prompt": "",
+
+        //这个是回答正确的描述，赋值
+        "aires": {
+            "c": `<p style=\"color:  blue;font-weight: bold;\">AI解析:</p><div><strong>功能描述不准确（0/5）：</strong>汉诺塔本质上是一个经典的递归算法问题，而非 “心理学实验研究问题”。汉诺塔主要是通过递归方法，实现将n个大小不同且有特定放置规则（大盘在下、小盘在上）的圆盘从起始柱借助中间柱移动到目标柱，每次只能移动一个圆盘且大盘不能放在小盘上面。原描述中 “主要是解决的是三个柱子排序的问题” 表述不准确，它不是简单的柱子排序，而是圆盘的移动操作。
+            <div><strong>术语表达不规范（1/5）：</strong>没有正确使用数据结构与算法的专业术语，整体表述较为口语化。应准确使用如 “递归”“输入参数”“输出参数” 等专业术语来描述问题。
+            <div><strong>上下文抽象不足（1/5）：</strong> 没有剔除无关背景信息（“汉诺塔是一个心理学实验研究问题” 属于错误且无关的信息），也没有对问题进行很好的抽象精炼表达。应突出汉诺塔问题中圆盘移动的核心内容，如圆盘数量、移动规则等关键信息。
+            <div><strong>接口定义不清晰（2/5）：</strong>“输入 3 个柱子的盘子数量，输出符合汉诺塔要求的程序”，没有明确定义输入参数的类型、范围、约束条件，也没有说明输出的具体格式要求（如输出移动步骤等），不符合模块化原则。应该清晰地定义输入的圆盘数量（整数且大于等于 1）、各柱子的标识（字符串且互不相同），输出是通过打印操作输出圆盘的移动步骤等内容。
+            <div>综上，需要对上述内容进行整体的修改和完善，使其功能描述准确、术语表达规范、上下文抽象精炼、接口定义清晰</div>`,
+            "p": "达成度:(4/20)"
+        }
+    }],
+    "S": [{
+
+        //第一次回答
+        "title": "S(拆解问题)",
+        "prompt": "",
+
+        //这个回答不够专业的得分
+        "aires": {
+            c: "<p style=\"color:  blue;font-weight: bold;\">AI解析:</p><div><strong>拆解维度合理（4/5）：</strong> 汉诺塔问题是一个递归结构的问题，可按流程进行拆解。" +
+                "<br/>首先，考虑递归终止条件，当只有一个圆盘时，直接将其从源柱移动到目标柱。" +
+                "<br/>然后，对于多个圆盘的情况，可将其分解为三个子问题：\n" +
+                "<br/>&nbsp;&nbsp;把 n-1 个圆盘从源柱借助目标柱移动到辅助柱。\n" +
+                "<br/>&nbsp;&nbsp;把第 n 个（最大的）圆盘从源柱移动到目标柱。\n" +
+                "<br/>&nbsp;&nbsp;把 n-1 个圆盘从辅助柱借助源柱移动到目标柱。\n" +
+                "<br/>这种拆解方式符合递归问题的解决思路，将复杂问题逐步简化为更小的相同子问题。</div>" +
+                "<div><strong>逻辑结构完整（3/5）：</strong> 上述拆解覆盖了汉诺塔问题的所有关键部分。递归终止条件（只有一个圆盘时直接移动）明确，移动过程包含了对多个圆盘情况的处理，通过递归调用实现了整体的移动逻辑，涵盖了将圆盘从源柱借助辅助柱移动到目标柱的整个过程。</div>" +
+                "<div><strong>颗粒度适中（3/5）：</strong>" +
+                "将汉诺塔问题拆解为递归终止条件和递归步骤两部分，对于已知递归概念的人来说，这种拆解符合认知逻辑。对于未认知递归的人来说，递归终止条件和递归步骤都是单一性问题，可以分别理解和掌握，颗粒度较为合适。", p: "达成度:(10/15)"
+        }
+    }, {
+
+        //第二次回答
+        "title": "S(拆解问题)",
+        "prompt": "",
+
+        //这个是回答正确的描述，赋值
+        "aires": {
+            c: "<p style=\"color:  blue;font-weight: bold;\">AI解析:</p><div><strong>拆解维度合理（4/5）：</strong> 汉诺塔问题是一个递归结构的问题，可按流程进行拆解。" +
+                "<br/>首先，考虑递归终止条件，当只有一个圆盘时，直接将其从源柱移动到目标柱。" +
+                "<br/>然后，对于多个圆盘的情况，可将其分解为三个子问题：\n" +
+                "<br/>&nbsp;&nbsp;把 n-1 个圆盘从源柱借助目标柱移动到辅助柱。\n" +
+                "<br/>&nbsp;&nbsp;把第 n 个（最大的）圆盘从源柱移动到目标柱。\n" +
+                "<br/>&nbsp;&nbsp;把 n-1 个圆盘从辅助柱借助源柱移动到目标柱。\n" +
+                "<br/>这种拆解方式符合递归问题的解决思路，将复杂问题逐步简化为更小的相同子问题。</div>" +
+                "<div><strong>逻辑结构完整（3/5）：</strong> 上述拆解覆盖了汉诺塔问题的所有关键部分。递归终止条件（只有一个圆盘时直接移动）明确，移动过程包含了对多个圆盘情况的处理，通过递归调用实现了整体的移动逻辑，涵盖了将圆盘从源柱借助辅助柱移动到目标柱的整个过程。</div>" +
+                "<div><strong>颗粒度适中（3/5）：</strong>" +
+                "将汉诺塔问题拆解为递归终止条件和递归步骤两部分，对于已知递归概念的人来说，这种拆解符合认知逻辑。对于未认知递归的人来说，递归终止条件和递归步骤都是单一性问题，可以分别理解和掌握，颗粒度较为合适。", p: "达成度:(10/15)"
+        }
+    }],
+    "R": [{
+
+        //第一次回答
+        "title": "R(结果)",
+        "prompt": "",
+
+        //这个回答不够专业的得分
+        "aires": {
+            c: "<p style=\"color:  blue;font-weight: bold;\">结果参考:</p><div><pre>public class Hanoi {\n" +
+                "    public static void hanoi(int n, char source, char auxiliary, char target) {\n" +
+                "        if (n == 1) {\n" +
+                "            System.out.println(\"将圆盘从 \" + source + \" 柱移动到 \" + target + \" 柱\");\n" +
+                "            return;\n" +
+                "        }\n" +
+                "        hanoi(n - 1, source, target, auxiliary);\n" +
+                "        System.out.println(\"将圆盘从 \" + source + \" 柱移动到 \" + target + \" 柱\");\n" +
+                "        hanoi(n - 1, auxiliary, source, target);\n" +
+                "    }\n" +
+                "\n" +
+                "    public static void main(String[] args) {\n" +
+                "        int n = 3;\n" +
+                "        hanoi(n, 'A', 'B', 'C');\n" +
+                "    }\n" +
+                "} \n" +
+                "\n" +
+                "# 测试\n" +
+                "n = 3\n" +
+                "hanoi(n, 'A', 'B', 'C')\n" +
+                "以上代码通过递归函数 hanoi 实现了汉诺塔问题的求解，输出了每一步圆盘的移动操作，是最终可执行的代码，满足有效性要求。</pre></div>", p: ""
+        }
+    }, {
+
+        //第二次回答
+        "title": "R(结果)",
+        "prompt": "",
+
+        //这个是回答正确的描述，赋值
+        "aires": {
+            c: "<p style=\"color:  blue;font-weight: bold;\">结果参考:</p><div><pre>public class Hanoi {\n" +
+                "    public static void hanoi(int n, char source, char auxiliary, char target) {\n" +
+                "        if (n == 1) {\n" +
+                "            System.out.println(\"将圆盘从 \" + source + \" 柱移动到 \" + target + \" 柱\");\n" +
+                "            return;\n" +
+                "        }\n" +
+                "        hanoi(n - 1, source, target, auxiliary);\n" +
+                "        System.out.println(\"将圆盘从 \" + source + \" 柱移动到 \" + target + \" 柱\");\n" +
+                "        hanoi(n - 1, auxiliary, source, target);\n" +
+                "    }\n" +
+                "\n" +
+                "    public static void main(String[] args) {\n" +
+                "        int n = 3;\n" +
+                "        hanoi(n, 'A', 'B', 'C');\n" +
+                "    }\n" +
+                "} \n" +
+                "\n" +
+                "# 测试\n" +
+                "n = 3\n" +
+                "hanoi(n, 'A', 'B', 'C')\n" +
+                "以上代码通过递归函数 hanoi 实现了汉诺塔问题的求解，输出了每一步圆盘的移动操作，是最终可执行的代码，满足有效性要求。</pre></div>", p: ""
+        }
+    }],
+    "E": [{
+
+        //第一次回答
+        "title": "E(评估方案)",
+        "prompt": "",
+
+        //这个回答不够专业的得分
+        "aires": {
+            "c": `<p style=\"color:  blue;font-weight: bold;\">结果参考:</p><div><strong>功能描述不准确（0/5）：</strong>汉诺塔本质上是一个经典的递归算法问题，而非 “心理学实验研究问题”。汉诺塔主要是通过递归方法，实现将n个大小不同且有特定放置规则（大盘在下、小盘在上）的圆盘从起始柱借助中间柱移动到目标柱，每次只能移动一个圆盘且大盘不能放在小盘上面。原描述中 “主要是解决的是三个柱子排序的问题” 表述不准确，它不是简单的柱子排序，而是圆盘的移动操作。
+                    <div><strong>术语表达不规范（1/5）：</strong>没有正确使用数据结构与算法的专业术语，整体表述较为口语化。应准确使用如 “递归”“输入参数”“输出参数” 等专业术语来描述问题。
+                    <div><strong>上下文抽象不足（1/5）：</strong> 没有剔除无关背景信息（“汉诺塔是一个心理学实验研究问题” 属于错误且无关的信息），也没有对问题进行很好的抽象精炼表达。应突出汉诺塔问题中圆盘移动的核心内容，如圆盘数量、移动规则等关键信息。
+                    <div><strong>接口定义不清晰（2/5）：</strong>“输入 3 个柱子的盘子数量，输出符合汉诺塔要求的程序”，没有明确定义输入参数的类型、范围、约束条件，也没有说明输出的具体格式要求（如输出移动步骤等），不符合模块化原则。应该清晰地定义输入的圆盘数量（整数且大于等于 1）、各柱子的标识（字符串且互不相同），输出是通过打印操作输出圆盘的移动步骤等内容。
+                    <div>综上，需要对上述内容进行整体的修改和完善，使其功能描述准确、术语表达规范、上下文抽象精炼、接口定义清晰</div>`,
+            "p": ""
+        }
+    }, {
+
+        //第二次回答
+        "title": "E(评估方案)",
+        "prompt": "",
+
+        //这个是回答正确的描述，赋值
+        "aires": {
+            "c": `<p style=\"color:  blue;font-weight: bold;\">结果参考:</p><div><strong>功能描述不准确（0/5）：</strong>汉诺塔本质上是一个经典的递归算法问题，而非 “心理学实验研究问题”。汉诺塔主要是通过递归方法，实现将n个大小不同且有特定放置规则（大盘在下、小盘在上）的圆盘从起始柱借助中间柱移动到目标柱，每次只能移动一个圆盘且大盘不能放在小盘上面。原描述中 “主要是解决的是三个柱子排序的问题” 表述不准确，它不是简单的柱子排序，而是圆盘的移动操作。
+            <div><strong>术语表达不规范（1/5）：</strong>没有正确使用数据结构与算法的专业术语，整体表述较为口语化。应准确使用如 “递归”“输入参数”“输出参数” 等专业术语来描述问题。
+            <div><strong>上下文抽象不足（1/5）：</strong> 没有剔除无关背景信息（“汉诺塔是一个心理学实验研究问题” 属于错误且无关的信息），也没有对问题进行很好的抽象精炼表达。应突出汉诺塔问题中圆盘移动的核心内容，如圆盘数量、移动规则等关键信息。
+            <div><strong>接口定义不清晰（2/5）：</strong>“输入 3 个柱子的盘子数量，输出符合汉诺塔要求的程序”，没有明确定义输入参数的类型、范围、约束条件，也没有说明输出的具体格式要求（如输出移动步骤等），不符合模块化原则。应该清晰地定义输入的圆盘数量（整数且大于等于 1）、各柱子的标识（字符串且互不相同），输出是通过打印操作输出圆盘的移动步骤等内容。
+            <div>综上，需要对上述内容进行整体的修改和完善，使其功能描述准确、术语表达规范、上下文抽象精炼、接口定义清晰</div>`,
+            "p": ""
+        }
+    }],
+    "N": [{
+
+        //第一次回答
+        "title": "N(补充了什么新知识)",
+        "prompt": "",
+
+        //这个回答不够专业的得分
+        "aires": {
+            "c": `<p style=\"color:  blue;font-weight: bold;\">结果参考:</p><div><strong>功能描述不准确（0/5）：</strong>汉诺塔本质上是一个经典的递归算法问题，而非 “心理学实验研究问题”。汉诺塔主要是通过递归方法，实现将n个大小不同且有特定放置规则（大盘在下、小盘在上）的圆盘从起始柱借助中间柱移动到目标柱，每次只能移动一个圆盘且大盘不能放在小盘上面。原描述中 “主要是解决的是三个柱子排序的问题” 表述不准确，它不是简单的柱子排序，而是圆盘的移动操作。
+                    <div><strong>术语表达不规范（1/5）：</strong>没有正确使用数据结构与算法的专业术语，整体表述较为口语化。应准确使用如 “递归”“输入参数”“输出参数” 等专业术语来描述问题。
+                    <div><strong>上下文抽象不足（1/5）：</strong> 没有剔除无关背景信息（“汉诺塔是一个心理学实验研究问题” 属于错误且无关的信息），也没有对问题进行很好的抽象精炼表达。应突出汉诺塔问题中圆盘移动的核心内容，如圆盘数量、移动规则等关键信息。
+                    <div><strong>接口定义不清晰（2/5）：</strong>“输入 3 个柱子的盘子数量，输出符合汉诺塔要求的程序”，没有明确定义输入参数的类型、范围、约束条件，也没有说明输出的具体格式要求（如输出移动步骤等），不符合模块化原则。应该清晰地定义输入的圆盘数量（整数且大于等于 1）、各柱子的标识（字符串且互不相同），输出是通过打印操作输出圆盘的移动步骤等内容。
+                    <div>综上，需要对上述内容进行整体的修改和完善，使其功能描述准确、术语表达规范、上下文抽象精炼、接口定义清晰</div>`,
+            "p": ""
+        }
+    }, {
+
+        //第二次回答
+        "title": "N(补充了什么新知识)",
+        "prompt": "",
+
+        //这个是回答正确的描述，赋值
+        "aires": {
+            "c": `<p style=\"color:  blue;font-weight: bold;\">结果参考:</p><div><strong>功能描述不准确（0/5）：</strong>汉诺塔本质上是一个经典的递归算法问题，而非 “心理学实验研究问题”。汉诺塔主要是通过递归方法，实现将n个大小不同且有特定放置规则（大盘在下、小盘在上）的圆盘从起始柱借助中间柱移动到目标柱，每次只能移动一个圆盘且大盘不能放在小盘上面。原描述中 “主要是解决的是三个柱子排序的问题” 表述不准确，它不是简单的柱子排序，而是圆盘的移动操作。
+            <div><strong>术语表达不规范（1/5）：</strong>没有正确使用数据结构与算法的专业术语，整体表述较为口语化。应准确使用如 “递归”“输入参数”“输出参数” 等专业术语来描述问题。
+            <div><strong>上下文抽象不足（1/5）：</strong> 没有剔除无关背景信息（“汉诺塔是一个心理学实验研究问题” 属于错误且无关的信息），也没有对问题进行很好的抽象精炼表达。应突出汉诺塔问题中圆盘移动的核心内容，如圆盘数量、移动规则等关键信息。
+            <div><strong>接口定义不清晰（2/5）：</strong>“输入 3 个柱子的盘子数量，输出符合汉诺塔要求的程序”，没有明确定义输入参数的类型、范围、约束条件，也没有说明输出的具体格式要求（如输出移动步骤等），不符合模块化原则。应该清晰地定义输入的圆盘数量（整数且大于等于 1）、各柱子的标识（字符串且互不相同），输出是通过打印操作输出圆盘的移动步骤等内容。
+            <div>综上，需要对上述内容进行整体的修改和完善，使其功能描述准确、术语表达规范、上下文抽象精炼、接口定义清晰</div>`,
+            "p": ""
+        }
+    }]
+}
+
+export {
+    steps, mockAI
+}