@getollie/cli 0.0.4 → 0.2.0

package/library/data_science-statistical_analysis/demonstrate-process-deriving-pi-html.json

@@ -1,68 +0,0 @@
-{
-  "index": 1775,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for demonstration purposes. Demonstrate the process of deriving pi (π) in HTML.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the mathematical derivation of π correctly implemented?",
-      "description": "Review whether the code accurately implements at least one classical π derivation method (such as Monte Carlo simulation, Leibniz series, Machin formula, or geometric methods like inscribed/circumscribed polygons). Check if the mathematical logic is sound and the algorithm converges correctly. Score 0 if no valid π derivation method is implemented, 5 if only basic approximation without proper mathematical foundation, and 10 if multiple rigorous mathematical methods are correctly implemented with proper convergence analysis.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the step-by-step visualization process effectively demonstrated?",
-      "description": "Evaluate whether the HTML implementation provides clear visual representation of the π derivation process through interactive elements, animated sequences, or progressive displays. Check if intermediate steps, calculations, and convergence progress are visually presented. Deduct 5 points if only static results are shown without process visualization, and 3 points if the visualization lacks mathematical context or educational value. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is real-time calculation and accuracy tracking implemented?",
-      "description": "Check whether the system provides real-time computation with accuracy metrics, iteration counters, and error analysis. Evaluate if the implementation shows convergence rates, precision improvements, and comparison with the actual π value. Deduct 5 points if no accuracy tracking is provided, and 3 points if the precision analysis is superficial or mathematically incorrect. Give 10 points for comprehensive accuracy analysis with multiple precision indicators.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Are interactive controls and parameter adjustments provided?",
-      "description": "Assess whether the code includes user controls for adjusting calculation parameters (such as iteration counts, sample sizes, or precision levels) and provides interactive elements to explore different aspects of π derivation. Check if users can modify computational parameters and observe real-time changes. Deduct 5 points if no interactive controls are implemented, and 3 points if controls are present but don't significantly impact the demonstration. 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 parameters, computational overflow, division by zero, infinite loops, or browser performance limitations) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle edge cases and provide graceful degradation. Give 10 points for comprehensive error handling, 5 points for basic exception management, and 0 points if no exceptions are handled.",
-      "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 mathematical demonstration experience (e.g., 1. Comparison of multiple π derivation methods simultaneously 2. Historical timeline of π calculation milestones 3. Interactive geometric proofs with dynamic manipulation 4. Performance benchmarking across different algorithms). 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 calculation methods without clear distinction 2. Function modules unrelated to π derivation (e.g., unrelated mathematical calculators) 3. Overly complex animations that distract from the mathematical content. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core mathematical demonstration is interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating calculation logic/visualization/UI components), code organization, and performance optimization. Deduct 5 points if global state pollution is found or proper separation of concerns is not implemented; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if mathematical calculations are 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 suitable for mathematical content (no more than 3 primary colors) 2) Proper layout spacing with clear mathematical notation (element spacing follows the 8px multiple principle) 3) Professional typography with readable mathematical expressions (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for distracting color combinations that hinder mathematical readability, and 5 points for poorly formatted mathematical expressions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the mathematical demonstration follows smooth interaction principles: 1) Parameter adjustment feedback delay ≤ 100ms 2) Animation transitions for mathematical processes controlled between 300-500ms 3) Clear visual focus on current calculation steps 4) Smooth progression through derivation stages. Deduct 5 points for each operation without immediate feedback, 3 points for jarring transitions that break mathematical flow, and 5 points for unclear progression indicators in the derivation process. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Statistical Analysis",
-  "difficulty": "easy"
-}

package/library/data_science-statistical_analysis/design-complete-quantitative-factor-research-platform.json

