@getollie/cli 0.0.1

package/library/data_science-data_visualization_dashboards/web-data-monitoring-excel-import.json

@@ -0,0 +1,68 @@
+{
+  "index": 1374,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. I want to create a web-based big data monitoring platform that sources data from Excel spreadsheets stored on my local computer.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Excel data import and parsing functionality",
+      "description": "Review whether the code properly implements Excel file import functionality using appropriate libraries (SheetJS/xlsx, Papa Parse, etc.). Check if the implementation can handle different Excel formats (.xlsx, .csv) and whether it includes robust data validation. Score 0 if file import is not implemented, 5 if only basic parsing without validation is included, and 10 if it handles multiple formats with error handling and validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Data processing and transformation pipeline",
+      "description": "Evaluate the data processing pipeline from raw Excel data to visualization-ready formats. Check for proper data cleaning, normalization, aggregation functions, and handling of missing/invalid values. Deduct 5 points if no data transformation logic exists, 3 points if transformations are inefficient (e.g., multiple iterations over large datasets), and 2 points if edge cases (null values, non-numeric data) are not handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Visualization components and dashboard design",
+      "description": "Check if appropriate visualization libraries (D3.js, Chart.js, Highcharts, etc.) are used to create dynamic, interactive visualizations. Verify if the dashboard includes essential big data visualizations (time series, distributions, correlations, etc.) and allows for custom view configurations. Deduct 5 points if visualizations are static, 3 points if interactivity is limited, and 5 points if the visualizations are not appropriate for the data types. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Real-time monitoring and automatic refresh",
+      "description": "Assess if the platform implements file watching/monitoring to detect changes in source Excel files and provides real-time or scheduled data refresh functionality. Check for WebSocket implementation or polling mechanisms with configurable intervals. Give 0 points if no refresh capability exists, 5 points for basic manual refresh, and 10 points for automatic detection with configurable refresh rates and change highlighting.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted Excel files, network interruption, 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. AI-driven anomaly detection in data 2. Natural language queries for data exploration 3. Automated insights generation 4. Custom alert thresholds with notifications). 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 data parsing methods coexisting) 2. Function modules unrelated to data monitoring (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., excessive animations that slow down rendering of critical data). 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 processing/visualization/user interface 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 dashboard design principles: 1) Harmonious color matching optimized for data visualization (no more than 3 primary colors) 2) Proper layout spacing with logical grouping of related metrics 3) Professional typography system (body font size ≥ 14px, clear hierarchy between titles and data). Deduct 3 points for each crowded visual element, 5 points for a color scheme that makes data hard to interpret, and 5 points for chaotic dashboard organization. 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 data dashboard best practices: 1) Filter/selection feedback delay ≤ 100ms 2) Smooth transitions when switching between views or applying filters 3) Clear visual indicators for loading states and data freshness. Deduct 5 points for operations without loading feedback, 3 points for jerky transitions when navigating between views, and 5 points if key metrics or controls are hidden behind unintuitive menus. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "medium"
+}

package/library/data_science-data_visualization_dashboards/web-page-excel-upload-charts-display.json

