id stringclasses 50
values | testsource stringclasses 6
values | language stringclasses 6
values | prefix stringlengths 16 3.39k | golden_completion stringlengths 23 3.14k | suffix stringlengths 0 2.68k | assertions stringlengths 0 2.72k | category stringclasses 6
values |
|---|---|---|---|---|---|---|---|
1 | devbench-api-usage | java | import java.security.MessageDigest;
import java.math.BigInteger;
public class AUTask1 {
public static String sha256Hex(byte[] data) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(data);
byte[] digest = md.digest();
return String.fo... | public static String describeSha256Hex() {
return "Computes SHA-256 hash using MessageDigest.getInstance(\"SHA-256\"). "
+ "Feeds input via update(byte[]) then retrieves raw digest with digest(). "
+ "Converts to 64-character lowercase hexadecimal string using "
+ "Big... |
public static void main(String[] args) {
String hash = sha256Hex("hello".getBytes());
assert hash.length() == 64 : "Hash must be 64 hex chars";
assert hash.equals("2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824");
String desc = describeSha256Hex();
assert ... | String d = AUTask1.describeSha256Hex().toLowerCase();
assert d.contains("getinstance") : "Must mention getInstance";
assert d.contains("update(byte[])") || d.contains("update(byte") : "Must mention update(byte[])";
assert d.contains("digest()") : "Must mention digest()";
assert d.contains("biginteger") : "Must mention ... | api_usage |
2 | devbench-api-usage | java | import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
public class AUTask2 {
public static void writeExclusive(Path path, List<String> lines) throws IOException {
Files.write(path, lines, StandardCharsets.UTF_8,
StandardOpen... | public static String describeWriteExclusive() {
return "Writes lines to path using Files.write(Path, Iterable, Charset, OpenOption...) "
+ "with StandardCharsets.UTF_8 encoding. Uses StandardOpenOption.CREATE_NEW to "
+ "atomically create a new file, failing with FileAlreadyExistsE... |
public static void main(String[] args) throws IOException {
Path tmp = Files.createTempDirectory("au2");
Path file = tmp.resolve("test.txt");
writeExclusive(file, List.of("hello", "world"));
assert Files.exists(file);
List<String> read = Files.readAllLines(file, StandardChar... | String d = AUTask2.describeWriteExclusive().toLowerCase();
assert d.contains("files.write") : "Must mention Files.write";
assert d.contains("create_new") : "Must mention CREATE_NEW";
assert d.contains("filealreadyexistsexception") || d.contains("already exists") : "Must mention FileAlreadyExistsException";
assert d.con... | api_usage |
3 | devbench-api-usage | java | import java.time.*;
import java.time.format.*;
public class AUTask3 {
// Parse a date string strictly: reject invalid dates like Feb 30 or Feb 29
// on non-leap years. Uses ResolverStyle.STRICT with 'uuuu' year pattern
// (not 'yyyy' which requires era). Return the parsed LocalDate.
// If parsing fails... | try {
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("uuuu-MM-dd")
.withResolverStyle(ResolverStyle.STRICT);
return LocalDate.parse(dateStr, fmt);
} catch (DateTimeParseException e) {
return null;
}
| }
public static void main(String[] args) {
assert parseStrict("2024-02-29") != null : "2024 is leap year";
assert parseStrict("2024-02-29").equals(LocalDate.of(2024, 2, 29));
assert parseStrict("2023-02-29") == null : "2023 is not leap year";
assert parseStrict("2024-02-30") == ... | assert AUTask3.parseStrict("2024-04-31") == null : "Apr has 30 days";
assert AUTask3.parseStrict("2024-06-31") == null : "Jun has 30 days";
assert AUTask3.parseStrict("2100-02-29") == null : "2100 is not leap (divisible by 100)";
assert AUTask3.parseStrict("2000-02-29") != null : "2000 IS leap (divisible by 400)";
asse... | api_usage |
4 | devbench-api-usage | java | import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
public class AUTask4 {
public static ConcurrentHashMap<String, Integer> countWords(String[] words) {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
for (String w : words) {
map.merg... | public static String describeCountAndCompute() {
return "countWords uses ConcurrentHashMap.merge(key, 1, Integer::sum) to atomically "
+ "increment word counts. merge() inserts the value 1 if key is absent, or applies "
+ "the remapping function Integer::sum to the existing value a... |
public static void main(String[] args) {
var counts = countWords(new String[]{"a", "b", "a", "c", "a", "b"});
assert counts.get("a") == 3;
assert counts.get("b") == 2;
assert counts.get("c") == 1;
computeIfPresentDouble(counts, "a");
assert counts.get("a") == 6 : "a... | String d = AUTask4.describeCountAndCompute().toLowerCase();
assert d.contains("merge(") || d.contains("merge(key") : "Must mention merge method call";
assert d.contains("integer::sum") || d.contains("integer.sum") : "Must mention Integer::sum";
assert d.contains("absent") : "Must mention absent key behavior";
assert d.... | api_usage |
5 | devbench-api-usage | java | import java.util.*;
public class AUTask5 {
public static List<String> wrapUnmodifiable(List<String> source) {
return Collections.unmodifiableList(source);
}
public static List<String> snapshot(List<String> source) {
return List.copyOf(source);
}
| public static String describeListWrapping() {
return "wrapUnmodifiable returns Collections.unmodifiableList(source), which creates "
+ "an unmodifiable view backed by the original list. Mutations to source are "
+ "visible through the returned view. Calling add/remove/set on the vi... |
public static void main(String[] args) {
List<String> src = new ArrayList<>(List.of("a", "b"));
List<String> view = wrapUnmodifiable(src);
List<String> copy = snapshot(src);
src.add("c");
assert view.size() == 3 : "View must reflect source mutation";
assert copy.siz... | String d = AUTask5.describeListWrapping().toLowerCase();
assert d.contains("view") || d.contains("backed") : "Must mention view/backed semantics";
assert d.contains("mutations to source") || d.contains("original list") : "Must mention live view semantics";
assert d.contains("unsupportedoperationexception") : "Must ment... | api_usage |
6 | devbench-api-usage | java | import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class AUTask6 {
// Encode inputBytes using URL-safe Base64 WITHOUT padding.
// Must use Base64.getUrlEncoder().withoutPadding().
// URL-safe Base64 uses '-' and '_' instead of '+' and '/'.
// The result must NOT contain '=' paddi... | return Base64.getUrlEncoder().withoutPadding().encodeToString(inputBytes);
| }
public static void main(String[] args) {
// Test with bytes that produce '+' and '/' in standard Base64
byte[] testData = {(byte)0xFB, (byte)0xFF, (byte)0xBF};
String standard = Base64.getEncoder().encodeToString(testData);
String urlSafe = urlSafeEncode(testData);
as... | // Test that URL-safe chars are used
byte[] d1 = {(byte)0x3E, (byte)0xFF, (byte)0x3F};
String r1 = AUTask6.urlSafeEncode(d1);
assert !r1.contains("+") && !r1.contains("/") && !r1.contains("=") : "Must use URL-safe alphabet without padding";
// Verify it decodes correctly
byte[] back = java.util.Base64.getUrlDecoder().d... | api_usage |
7 | devbench-api-usage | java | import java.util.regex.*;
import java.util.*;
public class AUTask7 {
public static List<String> findMatches(String text, String regex) {
Pattern p = Pattern.compile(regex,
Pattern.CASE_INSENSITIVE | Pattern.DOTALL | Pattern.MULTILINE);
Matcher m = p.matcher(text);
List<String> r... | public static String describeFindMatches() {
return "Compiles regex with Pattern.compile(regex, flags) using bitwise-OR combination "
+ "of Pattern.CASE_INSENSITIVE | Pattern.DOTALL | Pattern.MULTILINE. "
+ "CASE_INSENSITIVE enables Unicode-unaware case folding (ASCII only unless "... |
public static void main(String[] args) {
List<String> r = findMatches("Hello\nWORLD\ntest", "hello|world|test");
assert r.size() == 3 : "Should find 3 case-insensitive matches, got " + r.size();
assert r.contains("Hello");
assert r.contains("WORLD");
assert r.contains("test"... | String d = AUTask7.describeFindMatches().toLowerCase();
assert d.contains("pattern.compile") : "Must mention Pattern.compile";
assert d.contains("bitwise") || d.contains("or") || d.contains("|") : "Must mention flag combination";
assert d.contains("case_insensitive") : "Must mention CASE_INSENSITIVE flag";
assert d.con... | api_usage |
8 | devbench-api-usage | java | import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class AUTask8 {
public static String encodeStandard(byte[] data) {
return Base64.getEncoder().encodeToString(data);
}
public static String encodeUrlSafe(byte[] data) {
return Base64.getUrlEncoder().encodeToString(dat... | public static String describeEncoders() {
return "encodeStandard uses Base64.getEncoder() which produces RFC 4648 standard "
+ "encoding with characters A-Z, a-z, 0-9, '+', '/' and '=' padding. "
+ "encodeUrlSafe uses Base64.getUrlEncoder() which replaces '+' with '-' and "
... |
public static void main(String[] args) {
// 2 bytes: requires padding, and 0xFB 0xFF produces + and / in standard
byte[] data = {(byte)0xFB, (byte)0xFF};
String std = encodeStandard(data);
String url = encodeUrlSafe(data);
String urlNoPad = encodeUrlSafeNoPad(data);
... | String d = AUTask8.describeEncoders().toLowerCase();
assert d.contains("rfc 4648") || d.contains("rfc4648") : "Must mention RFC 4648";
assert d.contains("'+'") || d.contains("plus") : "Must mention + character";
assert d.contains("'/'") || d.contains("slash") : "Must mention / character";
assert d.contains("'-'") || d.... | api_usage |
9 | devbench-api-usage | java | import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
public class AUTask9 {
// Atomically initialize-or-update a running average in a ConcurrentHashMap.
// Each entry stores a double[] of {sum, count}. Use compute() to atomically
// update both sum and count. If ... | double[][] result = new double[1][];
map.compute(key, (k, existing) -> {
if (existing == null) {
result[0] = new double[]{value, 1};
} else {
existing[0] += value;
existing[1] += 1;
result[0] = existing;
... | }
public static void main(String[] args) {
ConcurrentHashMap<String, double[]> map = new ConcurrentHashMap<>();
double avg1 = updateAverage(map, "sensor", 10.0);
assert avg1 == 10.0 : "First value avg should be 10.0, got " + avg1;
double avg2 = updateAverage(map, "sensor", 20.0... | var m = new java.util.concurrent.ConcurrentHashMap<String, double[]>();
double r1 = AUTask9.updateAverage(m, "k", 100.0);
assert r1 == 100.0;
double r2 = AUTask9.updateAverage(m, "k", 200.0);
assert r2 == 150.0;
double r3 = AUTask9.updateAverage(m, "k", 0.0);
assert Math.abs(r3 - 100.0) < 0.001 : "Avg of 100,200,0 shou... | api_usage |
10 | devbench-api-usage | java | import java.time.*;
import java.time.format.*;
public class AUTask10 {
public static LocalDate parseSmartDate(String dateStr) {
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd")
.withResolverStyle(ResolverStyle.SMART);
return LocalDate.parse(dateStr, fmt);
}
pub... | public static String describeResolverStyles() {
return "parseSmartDate uses ResolverStyle.SMART (the default for ofPattern) which "
+ "adjusts invalid day-of-month to the last valid day. For example, June 31 "
+ "becomes June 30. February 29 on a non-leap year becomes February 28. ... |
public static void main(String[] args) {
// SMART: June 31 -> June 30
LocalDate smart = parseSmartDate("2024-06-31");
assert smart.equals(LocalDate.of(2024, 6, 30)) : "SMART: Jun 31 -> Jun 30";
// LENIENT: June 31 -> July 1
LocalDate lenient = parseLenientDate("2024-06-31")... | String d = AUTask10.describeResolverStyles().toLowerCase();
assert d.contains("resolverstyyle") || d.contains("resolverstyle") || d.contains("smart") : "Must reference ResolverStyle";
assert d.contains("adjusts") || d.contains("last valid day") || d.contains("clamp") : "Must describe SMART adjustment behavior";
assert ... | api_usage |
11 | devbench-api-usage | java | import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class AUTask11 {
public static int sumOfSquares(List<Integer> nums) {
return nums.parallelStream()
.reduce(0,
(acc, x) -> acc + x * x,
(a, b) -... | public static String describeSumOfSquares() {
return "Computes sum of squares using parallelStream().reduce(int, IntBinaryOperator, IntBinaryOperator) "
+ "with identity 0, accumulator (acc, x) -> acc + x * x, and combiner (a, b) -> a + b. "
+ "The identity value 0 is the initial v... |
public static void main(String[] args) {
assert sumOfSquares(Arrays.asList(1, 2, 3)) == 14 : "1+4+9=14";
assert sumOfSquares(Arrays.asList()) == 0 : "empty=0";
assert sumOfSquares(Arrays.asList(5)) == 25 : "single=25";
String doc = describeSumOfSquares();
assert doc != null ... | String doc11 = AUTask11.describeSumOfSquares();
assert doc11.contains("parallelStream") : "must mention parallelStream";
assert doc11.contains("identity") : "must mention identity value";
assert doc11.contains("0") : "must mention identity is 0";
assert doc11.contains("accumulator") : "must mention accumulator";
assert... | api_usage |
12 | devbench-api-usage | java | import java.util.*;
import java.util.stream.Collectors;
public class AUTask12 {
public static Map<Integer, Long> countByLength(List<String> words) {
return words.stream()
.collect(Collectors.groupingBy(
String::length,
Collectors.counting(... | public static String describeCountByLength() {
return "Groups words by their length using Collectors.groupingBy(String::length, Collectors.counting()). "
+ "The classifier function String::length maps each word to its character count. "
+ "The downstream collector Collectors.counti... |
public static void main(String[] args) {
Map<Integer, Long> r = countByLength(Arrays.asList("hi", "no", "yes", "ok", "run"));
assert r.get(2) == 3L : "three 2-letter words";
assert r.get(3) == 2L : "two 3-letter words";
String doc = describeCountByLength();
assert doc != nul... | String doc12 = AUTask12.describeCountByLength();
assert doc12.contains("Collectors.groupingBy") : "must name Collectors.groupingBy";
assert doc12.contains("String::length") : "must name classifier String::length";
assert doc12.contains("Collectors.counting") : "must name downstream Collectors.counting";
assert doc12.co... | api_usage |
13 | devbench-api-usage | java | import java.text.NumberFormat;
import java.math.RoundingMode;
import java.util.Locale;
public class AUTask13 {
public static String formatCurrency(double amount) {
NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.GERMANY);
nf.setRoundingMode(RoundingMode.HALF_UP);
nf.setMinimumFrac... | public static String describeFormatCurrency() {
return "Formats amount as German currency using NumberFormat.getCurrencyInstance(Locale.GERMANY). "
+ "Sets RoundingMode.HALF_UP via setRoundingMode to round half-values upward. "
+ "Configures exactly 2 fraction digits via setMinimum... |
public static void main(String[] args) {
String result = formatCurrency(1234.565);
assert result.contains("1.234,57") || result.contains("1234,57") : "should round 1234.565 -> ...57: " + result;
String doc = describeFormatCurrency();
assert doc != null && doc.contains("NumberFormat"... | String doc13 = AUTask13.describeFormatCurrency();
assert doc13.contains("getCurrencyInstance") : "must name getCurrencyInstance";
assert doc13.contains("Locale.GERMANY") : "must name Locale.GERMANY";
assert doc13.contains("RoundingMode.HALF_UP") : "must name RoundingMode.HALF_UP";
assert doc13.contains("setRoundingMode... | api_usage |
14 | devbench-api-usage | java | import java.util.Arrays;
import java.util.Comparator;
public class AUTask14 {
public static String[] sortNullsFirst(String[] arr) {
String[] copy = Arrays.copyOf(arr, arr.length);
Arrays.sort(copy, Comparator.nullsFirst(Comparator.naturalOrder()));
return copy;
}
| public static String describeSortNullsFirst() {
return "Copies the array via Arrays.copyOf(arr, arr.length), then sorts with "
+ "Arrays.sort(copy, Comparator.nullsFirst(Comparator.naturalOrder())). "
+ "Comparator.nullsFirst wraps Comparator.naturalOrder() so that null elements "
... |
public static void main(String[] args) {
String[] r = sortNullsFirst(new String[]{"banana", null, "apple"});
assert r[0] == null : "null first";
assert r[1].equals("apple") : "then apple";
assert r[2].equals("banana") : "then banana";
String doc = describeSortNullsFirst();
... | String doc14 = AUTask14.describeSortNullsFirst();
assert doc14.contains("Arrays.copyOf") : "must name Arrays.copyOf";
assert doc14.contains("Arrays.sort") : "must name Arrays.sort";
assert doc14.contains("Comparator.nullsFirst") : "must name Comparator.nullsFirst";
assert doc14.contains("Comparator.naturalOrder") : "mu... | api_usage |
15 | devbench-api-usage | java | import java.util.Optional;
import java.util.function.Function;
public class AUTask15 {
public static Optional<Integer> parseAndDouble(String input) {
return Optional.ofNullable(input)
.filter(s -> !s.isEmpty())
.flatMap(s -> {
try {
... | public static String describeParseAndDouble() {
return "Wraps input with Optional.ofNullable(input), filters out empty strings via filter(s -> !s.isEmpty()), "
+ "then uses flatMap to parse the string into an integer with Integer.parseInt. "
+ "flatMap is used instead of map becaus... |
public static void main(String[] args) {
assert parseAndDouble("5").equals(Optional.of(10));
assert parseAndDouble(null).equals(Optional.empty());
assert parseAndDouble("").equals(Optional.empty());
assert parseAndDouble("abc").equals(Optional.empty());
String doc = describe... | String doc15 = AUTask15.describeParseAndDouble();
assert doc15.contains("Optional.ofNullable") : "must name Optional.ofNullable";
assert doc15.contains("filter") : "must mention filter step";
assert doc15.contains("flatMap") : "must name flatMap";
assert doc15.contains("map") : "must name map for doubling";
assert doc1... | api_usage |
16 | devbench-api-usage | java | import java.util.Locale;
public class AUTask16 {
public static String formatDecimal(double value) {
return String.format(Locale.US, "%,.2f", value);
}
public static String formatDecimalDE(double value) {
return String.format(Locale.GERMANY, "%,.2f", value);
}
| public static String describeFormatDecimal() {
return "Formats value using String.format(Locale.US, \"%,.2f\", value). "
+ "The format specifier %,.2f means: comma as grouping separator, "
+ "2 decimal places, and floating-point conversion. "
+ "With Locale.US: comma g... |
public static void main(String[] args) {
assert formatDecimal(1234.5).equals("1,234.50") : formatDecimal(1234.5);
assert formatDecimalDE(1234.5).equals("1.234,50") : formatDecimalDE(1234.5);
String doc = describeFormatDecimal();
assert doc != null && doc.contains("Locale");
... | String doc16 = AUTask16.describeFormatDecimal();
assert doc16.contains("String.format") : "must name String.format";
assert doc16.contains("Locale.US") : "must name Locale.US";
assert doc16.contains("Locale.GERMANY") : "must name Locale.GERMANY";
assert doc16.contains("%,.2f") || doc16.contains("grouping separator") : ... | api_usage |
17 | devbench-api-usage | java | import java.util.*;
public class AUTask17 {
public static SortedMap<String, Integer> rangeQuery(
TreeMap<String, Integer> map, String fromKey, String toKey) {
return map.subMap(fromKey, toKey);
}
public static SortedMap<String, Integer> headQuery(
TreeMap<String, Integer> m... | public static String describeRangeQueries() {
return "subMap(fromKey, toKey) returns a live view from fromKey (inclusive) to toKey (exclusive). "
+ "headMap(toKey) returns a live view of keys strictly less than toKey. "
+ "tailMap(fromKey) returns a live view of keys greater than o... |
public static void main(String[] args) {
TreeMap<String, Integer> m = new TreeMap<>();
m.put("a", 1); m.put("b", 2); m.put("c", 3); m.put("d", 4);
SortedMap<String, Integer> sub = rangeQuery(m, "b", "d");
assert sub.size() == 2 : "b,c only: " + sub;
assert sub.containsKey("... | String doc17 = AUTask17.describeRangeQueries();
assert doc17.contains("inclusive") : "must mention fromKey inclusive";
assert doc17.contains("exclusive") : "must mention toKey exclusive";
assert doc17.contains("live view") || doc17.contains("backed view") : "must mention views are backed/live";
assert doc17.contains("h... | api_usage |
18 | devbench-api-usage | java | import java.util.*;
public class AUTask18 {
| public static List<String> makeLiveReadOnly(List<String> source) {
return Collections.unmodifiableList(source);
}
public static List<String> makeSnapshot(List<String> source) {
return List.copyOf(source);
}
|
public static void main(String[] args) {
List<String> base = new ArrayList<>(Arrays.asList("a", "b"));
// Live view: reflects changes to base
List<String> live = makeLiveReadOnly(base);
assert live.size() == 2;
base.add("c");
assert live.size() == 3 : "unmodifiableL... | List<String> base18 = new ArrayList<>(Arrays.asList("p", "q"));
List<String> live18 = AUTask18.makeLiveReadOnly(base18);
base18.add("r");
assert live18.contains("r") : "unmodifiableList must reflect source changes";
assert live18.size() == 3;
List<String> snap18 = AUTask18.makeSnapshot(Arrays.asList("a", "b"));
assert ... | api_usage |
19 | devbench-api-usage | java | import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class AUTask19 {
| public static <K, V> V atomicGetOrCreate(ConcurrentHashMap<K, V> map, K key, java.util.function.Function<K, V> factory) {
return map.computeIfAbsent(key, factory);
}
public static <K, V> V nonAtomicGetOrCreate(Map<K, V> map, K key, java.util.function.Function<K, V> factory) {
V val = map.ge... |
public static void main(String[] args) {
ConcurrentHashMap<String, List<Integer>> cmap = new ConcurrentHashMap<>();
// computeIfAbsent: mapping function runs at most once per key
List<Integer> list1 = atomicGetOrCreate(cmap, "nums", k -> new ArrayList<>());
list1.add(1);
Li... | ConcurrentHashMap<String, List<Integer>> cm19 = new ConcurrentHashMap<>();
List<Integer> r19a = AUTask19.atomicGetOrCreate(cm19, "x", k -> new ArrayList<>());
r19a.add(42);
List<Integer> r19b = AUTask19.atomicGetOrCreate(cm19, "x", k -> new ArrayList<>());
assert r19a == r19b : "computeIfAbsent must return same instanc... | api_usage |
20 | devbench-api-usage | java | import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.format.ResolverStyle;
import java.time.chrono.IsoChronology;
public class AUTask20 {
| public static LocalDate parseStrict(String dateStr) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd")
.withResolverStyle(ResolverStyle.STRICT)
.withChronology(IsoChronology.INSTANCE);
return LocalDate.parse(dateStr, formatter);
}
publi... |
public static void main(String[] args) {
// Valid dates
assert isValidDate("2024-02-29") : "2024 is leap year";
assert isValidDate("2024-01-31") : "Jan has 31 days";
// Invalid dates — STRICT mode rejects these
assert !isValidDate("2023-02-29") : "2023 is not leap year";
... | assert AUTask20.isValidDate("2000-02-29") : "2000 is leap";
assert !AUTask20.isValidDate("1900-02-29") : "1900 is not leap";
assert AUTask20.isValidDate("2024-12-31");
assert !AUTask20.isValidDate("2024-06-31") : "June has 30 days";
assert AUTask20.isValidDate("0000-01-01") : "year 0 (1 BC) is valid with uuuu";
assert ... | api_usage |
21 | devbench-api-usage | java | import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class AUTask21 {
public static String hmacSha256Base64(String message, String secretKey) {
try {
SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes("UTF-8"), "HmacSHA256");
Mac... | public static String describeHmacSha256Base64() {
return "Computes HMAC-SHA256 of the message using javax.crypto.Mac.getInstance(\"HmacSHA256\"). "
+ "The secret key is wrapped in a SecretKeySpec constructed with the algorithm name \"HmacSHA256\" "
+ "and the key bytes obtained via... |
public static void main(String[] args) {
String doc = describeHmacSha256Base64();
assert doc != null && !doc.isEmpty() : "Doc must not be empty";
assert doc.contains("Mac") : "Must mention Mac";
assert doc.contains("HmacSHA256") : "Must mention HmacSHA256";
// Functional ch... |
String d = describeHmacSha256Base64().toLowerCase();
assert d.contains("secretkeyspec") : "Must mention SecretKeySpec";
assert d.contains("mac.getinstance") : "Must mention Mac.getInstance";
assert d.contains("mac.init") : "Must mention Mac.init";
assert d.contains("dofinal") : ... | api_usage |
22 | devbench-api-usage | java | import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.LinkedHashMap;
import java.util.Map;
public class AUTask22 {
private static final Pattern LOG_PATTERN = Pattern.compile(
"(?<timestamp>\\d{4}-\\d{2}-\\d{2})\\s+(?<level>WARN|ERROR|INFO)\\s+(?<msg>.+)",
Pattern.CASE_INS... | public static String describeParseLogEntry() {
return "Parses a log line using Pattern.compile with named capturing groups (?<timestamp>...), "
+ "(?<level>...), and (?<msg>...) accessed via Matcher.group(String). "
+ "The pattern is compiled with flags Pattern.CASE_INSENSITIVE | P... |
public static void main(String[] args) {
String doc = describeParseLogEntry();
assert doc != null : "Doc must exist";
assert doc.contains("named") : "Must mention named groups";
Map<String, String> r = parseLogEntry("2024-01-15 ERROR something broke");
assert "2024-01-15".e... |
String d = describeParseLogEntry().toLowerCase();
assert d.contains("pattern.compile") : "Must mention Pattern.compile";
assert d.contains("case_insensitive") : "Must mention CASE_INSENSITIVE flag";
assert d.contains("dotall") : "Must mention DOTALL flag";
assert d.contains("mat... | api_usage |
23 | devbench-api-usage | java | import java.nio.file.*;
import java.io.IOException;
public class AUTask23 {
public static void atomicReplace(Path source, Path target) throws IOException {
Files.move(source, target,
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.ATOMIC_MOVE);
}
public static void ... | public static String describeFileOps() {
return "atomicReplace uses Files.move(Path, Path, CopyOption...) with "
+ "StandardCopyOption.REPLACE_EXISTING and StandardCopyOption.ATOMIC_MOVE. "
+ "ATOMIC_MOVE guarantees the move is an atomic filesystem operation; "
+ "if a... |
public static void main(String[] args) throws IOException {
String doc = describeFileOps();
assert doc != null : "Doc must exist";
assert doc.contains("ATOMIC_MOVE") : "Must mention ATOMIC_MOVE";
// Functional test
Path tmp = Files.createTempDirectory("au23");
Path ... |
String d = describeFileOps().toLowerCase();
assert d.contains("files.move") : "Must mention Files.move";
assert d.contains("files.copy") : "Must mention Files.copy";
assert d.contains("atomic_move") : "Must mention ATOMIC_MOVE";
assert d.contains("replace_existing") : "Must ment... | api_usage |
24 | devbench-api-usage | java | import java.util.concurrent.atomic.AtomicReference;
public class AUTask24 {
private static final AtomicReference<String> state = new AtomicReference<>("INIT");
public static boolean transitionTo(String expected, String next) {
return state.compareAndSet(expected, next);
}
public static String... | public static String describeTransitionTo() {
return "Uses AtomicReference.compareAndSet(expectedValue, newValue) for lock-free state transition. "
+ "compareAndSet atomically sets the value to newValue if the current value == expectedValue "
+ "using reference equality (==), not .... |
public static void main(String[] args) {
String doc = describeTransitionTo();
assert doc != null : "Doc must exist";
assert doc.contains("compareAndSet") : "Must mention compareAndSet";
reset();
assert "INIT".equals(getState()) : "Should start at INIT";
assert trans... |
String d = describeTransitionTo().toLowerCase();
assert d.contains("compareandset") : "Must mention compareAndSet";
assert d.contains("lock-free") || d.contains("lock free") : "Must mention lock-free";
assert d.contains("reference equality") || d.contains("==") : "Must mention reference... | api_usage |
25 | devbench-api-usage | java | import java.time.Duration;
import java.time.Period;
import java.time.LocalDate;
import java.time.LocalTime;
public class AUTask25 {
public static long computeOverlap(Duration shift1, Duration shift2, Duration gap) {
Duration total = shift1.plus(shift2).minus(gap);
return total.toMinutes();
}
... | public static String describeComputeOverlap() {
return "Computes overlap using Duration.plus(Duration) and Duration.minus(Duration), "
+ "which return new Duration instances (Duration is immutable). "
+ "Duration.toMinutes() truncates toward zero, discarding any seconds/nanos remai... |
public static void main(String[] args) {
String doc = describeComputeOverlap();
assert doc != null : "Doc must exist";
assert doc.contains("Duration") : "Must mention Duration";
long overlap = computeOverlap(
Duration.ofHours(8), Duration.ofHours(6), Duration.ofMinutes(... |
String d = describeComputeOverlap().toLowerCase();
assert d.contains("immutable") : "Must mention immutability";
assert d.contains("tominutes") || d.contains("tominutes()") : "Must mention toMinutes";
assert d.contains("truncate") || d.contains("truncat") : "Must mention truncation beha... | api_usage |
26 | devbench-api-usage | java | import java.util.*;
import java.util.stream.Collectors;
public class AUTask26 {
public static List<String> sortNullsFirst(List<String> items) {
return items.stream()
.sorted(Comparator.nullsFirst(Comparator.naturalOrder()))
.collect(Collectors.toList());
}
public static Lis... | public static String describeSortMethods() {
return "sortNullsFirst uses Comparator.nullsFirst(Comparator.naturalOrder()). "
+ "nullsFirst wraps another Comparator and considers null less than any non-null value. "
+ "When both values are null, they are considered equal (returns 0)... |
public static void main(String[] args) {
String doc = describeSortMethods();
assert doc != null : "Doc must exist";
assert doc.contains("nullsFirst") : "Must mention nullsFirst";
List<String> input = new ArrayList<>(Arrays.asList("banana", null, "apple", null, "cherry"));
L... |
String d = describeSortMethods().toLowerCase();
assert d.contains("nullsfirst") : "Must mention nullsFirst";
assert d.contains("nullslast") : "Must mention nullsLast";
assert d.contains("naturalorder") || d.contains("natural order") : "Must mention naturalOrder";
assert d.contai... | api_usage |
27 | devbench-api-usage | java | import java.nio.file.*;
import java.io.IOException;
import java.util.List;
public class AUTask27 {
// Write lines to a file that MUST NOT already exist.
// If the file exists, this method must throw an exception.
// The file should be created with default permissions.
public static void writeNewFile(Pa... | Files.write(path, lines,
StandardOpenOption.CREATE_NEW,
StandardOpenOption.WRITE);
| }
// Append lines to an existing file, creating it if needed.
public static void appendLines(Path path, List<String> lines) throws IOException {
Files.write(path, lines,
StandardOpenOption.CREATE,
StandardOpenOption.APPEND);
}
public static void main(String[] args) ... |
try {
Path tmp2 = Files.createTempDirectory("au27h");
Path f2 = tmp2.resolve("hidden_test.txt");
writeNewFile(f2, List.of("a", "b", "c"));
assert Files.readAllLines(f2).size() == 3 : "Must write 3 lines";
boolean threw2 = false;
try { writ... | api_usage |
28 | devbench-api-usage | java | import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.format.ResolverStyle;
import java.time.temporal.ChronoField;
public class AUTask28 {
// Parse a date string in "yyyy-MM-dd" format with STRICT validation.
// Must reject inval... | DateTimeFormatter fmt = DateTimeFormatter.ofPattern("uuuu-MM-dd")
.withResolverStyle(ResolverStyle.STRICT);
return LocalDate.parse(dateStr, fmt);
| }
public static void main(String[] args) {
// Valid dates
LocalDate d1 = parseStrict("2024-02-29");
assert d1.getYear() == 2024 && d1.getMonthValue() == 2 && d1.getDayOfMonth() == 29
: "Leap day 2024 should parse";
LocalDate d2 = parseStrict("2023-12-31");
a... |
// Apr 31 doesn't exist
boolean t1 = false;
try { parseStrict("2024-04-31"); }
catch (DateTimeParseException e) { t1 = true; }
assert t1 : "Apr 31 must be rejected in strict mode";
// Jun 31 doesn't exist
boolean t2 = false;
try { parseStrict("2024-06-31... | api_usage |
29 | devbench-api-usage | java | import java.util.Locale;
public class AUTask29 {
// Format a double as a price string with exactly 2 decimal places.
// MUST use Locale.US to ensure '.' as decimal separator regardless of system locale.
// MUST use the '$' prefix.
// Examples: 1234.5 -> "$1,234.50", 0.5 -> "$0.50", 1000000 -> "$1,000,0... | return String.format(Locale.US, "$%,.2f", amount);
| }
// Format with a different locale for comparison
public static String formatPriceGerman(double amount) {
return String.format(Locale.GERMANY, "%,.2f", amount);
}
public static void main(String[] args) {
assert "$1,234.50".equals(formatPrice(1234.5)) : "Basic formatting failed: " ... |
assert "$-1,234.50".equals(formatPrice(-1234.5)) : "Negative number format wrong: " + formatPrice(-1234.5);
assert "$100.00".equals(formatPrice(100)) : "No grouping under 1000: " + formatPrice(100);
assert "$10,000.10".equals(formatPrice(10000.1)) : "Rounding: " + formatPrice(10000.1);
... | api_usage |
30 | devbench-api-usage | java | import java.util.*;
public class AUTask30 {
// Return an unmodifiable VIEW of the input list.
// Changes to the original list MUST be reflected in the returned view.
public static List<String> liveView(List<String> source) {
| return Collections.unmodifiableList(source);
| }
// Return an unmodifiable SNAPSHOT (copy) of the input list.
// Changes to the original list must NOT affect the returned list.
public static List<String> snapshot(List<String> source) {
return List.copyOf(source);
}
public static void main(String[] args) {
List<String> origi... |
List<String> orig2 = new ArrayList<>(Arrays.asList("x", "y"));
List<String> v2 = liveView(orig2);
assert v2.size() == 2 : "View size wrong";
orig2.add("z");
assert v2.size() == 3 : "View must be a LIVE view reflecting original changes";
assert "z".equals(v2.get(2)) : "Vi... | api_usage |
31 | devbench-api-usage | java | import java.util.LinkedHashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.List;
public class AUTask31 {
public static Map<String, Integer> createAccessOrderCache(int capacity) {
return new LinkedHashMap<String, Integer>(capacity, 0.75f, true) {
@Override
pr... | return "Creates an LRU cache using LinkedHashMap constructed with "
+ "accessOrder=true (the third boolean parameter to the three-arg constructor). "
+ "When accessOrder is true, iteration order reflects access order (most-recently "
+ "accessed entry last) rather than ins... | }
public static void main(String[] args) {
Map<String, Integer> cache = createAccessOrderCache(3);
cache.put("a", 1);
cache.put("b", 2);
cache.put("c", 3);
cache.get("a");
cache.put("d", 4);
assert !cache.containsKey("b") : "b should be evicted as LRU";
... | String doc = AUTask31.describeAccessOrderCache();
assert doc.contains("accessOrder=true") || doc.contains("accessOrder = true") : "Must mention accessOrder=true";
assert doc.contains("third") || doc.contains("3rd") || doc.contains("boolean parameter") : "Must mention it is the third/boolean parameter";
assert doc.conta... | api_usage |
32 | devbench-api-usage | java | import java.util.PriorityQueue;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
public class AUTask32 {
public static List<String> drainInOrder(PriorityQueue<String> pq) {
List<String> result = new ArrayList<>();
while (!pq.isEmpty()) {
result.add(pq.poll())... | return "PriorityQueue is a min-heap backed by an Object[] array. "
+ "Elements are ordered by natural ordering (Comparable.compareTo) when no "
+ "Comparator is supplied to the constructor. The iterator does NOT return "
+ "elements in priority order; only poll() and peek(... | }
public static void main(String[] args) {
PriorityQueue<String> pq = new PriorityQueue<>(Arrays.asList("cherry", "apple", "banana"));
List<String> sorted = drainInOrder(pq);
assert sorted.equals(Arrays.asList("apple", "banana", "cherry")) : "Should drain in natural order";
Str... | String doc = AUTask32.describePriorityQueueOrdering();
assert doc.contains("min-heap") : "Must mention min-heap";
assert doc.contains("Object[]") || doc.contains("array") : "Must mention array backing";
assert doc.toLowerCase().contains("iterator") && (doc.toLowerCase().contains("not") || doc.toLowerCase().contains("do... | api_usage |
33 | devbench-api-usage | java | import java.text.Collator;
import java.text.CollationKey;
import java.util.Arrays;
import java.util.Locale;
public class AUTask33 {
public static String[] sortWithCollator(String[] words, Locale locale, int strength) {
Collator collator = Collator.getInstance(locale);
collator.setStrength(strength... | return "Collator.getInstance(Locale) returns a locale-sensitive Collator for "
+ "language-appropriate string comparison. setStrength controls comparison granularity: "
+ "Collator.PRIMARY ignores case and accents (e and E and \u00e9 are equal), "
+ "Collator.SECONDARY dis... | }
public static void main(String[] args) {
String[] words = {"resume", "r\u00e9sum\u00e9", "Resume"};
String[] primary = sortWithCollator(words, Locale.US, Collator.PRIMARY);
// PRIMARY treats all three as equal, so order is stable (original order)
assert primary.length == 3;
... | String doc = AUTask33.describeCollatorBehavior();
assert doc.contains("PRIMARY") : "Must mention Collator.PRIMARY";
assert doc.contains("SECONDARY") : "Must mention Collator.SECONDARY";
assert doc.contains("TERTIARY") : "Must mention Collator.TERTIARY";
assert doc.toLowerCase().contains("default") && doc.contains("TERT... | api_usage |
34 | devbench-api-usage | java | import java.util.zip.Deflater;
import java.util.zip.Inflater;
import java.util.Arrays;
public class AUTask34 {
public static byte[] compressBytes(byte[] input) {
Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION, true);
deflater.setInput(input);
deflater.finish();
byte[] b... | return "Deflater performs DEFLATE compression (RFC 1951). The constructor "
+ "Deflater(int level, boolean nowrap) accepts a compression level (0-9 or "
+ "Deflater.BEST_COMPRESSION=9) and a nowrap flag; when nowrap=true, raw DEFLATE "
+ "is produced without zlib header/tr... | }
public static void main(String[] args) throws Exception {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 20; i++) sb.append("Hello, DEFLATE compression world! ");
byte[] original = sb.toString().getBytes();
byte[] compressed = compressBytes(original);
asse... | String doc = AUTask34.describeDeflaterInflater();
assert doc.contains("RFC 1951") || doc.contains("DEFLATE") : "Must mention DEFLATE or RFC 1951";
assert doc.contains("nowrap") : "Must mention nowrap parameter";
assert doc.toLowerCase().contains("zlib") || doc.toLowerCase().contains("header") : "Must mention zlib heade... | api_usage |
35 | devbench-api-usage | java | import java.util.ServiceLoader;
import java.util.Iterator;
import java.util.stream.Collectors;
import java.nio.charset.spi.CharsetProvider;
import java.nio.charset.Charset;
import java.util.List;
import java.util.ArrayList;
public class AUTask35 {
public static List<String> listCharsetProviders() {
Servic... | return "ServiceLoader.load(Class<S>) discovers and lazily instantiates service "
+ "providers using the context class loader (Thread.currentThread().getContextClassLoader()). "
+ "Providers are declared in META-INF/services/<fully-qualified-interface-name> files "
+ "or vi... | }
public static void main(String[] args) {
// Just test the description function, not the actual service loading
String doc = describeServiceLoader();
assert doc != null;
assert doc.contains("ServiceLoader") : "must name ServiceLoader";
assert doc.contains("META-INF") : ... | String doc = AUTask35.describeServiceLoader();
assert doc.contains("META-INF/services") : "Must mention META-INF/services directory";
assert doc.contains("module-info") || doc.contains("JPMS") : "Must mention JPMS module support";
assert doc.contains("reload()") : "Must mention reload() method to clear cache";
assert d... | api_usage |
36 | devbench-api-usage | java | import java.beans.PropertyChangeSupport;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeEvent;
import java.util.ArrayList;
import java.util.List;
public class AUTask36 {
private final PropertyChangeSupport pcs;
private String name;
private int value;
public AUTask36() {
... | return "PropertyChangeSupport manages a list of PropertyChangeListeners and fires "
+ "PropertyChangeEvents via firePropertyChange(String, Object, Object). The constructor "
+ "takes a sourceBean Object used as the source in fired events. "
+ "Listeners can be registered g... | }
public static void main(String[] args) {
AUTask36 bean = new AUTask36();
List<String> events = new ArrayList<>();
bean.addPropertyChangeListener("name", evt -> events.add("name:" + evt.getNewValue()));
bean.setName("Alice");
bean.setName("Alice"); // same value, no eve... | String doc = AUTask36.describePropertyChangeSupport();
assert doc.contains("firePropertyChange") : "Must mention firePropertyChange method";
assert doc.contains("sourceBean") || doc.contains("source bean") || (doc.contains("source") && doc.contains("constructor")) : "Must mention sourceBean in constructor";
assert doc.... | api_usage |
37 | devbench-api-usage | java | import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class AUTask37 {
public static List<String> createLiveUnmodifiableView(List<String> source) {
| return Collections.unmodifiableList(source);
| }
public static List<String> createSnapshot(List<String> source) {
return List.copyOf(source);
}
public static void main(String[] args) {
List<String> source = new ArrayList<>(List.of("a", "b", "c"));
List<String> view = createLiveUnmodifiableView(source);
List<String>... | java.util.List<String> src = new java.util.ArrayList<>(java.util.List.of("x", "y"));
java.util.List<String> v = AUTask37.createLiveUnmodifiableView(src);
assert v.size() == 2;
src.add("z");
assert v.size() == 3 : "Must be a live view (Collections.unmodifiableList), not a copy";
assert v.contains("z") : "Live view must ... | api_usage |
38 | devbench-api-usage | java | import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.ResolverStyle;
import java.time.temporal.ChronoField;
import java.time.format.DateTimeParseException;
public class AUTask38 {
public static LocalDate parseStrictDate(Str... | DateTimeFormatter fmt = new DateTimeFormatterBuilder()
.appendValue(ChronoField.YEAR)
.appendLiteral('-')
.appendValue(ChronoField.MONTH_OF_YEAR)
.appendLiteral('-')
.appendValue(ChronoField.DAY_OF_MONTH)
.toFormatter()
.withRes... | }
public static void main(String[] args) {
// Valid date
LocalDate valid = parseStrictDate("2024-2-29");
assert valid.getYear() == 2024 : "2024 is a leap year";
assert valid.getMonthValue() == 2;
assert valid.getDayOfMonth() == 29;
// STRICT mode rejects Feb 29 ... | // Verify strict parsing works for valid dates
java.time.LocalDate d = AUTask38.parseStrictDate("2020-2-29");
assert d.getYear() == 2020 && d.getMonthValue() == 2 && d.getDayOfMonth() == 29;
// Verify strict mode rejects invalid dates
boolean rejected = false;
try { AUTask38.parseStrictDate("2019-2-29"); } catch (java... | api_usage |
39 | devbench-api-usage | java | import java.util.concurrent.ConcurrentHashMap;
public class AUTask39 {
public static ConcurrentHashMap<String, Integer> buildWordCounts(String[] words) {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
for (String word : words) {
| map.merge(word, 1, Integer::sum);
| }
return map;
}
public static ConcurrentHashMap<String, Integer> removeIfBelowThreshold(
ConcurrentHashMap<String, Integer> map, int threshold) {
// compute returns null -> entry is removed
for (String key : map.keySet()) {
map.compute(key, (k, v) -> (v !... | ConcurrentHashMap<String, Integer> m = AUTask39.buildWordCounts(new String[]{"a", "b", "a", "c", "a", "b"});
assert m.get("a") == 3 : "a should be 3";
assert m.get("b") == 2 : "b should be 2";
assert m.get("c") == 1 : "c should be 1";
// Verify atomic merge semantics — should not lose counts
ConcurrentHashMap<String, ... | api_usage |
40 | devbench-api-usage | java | import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class AUTask40 {
public static String encodeUrlSafeNoPadding(byte[] data) {
| return Base64.getUrlEncoder().withoutPadding().encodeToString(data);
| }
public static byte[] decodeUrlSafe(String encoded) {
return Base64.getUrlDecoder().decode(encoded);
}
public static void main(String[] args) {
byte[] data = {(byte)0xFB, (byte)0xFF, (byte)0xFE};
String encoded = encodeUrlSafeNoPadding(data);
// URL-safe uses - instea... | // Test with data known to produce + and / in standard base64
byte[] testData = {(byte)0x3E, (byte)0xFF, (byte)0xBF};
String urlSafe = AUTask40.encodeUrlSafeNoPadding(testData);
assert !urlSafe.contains("+") : "URL-safe encoding must use - instead of +";
assert !urlSafe.contains("/") : "URL-safe encoding must use _ ins... | api_usage |
41 | devbench-api-usage | java | import java.util.Scanner;
public class AUTask41 {
public static int[] parseCustomDelimited(String input) {
Scanner sc = new Scanner(input);
sc.useDelimiter("\\s*;\\s*");
sc.useRadix(16);
int[] results = new int[3];
for (int i = 0; i < 3; i++) {
results[i] = sc.ne... | "Parses three hexadecimal integers from a semicolon-delimited string using java.util.Scanner. "
+ "Sets the delimiter to semicolons with optional surrounding whitespace via Scanner.useDelimiter(\"\\\\s*;\\\\s*\"), "
+ "and switches the radix to 16 via Scanner.useRadix(16) so that Sca... | }
public static void main(String[] args) {
int[] r = parseCustomDelimited("1A ; FF ; 0B");
assert r[0] == 0x1A : "Expected 26";
assert r[1] == 0xFF : "Expected 255";
assert r[2] == 0x0B : "Expected 11";
String doc = describeParseCustomDelimited();
assert doc != ... |
String doc41 = AUTask41.describeParseCustomDelimited().toLowerCase();
assert doc41.contains("usedelimiter") : "Must mention useDelimiter";
assert doc41.contains("useradix") || doc41.contains("radix") : "Must mention useRadix or radix";
assert doc41.contains("16") || doc41.contains("hexa... | api_usage |
42 | devbench-api-usage | java | import java.io.*;
public class AUTask42 {
public static byte[] serializeObject(Serializable obj) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
oos.flush();
oos.close... | "Serializes a Serializable object to a byte array using java.io.ObjectOutputStream. "
+ "Creates a ByteArrayOutputStream, wraps it in an ObjectOutputStream (which writes a serialization stream header), "
+ "then calls ObjectOutputStream.writeObject(obj) to serialize the object graph.... | }
public static void main(String[] args) throws Exception {
byte[] data = serializeObject("Hello");
Object restored = deserializeObject(data);
assert "Hello".equals(restored) : "Round-trip failed";
String doc = describeSerializeObject();
assert doc != null && !doc.isEmp... |
String doc42 = AUTask42.describeSerializeObject().toLowerCase();
assert doc42.contains("objectoutputstream") : "Must mention ObjectOutputStream";
assert doc42.contains("bytearrayoutputstream") : "Must mention ByteArrayOutputStream";
assert doc42.contains("writeobject") : "Must mention w... | api_usage |
43 | devbench-api-usage | java | import java.util.*;
public class AUTask43 {
public enum Priority { LOW, MEDIUM, HIGH, CRITICAL }
public static EnumMap<Priority, List<String>> buildPriorityMap(String[][] entries) {
EnumMap<Priority, List<String>> map = new EnumMap<>(Priority.class);
for (Priority p : Priority.values()) {
... | "Builds an EnumMap<Priority, List<String>> using the EnumMap(Class) constructor with Priority.class. "
+ "Pre-populates all keys via Priority.values() with empty ArrayLists so every enum constant has an entry. "
+ "Parses each entry's priority via Priority.valueOf(String), which thro... | }
public static void main(String[] args) {
String[][] entries = {{"HIGH", "fix bug"}, {"LOW", "update docs"}, {"HIGH", "deploy"}};
EnumMap<Priority, List<String>> map = buildPriorityMap(entries);
assert map.get(Priority.HIGH).size() == 2;
assert map.get(Priority.LOW).size() == 1... |
String doc43 = AUTask43.describeBuildPriorityMap().toLowerCase();
assert doc43.contains("enummap") : "Must mention EnumMap";
assert doc43.contains("priority.class") || doc43.contains("class constructor") : "Must mention class-based constructor";
assert doc43.contains("valueof") : "Must ... | api_usage |
44 | devbench-api-usage | java | import java.util.BitSet;
public class AUTask44 {
public static BitSet createBitMask(int[] positions) {
| BitSet bs = new BitSet();
for (int pos : positions) {
bs.set(pos);
}
return bs;
| }
public static int[] bitSetToSortedArray(BitSet bs) {
int[] result = new int[bs.cardinality()];
int idx = 0;
for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) {
result[idx++] = i;
}
return result;
}
public static void main(String[] ar... |
java.util.BitSet bs44 = AUTask44.createBitMask(new int[]{2, 2, 2});
assert bs44.cardinality() == 1 : "Duplicate positions should not increase cardinality";
assert bs44.get(2);
java.util.BitSet empty44 = AUTask44.createBitMask(new int[]{});
assert empty44.cardinality() == 0 : "E... | api_usage |
45 | devbench-api-usage | java | import java.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
public class AUTask45 {
public static String runCommand(String... command) throws Exception {
ProcessBuilder pb = new ProcessBuilder(command);
pb.redirectErrorStream(true);
pb.environment().put("LANG", "en_US.UTF-8"... | "Executes an external command using java.lang.ProcessBuilder(String...). "
+ "Calls ProcessBuilder.redirectErrorStream(true) to merge stderr into stdout. "
+ "Modifies the environment via ProcessBuilder.environment().put() to set LANG=en_US.UTF-8. "
+ "Starts the process ... | }
public static void main(String[] args) throws Exception {
String result = runCommand("echo", "hello world");
assert result.equals("hello world") : "Expected 'hello world' but got: " + result;
String doc = describeRunCommand();
assert doc != null && !doc.isEmpty();
Sys... |
String doc45 = AUTask45.describeRunCommand().toLowerCase();
assert doc45.contains("processbuilder") : "Must mention ProcessBuilder";
assert doc45.contains("redirecterrorstream") : "Must mention redirectErrorStream";
assert doc45.contains("environment") : "Must mention environment modifi... | api_usage |
46 | devbench-api-usage | java | import java.util.StringJoiner;
public class AUTask46 {
public static String joinWithBrackets(String[] items) {
StringJoiner sj = new StringJoiner(", ", "[", "]");
sj.setEmptyValue("<none>");
for (String item : items) {
sj.add(item);
}
return sj.toString();
}
... | "Joins string items using java.util.StringJoiner with delimiter ', ' (comma-space), "
+ "prefix '[', and suffix ']' via the StringJoiner(CharSequence, CharSequence, CharSequence) constructor. "
+ "Calls StringJoiner.setEmptyValue(\"<none>\") so that toString() returns '<none>' "
... | }
public static void main(String[] args) {
assert joinWithBrackets(new String[]{"a", "b", "c"}).equals("[a, b, c]");
assert joinWithBrackets(new String[]{"x"}).equals("[x]");
// Critical: empty array returns emptyValue, NOT "[]"
assert joinWithBrackets(new String[]{}).equals("<n... |
String doc46 = AUTask46.describeJoinWithBrackets().toLowerCase();
assert doc46.contains("stringjoiner") : "Must mention StringJoiner";
assert doc46.contains("delimiter") : "Must mention delimiter";
assert doc46.contains("prefix") : "Must mention prefix";
assert doc46.contains("s... | api_usage |
47 | devbench-api-usage | java | import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
public class AUTask47 {
public static List<String> tokenize(String input, String delimiterRegex) {
| List<String> tokens = new ArrayList<>();
Scanner sc = new Scanner(input);
sc.useDelimiter(delimiterRegex);
while (sc.hasNext()) {
tokens.add(sc.next());
}
sc.close();
return tokens;
| }
public static void main(String[] args) {
// Pipe-delimited
List<String> r1 = tokenize("a|b|c", "\\|");
assert r1.size() == 3 : "Expected 3 tokens, got " + r1.size();
assert r1.get(0).equals("a") && r1.get(1).equals("b") && r1.get(2).equals("c");
// Multiple character ... |
// Trailing delimiter is also skipped
java.util.List<String> r47a = AUTask47.tokenize("a|b|", "\\|");
assert r47a.size() == 2 : "Trailing delim skipped, expected 2, got " + r47a.size();
assert r47a.get(0).equals("a") && r47a.get(1).equals("b");
// Multiple consecutive delimiter... | api_usage |
48 | devbench-api-usage | java | import java.util.EnumSet;
import java.util.Set;
public class AUTask48 {
public enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }
public static EnumSet<Day> getWeekdays() {
| return EnumSet.range(Day.MONDAY, Day.FRIDAY);
| }
public static EnumSet<Day> getWeekend() {
return EnumSet.complementOf(getWeekdays());
}
public static void main(String[] args) {
EnumSet<Day> weekdays = getWeekdays();
assert weekdays.size() == 5 : "Expected 5 weekdays";
assert weekdays.contains(Day.MONDAY);
a... |
// Verify range uses declaration order
java.util.EnumSet<AUTask48.Day> full = java.util.EnumSet.allOf(AUTask48.Day.class);
assert full.size() == 7;
// complementOf is live complement
java.util.EnumSet<AUTask48.Day> wd = AUTask48.getWeekdays();
java.util.EnumSet<AUTask48... | api_usage |
49 | devbench-api-usage | java | import java.util.BitSet;
public class AUTask49 {
public static BitSet intersect(BitSet a, BitSet b) {
BitSet result = (BitSet) a.clone();
result.and(b);
return result;
}
public static BitSet symmetricDiff(BitSet a, BitSet b) {
BitSet result = (BitSet) a.clone();
res... | "Performs set operations on java.util.BitSet instances. "
+ "intersect clones the first BitSet via BitSet.clone() (returns Object, must cast to BitSet) "
+ "then calls BitSet.and(BitSet) which modifies the receiver in-place to retain only bits set in both. "
+ "symmetricD... | }
public static void main(String[] args) {
BitSet a = new BitSet();
a.set(1); a.set(3); a.set(5);
BitSet b = new BitSet();
b.set(3); b.set(5); b.set(7);
BitSet inter = intersect(a, b);
assert inter.cardinality() == 2;
assert inter.get(3) && inter.get(5);... |
String doc49 = AUTask49.describeBitSetOperations().toLowerCase();
assert doc49.contains("clone") : "Must mention clone()";
assert doc49.contains("and") : "Must mention and()";
assert doc49.contains("xor") : "Must mention xor()";
assert doc49.contains("in-place") || doc49.contain... | api_usage |
50 | devbench-api-usage | java | import java.util.StringJoiner;
public class AUTask50 {
public static String mergeJoiners(String[][] groups, String innerDelim, String outerDelim) {
| StringJoiner outer = new StringJoiner(outerDelim);
for (String[] group : groups) {
StringJoiner inner = new StringJoiner(innerDelim);
for (String s : group) {
inner.add(s);
}
outer.merge(inner);
}
return outer.toString();
| }
public static void main(String[] args) {
// merge preserves inner delimiter within each group, outer delimiter between groups
String result = mergeJoiners(
new String[][]{{"a", "b"}, {"c", "d"}}, ", ", " | ");
assert result.equals("a, b | c, d") : "Expected 'a, b | c, d' b... |
// Inner delimiter is preserved within groups, outer between groups
String r50a = AUTask50.mergeJoiners(
new String[][]{{"1", "2"}, {"3"}}, "+", "-");
assert r50a.equals("1+2-3") : "Expected '1+2-3' but got: " + r50a;
// Single group
String r50b = AUTask50.mergeJoin... | api_usage |
1 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class JavaCPMutation1 {
static class ClaimResult {
final String status;
final BigDecimal patient;
final BigDecimal plan;
final BigDecimal deductible;
final BigDecimal coinsurance;
... | BigDecimal z = BigDecimal.ZERO.setScale(2);
if (processedClaims.contains(claimId)) return null;
BigDecimal rate = allowedRates.get(code); if (rate == null || (requiresAuth.contains(code) && !authorizedClaims.contains(claimId))) {
processedClaims.add(claimId); claimLedger.add("DENIED:... | }
public static void main(String[] args) {
reset();
ClaimResult r1 = adjudicateLine("C1", "THERAPY", new BigDecimal("400.00"), false, new BigDecimal("20.00"));
// Allowed: 400 * .80 = 320, primary pays 20, remaining 300.
// Patient pays $30 copay and $270 deductible; plan pays $... | assert visibleChecksDone == 1;
int ledgerBeforeDup = JavaCPMutation1.claimLedger.size();
BigDecimal oopBeforeDup = JavaCPMutation1.ytdOop;
ClaimResult dup = JavaCPMutation1.adjudicateLine("C1", "THERAPY", new BigDecimal("999.00"), false, BigDecimal.ZERO);
assert dup == null : "du... | code_purpose_understanding |
2 | devbench-code-purpose-understanding | java | import java.util.*;
public class JavaCPMutation2 {
static class Lot {
final String id;
final String sku;
int qty;
final int expiryDay;
final boolean quarantined;
Lot(String id, String sku, int qty, int expiryDay, boolean quarantined) {
this.id = id; this.... | if (ticketsByOrder.containsKey(orderId)) return new ArrayList<>(ticketsByOrder.get(orderId));
if (qty <= 0) throw new IllegalArgumentException("qty");
List<Lot> eligible = new ArrayList<>();
for (Lot l : lotsBySku.getOrDefault(sku, List.of())) if (!l.quarantined && l.qty > 0 && l.expiryD... | }
public static void main(String[] args) {
reset();
addLot("L1", "MED", 5, 10, false);
addLot("L2", "MED", 4, 7, false);
addLot("L3", "MED", 9, 6, true);
List<String> t1 = allocateOrder("O1", "MED", 6, 4, false);
assert t1.equals(List.of("PICK:L2:4", "PICK:L1:2")... | assert visibleChecksDone == 1;
int auditBeforeDup = JavaCPMutation2.auditLog.size();
List<String> dup = JavaCPMutation2.allocateOrder("O1", "MED", 99, 100, true);
assert dup.equals(List.of("PICK:L2:4", "PICK:L1:2")) : "duplicate ticket=" + dup;
assert JavaCPMutation2.auditLog.siz... | code_purpose_understanding |
3 | devbench-code-purpose-understanding | java | import java.util.*;
public class JavaCPMutation3 {
static int rxTotalQty;
static int filledQty;
static int daysSupply;
static int lastFillDay;
static boolean controlled;
static boolean expeditedUsed;
static int inventoryQty;
static Set<String> processedFillIds = new HashSet<>();
sta... | if (processedFillIds.contains(fillId)) return "DUPLICATE";
if (filledQty >= rxTotalQty) return "RX_COMPLETE";
if (requestedQty <= 0) throw new IllegalArgumentException("qty");
if (controlled && expedited) return "CONTROLLED_EXPEDITE_DENIED";
if (controlled && requestedQty > 30) r... | }
public static void main(String[] args) {
reset(90, 30, false, 50);
String first = fill("F1", 0, 30, false);
assert first.equals("FILLED") : first;
assert filledQty == 30 && inventoryQty == 20 : "first counters";
String early = fill("F2", 10, 20, false);
assert ... | assert visibleChecksDone == 1;
int logBeforeDup = JavaCPMutation3.fillLog.size();
String dup = JavaCPMutation3.fill("F1", 99, 99, true);
assert dup.equals("DUPLICATE") : "dup=" + dup;
assert JavaCPMutation3.fillLog.size() == logBeforeDup : "duplicate logged";
assert JavaC... | code_purpose_understanding |
4 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class JavaCPMutation4 {
static class Paycheck {
final BigDecimal retirement;
final BigDecimal tax;
final BigDecimal health;
final BigDecimal garnishment;
final BigDecimal net;
Payc... | if (processedRuns.contains(runId)) return null;
if (gross.compareTo(BigDecimal.ZERO) <= 0) throw new IllegalArgumentException("gross");
BigDecimal capLeft = retirementCap.subtract(ytdRetirement); if (capLeft.compareTo(BigDecimal.ZERO) < 0) capLeft = BigDecimal.ZERO;
BigDecimal retirement... | }
public static void main(String[] args) {
reset();
Paycheck p1 = runPayroll("R1", new BigDecimal("2000.00"));
// Retirement 100; taxable 1900; tax 100 + 180 = 280; health 200; disposable 1420; garnishment 213; net 1207.
assert p1.retirement.compareTo(new BigDecimal("100.00")) =... | assert visibleChecksDone == 1;
int logsBeforeDup = JavaCPMutation4.payrollLog.size();
BigDecimal ytdBeforeDup = JavaCPMutation4.ytdNet;
Paycheck dup = JavaCPMutation4.runPayroll("R1", new BigDecimal("9999.00"));
assert dup == null : "duplicate should return null";
assert ... | code_purpose_understanding |
5 | devbench-code-purpose-understanding | java | import java.util.*;
public class JavaCPMutation5 {
static class Grant {
final String id;
final String sku;
int remaining;
final int startDay;
final int endDay;
Grant(String id, String sku, int units, int startDay, int endDay) {
this.id = id; this.sku = sk... | if (tickets.containsKey(requestId)) return new ArrayList<>(tickets.get(requestId));
if (units <= 0) throw new IllegalArgumentException("units");
List<Grant> active = new ArrayList<>();
int total = 0, protectedUnits = 0;
for (Grant g : grants) if (g.sku.equals(sku) && g.remaining ... | }
public static void main(String[] args) {
reset();
addGrant("G1", "API", 5, 0, 10);
addGrant("G2", "API", 10, 0, 20);
addDeny("API", 2, 5, 15);
List<String> t1 = consume("R1", "API", 4, 6);
assert t1.equals(List.of("USE:G1:4")) : "ticket=" + t1;
assert r... | assert visibleChecksDone == 1;
int auditBeforeDup = JavaCPMutation5.auditLog.size();
List<String> dup = JavaCPMutation5.consume("R1", "API", 99, 6);
assert dup.equals(List.of("USE:G1:4")) : "dup=" + dup;
assert JavaCPMutation5.auditLog.size() == auditBeforeDup : "duplicate audite... | code_purpose_understanding |
6 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class JavaCPMutation6 {
static class UsageEvent {
final String id;
final int units;
boolean billed;
UsageEvent(String id, int units) { this.id = id; this.units = units; this.billed = false; }
... | if (invoices.containsKey(invoiceId)) return invoices.get(invoiceId);
List<UsageEvent> batch = new ArrayList<>();
int units = 0;
for (UsageEvent e : events) if (!e.billed) { batch.add(e); units += e.units; }
int overUnits = Math.max(0, units - includedUnits);
BigDecimal ov... | }
public static void main(String[] args) {
reset();
addUsage("E1", 60);
addUsage("E2", 50);
addCredit(new BigDecimal("30.00"));
Invoice i1 = closePeriod("INV1", 100, new BigDecimal("100.00"), new BigDecimal("2.00"));
// 110 units, 10 overage units at $2 = $20, mi... | assert visibleChecksDone == 1;
int auditBeforeDup = JavaCPMutation6.auditLog.size();
BigDecimal totalBeforeDup = JavaCPMutation6.totalInvoiced;
Invoice dup = JavaCPMutation6.closePeriod("INV1", 0, BigDecimal.ZERO, new BigDecimal("99.00"));
assert dup.due.compareTo(new BigDecimal(... | code_purpose_understanding |
7 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class JavaCPMutation7 {
static class Release {
final String status;
final BigDecimal payable;
final BigDecimal holdback;
final BigDecimal defectReserve;
Release(String status, BigDecimal p... | BigDecimal z = BigDecimal.ZERO.setScale(2);
if (processedReleaseIds.contains(releaseId)) return null;
if (status.equals("COMPLETE")) return new Release("CLOSED", z, holdback, defectReserve);
if (newProgressPct <= approvedProgressPct || newProgressPct > 100) return new Release("INVALID", ... | }
public static void main(String[] args) {
reset();
Release r1 = recordProgress("REL1", 30, false, false);
// 30% delta = $30000, 10% holdback = $3000, payable = $27000.
assert r1.payable.compareTo(new BigDecimal("27000.00")) == 0 : "r1 payable=" + r1.payable;
assert hol... | assert visibleChecksDone == 1;
int logBeforeDup = JavaCPMutation7.escrowLog.size();
Release dup = JavaCPMutation7.recordProgress("REL1", 100, false, true);
assert dup == null : "duplicate should return null";
assert JavaCPMutation7.escrowLog.size() == logBeforeDup : "duplicate lo... | code_purpose_understanding |
8 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask8 {
// Tax brackets: [upperBound, rate%] (marginal)
// 0-1000: 10%, 1001-3000: 20%, 3001+: 30%
static int[][] taxBrackets = {{1000, 10}, {3000, 20}, {Integer.MAX_VALUE, 30}};
static BigDecimal healthDedu... | static BigDecimal calculatePay(BigDecimal grossPay) {
BigDecimal tax = computeMarginalTax(grossPay);
BigDecimal postTax = grossPay.subtract(tax);
BigDecimal retirement = grossPay.multiply(retirementRate).setScale(2, RoundingMode.HALF_UP);
BigDecimal ded = healthDeduction.add(retireme... |
public static void main(String[] args) {
// grossPay = 5000
// tax: 1000*10% + 2000*20% + 2000*30% = 100 + 400 + 600 = 1100
// postTax = 3900
// health=200, retirement=250, ded=450
// garnishment = 390 (10% of 3900)
// net = 3900 - 450 - 390 = 3060 (above minimum, no... |
// Reset
ytdGross = BigDecimal.ZERO; ytdTax = BigDecimal.ZERO; ytdNet = BigDecimal.ZERO; auditLog.clear();
// Low pay triggers minimum net clamping
// grossPay = 1000
// tax: 1000*10% = 100
// postTax = 900
// health=200, retirement=50, ded=250
// garnis... | code_purpose_understanding |
9 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask9 {
static BigDecimal copay = new BigDecimal("30.00");
static BigDecimal annualDeductible = new BigDecimal("500.00");
static BigDecimal coinsuranceRate = new BigDecimal("0.20"); // patient pays 20%
static... | static BigDecimal adjudicate(String claimId, BigDecimal billedAmount) {
if (processedClaims.contains(claimId)) return null;
BigDecimal patientOwes = copay;
BigDecimal remainingBill = billedAmount.subtract(copay);
BigDecimal deductibleRemaining = annualDeductible.subtract(ytdDeductibl... |
public static void main(String[] args) {
// First claim: $1000 billed
// copay=30, remaining=970, deductible=min(970,500)=500, remaining=470
// coinsurance=470*0.20=94, patientOwes=30+500+94=624
// OOP cap check: 0+624 < 2000, no cap
BigDecimal p1 = adjudicate("C1", new BigD... |
// Idempotency
BigDecimal dup = adjudicate("C1", new BigDecimal("1000.00"));
assert dup == null : "idempotent should return null";
assert ytdOop.compareTo(new BigDecimal("624.00")) == 0 : "OOP unchanged";
// Second claim: deductible already fully met
// billed=2000, cop... | code_purpose_understanding |
10 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class JavaCPMutation10 {
static class PaymentResult {
final String status;
final BigDecimal fees;
final BigDecimal interest;
final BigDecimal principal;
final BigDecimal escrow;
fi... | BigDecimal z = BigDecimal.ZERO.setScale(2);
if (processedPayments.contains(paymentId)) return null;
if (amount.compareTo(BigDecimal.ZERO) <= 0) throw new IllegalArgumentException("amount");
processedPayments.add(paymentId);
BigDecimal[] rem = { amount.setScale(2, RoundingMode.HAL... | }
public static void main(String[] args) {
resetNormal();
PaymentResult p1 = applyPayment("P1", new BigDecimal("200.00"), 15);
// Late fee makes fees $45. Waterfall pays $45 fees, $100 interest, and $55 principal.
assert p1.fees.compareTo(new BigDecimal("45.00")) == 0 : "fees=" ... | assert visibleChecksDone == 1;
int logBeforeDup = JavaCPMutation10.paymentLog.size();
PaymentResult dup = JavaCPMutation10.applyPayment("P1", new BigDecimal("999.00"), 99);
assert dup == null : "duplicate should return null";
assert JavaCPMutation10.paymentLog.size() == logBefore... | code_purpose_understanding |
11 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.util.*;
public class CPTask11 {
// Pharmacy refill system with controlled substance rules
// Rules:
// 1. Controlled substances (schedule II-III) limited to max 3 refills total
// 2. Cannot refill if less than 75% of days_supply have elapsed since last fill
... | static boolean requestRefill(String rxId, int currentDay) {
boolean isControlled = controlled.getOrDefault(rxId, false);
int count = refillCounts.getOrDefault(rxId, 0);
int lastDay = lastFillDay.getOrDefault(rxId, 0);
int supply = daysSupply.getOrDefault(rxId, 30);
int earlie... |
public static void main(String[] args) {
refillCounts.clear(); lastFillDay.clear(); daysSupply.clear(); controlled.clear(); auditLog.clear();
// Non-controlled: should allow refill after 75% of supply
initRx("RX001", 30, false);
lastFillDay.put("RX001", 10);
assert requestRe... |
// Test controlled substance limit (max 3 refills)
CPTask11.refillCounts.clear();
CPTask11.lastFillDay.clear();
CPTask11.daysSupply.clear();
CPTask11.controlled.clear();
CPTask11.auditLog.clear();
CPTask11.initRx("CTL1", 10, true);
assert CPTask11.requestRefill("CTL1", 8) == true;
assert CPTask11.requestRefill("CTL1",... | code_purpose_understanding |
12 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.util.*;
public class CPTask12 {
// Lab result routing with critical value alerts
// Rules:
// 1. If value outside panicLow..panicHigh, route to "STAT" and set alert=true
// 2. If value outside normalLow..normalHigh but inside panic range, route to "ABNORMAL"
... | String route;
boolean alert = false;
if (value < panicLow || value > panicHigh) {
route = "STAT";
alert = true;
} else if (value < normalLow || value > normalHigh) {
route = "ABNORMAL";
} else {
route = "ROUTINE";
}
... |
public static void main(String[] args) {
previousValues.clear(); alerts.clear(); resultLog.clear();
// Normal value
assert routeResult("GLU", 95.0, 70, 110, 40, 400, 50).equals("ROUTINE");
// Abnormal but not panic
assert routeResult("GLU", 130.0, 70, 110, 40, 400, 50).equal... |
// Reset state
CPTask12.previousValues.clear();
CPTask12.alerts.clear();
CPTask12.resultLog.clear();
// Delta check across consecutive results
CPTask12.routeResult("HGB", 14.0, 12.0, 17.0, 7.0, 20.0, 3.0);
CPTask12.routeResult("HGB", 10.0, 12.0, 17.0, 7.0, 20.0, 3.0);
// |14-10| = 4 > 3, so DELTA_ALERT should be pres... | code_purpose_understanding |
13 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask13 {
// Shipping rate calculator with zones and weight tiers
// Rules:
// 1. Base rate per zone: zone 1=$5, zone 2=$8, zone 3=$12, zone 4=$18
// 2. Weight surcharge tiers (actual or dimensional, whichev... | BigDecimal baseRate = ZONE_RATES.getOrDefault(zone, new BigDecimal("18.00"));
int dimWeight = (int) Math.ceil((double)(lengthIn * widthIn * heightIn) / 139.0);
double billableWeight = Math.max(actualWeight, dimWeight);
BigDecimal surcharge;
if (billableWeight <= 5.0) {
... |
public static void main(String[] args) {
// Zone 1, light package, small dims
BigDecimal r1 = calculateShipping(1, 3.0, 10, 8, 6);
// dimWeight = ceil(480/139) = ceil(3.45) = 4, billable = max(3,4) = 4 => $0 surcharge
// total = 5 + 0 = 5, but minimum is 7
assert r1.compareT... |
// Dimensional weight exceeds actual weight
BigDecimal r3 = CPTask13.calculateShipping(2, 2.0, 30, 20, 15);
// dimWeight = ceil(9000/139) = ceil(64.74) = 65, billable = max(2,65) = 65 => $15 surcharge
// total = 8 + 15 = 23
assert r3.compareTo(new BigDecimal("23.00")) == 0 : "Dim weight should dominate: " + r3;
// Ex... | code_purpose_understanding |
14 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask14 {
// Warehouse pick optimization with FEFO (First-Expiry-First-Out)
// Rules:
// 1. Stock organized as list of lots: each lot has {lotId, qty, expiryDay}
// 2. Pick from earliest-expiring lots FIRST (sort by expiryDay ascending)
// 3. If a lot doesn't fu... | stockLots.sort((a, b) -> Integer.compare(a[2], b[2]));
int remaining = requestedQty;
int filled = 0;
Iterator<int[]> it = stockLots.iterator();
while (it.hasNext() && remaining > 0) {
int[] lot = it.next();
int take = Math.min(lot[1], remaining);
... |
public static void main(String[] args) {
stockLots.clear();
pickLog.clear();
addLot(101, 10, 30); // expires day 30
addLot(102, 5, 10); // expires day 10 (pick first)
addLot(103, 8, 20); // expires day 20
int[] result = pickOrder(12);
// Should pick: LO... |
// Test backorder scenario
CPTask14.stockLots.clear();
CPTask14.pickLog.clear();
CPTask14.addLot(201, 3, 5);
CPTask14.addLot(202, 4, 15);
int[] r2 = CPTask14.pickOrder(10);
assert r2[0] == 7 : "Should fill 7, got " + r2[0];
assert r2[1] == 3 : "Backorder of 3, got " + r2[1];
assert CPTask14.stockLots.isEmpty() : "All ... | code_purpose_understanding |
15 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask15 {
// Leave accrual system with carry-over limits
// Rules:
// 1. Employees accrue leaveRate hours per month
// 2. At year-end (month 12), balance is capped at carryOverMax
// Any excess is fo... | BigDecimal rate = accrualRates.get(empId);
BigDecimal bal = balances.get(empId).add(rate);
leaveLog.add("ACCRUED:" + empId + ":" + rate);
if (month == 12) {
BigDecimal cap = carryOverMax.get(empId);
if (bal.compareTo(cap) > 0) {
BigDecimal excess =... |
public static void main(String[] args) {
balances.clear(); accrualRates.clear(); carryOverMax.clear(); leaveLog.clear();
initEmployee("E001", new BigDecimal("10.00"), new BigDecimal("80.00"));
// Accrue 12 months
for (int m = 1; m <= 12; m++) {
accrueMonth("E001", m);
... |
// Test denial when insufficient balance
CPTask15.balances.clear();
CPTask15.accrualRates.clear();
CPTask15.carryOverMax.clear();
CPTask15.leaveLog.clear();
CPTask15.initEmployee("E002", new BigDecimal("8.00"), new BigDecimal("40.00"));
CPTask15.accrueMonth("E002", 1);
assert CPTask15.balances.get("E002").compareTo(ne... | code_purpose_understanding |
16 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask16 {
// Performance review calibration system
// Rules:
// 1. Ratings: 1(low) to 5(high). Forced distribution across a team:
// At most 20% can be rated 5, at most 20% can be rated 1
// (i.e., count of rating 5 <= floor(teamSize * 0.2), same for ratin... | if (rater.equals(ratee)) { reviewLog.add("DENIED:SELF_RATING"); return false; }
if (rating < 1 || rating > 5) { reviewLog.add("DENIED:INVALID_RATING"); return false; }
int maxForRating = (int) Math.floor(teamSize * 0.2);
if (rating == 5 || rating == 1) {
long count = finalRat... |
public static void main(String[] args) {
initTeam(5);
// floor(5 * 0.2) = 1, so only 1 person can get rating 5
assert submitRating("mgr", "alice", 5) == true;
assert submitRating("mgr", "bob", 5) == false;
assert reviewLog.contains("DENIED:DISTRIBUTION_LIMIT");
// S... |
// Test override too large
CPTask16.initTeam(10);
CPTask16.submitRating("mgr", "dave", 3);
assert CPTask16.overrideRating("dave", 5) == false;
assert CPTask16.reviewLog.contains("DENIED:OVERRIDE_TOO_LARGE");
assert CPTask16.finalRatings.get("dave") == 3 : "Rating should not change on failed override";
// Override non... | code_purpose_understanding |
17 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask17 {
// Cart pricing engine with stacking discount rules
// Rules:
// 1. Items have price and quantity
// 2. Discounts applied in order: PERCENT discounts first, then FLAT discounts
// 3. After ALL... | BigDecimal[] ep = new BigDecimal[items.size()];
for (int i = 0; i < items.size(); i++) ep[i] = items.get(i)[0];
for (Object[] d : discounts) if ("PERCENT".equals(d[0])) {
BigDecimal m = BigDecimal.ONE.subtract(((BigDecimal)d[1]).divide(new BigDecimal("100"),10,RoundingMode.HALF_UP));... |
public static void main(String[] args) {
items.clear();
discounts.clear();
// 2 items: $30 x1, $20 x2
addItem(new BigDecimal("30.00"), 1);
addItem(new BigDecimal("20.00"), 2);
addDiscount("PERCENT", new BigDecimal("10")); // 10% off
addDiscount("FLAT", new B... |
// Test per-item floor
CPTask17.items.clear();
CPTask17.discounts.clear();
CPTask17.addItem(new BigDecimal("3.00"), 3);
CPTask17.addDiscount("PERCENT", new BigDecimal("80")); // 80% off -> $0.60 each
// Floor kicks in: $1.00 each
BigDecimal[] r2 = CPTask17.calculateTotal();
// Subtotal: 1.00 * 3 = 3.00, shipping $5.9... | code_purpose_understanding |
18 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask18 {
// Return/refund system with restocking fees
// Rules:
// 1. Return window: 0-14 days: no fee, 15-30 days: 15% restocking fee,
// 31+ days: return DENIED
// 2. Restocking fee calculated on ... | if (daysSincePurchase > 30) {
returnLog.add("RETURN:" + orderId + ":DENIED:0.00");
refunds.put(orderId, BigDecimal.ZERO);
return BigDecimal.ZERO;
}
BigDecimal fee = BigDecimal.ZERO;
if (daysSincePurchase >= 15) {
fee = itemPrice.multiply(ne... |
public static void main(String[] args) {
returnLog.clear();
refunds.clear();
// Within 14 days: no fee
BigDecimal r1 = processReturn("ORD001", new BigDecimal("99.99"), 7);
assert r1.compareTo(new BigDecimal("99.99")) == 0 : "No fee within 14 days: " + r1;
// 15-30 d... |
// Boundary: exactly day 14 should have no fee
CPTask18.returnLog.clear();
CPTask18.refunds.clear();
BigDecimal b1 = CPTask18.processReturn("B1", new BigDecimal("80.00"), 14);
assert b1.compareTo(new BigDecimal("80.00")) == 0 : "Day 14 no fee: " + b1;
assert CPTask18.returnLog.get(0).contains("APPROVED");
// Boundary... | code_purpose_understanding |
19 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask19 {
// Rate limiter with burst allowance (token bucket variant)
// Rules:
// 1. Each client gets maxTokens tokens, refilled at refillRate tokens per second
// 2. A request costs 1 token. If tokens > 0, allow and decrement
// 3. Burst: client also gets burs... | double[] c = clients.get(clientId);
// Refill regular tokens
double elapsed = currentTime - c[2];
c[0] = Math.min(c[3], c[0] + elapsed * c[4]);
c[2] = currentTime;
// Try regular tokens first
if (c[0] >= 1.0) {
c[0] -= 1.0;
reqLog.add("REQ:... |
public static void main(String[] args) {
clients.clear(); reqLog.clear();
initClient("api-user", 3, 2, 1.0); // 3 regular, 2 burst, 1 token/sec refill
// Use all regular tokens at time 0
assert request("api-user", 0) == true; // token 3->2
assert request("api-user", 0) =... |
// Test burst tokens never refill
CPTask19.clients.clear();
CPTask19.reqLog.clear();
CPTask19.initClient("c1", 1, 1, 1.0);
CPTask19.request("c1", 0); // regular 1->0
CPTask19.request("c1", 0); // burst 1->0
// Wait long time
CPTask19.request("c1", 100); // refill 1 regular -> use it
assert CPTask19.request("c1", 1... | code_purpose_understanding |
20 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask20 {
// Circuit breaker with half-open state
// States: CLOSED (normal), OPEN (blocking), HALF_OPEN (testing)
// Rules:
// 1. CLOSED: allow requests. Track consecutive failures.
// If consecutiveFailures >= failureThreshold, transition to OPEN.
// ... | if (state.equals("OPEN")) {
if (currentTimeMs - openedAt >= resetTimeoutMs) { state = "HALF_OPEN"; probeCount = 0; }
else { cbLog.add("CB:OPEN:DENY"); return false; }
}
if (state.equals("HALF_OPEN")) {
if (probeCount >= probeLimit) { cbLog.add("CB:HALF_OPEN:DE... |
public static void main(String[] args) {
init(3, 5000, 1);
// CLOSED: allow requests
assert attemptRequest(0) == true;
recordSuccess();
// Accumulate failures
assert attemptRequest(100) == true;
recordFailure(100);
assert attemptRequest(200) == true... |
// Half-open probe fails -> back to OPEN
CPTask20.init(2, 1000, 1);
CPTask20.attemptRequest(0); CPTask20.recordFailure(0);
CPTask20.attemptRequest(0); CPTask20.recordFailure(0);
assert CPTask20.state.equals("OPEN");
// Wait for timeout
assert CPTask20.attemptRequest(1500) == true;
assert CPTask20.state.equals("HALF_OP... | code_purpose_understanding |
21 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.util.*;
public class CPTask21 {
enum Side { BUY, SELL }
static class Order {
final String id;
final Side side;
final BigDecimal price;
int qty;
int filledQty;
final long timestamp;
Order(String id, Side side, Big... | int totalFilled = 0;
Iterator<Order> it = sellBook.iterator();
while (it.hasNext() && buyOrder.remaining() > 0) {
Order sell = it.next();
if (sell.price.compareTo(buyOrder.price) > 0) break;
int fillQty = Math.min(buyOrder.remaining(), sell.remaining());
... | }
public static void main(String[] args) {
reset();
addSellOrder(new Order("S1", Side.SELL, new BigDecimal("100.00"), 10, 1));
addSellOrder(new Order("S2", Side.SELL, new BigDecimal("99.50"), 5, 2));
// S2 is cheaper so should match first despite later timestamp
Order bu... |
// Hidden: partial fill leaves remainder on book
reset();
addSellOrder(new Order("S10", Side.SELL, new BigDecimal("50.00"), 20, 1));
Order b2 = new Order("B2", Side.BUY, new BigDecimal("50.00"), 7, 2);
int f2 = matchBuyOrder(b2);
assert f2 == 7 : "Partial fill expected 7... | code_purpose_understanding |
22 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask22 {
static class Position {
final String symbol;
BigDecimal quantity;
final BigDecimal currentPrice;
Position(String symbol, BigDecimal quantity, BigDecimal currentPrice) {
... | BigDecimal maintenanceMargin = new BigDecimal("0.25");
BigDecimal tmv = totalMarketValue();
if (tmv.compareTo(BigDecimal.ZERO) == 0) return false;
if (equity.divide(tmv, 4, RoundingMode.HALF_UP).compareTo(maintenanceMargin) >= 0) return false;
positions.sort(Comparator.comparing(... | }
public static void main(String[] args) {
reset();
equity = new BigDecimal("200");
positions.add(new Position("AAPL", new BigDecimal("10"), new BigDecimal("150")));
positions.add(new Position("GOOG", new BigDecimal("5"), new BigDecimal("100")));
// TMV = 1500 + 500 = 20... |
// Hidden: no liquidation needed when already above margin
reset();
equity = new BigDecimal("500");
positions.add(new Position("MSFT", new BigDecimal("5"), new BigDecimal("100")));
// TMV = 500, ratio = 500/500 = 1.0 >= 0.25
boolean r2 = checkAndLiquidate();
asse... | code_purpose_understanding |
23 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;
public class CPTask23 {
static List<String> auditLog = new ArrayList<>();
// Calculate final grade with drop-lowest and curve.
// Rules:
// 1. Sort scores ascending and drop the lowest... | List<Integer> sorted = scores.stream().sorted().collect(Collectors.toList());
List<Integer> dropped = sorted.subList(0, dropCount);
List<Integer> kept = sorted.subList(dropCount, sorted.size());
BigDecimal sum = kept.stream().map(BigDecimal::new).reduce(BigDecimal.ZERO, BigDecimal::add);... | }
public static void main(String[] args) {
auditLog.clear();
List<Integer> scores = Arrays.asList(70, 85, 90, 60, 95);
BigDecimal result = calculateFinalGrade(scores, 1, new BigDecimal("5"));
// Drop 60, remaining: [70,85,90,95], avg = 340/4 = 85.00, +5 = 90.00
assert re... |
// Hidden: curve causes cap at 100
auditLog.clear();
List<Integer> s2 = Arrays.asList(95, 98, 92, 88, 97);
BigDecimal r2 = calculateFinalGrade(s2, 1, new BigDecimal("10"));
// Drop 88, remaining: [92,95,97,98], avg = 382/4 = 95.50, +10 = 105.50 -> cap 100.00
assert r2.co... | code_purpose_understanding |
24 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask24 {
static Map<String, Set<String>> prerequisites = new HashMap<>(); // course -> required courses
static Map<String, Integer> capacity = new HashMap<>(); // course -> max seats
static Map<String, List<String>> enrolled = new HashMap<>(); // course ->... | Set<String> prereqs = prerequisites.getOrDefault(course, Collections.emptySet());
Set<String> done = completed.getOrDefault(student, Collections.emptySet());
if (!done.containsAll(prereqs)) {
enrollLog.add("PREREQ_FAIL:" + student + ":" + course);
return "PREREQ_FAIL";
... | }
public static void main(String[] args) {
reset();
capacity.put("CS201", 2);
prerequisites.put("CS201", new HashSet<>(Arrays.asList("CS101")));
completed.put("Alice", new HashSet<>(Arrays.asList("CS101")));
completed.put("Bob", new HashSet<>(Arrays.asList("CS101")));
... |
// Hidden: prerequisite failure
reset();
capacity.put("CS301", 10);
prerequisites.put("CS301", new HashSet<>(Arrays.asList("CS201")));
completed.put("Dave", new HashSet<>(Arrays.asList("CS101")));
String r1 = enroll("Dave", "CS301");
assert r1.equals("PREREQ_FAIL... | code_purpose_understanding |
25 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask25 {
static List<String> qcLog = new ArrayList<>();
// Inspect a batch of items and decide pass/reject.
// Rules:
// 1. Defect rate = defectCount / totalCount (BigDecimal, scale 4, HALF_UP)
// 2.... | BigDecimal rate = new BigDecimal(defectCount).divide(new BigDecimal(totalCount), 4, RoundingMode.HALF_UP);
boolean rateExceeded = rate.compareTo(maxDefectRate) > 0;
boolean consExceeded = consecutiveDefects > maxConsecutive;
String reason;
String result;
if (rateExceeded ... | }
public static void main(String[] args) {
qcLog.clear();
// 5/100 = 0.05, max 0.04 -> rate exceeded; consecutive 2, max 3 -> ok
String r = inspectBatch("B001", 100, 5, 2, 3, new BigDecimal("0.04"));
assert r.equals("REJECT") : "Expected REJECT, got " + r;
assert qcLog.g... |
// Hidden: PASS case
qcLog.clear();
String r3 = inspectBatch("B003", 200, 5, 1, 3, new BigDecimal("0.05"));
// rate = 5/200 = 0.0250, max 0.05 -> ok; consec 1, max 3 -> ok
assert r3.equals("PASS") : "Expected PASS, got " + r3;
assert qcLog.get(0).equals("BATCH:B003:PASS:... | code_purpose_understanding |
26 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask26 {
static class Job {
final String id;
final String productType;
final int duration; // minutes
final int priority; // lower = higher priority
Job(String id, String productType, int duration, int priority) {
this.id = id;... | List<Job> sorted = new ArrayList<>(jobs);
sorted.sort(Comparator.comparingInt(j -> j.priority));
int currentTime = machineAvailableFrom;
String lastProductType = null;
int scheduled = 0;
for (Job job : sorted) {
int start = currentTime;
if (lastPro... | }
public static void main(String[] args) {
reset();
machineAvailableFrom = 480; // 8:00 AM
machineAvailableUntil = 600; // 10:00 AM (120 min window)
setupTime = 10;
List<Job> jobs = Arrays.asList(
new Job("J1", "TypeA", 30, 2),
new Job("J2", "Ty... |
// Hidden: job skipped when insufficient time
reset();
machineAvailableFrom = 0;
machineAvailableUntil = 50;
setupTime = 5;
List<Job> j2 = Arrays.asList(
new Job("A", "X", 30, 1),
new Job("B", "Y", 20, 2)
);
int c2 = scheduleJobs(j... | code_purpose_understanding |
27 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.util.*;
public class CPTask27 {
enum EscrowStatus { OPEN, CONTINGENCY_FAILED, CLOSED, FORFEITED }
static class Contingency {
final String name;
final int deadlineDay; // day number by which it must be satisfied
boolean satisfied;
Cont... | List<Contingency> sorted = new ArrayList<>(contingencies);
sorted.sort(Comparator.comparingInt(c -> c.deadlineDay));
for (Contingency c : sorted) {
if (c.deadlineDay > currentDay) continue;
if (!c.satisfied) {
status = EscrowStatus.CONTINGENCY_FAILED;
... | }
public static void main(String[] args) {
reset();
earnestMoney = new BigDecimal("25000");
contingencies = new ArrayList<>(Arrays.asList(
new Contingency("INSPECTION", 10),
new Contingency("APPRAISAL", 20),
new Contingency("FINANCING", 30)
))... |
// Hidden: first unsatisfied contingency forfeits earnest money
reset();
earnestMoney = new BigDecimal("50000");
contingencies = new ArrayList<>(Arrays.asList(
new Contingency("INSPECTION", 10),
new Contingency("APPRAISAL", 20)
));
contingencies.g... | code_purpose_understanding |
28 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask28 {
static List<String> commissionLog = new ArrayList<>();
// Calculate agent commission from a property sale with tiered rates.
//
// Commission tiers (on sale price):
// - First tierOneLimit: ti... | BigDecimal total = BigDecimal.ZERO;
if (salePrice.compareTo(tierOneLimit) <= 0) {
total = salePrice.multiply(tierOneRate);
} else if (salePrice.compareTo(tierTwoLimit) <= 0) {
total = tierOneLimit.multiply(tierOneRate)
.add(salePrice.subtract(tierOneLi... | }
public static void main(String[] args) {
commissionLog.clear();
// $500K sale, tiers: 0-200K@6%, 200K-400K@5%, 400K+@4%
// Tier1: 200000*0.06=12000, Tier2: 200000*0.05=10000, Tier3: 100000*0.04=4000
// Total = 26000, listing 60%=15600, buying 40%=10400
BigDecimal[] r =... |
// Hidden: minimum guarantee kicks in
commissionLog.clear();
BigDecimal[] r2 = calculateCommission(
new BigDecimal("50000"),
new BigDecimal("200000"), new BigDecimal("0.06"),
new BigDecimal("400000"), new BigDecimal("0.05"),
new BigDecimal("0.04")... | code_purpose_understanding |
29 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask29 {
static Map<String, Set<String>> prerequisites = new HashMap<>(); // achievement -> required achievements
static Map<String, Integer> achievementPoints = new HashMap<>(); // achievement -> point value
static Set<String> unlocked = new HashSet<>();
static int t... | if (unlocked.contains(achieveId)) {
achieveLog.add("DUPLICATE:" + achieveId);
return false;
}
Set<String> prereqs = prerequisites.getOrDefault(achieveId, Collections.emptySet());
Set<String> missing = new TreeSet<>();
for (String p : prereqs) {
... | }
public static void main(String[] args) {
reset();
achievementPoints.put("FIRST_KILL", 10);
achievementPoints.put("COMBO_5", 25);
achievementPoints.put("BOSS_SLAYER", 75);
prerequisites.put("COMBO_5", new HashSet<>(Arrays.asList("FIRST_KILL")));
prerequisites.pu... |
// Hidden: prerequisite not met
reset();
achievementPoints.put("A", 50);
achievementPoints.put("B", 50);
prerequisites.put("B", new HashSet<>(Arrays.asList("A")));
boolean r1 = tryUnlock("B");
assert !r1 : "B requires A";
assert achieveLog.get(0).equals("... | code_purpose_understanding |
30 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask30 {
static class Player {
final String name;
final int seed; // lower = better
int score;
Player(String name, int seed) { this.name = name; this.seed = seed; this.score = 0; }
}
static List<String> bracketLog = new ArrayList<>();
... | List<Player> sorted = new ArrayList<>(players);
sorted.sort(Comparator.comparingInt(p -> p.seed));
int n = sorted.size();
int bracketSize = 1;
while (bracketSize < n) bracketSize *= 2;
int byes = bracketSize - n;
List<String> advancing = new ArrayList<>();
... | }
public static void main(String[] args) {
resetLog();
List<Player> players = Arrays.asList(
new Player("Alice", 1),
new Player("Bob", 4),
new Player("Charlie", 2),
new Player("Diana", 3)
);
// 4 players, bracketSize=4, byes=0
... |
// Hidden: 3 players — 1 bye
resetLog();
List<Player> p2 = Arrays.asList(
new Player("X", 3), new Player("Y", 1), new Player("Z", 2)
);
// bracketSize=4, byes=1. Y(seed1) gets bye.
// Remaining: Z(2) vs X(3)
List<String> adv2 = generateFirstRound(p2);... | code_purpose_understanding |
31 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask31 {
static BigDecimal balance;
static BigDecimal dailyLimit;
static BigDecimal dailyTransferred;
static boolean fraudLocked;
static List<String> auditLog;
static Set<String> processedTxIds;
... | if (processedTxIds.contains(txId)) return "DUPLICATE";
if (fraudLocked) return "FRAUD_HOLD";
if (amount.compareTo(BigDecimal.ZERO) <= 0) return "INVALID_AMOUNT";
if (amount.compareTo(balance) > 0) return "INSUFFICIENT_FUNDS";
if (dailyTransferred.add(amount).compareTo(dailyLimit)... | }
public static void main(String[] args) {
init();
String r1 = transfer("T1", new BigDecimal("1000.00"));
assert r1.equals("SUCCESS") : "T1 should succeed, got " + r1;
assert balance.compareTo(new BigDecimal("9000.00")) == 0 : "Balance should be 9000";
assert auditLog.si... | // Idempotency
init();
transfer("TX1", new BigDecimal("1000.00"));
BigDecimal balBefore = balance;
int logBefore = auditLog.size();
String dup = transfer("TX1", new BigDecimal("500.00"));
assert dup.equals("DUPLICATE") : "Duplicate should return DUPLICATE, got " +... | code_purpose_understanding |
32 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask32 {
static BigDecimal principal;
static BigDecimal interestRate;
static int termMonths;
static int currentMonth;
static boolean redeemed;
static List<String> auditLog;
static void init(int m... | if (redeemed) { auditLog.add("ALREADY_REDEEMED"); return BigDecimal.ZERO; }
if (currentMonth >= termMonths) {
BigDecimal total = principal.add(principal.multiply(interestRate)).setScale(2, RoundingMode.HALF_UP);
auditLog.add("MATURED:" + total);
redeemed = true;
... | }
public static void main(String[] args) {
init(6);
BigDecimal result = withdraw();
// At month 6 of 12: earned = 10000 * 0.05 * 6/12 = 250.00
// Penalty = 10000 * 0.05 * 3/12 = 125.00
// Net = 10000 + 250 - 125 = 10125.00
assert result.compareTo(new BigDecimal("... | // Already redeemed - idempotency
init(6);
withdraw(); // first withdraw
BigDecimal again = withdraw();
assert again.compareTo(BigDecimal.ZERO) == 0 : "Second withdraw should return 0, got " + again;
assert auditLog.get(1).equals("ALREADY_REDEEMED") : "Should log ALREADY_... | code_purpose_understanding |
33 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask33 {
static BigDecimal basePlanGB;
static BigDecimal rolloverGB;
static BigDecimal rolloverCap;
static BigDecimal throttleThreshold;
static BigDecimal overageRatePerGB;
static BigDecimal usedGB;
... | BigDecimal effectiveRollover = rolloverGB.min(rolloverCap);
BigDecimal totalAllowance = basePlanGB.add(effectiveRollover);
usedGB = usedGB.add(usageGB);
BigDecimal throttlePoint = totalAllowance.multiply(throttleThreshold).setScale(2, RoundingMode.HALF_UP);
if (usedGB.compareTo(t... | }
public static void main(String[] args) {
init(new BigDecimal("3.00"));
// totalAllowance = 10 + min(3, 5) = 13 GB
// throttle at 13 * 0.90 = 11.70
BigDecimal r1 = recordUsage(new BigDecimal("5.00"));
assert r1.compareTo(new BigDecimal("5.00")) == 0 : "Used should be 5,... | // Overage test
init(new BigDecimal("3.00"));
recordUsage(new BigDecimal("5.00"));
recordUsage(new BigDecimal("7.00"));
BigDecimal r3 = recordUsage(new BigDecimal("3.00"));
assert r3.compareTo(new BigDecimal("15.00")) == 0 : "Used should be 15, got " + r3;
assert ... | code_purpose_understanding |
34 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask34 {
enum SimState { NEW, PORT_REQUESTED, PORT_VERIFIED, ACTIVE, SUSPENDED }
static SimState state;
static String phoneNumber;
static String carrier;
static BigDecimal activationFee = new BigDecimal("... | if (state != SimState.NEW && timestamp - lastActionTime < cooldownPeriod) return "COOLDOWN";
if (action.equals("PORT_REQUEST")) {
if (state != SimState.NEW) return "INVALID_TRANSITION";
state = SimState.PORT_REQUESTED; phoneNumber = number; carrier = fromCarrier;
audi... | }
public static void main(String[] args) {
init();
String r1 = processAction("PORT_REQUEST", 0, "5551234567", "OldCarrier");
assert r1.equals("OK") : "Port request should succeed, got " + r1;
assert state == SimState.PORT_REQUESTED;
String r2 = processAction("PORT_VERIF... | // Cooldown test
init();
processAction("PORT_REQUEST", 0, "5551111111", "CarrierA");
processAction("PORT_VERIFY", 100, null, null);
processAction("ACTIVATE", 200, null, null);
String r4 = processAction("SUSPEND", 210, null, null);
assert r4.equals("COOLDOWN") : "S... | code_purpose_understanding |
35 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask35 {
static BigDecimal hourlyRate;
static BigDecimal clientCap;
static BigDecimal totalBilled;
static BigDecimal totalWrittenOff;
static BigDecimal writeOffLimit;
static List<String> auditLog;
... | if (processedEntries.contains(entryId)) return "DUPLICATE";
BigDecimal amt = hours.multiply(hourlyRate).setScale(2, RoundingMode.HALF_UP);
String result;
if (writeOff) {
if (totalWrittenOff.add(amt).compareTo(writeOffLimit) > 0) return "WRITEOFF_LIMIT";
totalWritt... | }
public static void main(String[] args) {
init();
// Normal billing: 10 hours * 350 = 3500
String r1 = recordHours("E1", new BigDecimal("10"), false);
assert r1.equals("BILLED") : "E1 should be billed, got " + r1;
assert totalBilled.compareTo(new BigDecimal("3500.00")) ... | // Duplicate entry
init();
recordHours("E1", new BigDecimal("10"), false);
String dup = recordHours("E1", new BigDecimal("10"), false);
assert dup.equals("DUPLICATE") : "E1 should be duplicate, got " + dup;
// Partial billing at cap with auto-writeoff
init();
... | code_purpose_understanding |
36 | devbench-code-purpose-understanding | java | import java.util.*;
public class CPTask36 {
static int version;
static String status;
static List<String> approvers;
static int requiredApprovals;
static List<String> auditLog;
static String content;
static void init() {
version = 1; status = "DRAFT"; approvers = new ArrayList<>();... | if (action.equals("EDIT")) {
if (!status.equals("DRAFT")) return "INVALID";
content = newContent; version++;
auditLog.add("EDIT:v" + version);
} else if (action.equals("SUBMIT")) {
if (!status.equals("DRAFT")) return "INVALID";
status = "REVIEW... | }
public static void main(String[] args) {
init();
String r1 = processAction("EDIT", null, "Updated draft");
assert r1.equals("OK") : "Edit should work in DRAFT";
assert version == 2 : "Version should be 2";
assert content.equals("Updated draft");
String r2 = pr... | // Duplicate approver test
init();
processAction("SUBMIT", null, null);
processAction("APPROVE", "Alice", null);
processAction("APPROVE", "Alice", null); // duplicate
assert approvers.size() == 1 : "Duplicate approver should not increase count, got " + approvers.size();
... | code_purpose_understanding |
37 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask37 {
static BigDecimal lastActualReading;
static BigDecimal lastBilledReading;
static BigDecimal estimatedUsage;
static BigDecimal totalBilled;
static BigDecimal tier1Limit = new BigDecimal("500");
... | if (estimated) {
if (estimateCount >= maxConsecutiveEstimates) return new BigDecimal("-1");
BigDecimal usage = reading.subtract(lastBilledReading);
estimatedUsage = estimatedUsage.add(usage); estimateCount++;
BigDecimal bill = calculateBill(usage); totalBilled = t... | }
public static void main(String[] args) {
init();
// First estimated read: 400 kWh, tier 1: 400 * 0.10 = 40.00
BigDecimal r1 = recordReading(new BigDecimal("400"), true);
assert r1.compareTo(new BigDecimal("40.00")) == 0 : "First bill should be 40.00, got " + r1;
assert... | // Estimate limit + reconciliation
init();
recordReading(new BigDecimal("400"), true); // est 400, bill 40
recordReading(new BigDecimal("700"), true); // est 300, bill 30, total 70
BigDecimal r3 = recordReading(new BigDecimal("900"), true);
assert r3.compareTo(new Big... | code_purpose_understanding |
38 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask38 {
static BigDecimal gridRate = new BigDecimal("0.12");
static BigDecimal solarCreditRate = new BigDecimal("0.08");
static BigDecimal creditBalance;
static BigDecimal maxMonthlyCredit = new BigDecimal("... | BigDecimal gridCost = consumedKWh.multiply(gridRate).setScale(2, RoundingMode.HALF_UP);
BigDecimal solarCredit = exportedKWh.multiply(solarCreditRate).setScale(2, RoundingMode.HALF_UP);
BigDecimal effectiveCredit = solarCredit.min(maxMonthlyCredit);
BigDecimal excess = solarCredit.subtra... | }
public static void main(String[] args) {
init();
// Month 1: consumed 500 kWh ($60), exported 800 kWh ($64)
// effectiveCredit = min(64, 50) = 50, excess = 14, creditBalance = 14
// availableCredit = 50 + 14 = 64 >= 60, payment = 0
// creditBalance = 64 - 60 = 4
... | // Multi-month test
init();
// Month 1: consumed 500 ($60), exported 800 ($64)
processBilling(new BigDecimal("500"), new BigDecimal("800"));
assert creditBalance.compareTo(new BigDecimal("4.00")) == 0;
// Month 2: consumed 1000 ($120), exported 200 ($16)
// effec... | code_purpose_understanding |
39 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask39 {
static Map<String, BigDecimal> baseRecipe = new LinkedHashMap<>();
static Map<String, String> substitutions = new HashMap<>();
static Map<String, BigDecimal> substitutionRatios = new HashMap<>();
sta... | Map<String, BigDecimal> result = new LinkedHashMap<>();
BigDecimal scaleFactor = new BigDecimal(targetServings)
.divide(new BigDecimal(baseServings), 4, RoundingMode.HALF_UP);
for (Map.Entry<String, BigDecimal> entry : baseRecipe.entrySet()) {
String ingredient = entry.ge... | }
public static void main(String[] args) {
auditLog.clear();
Map<String, BigDecimal> recipe = scaleRecipe(8);
// scaleFactor = 8/4 = 2.0
// flour: 2*2 = 4.00, sugar: 1*2 = 2.00, butter->oil: 0.5*2*0.75 = 0.75
// eggs: 3*2 = 6.00, milk->oat_milk: 1*2*1.0 = 2.00
as... | // Scale down to 1 serving — test minimum amount clamping
auditLog.clear();
Map<String, BigDecimal> small = scaleRecipe(1);
// scaleFactor = 0.2500
// flour: 0.50, sugar: 0.25, butter->oil: 0.5*0.25*0.75=0.09 -> 0.25
// eggs: 0.75, milk->oat_milk: 0.25
assert smal... | code_purpose_understanding |
40 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask40 {
static BigDecimal dangerZoneLow = new BigDecimal("40");
static BigDecimal dangerZoneHigh = new BigDecimal("140");
static int maxDangerMinutes = 120;
static int consecutiveViolationLimit = 3;
stat... | if (foodStatus.equals("DISCARD")) return "DISCARDED";
tempHistory.add(temp);
boolean inDanger = temp.compareTo(dangerZoneLow) > 0 && temp.compareTo(dangerZoneHigh) < 0;
if (inDanger) {
totalDangerMinutes += minutesSinceLastCheck;
consecutiveViolations++;
... | }
public static void main(String[] args) {
init();
// Safe reading at boundary
String r1 = recordTemp(new BigDecimal("140"), 0);
assert r1.equals("SAFE") : "140F should be safe, got " + r1;
// Danger zone reading
String r2 = recordTemp(new BigDecimal("80"), 30);... | // Total danger persists after safe reading
init();
recordTemp(new BigDecimal("80"), 30); // danger, total=30
recordTemp(new BigDecimal("160"), 15); // safe
assert totalDangerMinutes == 30 : "Total danger should persist, got " + totalDangerMinutes;
// Three consecutive -... | code_purpose_understanding |
41 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.util.*;
public class CPTask41 {
enum Tier { BRONZE, SILVER, GOLD, PLATINUM }
static Map<String, Tier> passengerTiers = new HashMap<>();
static Map<String, String> seatAssignments = new HashMap<>();
static List<String> standbyQueue = new ArrayList<>();
stati... | if (processedUpgrades.contains(passenger)) {
return "ALREADY_PROCESSED";
}
processedUpgrades.add(passenger);
Tier tier = passengerTiers.getOrDefault(passenger, Tier.BRONZE);
if (tier == Tier.GOLD || tier == Tier.PLATINUM) {
seatAssignments.put(passenger, n... | }
public static void main(String[] args) {
passengerTiers.put("Alice", Tier.PLATINUM);
passengerTiers.put("Bob", Tier.BRONZE);
passengerTiers.put("Carol", Tier.SILVER);
assert requestUpgrade("Alice", "1A").equals("UPGRADED");
assert seatAssignments.get("Alice").equals("... | // Self-contained assertion tests (runs before main as static init)
// Reset all state
CPTask41.passengerTiers.clear();
CPTask41.seatAssignments.clear();
CPTask41.standbyQueue.clear();
CPTask41.processedUpgrades.clear();
CPTask41.auditLog.clear();
CPTask4... | code_purpose_understanding |
42 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask42 {
// Baggage fee rules:
// 1. First bag free, 2nd bag $35, 3rd+ bag $75 each
// 2. Overweight surcharge: bags > 50 lbs get $100 surcharge PER overweight bag
// 3. Oversize surcharge: bags > 62 linear i... | bagCount++;
BigDecimal baseFee = bagCount == 1 ? BigDecimal.ZERO
: bagCount == 2 ? new BigDecimal("35") : new BigDecimal("75");
BigDecimal surcharge = BigDecimal.ZERO;
if (weightLbs > 50) surcharge = surcharge.add(new BigDecimal("100"));
if (linearInches > 62) surchar... | }
public static void main(String[] args) {
// Bag 1: 40 lbs, 50 inches — free, no surcharges
BigDecimal f1 = checkBag(40, 50);
assert f1.compareTo(BigDecimal.ZERO) == 0 : "Bag 1 fee: " + f1;
// Bag 2: 55 lbs, 50 inches — $35 base + $100 overweight = $135
BigDecimal f2 =... | // Self-contained: reset state
CPTask42.feeLog.clear();
CPTask42.bagCount = 0;
CPTask42.totalCharged = BigDecimal.ZERO;
// Bag 1: free
BigDecimal a1 = CPTask42.checkBag(40, 50);
assert a1.compareTo(BigDecimal.ZERO) == 0 : "A-Bag1: " + a1;
// Bag 2: $35 b... | code_purpose_understanding |
43 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask43 {
// Premium calculation rules:
// 1. Base premium starts at basePremium
// 2. Each risk factor multiplies the premium: SMOKER=1.5, HIGH_BMI=1.3, SENIOR=1.4
// Applied multiplicatively in order they... | BigDecimal premium = basePremium;
for (String factor : riskFactors) {
BigDecimal multiplier = RISK_MULTIPLIERS.get(factor);
if (multiplier != null) {
premium = premium.multiply(multiplier);
}
}
int discountPct = Math.min(claimFreeYears ... | }
public static void main(String[] args) {
// Base $200, SMOKER+HIGH_BMI → 200*1.5*1.3 = 390, 3 claim-free years → 15% off → 331.50
BigDecimal p1 = calculatePremium(new BigDecimal("200"), List.of("SMOKER", "HIGH_BMI"), 3);
assert p1.compareTo(new BigDecimal("331.50")) == 0 : "p1=" + p1;... | // Max discount cap: 10 claim-free years → still only 30% discount
BigDecimal p3 = CPTask43.calculatePremium(new BigDecimal("200"), List.of(), 10);
// 200 * 0.70 = 140.00
assert p3.compareTo(new BigDecimal("140.00")) == 0 : "Max discount cap failed: " + p3;
// Minimum premium fl... | code_purpose_understanding |
44 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask44 {
// Policy renewal rules:
// 1. Policy states: ACTIVE, GRACE, LAPSED, CANCELLED
// 2. If currentDay <= expiryDay and policyState is ACTIVE, return "ALREADY_ACTIVE"
// 3. Days past expiry = max(0, curr... | if (policyState.equals("ACTIVE") && currentDay <= expiryDay) {
return "ALREADY_ACTIVE";
}
int daysPastExpiry = currentDay - expiryDay;
if (daysPastExpiry < 0) daysPastExpiry = 0;
if (daysPastExpiry <= 30) {
policyState = "ACTIVE";
expiryDay = ... | }
public static void main(String[] args) {
// Before expiry — already active
assert renewPolicy("POL-1", 50).equals("ALREADY_ACTIVE");
// Day 110 — 10 days past expiry, within grace → renew at base $400
policyState = "ACTIVE";
expiryDay = 100;
String r1 = renewP... | // Self-contained: reset state
CPTask44.policyState = "ACTIVE";
CPTask44.expiryDay = 200;
CPTask44.auditLog.clear();
// Day 250 — 50 days past expiry → penalty window: 400 + 100 + 75 = $575.00
String r2 = CPTask44.renewPolicy("POL-2", 250);
assert r2.equals("RENE... | code_purpose_understanding |
45 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask45 {
// Usage metering rules:
// 1. Committed tier: first 1000 units included in base fee ($200)
// 2. Overage: units 1001-2000 at $0.30/unit; units 2001+ at $0.50/unit (burst pricing)
// 3. Running usage... | BigDecimal baseFee = new BigDecimal("200.00");
BigDecimal overage = BigDecimal.ZERO;
if (currentUsage > 2000) {
overage = new BigDecimal("1000").multiply(new BigDecimal("0.30"))
.add(new BigDecimal(currentUsage - 2000).multiply(new BigDecimal("0.50")));
} else... | }
public static void main(String[] args) {
// Record 1500 units across two calls
recordUsage(800);
recordUsage(700);
// 1500 total: 1000 included, 500 overage at $0.30 = $150, total = $350
BigDecimal bill1 = closeBillingPeriod();
assert bill1.compareTo(new BigDec... | // Self-contained: reset
CPTask45.currentUsage = 0;
CPTask45.credits = BigDecimal.ZERO;
CPTask45.auditLog.clear();
// Zero usage — minimum charge $200
BigDecimal bill3 = CPTask45.closeBillingPeriod();
assert bill3.compareTo(new BigDecimal("200.00")) == 0 : "Zero ... | code_purpose_understanding |
46 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.util.*;
public class CPTask46 {
enum Plan { FREE, STARTER, BUSINESS, ENTERPRISE }
static final Map<Plan, Set<String>> PLAN_FEATURES = new LinkedHashMap<>();
static final Map<Plan, Integer> SEAT_LIMITS = new LinkedHashMap<>();
static final Map<Plan, Integer> STO... | expireTrialIfNeeded(currentDay);
if (action.equals("ADD_SEAT")) {
return addSeat(currentDay);
} else if (action.startsWith("USE_STORAGE:")) {
int mb = Integer.parseInt(action.split(":")[1]);
return useStorage(mb, currentDay);
} else if (action.startsWi... | }
public static void main(String[] args) {
// FREE plan: 3 seats max
assert provision("ADD_SEAT", 1).equals("OK"); // seat 2
assert provision("ADD_SEAT", 2).equals("OK"); // seat 3
assert provision("ADD_SEAT", 3).equals("SEAT_LIMIT_REACHED");
// Storage: 500 MB limit on... | // Self-contained: reset all state
CPTask46.currentPlan = Plan.FREE;
CPTask46.currentSeats = 1;
CPTask46.currentStorageMB = 0;
CPTask46.trialActive = false;
CPTask46.trialExpiryDay = -1;
CPTask46.trialUsed = false;
CPTask46.provisionLog.clear();
/... | code_purpose_understanding |
47 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask47 {
// Corporate donation matching rules:
// 1. Company matches employee donations at 1:1 ratio up to $500 per donation
// 2. Annual corporate matching cap: $10,000 total across all employees
// 3. Remai... | // Per-donation match cap: $500
BigDecimal maxMatch = new BigDecimal("500.00");
BigDecimal desiredMatch = amount.compareTo(maxMatch) > 0 ? maxMatch : amount;
// Apply annual budget constraint
BigDecimal actualMatch;
if (annualBudgetRemaining.compareTo(BigDecimal.ZERO) <=... | }
public static void main(String[] args) {
// $300 donation — matched 1:1 ($300), total $600
BigDecimal t1 = processDonation("Alice", new BigDecimal("300.00"));
assert t1.compareTo(new BigDecimal("600.00")) == 0 : "t1=" + t1;
// $800 donation — match capped at $500, total $1300... | // Self-contained: reset state
CPTask47.annualBudgetRemaining = new BigDecimal("10000.00");
CPTask47.taxReceipts.clear();
// Use up most of budget: 19 donations of $500 each → 19*500 = 9500 matched
for (int i = 0; i < 19; i++) {
CPTask47.processDonation("Emp" + i, ne... | code_purpose_understanding |
48 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask48 {
// Grant disbursement rules:
// 1. Grant has milestones (ordered list). Each has a percentage of total grant.
// 2. Milestones must be completed IN ORDER — cannot skip ahead
// 3. Each milestone rele... | if (grantState.equals("CLAWBACK")) return "GRANT_CLAWBACK";
if (completedMilestones.contains(milestone)) return "ALREADY_COMPLETED";
if (nextMilestoneIdx >= milestones.size() || !milestones.get(nextMilestoneIdx).equals(milestone))
return "WRONG_SEQUENCE";
if (!passed) {
... | }
public static void main(String[] args) {
// DESIGN: 10% of 100k = 10000, holdback 10% = 1000, disbursed = 9000
String r1 = completeMilestone("DESIGN", true);
assert r1.equals("DISBURSED") : r1;
assert totalDisbursed.compareTo(new BigDecimal("9000.00")) == 0 : "d=" + totalDisbu... | // Self-contained: reset all state
CPTask48.totalGrant = new BigDecimal("100000.00");
CPTask48.nextMilestoneIdx = 0;
CPTask48.totalDisbursed = BigDecimal.ZERO;
CPTask48.holdback = BigDecimal.ZERO;
CPTask48.completedMilestones.clear();
CPTask48.grantState = "ACTIVE... | code_purpose_understanding |
49 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask49 {
// Draft pick trading rules:
// 1. Pick values: Round 1 = $5M, Round 2 = $3M, Round 3 = $1.5M, Round 4+ = $0.5M
// 2. Each team has a salary cap space. Acquiring picks consumes cap space by pick value.
... | BigDecimal givenVal = totalValue(pickRoundsGiven);
BigDecimal recvVal = totalValue(pickRoundsReceived);
if (givenVal.compareTo(recvVal.multiply(new BigDecimal("0.80"))) < 0) return "TRADE_IMBALANCED";
if (capSpace.get(teamA).compareTo(recvVal) < 0) return "CAP_EXCEEDED";
List<Int... | }
public static void main(String[] args) {
teamPicks.put("Eagles", new ArrayList<>(List.of(1, 3, 4)));
teamPicks.put("Bears", new ArrayList<>(List.of(2, 2, 4)));
capSpace.put("Eagles", new BigDecimal("10000000"));
capSpace.put("Bears", new BigDecimal("8000000"));
// Eag... | // Self-contained: reset state
CPTask49.teamPicks.clear();
CPTask49.capSpace.clear();
CPTask49.tradeLog.clear();
CPTask49.teamPicks.put("Lions", new ArrayList<>(List.of(1, 2, 3)));
CPTask49.teamPicks.put("Hawks", new ArrayList<>(List.of(1, 4, 4)));
CPTask49.capSp... | code_purpose_understanding |
50 | devbench-code-purpose-understanding | java | import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class CPTask50 {
// Player contract rules:
// 1. Base salary: paid each season via recordSeason()
// 2. Performance bonuses (tiered):
// - 10+ goals: $100K bonus
// - 20+ goals: additional $200K (total $300... | currentSeason++;
BigDecimal salary, bonus = BigDecimal.ZERO;
if (gamesPlayed < 10) {
salary = baseSalary.multiply(new BigDecimal("0.50"));
payLog.add("SEASON:" + currentSeason + ":salary=$" + salary.setScale(2, RoundingMode.HALF_UP) + ":bonus=$0.00:injury=true");
... | }
public static void main(String[] args) {
// Season 1: 15 goals, 30 games — $100K bonus but escrowed
recordSeason(15, 30);
// Paid: $2M salary only (bonus escrowed)
assert totalPaid.compareTo(new BigDecimal("2000000.00")) == 0 : "S1 paid: " + totalPaid;
assert escrow.co... | // Self-contained: reset all state
CPTask50.baseSalary = new BigDecimal("2000000.00");
CPTask50.currentSeason = 0;
CPTask50.totalPaid = BigDecimal.ZERO;
CPTask50.escrow = BigDecimal.ZERO;
CPTask50.vested = false;
CPTask50.payLog.clear();
// S1: 15 goals, ... | code_purpose_understanding |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.