@getollie/cli 0.0.1

package/library/data_science-machine_learning/opencvjs-image-polygon-text-extraction.json

@@ -0,0 +1,68 @@
+{
+  "index": 1450,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. Implement, using HTML with Opencv.js, a method to set polygon coordinates on an image and extract text from within the selected polygon area.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the polygon coordinate selection system properly implemented?",
+      "description": "Check if the HTML interface allows users to create and modify polygon vertices on the image. The implementation should include point creation on click, vertex dragging, and completion of the polygon. Score 0 if no polygon creation exists, 5 if only basic point placement is implemented, and 10 if a complete, interactive polygon drawing system with editing capabilities is present.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image loading and display functionality robust?",
+      "description": "Evaluate whether the code properly handles image loading, including error handling for invalid images, support for different image formats (JPEG, PNG, etc.), and responsive sizing that maintains aspect ratio. The image should be properly displayed as a canvas element for OpenCV.js processing. Deduct 5 points if there's no image validation, 3 points if responsive sizing is missing, and 2 points if the canvas setup is incorrect. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the OpenCV.js integration correctly implemented?",
+      "description": "Assess the initialization of OpenCV.js, proper usage of cv.Mat objects, and memory management with .delete() calls to prevent leaks. Check for proper module loading detection and fallback mechanisms if OpenCV fails to load. Deduct 5 points for missing memory management, 5 points for no OpenCV loading verification, and 3 points for inefficient usage of OpenCV objects. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the text extraction from the polygon region correctly implemented?",
+      "description": "Verify that the code correctly masks the image using the defined polygon, applies appropriate preprocessing (like grayscale conversion, thresholding, noise removal) before OCR, and extracts text from only within the polygon. Check for OCR library integration (like Tesseract.js). Deduct 5 points if the masking is incorrect, 5 points if no preprocessing is applied, and 5 points if OCR integration is missing. 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 polygon shapes, extremely small polygons, images that fail to load, or browser compatibility issues) 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. Auto-adjustment of polygon for better text recognition 2. Multiple polygon support with labeling 3. Text extraction result highlighting on the original image). 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 image processing functions 2. Unnecessary UI elements unrelated to the polygon creation and text extraction task 3. Heavy computational methods that slow down browser performance. 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/image processing/OCR logic), error handling, and code comments. 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 meaningful comments explaining complex OpenCV operations. 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) Clean and intuitive UI for polygon creation 2) Proper layout spacing between controls and the image canvas 3) Professional visual feedback when selecting points and creating polygons. Deduct 3 points for each crowded visual element, 5 points for poorly contrasting colors making polygon points hard to see, and 5 points for chaotic button/control 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) Immediate visual feedback when placing polygon points 2) Smooth polygon dragging and reshaping 3) Clear indication when the polygon is complete and ready for text extraction. Deduct 5 points for each operation without feedback, 3 points for laggy polygon manipulation, and 5 points for confusing interaction patterns that don't follow standard conventions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "hard"
+}

package/library/data_science-machine_learning/pyqt-interface-brain-tumor-yolov8-detection.json