@@ -0,0 +1,68 @@
+{
+  "index": 1766,
+  "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. Create a web page using HTML+CSS+Java that can upload Excel files and display charts on the web page.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Excel file upload function fully implemented?",
+      "description": "Review whether the code accurately implements file upload through HTML input and JavaScript, including file type validation (only Excel formats like .xlsx, .xls), file size restrictions, and proper error handling for invalid files. Check if drag-and-drop upload is supported. Score 0 if basic upload is not working, 5 if only basic upload without validation is implemented, and 10 if comprehensive upload with all validations and user feedback is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Excel data parsing and processing correctly implemented?",
+      "description": "Evaluate whether the code properly parses Excel files using appropriate libraries (such as SheetJS/xlsx.js), handles different data types (numbers, strings, dates), manages empty cells, and converts data into usable JavaScript objects/arrays. Check if multiple sheets are supported. Deduct 5 points if date formatting is incorrect, 3 points if special characters cause parsing errors. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are comprehensive and interactive charts implemented?",
+      "description": "Check whether the code generates meaningful charts from Excel data using proper charting libraries (Chart.js, D3.js, etc.), supports multiple chart types (bar, line, pie, scatter), includes interactive features (hover tooltips, zoom, legend toggles), and handles dynamic data updates. Deduct 5 points if charts are static without interaction, 3 points if chart types are limited to basic ones only. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data visualization workflow and user experience well-designed?",
+      "description": "Evaluate whether the application provides a smooth user journey from file upload to chart display, includes data preview before visualization, allows users to select which columns/rows to chart, provides chart customization options (colors, titles, axis labels), and handles large datasets efficiently. Deduct 5 points if no data preview is provided, 3 points if chart customization is limited. Give 10 points if fully implemented with excellent UX flow.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted Excel files, network interruption, oversized files, malformed data, 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. Real-time chart animation during data loading 2. Export charts as images/PDF 3. Multiple file comparison views 4. Data filtering and search capabilities 5. Chart template gallery). 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 file parsing libraries loaded simultaneously) 2. Function modules unrelated to Excel processing and charting (e.g., built-in games or social features) 3. Excessive animations that slow down data processing. 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 (separating file handling/data processing/visualization layers), proper error handling patterns, and clean code structure. Deduct 5 points if global variables pollute the namespace or no proper design patterns are used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no proper dependency management or code organization is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional standards?",
+      "description": "Evaluate whether the overall design follows modern web design principles: 1) Harmonious color scheme (no more than 3 primary colors) 2) Proper spacing and layout (consistent margins and padding) 3) Professional typography (readable font sizes ≥ 14px, proper line height) 4) Clear visual hierarchy for upload area, data preview, and charts. Deduct 3 points for each cluttered visual element, 5 points for poor color combinations, and 5 points for inconsistent layout patterns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the interactions smooth and provide clear feedback?",
+      "description": "Judge whether the user interactions are intuitive and responsive: 1) File upload progress indicators 2) Loading states during Excel parsing 3) Smooth chart rendering transitions 4) Clear success/error messages 5) Responsive design for different screen sizes. Deduct 5 points for each operation without proper feedback, 3 points for slow response times (>2 seconds for file processing), and 5 points for unclear navigation or confusing interface states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "easy"
+}

package/library/data_science-data_visualization_dashboards/wechat-mini-program-data-analysis-page.json

@@ -0,0 +1,68 @@
+{
+  "index": 1245,
+  "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 purposes. Next, write a data analysis page in a WeChat Mini Program that visually displays the obtained data.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic WeChat Mini Program structure implemented correctly?",
+      "description": "Verify if the code contains the essential WXML, WXSS, JS files with proper structure, page registration in app.json, and follows Mini Program development specifications. Check if it includes proper page lifecycle hooks (onLoad, onShow, etc.) and follows the correct directory structure. Score 0 if the core Mini Program structure is missing, 5 if basic structure exists with minor issues, and 10 if fully compliant with WeChat specification.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the data acquisition and processing logic complete?",
+      "description": "Examine whether the code includes proper data fetching mechanisms (wx.request or equivalent), data transformation functions, error handling for API calls, and caching strategies. Check for loading states and retry mechanisms. Deduct 5 points if API error handling is absent, 3 points if there's no loading state management, and 3 points if data transformation logic is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are appropriate visualization components implemented?",
+      "description": "Assess if the code uses appropriate visualization libraries (like ec-canvas for ECharts, wx-chart, or Canvas API) with proper chart types matching the data characteristics. Check if the visualizations include proper labels, legends, tooltips, and responsive sizing. Deduct 5 points if chart types don't match the data nature, 3 points for missing interactive elements, and 5 points for poor responsiveness. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the solution include user interaction for data analysis?",
+      "description": "Evaluate whether the code implements filtering options, time range selection, category toggles, data drill-down capabilities, and other interactive analysis features. Check if the interactions update the visualizations in real-time. Score 0 if no data interaction exists, 5 if only basic filters are present, and 10 if comprehensive analysis interactions are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as empty data sets, network errors, unexpected data formats, 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-driven data insights 2. Custom gesture controls for analysis 3. Social sharing of analysis results). 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 chart libraries for the same purpose) 2. Function modules unrelated to data analysis (e.g., a built-in game) 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), component reusability, and Mini Program optimization practices. 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 performance optimization measures are absent. 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 WeChat Mini Program 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 chart layouts. 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) Chart transitions occur within 300ms 2) Touch feedback delay ≤ 100ms 3) Clear visual focus guidance when switching between analysis views. Deduct 5 points for each operation without feedback, 3 points for laggy chart rendering, and 5 points for awkward gesture recognition. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "easy"
+}

