@getollie/cli 0.0.1

package/library/web_applications-education_learning/peer-competition-statistics-table-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 428,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Please help me create a webpage for a peer competition statistics table. It should display student names at the beginning, followed by statistics for each exam, and have the capability to save data when closed.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is a complete HTML structure with table implementation provided?",
+      "description": "Check if the HTML structure includes proper DOCTYPE, head, body sections, and a well-structured table with appropriate headers for student names and exam scores. Evaluate whether semantic HTML elements are used (like <thead>, <tbody>, and proper <th> elements). Score 0 if the basic table structure is missing, 5 if basic implementation exists but lacks semantic elements, 10 if fully implemented with semantic elements and proper structure.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the data management system properly implemented?",
+      "description": "Assess whether the code includes functionality to add, edit, and delete student records and exam scores. Check if the implementation allows for flexible addition of new exams. Deduct 5 points if editing functionality is missing, 3 points if deletion capability is absent, and 2 points if adding new exams isn't supported. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data persistence mechanism correctly implemented?",
+      "description": "Evaluate whether localStorage or IndexedDB is properly used to save the table data when the page is closed, and whether data is correctly retrieved when the page is reopened. Check if error handling for storage quota limits or private browsing mode is implemented. Deduct 5 points if data isn't automatically saved on page close, 3 points if loading saved data is buggy, and 5 points if no error handling for storage failures exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are sorting and filtering capabilities implemented for the statistics table?",
+      "description": "Check if the table includes functionality to sort data by student name or exam scores (ascending/descending), and if filtering options are available for quickly finding specific students or score ranges. Deduct 5 points if sorting functionality is missing or incomplete, 3 points if no filtering options exist, and 2 points if these features aren't intuitive to use. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid input data, localStorage unavailability, concurrent edits by multiple users, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Visual statistics like charts/graphs 2. Color-coding for performance levels 3. Export functionality to CSV/Excel 4. Print optimized view). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple sorting algorithms) 2. Function modules unrelated to peer competition statistics (e.g., built-in games) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating data/view/controller layers), code reusability, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if variable/function naming is unclear or inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual jank during table interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/periodic-table-for-middle-school-chemistry.json