@@ -1,68 +0,0 @@
-{
-  "index": 777,
-  "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 and properly displayed. Help me design a complete quantitative factor research platform, providing the full code. I store all my data in parquet format.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Data Import and Processing Pipeline",
-      "description": "Evaluate whether the platform implements a complete data processing pipeline for parquet files. Check for efficient loading mechanisms with parallel processing, data type validation, handling of missing values, and automatic schema detection. Verify if there's memory optimization for large datasets through streaming or chunking. Score 0 if basic parquet loading is missing, 5 if only simple reading is implemented, and 10 if a complete pipeline with optimization is present.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Factor Creation and Calculation Framework",
-      "description": "Review the implementation of factor creation tools. Check for a flexible API that allows custom factor definitions, vectorized operations, proper time series alignment, and cross-sectional normalization. Verify if the code includes performance tracking for calculation time. Deduct 5 points if the framework doesn't support customized factor expressions, 3 points if it lacks batch processing capabilities. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Backtesting Engine Quality",
-      "description": "Assess the robustness of the backtesting engine, including accurate position tracking, proper handling of transaction costs, dividend adjustments, and various rebalancing strategies. Check if it supports multiple portfolio construction methods and risk models. Deduct 5 points if look-ahead bias prevention is missing, 3 points if transaction cost models are oversimplified, and 2 points if it lacks support for position constraints. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Performance Analysis and Visualization Tools",
-      "description": "Evaluate the comprehensiveness of performance metrics calculation and visualization capabilities. Check for standard metrics (Sharpe, Sortino, drawdowns, etc.), factor exposure analysis, and interactive visualization tools. The system should offer both time-series and cross-sectional analysis views. Deduct 5 points if key performance metrics are missing, 5 points if visualizations are static-only with no interactivity, 3 points if correlation/regression analysis tools are absent. 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 corrupted parquet files, out-of-memory errors, numerical instabilities in calculations, etc.) and provide friendly error prompts or recovery mechanisms. Check for proper exception handling, input validation, and edge case management. 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. Auto-factor discovery algorithms 2. Machine learning integration for factor evaluation 3. Real-time data streaming capabilities 4. GPU acceleration for calculations). 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 implementations of similar analysis functions (e.g., multiple ways to calculate the same metric) 2. Function modules unrelated to quantitative research (e.g., unnecessary UI elements) 3. Computationally expensive features that affect performance without adding value. 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 (separation of data access, factor calculation, backtesting, and visualization layers), unit test coverage for critical components, and build process automation. Check for proper documentation, maintainable code structure, and performance optimizations. 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 dashboard and visualization designs follow modern data visualization principles: 1) Consistent color coding for metrics (no more than 5 primary colors) 2) Proper layout with clear information hierarchy 3) Professional typography with appropriate sizing for data displays. Check if interactive elements are clearly distinguishable and follow standard conventions. Deduct 3 points for cluttered visualizations, 5 points for misleading data representations (e.g., truncated axes), and 5 points for poor information density. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the platform's interactive elements perform well: 1) Calculation and filtering operations respond within 500ms for standard datasets 2) Transitions between views are smooth and logical 3) Interactive charts provide immediate feedback on hover/selection. Evaluate if large data operations employ progress indicators or asynchronous processing. Deduct 5 points for unresponsive interfaces during calculations, 3 points for jarring transitions between analysis views, and 5 points for confusing navigation patterns. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Statistical Analysis",
-  "difficulty": "hard"
-}

package/library/data_science-statistical_analysis/energy-water-consumption-heat-stations-chart-analysis.json