package/library/data_science-data_visualization_dashboards/world-empires-gantt-chart.json

@@ -0,0 +1,68 @@
+{
+  "index": 1426,
+  "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 when possible. Write an HTML file that draws a Gantt chart depicting the rise and fall of world empires spanning across Europe, Asia, and Africa.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Gantt chart visualization fully implemented?",
+      "description": "Review whether the HTML file correctly implements a Gantt chart structure with proper timeline representation of empires. Check if it includes time scales, empire names, and duration bars. Score 0 if visualization is missing, 5 if basic chart is implemented but lacks detail, and 10 if the chart clearly depicts multiple empires with accurate time periods.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are historical empires of Europe, Asia, and Africa accurately represented?",
+      "description": "Evaluate the historical accuracy and comprehensiveness of the empires included. The visualization should include major empires from all three continents (at least 5 from each continent) with reasonably accurate time periods. Deduct 2 points for each continent underrepresented (fewer than 5 empires), and 5 points if historical dates have significant inaccuracies (>50 years for ancient empires, >20 years for more recent ones).",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the timeline implementation effective and well-scaled?",
+      "description": "Check if the timeline handles the vast historical span appropriately (potentially covering 3000+ years). Assess if the scale is consistent, if important historical periods are highlighted, and if overlapping empires are clearly distinguished. Deduct 5 points if the timeline scale is distorted or inconsistent, and 3 points if overlapping empires are difficult to distinguish.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the visualization include interactive features for better understanding?",
+      "description": "Evaluate implementation of interactive features such as zooming, panning, filtering by region/period, tooltips with additional information, or highlighting related empires. Award 2 points for each well-implemented interactive feature (max 10 points), with particular attention to features that enhance historical understanding and exploration.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as browser compatibility issues, missing data handling, responsive design for different screen sizes, etc.) and provide fallback 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 representation of empire expansion/contraction 2. Integration of important historical events as markers 3. Comparative visualization of empire territories/population/influence). 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 visualization functions 2. Feature modules unrelated to historical empires visualization 3. Fancy effects that affect performance without adding historical context. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core visualization 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/visualization/interaction layers), code organization, and optimization techniques. Deduct 5 points if global state pollution is found or if appropriate design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the visualization performance is poor with noticeable lag. 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 data visualization principles: 1) Clear visual hierarchy with appropriate emphasis on important empires 2) Harmonious color coding system that helps distinguish between regions/continents 3) Professional typography with readable labels (even for small empires). Deduct 3 points for each cluttered visual element, 5 points for poor color scheme that makes empire distinction difficult, and 5 points for illegible labels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects enhance historical understanding: 1) Smooth transitions when filtering/sorting empires 2) Responsive tooltips appearing within 100ms 3) Clear visual cues for interactive elements. Deduct 5 points for jerky animations, 3 points for delayed responses to user interactions, and 5 points for confusing or hidden interactive controls. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "medium"
+}

package/library/data_science-machine_learning/ai-quant-trading-digital-currency-product.json