@@ -0,0 +1,68 @@
+{
+  "index": 314,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code for demonstration. Create an HTML code for teaching the periodic table of elements for middle school chemistry.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the periodic table structure fully implemented?",
+      "description": "Review whether the HTML code correctly represents the standard periodic table layout with all 118 elements positioned in their correct groups and periods. Check if the table maintains proper spacing and alignment between elements. Score 0 if elements are missing or misplaced, 5 if the basic structure is implemented but with minor positioning errors, and 10 if the periodic table structure is complete and accurately arranged.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the element details comprehensive and educationally appropriate?",
+      "description": "Evaluate whether each element includes essential information for middle school education: atomic number, symbol, name, atomic weight, and electron configuration. Check if information is presented in a clear hierarchy with appropriate technical detail for the middle school level. Deduct 5 points if key information is missing, 3 points if the detail level is inappropriate for middle schoolers. Give 10 points if comprehensive and age-appropriate.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are interactive features implemented for learning enhancement?",
+      "description": "Assess if the code includes interactive features that aid learning, such as element highlighting, pop-up information cards, filtering by element properties, or visual grouping by element categories. Deduct 5 points if no interactivity is implemented, 3 points if interactions are limited or buggy. Give 10 points for comprehensive, smooth, and educationally valuable interactions.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the periodic table visually coded for element categorization?",
+      "description": "Check if the code implements visual distinctions (colors, patterns, borders) to differentiate element categories (metals, non-metals, metalloids, noble gases, etc.) and if a legend is provided to explain these visual codes. Deduct 5 points if categories are not visually distinguished, 3 points if visual coding is present but confusing or lacks a legend. Give 10 points for clear, consistent, and educational visual categorization.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common issues (such as various screen sizes, browser compatibility, loading failures for resources) and provides fallbacks or graceful degradation. Code with strong robustness should work across modern browsers and accommodate different viewport sizes. Give 10 points for comprehensive robustness with responsive design, 5 points if partially robust, and 0 points if serious compatibility issues exist.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the learning experience (e.g., 1. Element comparison tool 2. Quiz/game components 3. Interactive electron configuration visualizations 4. 3D element models). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Overlapping information displayed multiple times unnecessarily 2. Features unrelated to chemistry education 3. Excessive animations or effects that distract from learning. Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with the educational purpose.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review code organization (semantic HTML structure, separation of concerns with CSS/JavaScript), maintainability, and performance optimization. Deduct 5 points if non-semantic div/span elements dominate the structure; deduct 5 points if CSS/JS is not separated from HTML; deduct 5 points if the code contains unnecessary dependencies or unoptimized resources. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional educational design standards?",
+      "description": "Evaluate whether the design follows educational interface principles: 1) Appropriate color contrast for readability (WCAG 2.1 AA compliance) 2) Clear visual hierarchy with primary information emphasized 3) Adequate white space for cognitive processing 4) Age-appropriate typography (sans-serif fonts, size ≥ 14px). Deduct 3 points for each readability issue, 5 points for poor contrast ratios, and 5 points for cluttered information architecture. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the interactive learning experience effective and age-appropriate?",
+      "description": "Judge whether the interactive elements support middle school learning objectives: 1) Interactions teach scientific concepts rather than just entertain 2) Feedback is immediate and instructive 3) Progressive disclosure of complex information prevents cognitive overload. Deduct 5 points for interactions that don't support learning goals, 3 points for overly complex interactions beyond middle school comprehension, and 5 points for missing scaffolding in presenting information. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/personalized-learning-recommendation-website-vue-django-mysql.json

@@ -0,0 +1,68 @@
+{
+  "index": 1324,
+  "question": "You are a coding expert. Please use your professional knowledge to generate accurate, professional responses. Be sure that the code you provide is executable. Based on the content, help me build a personalized learning recommendation website powered by knowledge graphs from scratch, step by step. The frontend will use Vue, the backend will use the Django framework, and MySQL will serve as the database.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the knowledge graph construction and visualization fully implemented?",
+      "description": "Review whether the code accurately implements knowledge graph data modeling through Vue.js frontend and Django backend, including node/edge relationships, graph traversal algorithms, and interactive visualization components. Check if D3.js or similar libraries are properly integrated for graph rendering. Score 0 if core graph structure is missing, 5 if only basic nodes/edges are displayed, and 10 if complete interactive knowledge graph with search, filtering, and relationship exploration is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the personalized recommendation algorithm properly implemented?",
+      "description": "Evaluate whether the recommendation engine includes collaborative filtering, content-based filtering, or hybrid approaches. Check if user behavior tracking, learning path analysis, and preference modeling are implemented. Verify integration between Django models and recommendation logic. Deduct 5 points if only basic similarity matching is used, 3 points if real-time recommendation updates are missing. Full score requires sophisticated ML-based recommendations with A/B testing capability.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the full-stack architecture properly designed with Vue-Django-MySQL integration?",
+      "description": "Check whether the system follows proper RESTful API design between Vue frontend and Django backend, with appropriate serializers, viewsets, and routing. Evaluate MySQL database schema design for users, learning materials, knowledge entities, and relationships. Deduct 5 points if API versioning is missing, 3 points if database indexing is inadequate. Requires proper CORS handling, authentication middleware, and optimized query performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the learning progress tracking and analytics system complete?",
+      "description": "Verify implementation of user learning journey tracking, progress visualization, achievement systems, and learning analytics dashboard. Check if the system includes learning path optimization, completion rates, time-spent analytics, and adaptive difficulty adjustment. Deduct 5 points if progress persistence is not implemented, 3 points if analytics visualization is basic. Full score requires comprehensive learning insights with predictive analytics.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust and handles edge cases effectively?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid graph queries, failed API calls, database connection issues, malformed learning data, etc.) and provides friendly error prompts or recovery mechanisms. Code with strong robustness should include proper exception handling, input validation, and graceful degradation, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there innovative features that enhance the learning experience?",
+      "description": "Check whether the code includes compelling features that improve personalization (e.g., 1. AI-powered learning path generation 2. Social learning communities with peer recommendations 3. Adaptive content difficulty based on performance 4. Multi-modal content integration 5. Gamification elements). Add 2-3 points for each well-implemented innovative feature that demonstrates technical sophistication (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant or unnecessary features?",
+      "description": "Strictly check three types of redundancy: 1. Duplicate recommendation logic implementations 2. Unused Vue components or Django apps unrelated to learning recommendations 3. Over-engineered graph visualizations that impact performance without adding value. Deduct 3 points for each redundancy found, and directly deduct 10 points if core learning recommendation functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code demonstrate proper engineering quality and architecture?",
+      "description": "Review modular design separating concerns (Vue components, Django apps, database layers), proper state management (Vuex), API documentation, and testing coverage. Deduct 5 points if global state pollution is found or if Django best practices are ignored; deduct 5 points if code duplication rate exceeds 30%; deduct 5 points if no automated testing or CI/CD pipeline is implemented. Full score requires clean architecture with proper separation of concerns.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the user interface meet modern educational platform design standards?",
+      "description": "Evaluate whether the Vue.js frontend follows contemporary educational UX principles: 1) Intuitive navigation with clear learning paths 2) Accessible color contrast ratios (WCAG 2.1 AA compliance) 3) Responsive design across devices 4) Professional typography hierarchy with readable font sizes (≥14px body text). Deduct 3 points for each cluttered interface element, 5 points for poor accessibility, and 5 points for non-responsive layout components. Full score requires polished educational platform aesthetics.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the interactive elements smooth and provide excellent user experience?",
+      "description": "Judge whether dynamic interactions meet educational platform standards: 1) Knowledge graph navigation with smooth zoom/pan (60fps) 2) Recommendation updates with loading states ≤200ms 3) Form submissions with proper validation feedback 4) Search functionality with real-time suggestions 5) Progress indicators and achievement animations. Deduct 5 points for each laggy interaction, 3 points for missing loading states, and 5 points for confusing navigation flow. Full score requires seamless, intuitive learning experience.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "hard"
+}

package/library/web_applications-education_learning/pomodoro-diary-system-vue-springboot-mysql.json

@@ -0,0 +1,68 @@
+{
+  "index": 1273,
+  "question": "You are a code expert. Please utilize your professional knowledge to generate accurate and professional responses. Ensure that the code you generate is executable whenever possible. 2.2.1 Front-end Development Technology Overview:\n\n(1) WeChat Mini Program Development: As a lightweight application, WeChat Mini Programs allow users to directly use them within the WeChat environment without separate downloads. Developers can rely on the WeChat Mini Program framework, components, and APIs for efficient development, implementing interface construction and interactive functions. Through Mini Program development, users can conveniently perform campus second-hand transactions and life services operations within WeChat without switching to other applications.\n\nVue Framework Application: As a popular JavaScript framework, Vue is primarily used for creating user interfaces. Its application in web-based management system development enables developers to build interfaces quickly and efficiently. The Vue framework provides a series of components and directives that allow developers to easily implement various functions, while also offering reactive data binding and component-based development features, which are beneficial for code organization and maintenance. Now, based on the above content, please write about my Pomodoro diary system, which uses Vue, Spring Boot, and MySQL technologies.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Pomodoro timing system properly implemented in Vue?",
+      "description": "Examine whether the code correctly implements core Pomodoro functionality: 25-minute work periods, 5-minute short breaks, 15-minute long breaks after 4 work sessions. Check for visual countdown timer, progress indicators, and customizable time settings. Score 0 if the core timing mechanism is absent, 5 if basic timing exists but lacks configurability, and 10 if the implementation includes sound notifications, visual progress tracking, and allows user customization of time intervals.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the diary entry functionality properly connected to the Pomodoro system?",
+      "description": "Verify that completed Pomodoro sessions automatically prompt for diary entries or task completion notes. The system should record timestamps, duration, associated tasks, and completion status. Check if users can add reflections on productivity or notes about the completed work. Deduct 5 points if diary entries aren't linked to Pomodoro sessions, 3 points if entries lack metadata like timestamps or categories. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Spring Boot backend architecture properly designed with appropriate endpoints?",
+      "description": "Evaluate whether the API design follows RESTful principles with proper resource naming, HTTP methods (GET, POST, PUT, DELETE), and status codes. Check if controllers handle Pomodoro sessions, diary entries, user authentication, and data analytics endpoints. API versioning and documentation should be present. Deduct 5 points for missing authentication middleware, 3 points for inconsistent endpoint design patterns, and 5 points for poor error handling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the MySQL database schema optimized for the Pomodoro diary system?",
+      "description": "Review whether the database design includes appropriate tables (users, pomodoro_sessions, diary_entries, tasks, categories) with proper relationships and constraints. Evaluate if indexes are used for frequently queried fields, if normalization principles are followed, and if the schema supports analytics and reporting features. Deduct 5 points for missing foreign key relationships, 3 points for poor field type choices, and 5 points if data integrity constraints are inadequate. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption during a Pomodoro session, failed diary saves, authentication failures, etc.) and provide friendly error prompts or recovery mechanisms. Check if the application maintains state during browser refreshes. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Productivity analytics and visualizations 2. Intelligent task suggestions based on past performance 3. Focus mode with website blocking 4. Integration with calendar systems). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple timer implementations) 2. Function modules unrelated to Pomodoro/diary functionality (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive animations during focus time). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating frontend components, backend services, and data access layers), unit test coverage for critical timing logic and data persistence, and build process automation. Deduct 5 points if global state management is poorly implemented; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching that supports focus (calming colors during work periods, energizing colors during breaks) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for distracting color combinations during focus time, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Timer updates occur without visual jitter 2) Transition between work and break states is clear but not jarring 3) Diary entry forms appear with appropriate timing and smooth animations. Deduct 5 points for each operation without feedback, 3 points for laggy timer countdowns, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "hard"
+}

package/library/web_applications-education_learning/programming-teaching-website-with-editor.json

@@ -0,0 +1,68 @@
+{
+  "index": 687,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to make the generated code executable for demonstration. Design a programming teaching website that provides a code editor with real-time preview functionality. Users can write HTML, CSS, and JavaScript code online and view the running results on the same page in real time. The website needs to offer code highlighting, auto-completion, and syntax checking features. Implement a code saving function that allows users to create projects and return to continue editing at any time. The website should include a series of programming challenges, providing immediate feedback and suggestions for next steps in learning upon completion of each challenge.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the code editor implementation complete?",
+      "description": "Review whether the code implements a fully functional editor with key features: syntax highlighting (proper coloring for HTML, CSS, and JavaScript), auto-completion (suggests tags, properties, or functions), and syntax checking (real-time error detection). Score 0 if none of these features are implemented, 5 if only highlighting is present, and 10 if all three core features are properly implemented with accurate language detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the real-time preview functionality properly implemented?",
+      "description": "Evaluate the real-time preview mechanism. Check if changes in the editor are reflected in the preview without requiring manual refresh. Verify the preview works for all three languages (HTML structure, CSS styling, and JavaScript functionality). Deduct 3 points if there's a noticeable delay (>1s), 4 points if certain code types don't update properly, and 5 points if manual refresh is required. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the code saving and project management system functional?",
+      "description": "Check if the system allows users to save projects with appropriate metadata (title, description, timestamps), load previously saved projects, and automatically save changes (autosave). Evaluate if the solution includes proper state persistence (localStorage, database, or cloud storage). Deduct 4 points if there's no version history, 3 points if the autosave feature is missing, and 5 points if projects can't be organized or categorized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the programming challenges and learning path features implemented?",
+      "description": "Assess the quality and implementation of programming challenges. Check for: progression system with increasing difficulty, immediate feedback mechanisms that highlight errors or suggest improvements, and next-step learning recommendations. Deduct 4 points if challenges lack clear goals, 3 points if feedback is generic/unhelpful, and 5 points if there's no learning path progression. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid syntax input, network interruption during save, browser compatibility issues) and provide friendly error messages or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Multiple view modes like split/side-by-side/preview only 2. Social sharing of code snippets 3. Themes and personalization options 4. Collaborative editing features). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple code parsing libraries doing the same job) 2. Function modules unrelated to code editing and learning (e.g., a built-in game irrelevant to programming) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the editor). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating editor/preview/storage components), unit test coverage, and build process optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not optimized for performance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (editor and preview panels should have adequate proportions) 3) Professional font system (monospace fonts for code, appropriate contrast). Deduct 3 points for each cramped visual element, 5 points for a glaring color combination, and 5 points for poor visual hierarchy between editor and preview sections. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Typing feedback with no perceptible lag (<50ms) 2) Smooth transitions between different views/panels 3) Clear visual feedback for actions like saving, error detection, or challenge completion. Deduct 5 points for editor lag during typing, 3 points for jarring transitions between editor and preview, and 5 points for confusing or missing action feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/pyside6-flashcards-random-sequential-reverse-order.json

@@ -0,0 +1,68 @@
+{
+  "index": 1218,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Make sure that the code you generate is executable when possible. Create a software similar to Anki using PySide6, but without the spaced repetition scheduling - only include options for random, sequential, or reverse order.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core flashcard review functionality implemented?",
+      "description": "Review whether the code includes the essential flashcard functions: adding cards, viewing cards, flipping/revealing answers, and marking cards as correct/incorrect. The implementation should handle different card types (text, images) and support basic styling. Score 0 if there's no functional review system, 5 if only basic text cards are supported, and 10 if it includes multiple card types with proper navigation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the three required card ordering modes correctly implemented?",
+      "description": "Check if the application properly implements random, sequential, and reverse order card review modes. The random mode should use a proper randomization algorithm (not pseudo-random patterns), sequential should maintain deck order, and reverse should correctly invert the sequence. Deduct 3 points if any mode is missing, 5 points if the randomization has obvious patterns, and 3 points if mode switching causes state issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the card management system complete?",
+      "description": "Evaluate if the code provides comprehensive card management features including creating decks, adding/editing/deleting cards, organizing cards into categories/decks, and importing/exporting functionality. Deduct 5 points if editing capabilities are missing, 3 points if there's no export/import function, and 5 points if deck organization is insufficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is PySide6 utilized properly and effectively?",
+      "description": "Assess whether the implementation uses PySide6 components appropriately - proper use of widgets (QLabel, QPushButton, etc.), layouts (QVBoxLayout, QGridLayout, etc.), signals/slots mechanism for event handling, and style sheets for visual customization. Deduct 5 points for using direct Tkinter or other frameworks instead of PySide6, 3 points for poor widget hierarchy, and 3 points for not utilizing Qt's signal-slot mechanism. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid card formats, database corruption, file permission issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Card statistics and progress tracking 2. Custom card templates or formatting 3. Light/dark mode support). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to view statistics) 2. Function modules unrelated to flashcard review (e.g., a built-in calculator) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating card logic/UI/data persistence layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during transitions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}

package/library/web_applications-education_learning/qingdao-subway-map-vue2-canvas.json

@@ -0,0 +1,68 @@
+{
+  "index": 882,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure that the code you generate is executable for display. Create a Qingdao subway map of all lines using Vue2 and Canvas, making special markings for transfer stations. The map should be zoomable and scalable, with a background image that can also be zoomed and scaled. Place it in a container that is 1006px high and 500px wide.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the complete Qingdao subway map implemented with accurate line representation?",
+      "description": "Review whether the code accurately implements all subway lines in Qingdao with correct routes, station names, and line colors. Verify that the data structure properly represents the network topology. Score 0 if only partial lines are implemented, 5 if all lines are present but with minor inaccuracies, and 10 if the complete subway network is precisely rendered with proper geographical relationships.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are transfer stations properly highlighted and differentiated?",
+      "description": "Check whether transfer stations are visually distinguished from regular stations (e.g., different shapes, sizes, colors, or special markers). Verify that the code handles the logic for identifying intersecting lines and appropriately renders these transfer points. Deduct 5 points if transfer stations aren't visually differentiated, 3 points if the differentiation is subtle or inconsistent. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the zoom and scale functionality properly implemented?",
+      "description": "Evaluate if the Vue2/Canvas implementation includes smooth zooming and scaling capabilities with proper event handling. Check for pinch-to-zoom support on touch devices, mouse wheel zoom for desktop, and intuitive scale controls. Deduct 5 points if zooming causes rendering artifacts, 3 points if zoom levels are limited or jerky. The code should maintain proper aspect ratios during scaling and preserve station relative positions. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the background image handling correct with zoom/scale synchronization?",
+      "description": "Verify that the background image scales and zooms in sync with the subway map overlay. Check if the image resolution adapts appropriately to different zoom levels without pixelation or blurring. Deduct 5 points if background-map synchronization is inconsistent during zoom operations, 3 points if image quality degrades significantly at higher zoom levels. Check that the background handles the required 1006px by 500px container constraints. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing data, browser compatibility issues, window resizing, touch/mouse input variations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Station information popups on hover/click 2. Animated train movements along routes 3. Interactive path finding between stations). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple zoom implementations coexisting) 2. Function modules unrelated to subway visualization (e.g., a built-in weather widget) 3. Fancy effects that affect performance (e.g., unnecessary animations or visual effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review Vue2 component architecture (such as separating map rendering/controls/data management), modular organization, and proper use of Vue lifecycle methods. Deduct 5 points if global state pollution is found or Vue best practices are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if canvas drawing operations are not optimized or if rendering performance suffers. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the subway map visualization follows transit map design principles: 1) Clear line distinction with appropriate color coding 2) Proper station labeling with legible typography (minimum 12px font size) 3) Professional layout with balanced station spacing and line angles (preferring 45° or 90° angles). Deduct 3 points for cluttered station labels, 5 points for poor color choices making lines difficult to distinguish, and 5 points for chaotic line routing that doesn't resemble standard transit map conventions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the map interactions conform to user expectations: 1) Responsive zoom controls with <100ms feedback 2) Smooth pan/drag operations without jitter 3) Appropriate animation durations (200-400ms) for transitions. Deduct 5 points for each operation with noticeable lag, 3 points for jerky animations during interactions, and 5 points for controls that are difficult to discover or use. Test if the map behaves correctly within the specified 1006px × 500px container across different screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "medium"
+}

package/library/web_applications-education_learning/random-name-caller-html-webpage-apple-style.json

@@ -0,0 +1,68 @@
+{
+  "index": 1803,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the generated code is executable for demonstration. Help me create a random name-calling HTML webpage with the following requirements: it should only identify names, include a start button, a pause button, and a reset button. I should be able to upload an xlsx format document which the system can recognize for the name-calling activity. The reset function should be able to loop, and the webpage style should emulate the Apple official website's design.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core name-calling functionality correctly implemented?",
+      "description": "Evaluate whether the code properly implements random name selection from the uploaded list. Check if the randomization algorithm ensures each name has equal probability of being selected and if the system prevents repetition until all names have been called. Score 0 if the core functionality is missing, 5 if basic random selection works but with flaws, 10 if the implementation is complete with proper randomization and non-repetition control.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the Excel (xlsx) file upload and parsing feature work properly?",
+      "description": "Assess the file upload mechanism and xlsx parsing implementation. Check if the code handles different Excel formats, properly extracts name data from various column structures, and provides clear feedback on successful upload. Deduct 5 points if the parser only works with specific Excel structures, 3 points if error handling is missing for malformed files, and 2 points if there's no visual feedback during the upload process. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are all required control buttons (start, pause, reset) implemented with proper functionality?",
+      "description": "Verify that all three buttons (start, pause, reset) are implemented with correct functionality. Start should begin the name-calling process, pause should temporarily halt it while preserving state, and reset should clear the current session and allow restarting. Deduct 3 points for each button with incorrect behavior, 2 points if the buttons lack proper state management (e.g., disabling start when already running). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the looping reset function properly implemented?",
+      "description": "Examine whether the reset function allows for proper looping through all names and restarting the process. Check if the system tracks which names have already been called and can properly reset this tracking. Score 0 if reset doesn't work, 5 if it resets but doesn't properly prepare for a new complete cycle, and 10 if it fully implements the looping functionality with clear state management.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid file uploads, empty name lists, rapid button clicking, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Animation effects when displaying selected names 2. Sound effects for selection process 3. Statistics tracking of selected names 4. Custom configuration options for selection speed or display style). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to reset the system) 2. Function modules unrelated to name-calling (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the interface). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic/file handling components), code organization, and maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation for key functions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet Apple's design standards?",
+      "description": "Evaluate whether the design authentically replicates Apple's official website aesthetic: 1) Clean, minimalist design with ample white space 2) San Francisco or similar font family with proper typography hierarchy 3) Subtle shadows and refined animations 4) High-quality imagery and icons. Deduct 3 points for each element that doesn't match Apple's design language, 5 points for inconsistent styling across components, and 5 points for poor responsive design. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to Apple's interaction patterns: 1) Subtle animations for state changes 2) Smooth transitions between different states 3) Immediate visual feedback for user actions 4) Accessible interface with proper focus states. Deduct 5 points for choppy animations, 3 points for delayed response to user input, and 5 points for missing transition effects between name selections. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Web Applications-Education/Learning",
+  "difficulty": "easy"
+}