@@ -0,0 +1,68 @@
+{
+  "index": 892,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that any code you generate is executable for demonstration purposes. Please help me design a PyQt interface for a brain tumor system based on YOLOv8 deep learning detection.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "YOLOv8 integration completeness",
+      "description": "Evaluate how completely the YOLOv8 detection model is integrated into the PyQt application. Check if the code properly loads pretrained models, handles image preprocessing, and implements proper inference pipelines for brain tumor detection.Score 0 if YOLOv8 is not integrated at all, 5 if basic integration exists but lacks optimization, and 10 if the implementation includes proper model loading, inference pipeline, confidence thresholds, and NMS settings specific to medical imaging contexts.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Medical image handling capabilities",
+      "description": "Assess whether the application correctly handles medical imaging formats (DICOM, NIfTI) with proper metadata preservation. Check if it includes necessary preprocessing specific to brain MRI/CT scans (normalization, windowing) and supports different cross-sectional views.Deduct 3 points if standard medical formats aren't supported, 3 points if metadata isn't preserved, and 4 points if brain-specific preprocessing is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Visualization of detection results",
+      "description": "Evaluate how tumor detection results are visualized. Check if the interface includes proper bounding box overlays, segmentation masks, confidence scores, and multi-slice viewing capabilities for 3D data.Score 0 if visualization is absent, 5 if basic bounding boxes are implemented, and 10 if the system provides comprehensive visualization with color-coded overlays, adjustable transparency, and measurement tools for clinical assessment.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Clinical workflow integration",
+      "description": "Assess whether the PyQt interface supports a complete clinical workflow including patient data management, scan history, reporting capabilities, and integration points with hospital systems.Deduct 3 points if patient management is missing, 3 points if reporting functionality is absent, and 4 points if the system lacks interoperability features (DICOM networking, HL7). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code robustness",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted images, model loading failures, memory limitations with large datasets) 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": "Innovative features that are eye-catching",
+      "description": "Check whether the code includes surprise features that enhance the clinical experience (e.g., 1. Real-time volumetric measurements 2. Automatic report generation with findings 3. Comparative analysis between scans 4. Growth trajectory prediction).Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Redundant features",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementations of similar functions (e.g., multiple image loading pipelines) 2. Function modules unrelated to tumor detection (e.g., generic image editing tools) 3. Fancy effects that affect performance or clinical accuracy.Deduct 3 points for each redundancy found, and directly deduct 10 points if the core medical functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Engineering quality",
+      "description": "Review modular design (such as separating medical processing/UI/model inference layers), unit test coverage (especially for critical detection algorithms), and build process automation.Deduct 3 points if global state pollution is found; deduct 3 points if the code duplication rate is too high (over 30%); deduct 4 points if there are no validations for medical data integrity. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Interface vision meets clinical standards",
+      "description": "Evaluate whether the interface follows clinical software design principles: 1) High contrast for tumor visualization 2) Consistent layout optimized for radiology workflows 3) Clear distinction between diagnostic and administrative features 4) Accessibility considerations for hospital environments.Deduct 3 points for poor tumor visibility, 3 points for workflow inefficiencies requiring excessive clicks, and 4 points for interfaces that don't follow medical software conventions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Dynamic interaction smoothness",
+      "description": "Judge whether the PyQt interface provides smooth interactions essential for clinical use: 1) Responsive zooming/panning of medical images ≤ 100ms 2) Background processing for heavy computations 3) Progress indicators for long-running operations 4) Responsive UI during model inference.Deduct 3 points for each laggy operation when handling medical images, 3 points for UI freezing during detection, and 4 points if the interface becomes unresponsive with larger datasets. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "hard"
+}

package/library/data_science-machine_learning/text-to-image-generation-tool-development.json

@@ -0,0 +1,68 @@
+{
+  "index": 1433,
+  "question": "You are a code expert. Please use your professional expertise to generate accurate, professional responses. Be sure to provide executable code when possible. I want to develop my own text-to-image generation tool. What do I need to prepare? Please describe in detail, and ideally help me write some code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the text-to-image generation model selection and integration properly implemented?",
+      "description": "Check whether the code includes proper selection and integration of text-to-image models (such as Stable Diffusion, DALL-E, or Midjourney-like architectures). Assess if the code provides clear instructions for model download/installation, API integration, or local deployment. Score 0 if no specific model implementation is provided, 5 if only basic API calls are implemented, and 10 if there's comprehensive model integration with parameter tuning options.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the necessary dependencies and environment setup clearly specified?",
+      "description": "Evaluate whether the code includes complete environment setup instructions (Python version, GPU requirements, CUDA compatibility, memory needs) and dependency management (requirements.txt, Docker configuration, or virtual environment setup). Deduct 5 points if hardware requirements are not specified, 3 points if dependency versions are ambiguous. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the prompt engineering functionality implemented with appropriate controls?",
+      "description": "Assess whether the code implements prompt engineering capabilities, including prompt templates, modifier keywords, negative prompting, and weight/emphasis controls. Check if the system allows users to save, edit, and reuse successful prompts. Score 0 if basic text input only, 5 if simple prompt mechanisms exist, and 10 if advanced prompt engineering with guidance is fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a comprehensive user interface for image generation and management?",
+      "description": "Verify that the code implements a functional UI (web-based, desktop application, or CLI) with proper image generation controls, preview functionality, batch processing capability, and history/gallery management. Deduct 5 points if the UI lacks image manipulation features, 3 points if generation parameters cannot be adjusted intuitively, and 5 points if the gallery/history management is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common failure scenarios (GPU memory errors, API rate limits, network interruptions, invalid prompts) and provides appropriate error handling with user-friendly messages. Code should include timeout handling, retry logic, and graceful degradation. Give 10 points for comprehensive error handling, 5 points for basic error catching, and 0 points if exceptions are unhandled.",
+      "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. Image interpolation between prompts 2. Automatic prompt improvement suggestions 3. Style transfer capabilities 4. Integration with external content APIs). 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 model implementations that serve the same purpose 2. Unnecessary preprocessing steps that don't improve output quality 3. Over-complicated UI elements that obscure 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 (separating model interaction, UI, prompt processing, and image handling), configuration management, and scalability considerations. Deduct 5 points for global state pollution or monolithic architecture; deduct 5 points if the code lacks abstraction layers or has high coupling; deduct 5 points if configuration requires code changes rather than external files. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI design follows modern principles: 1) Clean layout with logical grouping of controls 2) Proper visual hierarchy highlighting important features 3) Consistent styling throughout the application 4) Responsive design accommodating different screen sizes. Deduct 3 points for cluttered interfaces, 5 points for inconsistent styling, and 5 points for poor accessibility features. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the performance optimization adequately addressed?",
+      "description": "Judge whether the code implements performance optimizations: 1) Efficient model loading and caching 2) Batch processing capabilities 3) Resource management (memory usage, concurrent generations) 4) Progress indicators for long-running operations. Deduct 5 points for each missing optimization strategy, 3 points for not handling large image generations efficiently, and 5 points for lack of resource monitoring. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "hard"
+}