@@ -0,0 +1,68 @@
+{
+  "index": 1627,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure the generated code is executable for demonstration. Help create an AI quantitative trading product in the digital currency field that integrates multi-factor models, basic trading indicators, risk control mechanisms, position management, data statistics, and dashboard functionality. The requirements are a monthly return of 15% with risk lower than 5%. Please provide complete executable code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the multi-factor model for crypto trading fully implemented?",
+      "description": "Review whether the code implements comprehensive multi-factor analysis, including at minimum: momentum factors, value factors, sentiment analysis, and on-chain metrics. Score 0 if no factors are implemented, 5 if only basic factors (like simple moving averages) are used, and 10 if the model incorporates at least 4 distinct factor categories with proper normalization and weighting mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are standard trading indicators and their integration implemented?",
+      "description": "Evaluate the implementation of at least 5 essential trading indicators (e.g., MACD, RSI, Bollinger Bands, OBV, Stochastic) and how they're combined into trading signals. Verify that the indicators are properly parameterized and that signal conflicts are resolved through a clear decision framework. Deduct 2 points for each missing core indicator, and 3 points if there's no signal aggregation logic.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the risk control mechanism robust and comprehensive?",
+      "description": "Check if the system includes stop-loss mechanisms, volatility-based position sizing, drawdown controls, and market regime detection. The code must implement at least two layers of risk control (trade level and portfolio level) with clear risk metrics calculation (VaR, maximum drawdown). Deduct 5 points if there's no volatility adjustment logic, and 3 points if maximum loss limits aren't enforced. Full score requires all these elements plus backtesting of the risk controls.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is position management and sizing algorithm implemented?",
+      "description": "Assess whether the code handles dynamic position sizing based on account equity, market conditions, and signal strength. Check for implementation of Kelly criterion or similar mathematical position sizing, diversification logic across multiple assets, and correlation-aware allocation. Deduct 5 points if position sizing is static, 3 points if rebalancing logic is missing, and 2 points if there's no consideration for trading costs in the position calculations.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as market data gaps, API failures, extreme volatility events, etc.) and provide error handling or recovery mechanisms. Code with strong robustness should include retry mechanisms, data validation, exception handling for API calls, and graceful degradation in adverse conditions. If robust error handling exists across all modules, give 10 points. If error handling is inconsistent, give 5 points. If critical operations lack error handling, 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 system (e.g., 1. Auto-adaptation to market regimes 2. Machine learning for parameter optimization 3. Sentiment analysis from social media integration 4. Advanced order execution 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 functions (e.g., multiple position sizing algorithms running in parallel) 2. Function modules unrelated to trading (e.g., unnecessary data visualization) 3. Computationally expensive operations that don't contribute to performance (e.g., excessive resampling of data). 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 acquisition/signal generation/execution/risk management layers), unit test coverage, and configuration management. 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's no configuration separation from the code. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the dashboard and visualization meet professional standards?",
+      "description": "Evaluate whether the trading dashboard follows financial visualization best practices: 1) Clear performance metrics display (CAGR, Sharpe ratio, drawdown) 2) Proper equity curve and drawdown visualization 3) Trade distribution analysis 4) Risk exposure charts. Deduct 3 points for each missing critical visualization, 5 points for misleading performance representation, and 5 points for poor data-to-ink ratio. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Does the system meet the performance requirements?",
+      "description": "Judge whether the backtesting results demonstrate the required 15% monthly return with risk under 5%. Check if the performance is consistent across different market conditions and time periods. Deduct 5 points if backtesting doesn't include transaction costs and slippage, 3 points if there's no out-of-sample testing, and 5 points if the Sharpe ratio is below 2.0. The full score is 10 points if all requirements are met with convincing statistical significance.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "hard"
+}

package/library/data_science-machine_learning/eyebrow-controlled-phone-app-with-ui.json