@@ -1,68 +0,0 @@
-{
-  "index": 1430,
-  "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. Design a chart to record and analyze the statistics of energy consumption and water consumption from multiple heat source stations.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the multi-source data collection and processing system fully implemented?",
-      "description": "Review whether the code accurately implements data collection interfaces for multiple heat source stations through APIs/WebSocket connections, and whether it includes real-time data validation, data normalization, and timestamp synchronization mechanisms. Score 0 if no data collection logic is implemented, 5 if only basic data fetching is present, and 10 if comprehensive data processing with error handling and data quality checks are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the energy and water consumption statistical analysis functions comprehensively implemented?",
-      "description": "Check whether the statistical analysis includes multiple dimensions: hourly/daily/monthly consumption trends, peak/off-peak analysis, efficiency ratios, comparative analysis between stations, and anomaly detection algorithms. Deduct 5 points if aggregation functions are missing, and 3 points if no trend analysis is provided. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the chart visualization system designed with professional data presentation capabilities?",
-      "description": "Evaluate whether the visualization system uses appropriate chart types (line charts for trends, bar charts for comparisons, heat maps for distribution patterns) with interactive features like zoom, filter, and drill-down capabilities. Deduct 5 points if chart types are inappropriate for data nature. Check whether real-time data updates are smoothly reflected in charts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete data persistence and historical analysis framework constructed?",
-      "description": "Check whether the code includes complete data storage mechanisms with efficient querying capabilities, historical data archiving, data export functionality (CSV/Excel/PDF), and backup/recovery systems. Deduct 5 points if no data persistence is implemented, and 3 points if historical data querying is inefficient (>3s response time). Give 10 points if fully implemented with optimized database indexing.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as network timeouts, invalid data formats, missing data points, API failures, 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. AI-powered consumption prediction models 2. Automated alert system for abnormal consumption patterns 3. Interactive dashboard with customizable widgets 4. Energy efficiency scoring system). 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 chart types (e.g., multiple line chart libraries coexisting) 2. Function modules unrelated to energy/water analysis (e.g., built-in games or social features) 3. Excessive visual effects that slow down data rendering (e.g., unnecessary 3D animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if core analytics 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 layer/business logic/presentation layers), unit test coverage for calculation functions, 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 dashboard design standards?",
-      "description": "Evaluate whether the dashboard design follows modern data visualization principles: 1) Harmonious color coding for different data types (no more than 5 primary colors) 2) Proper grid layout with consistent spacing (following 8px grid system) 3) Professional typography hierarchy (headers ≥ 16px, body text ≥ 14px, line height 1.4-1.6). Deduct 3 points for each cluttered visual element, 5 points for poor color contrast in charts, and 5 points for inconsistent visual hierarchy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the interactive elements conform to professional dashboard standards: 1) Chart loading and filtering response time ≤ 500ms 2) Smooth transitions between different time periods (200-400ms duration) 3) Clear hover states and tooltips with relevant context 4) Intuitive navigation between different analysis views. Deduct 5 points for each unresponsive interaction, 3 points for laggy chart updates, and 5 points for unclear data point identification. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Statistical Analysis",
-  "difficulty": "hard"
-}

package/library/data_science-statistical_analysis/stock-selection-yearly-moving-average-breakthrough.json

@@ -1,68 +0,0 @@
-{
-  "index": 1221,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional replies. Make sure any code you generate is executable and functional. Help me write a small stock selection program with the condition: stocks that have broken through their yearly moving average within the last 7 days.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the stock data source integration properly implemented?",
-      "description": "Check if the code includes reliable API connections (Yahoo Finance, Alpha Vantage, etc.) with proper error handling. Verify if the data fetching includes necessary authentication, rate limiting management, and handling of network failures. Score 0 if no data source is specified, 5 if basic APIs are used without error handling, 10 if comprehensive data retrieval with fallback mechanisms is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the yearly moving average calculation correct?",
-      "description": "Verify the yearly moving average calculation methodology (standard 250 or 252 trading days). Check if the formula properly handles weekends/holidays and data gaps. Ensure the calculation doesn't suffer from look-ahead bias. Score 0 if calculation is mathematically incorrect, 5 if basic calculation is present but edge cases aren't handled, 10 if implementation is statistically sound.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the breakthrough detection algorithm properly implemented?",
-      "description": "Assess the breakthrough definition - verify if the code checks both price crossing above the moving average and the timing within the 7-day window. Check if the algorithm handles false signals (e.g., requiring confirmation over multiple periods). Deduct 5 points if the algorithm doesn't handle price gaps, and 3 points if it doesn't account for volatility. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Does the program include adequate screening parameters and filters?",
-      "description": "Evaluate if the program allows filtering by market capitalization, sector, trading volume, or other relevant metrics beyond just the moving average breakthrough. Check if parameters are configurable by users. Score 3 points for each useful filter implemented (volume threshold, sector selection, volatility filter), up to 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 points, API failures, invalid inputs, 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. Visualization of breakthrough patterns 2. Historical backtest capabilities 3. Alert system for new breakthroughs 4. Integration with fundamental data). 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 screening methods 2. Function modules unrelated to stock selection 3. Computationally expensive operations that don't contribute to the core functionality. 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 retrieval/analysis/presentation 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 for stock charts (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) Data refresh/update delay ≤ 500ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus on breakthrough stocks. Deduct 5 points for each operation without feedback, 3 points for visual after-images during rapid data updates, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Statistical Analysis",
-  "difficulty": "medium"
-}