package/library/data_science-machine_learning/web-program-import-tables-convert-to-ai-language.json

@@ -0,0 +1,68 @@
+{
+  "index": 1631,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring the code you generate is executable. Help me create a web program that imports tables and can convert them into a language that AI can analyze.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the table import functionality fully implemented?",
+      "description": "Review whether the code implements multiple table import methods (e.g., CSV, Excel, JSON, direct input) and properly handles different file encodings and formats. Score 0 if import functionality is missing, 5 if only basic format support is available, and 10 if comprehensive import options with error handling are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the table parsing and data extraction logic robust?",
+      "description": "Check whether the code correctly parses various table structures, handles headers, detects data types, and manages special characters. Examine if it deals with merged cells, empty values, and inconsistent formats. Deduct 5 points if basic CSV parsing only, 3 points if no data type inference exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the AI-compatible format conversion implemented correctly?",
+      "description": "Evaluate whether the code transforms tabular data into AI-readable formats (e.g., structured JSON, CSV with metadata, labeled datasets). Check for proper schema definition, adherence to common AI input conventions, and inclusion of relevant metadata. Deduct 5 points if the output lacks structure, 3 points if metadata is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a preview and validation system for the conversion?",
+      "description": "Assess if the code includes features to preview data before conversion, validate the transformed output, and provide feedback on potential issues (e.g., missing values, inconsistencies). Examine whether users can adjust settings and see real-time results. Deduct 5 points if preview functionality is absent, 3 points if validation is missing. 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 malformed tables, excessively large files, network interruptions during upload, 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-assisted data cleaning 2. Automatic column type detection and annotation 3. Historical conversion tracking and comparison). 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 parsing functions 2. Function modules unrelated to table conversion (e.g., unnecessary animations or widgets) 3. Complex features that affect core performance (e.g., overly sophisticated 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 import/parsing/conversion/UI layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Feedback on file upload/processing ≤ 100ms 2) Progress indicators for lengthy operations 3) Clear visual guidance through the conversion workflow. Deduct 5 points for each operation without feedback, 3 points for lack of progress indication during processing, and 5 points for confusing navigation between import and conversion steps. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Machine Learning",
+  "difficulty": "easy"
+}

package/library/data_science-predictive_modeling/grain-oil-futures-analysis-software.json

