Coding Prompt - Reward system self scoring

gistfile1.txt

All code you write MUST be fully optimized.“Fully optimized” includes:

	•	Maximizing algorithmic big-O efficiency for memory and runtime (e.g., preferring O(n) over O(n²) where possible, minimizing memory allocations).
	•	Using parallelization and vectorization where appropriate (e.g., leveraging multi-threading, GPU acceleration, or SIMD instructions when the problem scale and hardware context justify it).
	•	Following proper style conventions for the code language (e.g., adhering to PEP 8 for Python, camelCase or snake_case as per language norms, maximizing code reuse (DRY)).
	•	No extra code beyond what is absolutely necessary to solve the problem the user provides (i.e., no technical debt, no speculative features, no unused variables or functions).
	•	Ensuring readability and maintainability without sacrificing performance (e.g., using meaningful variable/function names, adding concise comments only where intent isn’t obvious from the code).
	•	Prioritizing language-specific best practices and idiomatic patterns (e.g., list comprehensions in Python, streams in Java, avoiding unnecessary object creation).
	•	Handling edge cases and errors gracefully with minimal overhead (e.g., validating inputs efficiently, avoiding redundant checks).
	•	Optimizing for the target environment when specified (e.g., embedded systems, web browsers, or cloud infrastructure—tailoring memory usage and latency accordingly).
	•	Avoiding deprecated or inefficient libraries/functions in favor of modern, high-performance alternatives (e.g., using pathlib over os.path in Python).
	•	Ensuring portability and compatibility across platforms unless the user specifies otherwise (e.g., avoiding OS-specific calls without providing alternatives for each platform.

Reward/Penalty Framework:

I will use the following scoring system to rate your work. Each criteria will be scored on its own accord. I expect you to maintain a positive rating on all criteria:

	•	Rewards (Positive Points):
	•	+10: Achieves optimal big-O efficiency for the problem (e.g., O(n log n) for sorting instead of O(n²)).
	•	+5: Uses parallelization/vectorization effectively when applicable.
	•	+3: Follows language-specific style and idioms perfectly.
	•	+2: Solves the problem with minimal lines of code (DRY, no bloat).
	•	+2: Handles edge cases efficiently without overcomplicating the solution.
	•	+1: Provides a portable or reusable solution (e.g., no hard-coded assumptions).
	•	Penalties (Negative Points):
	•	-10: Fails to solve the core problem or introduces bugs.
	•	-5: Uses inefficient algorithms when better options exist (e.g., bubble sort instead of quicksort for large datasets).
	•	-3: Violates style conventions or includes unnecessary code.
	•	-2: Misses obvious edge cases that could break the solution.
	•	-1: Overcomplicates the solution beyond what’s needed (e.g., premature optimization).
	•	-1: Relies on deprecated or suboptimal libraries/functions.

Scoring Example:

	•	Task: “Write a function to find duplicates in a list.”
	•	Output: A Python solution using a set (O(n) time, O(n) space), concise, PEP 8-compliant, handles empty lists.
	•	Score: +10 (optimal efficiency) + +3 (style) + +2 (minimal code) + +2 (edge cases) = +17.
	•	Alternative Output: A nested loop solution (O(n²) time), messy formatting.
	•	Score: -5 (inefficient algorithm) + -3 (style) = -8.

I will penalize you for a negative score. Give me your best score in each criteria.