package/library/data_science-statistical_analysis/web-page-compare-number-frequency-shuffle-reorder.json

@@ -1,68 +0,0 @@
-{
-  "index": 1805,
-  "question": "You are a code expert, please use your professional knowledge to generate accurate, professional responses. Ensure that the generated code is executable for display. Help me write a web page code that can compare multiple sets of numbers, list the frequency of each number in order with color markers, and include a function to shuffle the numbers and then reorder them.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the number comparison system fully implemented?",
-      "description": "Evaluate whether the code provides a complete mechanism to input and compare multiple sets of numbers. Check if it allows users to input/define multiple datasets or import data from external sources. Score 0 if comparison functionality is missing, 5 if basic comparison is implemented but with limitations, and 10 if the system handles arbitrary numbers of datasets with proper validation.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the frequency calculation and ordering function implemented correctly?",
-      "description": "Examine the algorithm that calculates the frequency of each number and orders them. Verify the algorithm's correctness through edge cases (empty arrays, duplicate values, very large/small numbers). Deduct 3 points if the frequency calculation is incorrect, 4 points if ordering doesn't work properly, and 3 points if edge cases aren't handled. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are color markers implemented effectively for visual representation?",
-      "description": "Assess the color marker implementation for representing frequencies. Evaluate whether the color scheme is visually informative (e.g., heat map style), accessible (sufficient contrast ratio ≥4.5:1), and properly conveys data intensity. Deduct 5 points if colors don't correlate with frequency values, 3 points if the color scheme is confusing or inaccessible, and 2 points if there's no legend explaining the color mapping. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the shuffle and reorder functionality implemented effectively?",
-      "description": "Review the shuffle algorithm implementation (preferably Fisher-Yates or equivalent) and the reordering mechanism. Verify that shuffling is truly random and the reordering process works consistently. Check for animation transitions between states. Deduct 4 points for biased shuffle algorithms, 3 points for inconsistent reordering, and 3 points if there's no visual feedback during state transitions. 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 non-numeric inputs, extremely large datasets, 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. Interactive visualization options 2. Data export/import capabilities 3. Statistical analysis of number patterns). 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 number comparison (e.g., unrelated data visualization) 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 logic/view layers), code organization, and performance 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 there are no performance considerations for large datasets. 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 plus their shades) 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 lag during data reordering, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Statistical Analysis",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/browser-dinosaur-game-theme.json

@@ -1,68 +0,0 @@
-{
-  "index": 1744,
-  "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. Create a browser dinosaur game themed game.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core dinosaur game mechanics fully implemented?",
-      "description": "Review whether the code accurately implements the dinosaur character movement (jump/duck), obstacle generation system, and collision detection through HTML/JavaScript. Check if it includes proper physics simulation for jumping arc and gravity effects. Score 0 if core game loop is missing, 5 if only basic jumping is implemented, and 10 if all mechanics including ducking, variable jump height, and accurate collision boundaries are fully included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the progressive difficulty and scoring system implemented?",
-      "description": "Evaluate whether the game includes dynamic speed acceleration, obstacle frequency adjustment, and a comprehensive scoring mechanism. Check if the difficulty curve is well-balanced with proper obstacle spacing and speed ramping. Deduct 5 points if speed doesn't increase over time, 3 points if obstacle generation is static, and 2 points if scoring system lacks milestone rewards. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the game state management and restart functionality properly designed?",
-      "description": "Check whether the code includes complete game state transitions (start/playing/game over/restart), high score persistence using localStorage, and smooth state switching. Evaluate if the restart mechanism properly resets all game variables and maintains score history. Deduct 5 points if game states are not properly managed, 3 points if high scores aren't saved, and 2 points if restart doesn't clean up properly. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the visual rendering and animation system comprehensive?",
-      "description": "Assess whether the code implements smooth sprite animations for the dinosaur (running/jumping/ducking), scrolling background effects, and obstacle animations. Check if the rendering uses efficient techniques like requestAnimationFrame and proper sprite management. Give 10 points if all animations are smooth and optimized, 5 points if basic animations exist but lack polish, and 0 points if animations are choppy or missing. Deduct 3 points for performance issues during rendering.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as rapid key presses, browser tab switching, window resizing, and edge case collisions) and provide appropriate error handling. Code with strong robustness should effectively manage game pause/resume when tab loses focus, handle multiple simultaneous inputs gracefully, and recover from unexpected errors. Give 10 points for comprehensive error handling, 5 points for basic robustness, and 0 points if no exception handling exists.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that enhance gameplay?",
-      "description": "Check whether the code includes engaging features beyond basic gameplay (e.g., 1. Multiple obstacle types with different behaviors 2. Power-ups or special abilities 3. Day/night cycle or weather effects 4. Sound effects and background music 5. Particle effects for actions). Add 2-3 points for each well-implemented innovative feature that adds meaningful gameplay value (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 collision detection systems) 2. Features unrelated to the dinosaur game concept (e.g., built-in chat system) 3. Overly complex visual effects that impact performance (e.g., excessive particle systems). Deduct 3 points for each redundancy found, and directly deduct 10 points if core game performance is significantly impacted by unnecessary features.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating game logic/rendering/input handling), code organization with clear class structures, and proper variable naming conventions. Deduct 5 points if global variables are overused or game logic is mixed with rendering; deduct 5 points if code duplication rate exceeds 30%; deduct 3 points if functions are overly long (>50 lines) without proper decomposition. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface design meet modern game UI standards?",
-      "description": "Evaluate whether the visual design follows game UI principles: 1) Cohesive pixel art or modern graphic style 2) Readable score display with appropriate contrast 3) Clear game state indicators (start screen, game over screen) 4) Proper use of colors that don't strain eyes during extended play. Deduct 3 points for each UI element that lacks visual hierarchy, 5 points for poor color choices that affect gameplay visibility, and 5 points for inconsistent art style. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Are the controls responsive and gameplay smooth?",
-      "description": "Judge whether the game controls meet responsive gaming standards: 1) Input response delay ≤ 50ms for jump/duck actions 2) Consistent 60fps performance during gameplay 3) Smooth collision feedback without jarring interruptions 4) Intuitive control scheme (spacebar/arrow keys). Deduct 5 points for each control that feels unresponsive, 3 points for frame rate drops during normal gameplay, and 5 points for unclear visual feedback on player actions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "medium"
-}

package/library/game_development-action_rhythm/catch-fruit-game-html-javascript.json

@@ -1,68 +0,0 @@
-{
-  "index": 72,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration.\n\nPlease implement a \"Catch Fruit\" game using HTML and JavaScript.\n\nTask: Create a fruit-catching game where players need to catch falling fruits within a limited time.\n\nHint: Use timers and collision detection to implement the game logic.\n\nPlease include comments in your code to help other developers understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the core game loop fully implemented?",
-      "description": "Review whether the code implements the essential game mechanics through HTML/JavaScript, including fruit generation, gravity simulation for falling objects, player-controlled basket/character movement, and precise collision detection. Score 0 if the core interaction logic is missing, 5 if only basic movement without proper collision detection is implemented, and 10 if the complete game cycle with variable difficulty is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the timer and scoring system implemented correctly?",
-      "description": "Check if the game includes a functional countdown timer that properly terminates the game, and a scoring system that accurately tracks successful fruit catches. Verify that the score is properly incremented when fruits are caught and that the timer decrements correctly. Deduct 5 points if the timer doesn't end the game, 3 points if score calculation has bugs, and 2 points if there's no visual feedback when points are earned. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are multiple fruit types implemented with varying behaviors?",
-      "description": "Evaluate whether the game features different fruit types with distinct visual appearances, falling speeds, point values, or special effects. Deduct 5 points if only a single fruit type exists, 3 points if fruits look different but behave identically, and 2 points if there's insufficient variety (less than 3 types). Give full 10 points for rich variety with meaningful gameplay differences.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the game difficulty progression properly implemented?",
-      "description": "Assess if the game's difficulty increases over time through mechanisms like faster falling fruits, more fruits appearing simultaneously, or introduction of obstacles/distractions. Check if level progression or wave system is clearly communicated to players. Deduct 5 points if difficulty remains static throughout gameplay, and 3 points if difficulty curve is too steep or unbalanced. 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 browser resizing, rapid input changes, performance issues on slower devices, 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. Special bonus fruits with unique effects 2. Power-ups that modify gameplay 3. Combo system for catching multiple fruits in succession). 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 collision detection systems coexisting) 2. Function modules unrelated to fruit catching (e.g., unnecessary minigames) 3. Fancy effects that affect performance (e.g., excessive particle 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 modular design (such as separating game entities, physics, rendering, and input handling), code readability, and comprehensive commenting as requested. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if comments are missing or unhelpful. 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 (clear separation between game area, score display, and timer) 3) Professional font system (readable text size, consistent styling). 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) Responsive player movement with minimal input lag 2) Smooth animations for falling fruits and catching interactions 3) Clear visual and audio feedback when fruits are caught or missed. Deduct 5 points for each operation without feedback, 3 points for choppy animations during gameplay, and 5 points for unresponsive controls. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}

package/library/game_development-action_rhythm/character-animation-state-switching.json

@@ -1,68 +0,0 @@
-{
-  "index": 69,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and demonstrable.\n\nPlease use HTML and JavaScript to implement an animation transition: enable character animation switching between different states, such as walking, running, jumping, and other different actions.\n[CHAT_SEP]Please optimize the above game response and add some comments in the code so that other developers can understand your implementation process.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the character animation system properly implemented?",
-      "description": "Check if the code implements the core animation system with state management for different character actions (walking, running, jumping). Evaluate the state machine architecture, handling transitions between animation states cleanly. Score 0 if no state transitions exist, 5 if only basic transitions are implemented, and 10 if all specified actions with seamless transitions are included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is sprite sheet or animation framework implementation correct?",
-      "description": "Review the implementation of sprite animation technique (whether using sprite sheets, CSS animations, or canvas-based animation). Check for proper frame sequencing, timing control, and animation loops. Deduct 5 points if animation frames are incorrectly sequenced, 3 points if timing control is inconsistent. Full score requires proper sprite resource management and optimization.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Are the animation transitions smooth and natural?",
-      "description": "Evaluate the transition logic between different animation states (e.g., walking to running, running to jumping). Check for interpolation techniques, easing functions, and blending between animations. Deduct 5 points for abrupt transitions, 3 points for inconsistent animation speeds. 10 points for natural, realistic transitions that follow physical movement principles.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is user input handling implemented correctly for animation control?",
-      "description": "Examine if the code includes proper event listeners for keyboard/mouse/touch input to trigger different animation states. Check if there's debouncing for rapid input changes and proper handling of simultaneous inputs. Deduct 5 points if input lag exceeds 100ms, 3 points if certain input combinations cause animation glitches. Full score requires responsive and intuitive controls.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles edge cases like rapid state transitions, browser compatibility issues, and resource loading failures. Code with strong robustness should implement error boundaries and fallback animations. Deduct 5 points for each unhandled edge case. Give 10 points if all common exceptions are properly managed with graceful fallbacks.",
-      "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. Particle effects during transitions 2. Dynamic camera following 3. Interactive environment reactions to movement). 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 animation loops or duplicate frame calculations 2. Unnecessary rendering cycles that affect performance 3. Overlapping event listeners causing multiple triggers. Deduct 3 points for each redundancy found, and directly deduct 10 points if core animation functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating animation logic, rendering, and input handling), code reusability, and performance optimization. Deduct 5 points if animation and business logic are tightly coupled; deduct 5 points if requestAnimationFrame is not properly implemented; deduct 5 points if there's no performance consideration for mobile devices. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the character and animation design follows good visual principles: 1) Consistent art style and proportions 2) Clear silhouette during different actions 3) Appropriate use of color to indicate different states. Deduct 3 points for inconsistent art style, 5 points for unclear visual feedback during state changes, and 5 points for poor contrast against backgrounds. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the animation performance optimized?",
-      "description": "Judge whether the animations run smoothly at 60fps: 1) Proper use of GPU acceleration techniques 2) Efficient DOM manipulation or Canvas drawing 3) Asset preloading and memory management. Deduct 5 points for frame drops below 45fps on standard devices, 3 points for memory leaks during long animation sequences, and 5 points for not implementing any performance optimization techniques. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Game Development-Action/Rhythm",
-  "difficulty": "easy"
-}