@@ -0,0 +1,68 @@
+{
+  "index": 1608,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable and demonstrable. Help me write a software for analyzing grain and oil futures on a six-month cycle that can obtain real-time trading information and policies for domestic grain and oil products. The data should be sourced from the National Grain Trade Center and GrainOil Duoduo. Ideally, it should integrate with AI large models. Please write all the code for the entire project.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the data acquisition system fully implemented?",
+      "description": "Review whether the code accurately implements web scraping or API integration with the National Grain Trade Center and GrainOil Duoduo. Check for proper authentication handling, rate limiting, error handling during data fetching, and data storage mechanisms. Score 0 if no data acquisition is implemented, 5 if only basic scraping without error handling is present, and 10 if robust data acquisition with fallback mechanisms and comprehensive error handling is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the six-month cycle futures analysis functionality properly implemented?",
+      "description": "Evaluate whether the code includes time series analysis algorithms appropriate for six-month cycle futures analysis (e.g., seasonal decomposition, cyclical pattern detection, trend analysis). Check for implementation of statistical methods like moving averages, ARIMA models, or other forecasting techniques. Deduct 5 points if only basic charting without actual cycle analysis is implemented, and 3 points if the analysis lacks statistical validation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is real-time trading information processing implemented?",
+      "description": "Check whether the code includes functionality to process and update real-time trading data, including websocket connections or frequent API polling, data transformation pipelines, and real-time visualization updates. Verify if price alerts, threshold notifications, or other real-time features are included. Deduct 5 points if data refresh rate is inadequate for trading decisions (>1 minute delay), and 5 points if there's no mechanism to handle network interruptions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the policy analysis integration with AI large models implemented?",
+      "description": "Assess whether the code effectively integrates with AI large models (e.g., GPT, BERT) for policy analysis, including proper API usage, prompt engineering for financial analysis, and context handling. Check if results from AI models are properly integrated into the analysis workflow. Deduct 5 points if AI integration is superficial with no domain-specific tuning, and 5 points if there's no evaluation mechanism for AI-generated insights. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures, API changes, malformed data, missing values in time series) 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 for market movements 2. Natural language query interface for market data 3. Custom alert system with multiple notification channels). 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 analysis functions (e.g., multiple trend detection algorithms without clear purpose) 2. Function modules unrelated to futures analysis (e.g., general financial calculators not specific to grain/oil) 3. Fancy visualizations that affect performance without adding analytical 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 (such as separating data acquisition/analysis/visualization 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 financial software standards?",
+      "description": "Evaluate whether the overall design follows professional financial software design principles: 1) Color scheme appropriate for financial data (clear differentiation between positive/negative trends, alerts) 2) Proper layout of multiple data panels without overwhelming the user 3) Professional typography for financial data presentation (clear hierarchy, readable numbers). Deduct 3 points for each crowded dashboard panel, 5 points for confusing trend visualization color schemes, and 5 points for poor information hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive for trading analysis?",
+      "description": "Judge whether the dynamic effects support effective financial analysis: 1) Chart interaction response ≤ 200ms 2) Smooth transitions between different timeframes and analysis views 3) Intuitive filtering and comparison tools. Deduct 5 points if data filtering causes significant lag, 3 points for jumpy transitions between analysis views, and 5 points for hidden or complex access to critical trading information. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Predictive Modeling",
+  "difficulty": "hard"
+}

package/library/data_science-predictive_modeling/power-station-trend-prediction-optimization-scheduling.json