@@ -0,0 +1,68 @@
+{
+  "index": 1326,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure the generated code is executable for demonstration. I also need a UI interface with 2 buttons: one for \"Start\" and one for \"Exit.\" After clicking Start, the app should run in the background, allowing users to control their phone through eyebrow movements.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the eyebrow movement detection system fully implemented?",
+      "description": "Review whether the code accurately implements facial landmark detection through computer vision libraries (like MediaPipe/OpenCV), specifically targeting eyebrow region tracking. Check if it includes proper calibration for different users, noise filtering, and gesture recognition accuracy. Score 0 if core detection logic is missing, 5 if only basic face detection is implemented, and 10 if precise eyebrow movement patterns are accurately captured with >90% recognition rate.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the phone control mapping functionality implemented?",
+      "description": "Check whether the eyebrow movements are properly mapped to phone control actions (swipe, tap, scroll, etc.). Evaluate if the system includes customizable gesture-to-action mapping, sensitivity adjustment, and multi-directional control support. Deduct 5 points if only basic directional mapping exists, and 3 points if no sensitivity calibration is provided. The full score requires comprehensive control coverage including navigation, app switching, and text input assistance.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the background service architecture properly designed with camera access management?",
+      "description": "Evaluate whether the background service properly handles camera resource management, permission requests, and system-level integration without blocking other apps. Check for proper service lifecycle management, memory optimization, and battery usage consideration. Deduct 5 points if camera resource conflicts occur, and 5 points if the service doesn't properly handle system interruptions (calls, notifications). Requires seamless background operation.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete accessibility and calibration system constructed?",
+      "description": "Check whether the code includes comprehensive user calibration flow, accessibility settings for different physical abilities, and adaptive learning for individual eyebrow movement patterns. Evaluate if it provides feedback mechanisms, adjustment tutorials, and personalization options. Deduct 5 points if no calibration process exists, and 3 points if accessibility considerations are minimal. Give 10 points if fully adaptive system with learning capabilities is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as poor lighting conditions, camera obstruction, multiple faces in frame, system resource constraints, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like face detection failures, camera permission denials, and hardware limitations, 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 any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance accessibility and user experience (e.g., 1. Voice feedback for movement confirmation 2. Gesture recording and playback for complex actions 3. Integration with system accessibility services 4. Multi-user profile support 5. Gesture macro creation). 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 detection algorithms (e.g., multiple face detection libraries running simultaneously) 2. Function modules unrelated to eyebrow control (e.g., built-in games or entertainment features) 3. Resource-intensive effects that impact detection performance (e.g., heavy UI animations during detection). Deduct 3 points for each redundancy found, and directly deduct 10 points if core detection 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 detection engine/control mapping/UI layers), proper error handling, and performance optimization. Deduct 5 points if memory leaks in camera handling are found or poor separation of concerns; deduct 5 points if the detection loop blocks the main thread; deduct 5 points if no proper resource cleanup mechanisms exist. The full score requires clean architecture with proper threading and resource management.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet accessibility design standards?",
+      "description": "Evaluate whether the UI design follows accessibility principles: 1) High contrast design suitable for users with visual impairments 2) Large, easily identifiable buttons (minimum 44px touch targets) 3) Clear visual feedback for all interactions 4) Simple, uncluttered layout focusing on essential controls. Deduct 3 points for each accessibility guideline violation, 5 points for poor color contrast ratios (<4.5:1), and 5 points for confusing button layouts. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the real-time performance smooth and responsive?",
+      "description": "Judge whether the detection and control response meets real-time requirements: 1) Detection frame rate ≥ 15fps for smooth tracking 2) Gesture-to-action delay ≤ 200ms 3) Consistent performance across different lighting conditions 4) No noticeable lag in background operation. Deduct 5 points for each stuttering interaction, 3 points for inconsistent detection rates, and 5 points for performance degradation during extended use. The full score requires consistently smooth real-time operation.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "hard"
+}

package/library/data_science-machine_learning/facial-expression-recognition-webcam-project.json

@@ -0,0 +1,68 @@
+{
+  "index": 1473,
+  "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 and can be demonstrated. I want to create a facial expression recognition project that can recognize my expressions through my webcam. Please provide me with the complete project code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the facial expression detection functionality completely implemented?",
+      "description": "Evaluate whether the code correctly implements real-time facial detection, facial landmark extraction, and expression classification (at least 6 basic emotions: happy, sad, angry, surprised, fearful, disgusted). Score 0 if facial detection is missing, 5 if only basic detection without expression classification is implemented, and 10 if both detection and accurate multi-expression classification are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the webcam integration properly implemented?",
+      "description": "Check whether the code includes proper webcam access (with browser permissions handling), video streaming setup, frame capture at appropriate intervals (15-30 fps), and fallback mechanisms for devices without cameras. Deduct 5 points if there's no error handling for camera permission denial, 3 points if the frame rate isn't optimized, and 2 points if there's no camera availability check. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the machine learning model implementation appropriate?",
+      "description": "Assess whether the code uses a suitable pre-trained model (like TensorFlow.js with MobileNet, face-api.js, or custom CNN) with proper model loading, inference optimization, and model versioning. Evaluate if model size balances accuracy vs. performance (under 10MB for browser usage). Deduct 5 points if the model accuracy is below industry standards, 3 points if inference time exceeds 100ms per frame. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the expression visualization and feedback system well-designed?",
+      "description": "Review how expression results are visualized (e.g., emotion labels, confidence percentages, facial landmark overlays, emotion history graphs). Check for real-time feedback with low latency (<200ms), smooth transitions between detected expressions, and clear confidence indicators. Deduct 5 points if visualization is minimal or unclear, 3 points if there's significant lag in the feedback loop. 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 poor lighting conditions, multiple faces in frame, profile views, occlusions, webcam disconnection, etc.) and provide graceful degradation or recovery. Code with strong robustness should log errors, provide user feedback for issues, and implement appropriate fallbacks, 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. Expression-triggered animations or effects 2. Expression history tracking with statistics 3. Expression-based avatar mirroring 4. Multi-user comparison mode). 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 detection algorithms 2. Unnecessary processing steps that impact performance 3. Excessive UI elements unrelated to expression recognition. 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/model/controller components), error handling, performance optimization techniques (like requestAnimationFrame usage, canvas vs. DOM manipulation), and code commenting. 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 there's no performance optimization for continuous video processing. 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) Clear visual hierarchy highlighting expression results 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Appropriate use of color to indicate different emotions 4) Professional typography for results display. Deduct 3 points for each crowded visual element, 5 points for poor visual distinction between emotions, and 5 points for chaotic camera feed and result positioning. 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) Expression detection latency ≤ 200ms 2) Smooth transitions when expression changes 3) Responsive UI even during intensive processing. Deduct 5 points for noticeable frame drops during detection, 3 points for jerky visualization transitions, and 5 points for UI freezes during model processing. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "easy"
+}