@@ -0,0 +1,68 @@
+{
+  "index": 1030,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Ensure that the generated code is executable for demonstration. Using Java and Angular code, please implement:\n\nTrend prediction and optimization scheduling: Through data modeling, predict the future operational trends of power stations, providing scientific basis for power dispatching and energy allocation.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the data modeling and trend prediction algorithm fully implemented?",
+      "description": "Review whether the Java backend accurately implements time series analysis algorithms (such as ARIMA, LSTM, or Prophet models) for power station operational trend prediction. Check if the code includes data preprocessing, feature engineering, model training, and prediction validation. Score 0 if no prediction algorithm is implemented, 5 if only basic linear regression is used, and 10 if advanced machine learning models with proper validation metrics (MAE, RMSE, MAPE) are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the optimization scheduling system properly designed?",
+      "description": "Evaluate whether the Java implementation includes sophisticated optimization algorithms for power dispatching (such as genetic algorithms, particle swarm optimization, or linear programming). Check if the system considers constraints like power demand, generation capacity, transmission limits, and cost optimization. Deduct 5 points if only basic rule-based scheduling is implemented, and 3 points if real-time constraint handling is missing. Full score requires multi-objective optimization with constraint satisfaction.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the Angular frontend data visualization comprehensive and accurate?",
+      "description": "Check whether the Angular application provides comprehensive dashboards with real-time charts showing power generation trends, prediction accuracy, scheduling optimization results, and key performance indicators. Evaluate if interactive charts (using libraries like Chart.js, D3.js, or Highcharts) allow users to drill down into historical data and future predictions. Deduct 5 points if visualizations are static, and 3 points if real-time data updates are not implemented. Full score requires interactive, responsive charts with proper data binding.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the system integration between Java backend and Angular frontend robust?",
+      "description": "Assess whether the Java Spring Boot backend provides RESTful APIs with proper data serialization/deserialization for trend prediction results and scheduling recommendations. Check if Angular services properly consume these APIs with error handling, loading states, and real-time updates. Deduct 5 points if API documentation is missing, and 3 points if no proper error handling between frontend and backend. Full score requires complete API integration with proper authentication and data validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing data points, network interruptions, invalid input parameters, model prediction failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include proper exception handling, data validation, and graceful degradation. Give 10 points if fully implemented, 5 points if robustness is average, 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 experience (e.g., 1. Real-time anomaly detection alerts 2. What-if scenario analysis for different scheduling strategies 3. AI-powered recommendations for energy optimization 4. Integration with weather data for better predictions). 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 prediction models (e.g., multiple forecasting algorithms without proper comparison) 2. Function modules unrelated to power management (e.g., built-in social features) 3. Overly complex visualizations that affect performance (e.g., 3D animations without functional purpose). Deduct 3 points for each redundancy found, and directly deduct 10 points if core prediction/scheduling functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating prediction models, scheduling algorithms, data access layers, and Angular components/services), unit test coverage for critical algorithms, and proper build configuration. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if code duplication rate is too high (over 30%); deduct 5 points if no automated testing or build pipeline is implemented. Full score requires clean architecture with proper separation of concerns.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the Angular dashboard follows modern design principles: 1) Professional color scheme suitable for industrial applications (no more than 3 primary colors) 2) Proper grid layout with consistent spacing (following 8px grid system) 3) Professional typography with readable fonts (body text ≥ 14px, line height ≥ 1.5). Deduct 3 points for each cluttered visual element, 5 points for inappropriate color combinations that hinder data interpretation, and 5 points for poor information hierarchy. Full score requires clean, professional industrial UI design.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the Angular application's dynamic effects conform to user experience standards: 1) Data loading feedback ≤ 100ms 2) Chart transitions and animations between 300-500ms 3) Clear visual indicators for prediction confidence and scheduling status. Deduct 5 points for each operation without proper loading states, 3 points for choppy chart animations during data updates, and 5 points if critical prediction/scheduling controls are hard to locate. Full score requires smooth, responsive interactions with proper visual feedback.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Predictive Modeling",
+  "difficulty": "hard"
+}

package/library/data_science-predictive_modeling/program-for-market-software-buy-sell-signals.json

@@ -0,0 +1,68 @@
+{
+  "index": 1503,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure that the code you produce is executable for demonstration. You should create a program that connects to market software to provide buy and sell signals based on individually provided indicator requirements.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the market data connection implementation complete?",
+      "description": "Review whether the code properly implements connection to market software with authentication, error handling, and reconnection mechanisms. Check if it handles different API protocols (REST, WebSocket, FIX) and includes rate limiting compliance. Score 0 if no connection is implemented, 5 if basic connection exists but lacks error handling, and 10 if a robust connection system with failover is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the technical indicators correctly implemented?",
+      "description": "Evaluate whether common technical indicators (e.g., moving averages, RSI, MACD, Bollinger Bands) are accurately calculated with proper mathematical formulas and optimized algorithms. Verify indicator parameterization for customization. Deduct 5 points for calculation errors, 3 points for inefficient implementations that would cause performance issues with large datasets. Full score requires at least 5 properly implemented indicators with customizable parameters.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the signal generation logic comprehensive?",
+      "description": "Check if buy/sell signal generation follows clear rules based on indicator combinations. Verify presence of signal strength categorization, false signal filtering, and confirmation logic. Assess if the system handles conflicting signals appropriately. Deduct 5 points if signals are based on single indicators only, 3 points if there's no noise filtering. Give 10 points only if the system includes multiple timeframe analysis and signal confirmation strategies.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Does the program include backtesting capability?",
+      "description": "Evaluate whether the code includes historical backtesting functionality with performance metrics (win rate, profit factor, maximum drawdown, Sharpe ratio). Check if it handles different market conditions and allows parameter optimization. Score 0 if no backtesting exists, 5 if basic backtesting without performance metrics is implemented, and 10 if comprehensive backtesting with optimization capabilities is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as API disconnections, market data gaps, extreme volatility events, etc.) and provide appropriate error handling and 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. Machine learning signal validation 2. Sentiment analysis integration 3. Risk management with position sizing 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 indicators or signals 2. Function modules unrelated to trading decision making 3. Unnecessary complex calculations that add little value to signal generation. 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 fetching/signal generation/notification layers), unit test coverage, and logging mechanisms. 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 appropriate error logging system. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the visualization interface meet professional standards?",
+      "description": "Evaluate whether the trading interface (if applicable) follows professional design principles: 1) Clear presentation of indicators and signals 2) Proper use of colors for buy/sell signals (e.g., green/red) 3) Legible charts with appropriate time scaling. Deduct 3 points for cluttered visualizations, 5 points for misleading visual representations of data, and 5 points for charts lacking essential information (price, volume, time). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the alert and notification system effective?",
+      "description": "Judge whether the signal notification system is well-designed: 1) Timely alerts within 1 second of signal generation 2) Multiple notification channels (email, SMS, push notifications) 3) Clear differentiation between signal types and urgency levels. Deduct 5 points for delayed notifications, 3 points for limited notification options, and 5 points for ambiguous alert messages that don't clearly indicate action required. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Predictive Modeling",
+  "difficulty": "hard"
+}

package/library/data_science-predictive_modeling/real-time-trading-signals-high-accuracy.json

@@ -0,0 +1,68 @@
+{
+  "index": 1563,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate can be executed and displayed. Integrate real-time market data to show buy and sell signals with 90% accuracy and 30% return rate. After generating the code, conduct practical testing.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the market data integration system fully implemented?",
+      "description": "Review whether the code properly integrates with market data APIs (like Yahoo Finance, Alpha Vantage, or IEX Cloud), implements proper error handling for API limits/failures, and correctly parses the returned data. Score 0 if no real market data integration is implemented, 5 if basic integration exists but lacks error handling, and 10 if comprehensive data fetching with fallback mechanisms and caching strategies is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the buy/sell signal algorithms properly implemented with verification?",
+      "description": "Evaluate whether the code implements substantiated technical analysis algorithms (such as MACD, RSI, Bollinger Bands) or machine learning models with proper backtesting framework. Check if the claimed 90% accuracy is verified with proper statistical testing (precision, recall, F1 score) on out-of-sample data. Score 0 if algorithms are merely referenced without implementation, 5 if basic indicators are implemented but lack validation, and 10 if comprehensive signal generation with statistical validation is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is a performance backtesting system implemented to verify the 30% return rate?",
+      "description": "Check whether the code includes a proper backtesting framework that accounts for transaction costs, slippage, and market impact. Verify that the claimed 30% return is tested against historical data with proper risk-adjusted metrics (Sharpe ratio, maximum drawdown, Sortino ratio). Deduct 5 points if backtesting doesn't include transaction costs, and 3 points if risk metrics are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the visualization of market data and signals well-implemented?",
+      "description": "Review whether the code implements interactive charts (using libraries like D3.js, Highcharts, or Plotly) that clearly mark buy/sell signals on price data, with proper tooltips, zoom functionality, and time period selection. Score 0 if no visualization is implemented, 5 if basic static charts are provided, and 10 if fully interactive visualizations with clear signal indicators and performance metrics are included.",
+      "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, market holidays, extreme volatility, 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 alerts via email/SMS 2. Portfolio optimization suggestions 3. Market sentiment analysis integration). 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 technical indicators 2. Function modules unrelated to trading (e.g., unnecessary social media integration) 3. Fancy effects that affect performance (e.g., excessive animations that slow down market data updates). 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 fetching/analysis/visualization 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 financial dashboard standards?",
+      "description": "Evaluate whether the design follows professional financial interface principles: 1) Appropriate color schemes for market data (red/green for price changes, muted colors for background) 2) Clear data hierarchy with proper emphasis on key metrics 3) Professional typography with high readability for numbers. Deduct 3 points for each misleading visual element, 5 points for inappropriate color schemes that hinder data interpretation, and 5 points for cluttered dashboards that obscure critical information. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive for real-time market updates?",
+      "description": "Judge whether the dynamic effects support effective market monitoring: 1) Real-time data updates without page refresh 2) Smooth transitions when new data points arrive 3) Responsive interface that maintains performance even with high-frequency data. Deduct 5 points for each second of lag in data updates, 3 points for jumpy/disruptive transitions during data refreshes, and 5 points for performance degradation during market hours. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Predictive Modeling",
+  "difficulty": "hard"
+}