package/library/data_science-machine_learning/model-training-page.json

@@ -0,0 +1,68 @@
+{
+  "index": 1387,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable and demonstrable.\n\n+---------------------------------------------------------------+\n| Model Training Page                                           |\n+-------------------+-------------------+-----------------------+\n| Model Selection   | Dataset Selection | Training Configuration|\n| - Model List      | - Dataset List    | - Learning Rate       |\n| - Model Description| - Dataset Preview | - Batch Size         |\n| - Model Parameters| - Data Preprocessing| - Iterations        |\n+-------------------+-------------------+-----------------------+\n| Training Process Visualization                                |\n| - Real-time Training Curves | - Progress Bar | - Log Output   |\n+---------------------------------------------------------------+\n| Model Evaluation                                              |\n| - Evaluation Metrics | - Confusion Matrix | - ROC Curve       |\n+---------------------------------------------------------------+\n| Model Saving and Export                                       |\n| - Save Model        | - Export Results   |                    |\n+---------------------------------------------------------------+\n| History                                                       |\n| - Training History  | - Retrain          |                    |\n+---------------------------------------------------------------+\n| Help and Documentation                                        |\n| - Operation Guide   | - Model Documentation |                 |\n+---------------------------------------------------------------+\nPlease help me generate a page based on this layout",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the entire model training interface layout accurately implemented?",
+      "description": "Evaluate if the HTML/CSS code precisely implements the specified layout with all six main sections (Model Selection, Dataset Selection, Training Configuration, Training Process Visualization, Model Evaluation, Model Saving and Export, History, Help and Documentation). Verify that each section contains the correct subsections as specified in the diagram. Score 0 if major sections are missing, 5 if all sections exist but with layout inaccuracies, and 10 if the layout perfectly matches the specification.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the model and dataset selection components fully functional?",
+      "description": "Check if the implementation includes interactive model and dataset selection components with proper lists, descriptions, and parameter configurations. Verify if model descriptions update dynamically when a model is selected, and if dataset preview functionality is implemented. Score 3 for basic selection dropdowns, 7 for selection with dynamic information display, and 10 for comprehensive components with parameter configuration and dataset preview capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the training configuration section properly implemented with validation?",
+      "description": "Assess if the training configuration section includes proper input fields for learning rate, batch size, and iterations with appropriate validation (numeric constraints, reasonable ranges). Check if there are tooltips or guidance for optimal parameter selection. Deduct 3 points for missing validation, 2 points for lacking tooltips/guidance, and 2 points if parameter interdependencies are not handled. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "How comprehensive is the training process visualization implementation?",
+      "description": "Evaluate the quality of the training visualization components: real-time curves (should update dynamically, show multiple metrics), progress bar (should show accurate percentage and estimated time), and log output (should auto-scroll, allow filtering). Deduct 3 points for static/non-updating visualizations, 3 points for missing any of the three required components, and 2 points for poor real-time performance. 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 parameter inputs, API failures, incompatible model-dataset combinations, 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 model architecture visualization 2. Transfer learning capabilities 3. A/B testing of different configurations 4. Auto-parameter suggestions). 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 chart libraries for the same visualization) 2. Function modules unrelated to model training (e.g., a built-in chat system) 3. Fancy effects that affect performance (e.g., unnecessary animations in training visualizations). 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 components/data processing/visualization logic), state management approach, and code 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's no clear separation between UI and business logic. 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 fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "easy"
+}