File size: 206,652 Bytes
aff484f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 | task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
HSP,HSP,"We just moved in and want to standardize detectors: each room can accept certain models, and the plan is to decide on the fewest different detector models that still appear in every room’s acceptable list. The “best” plan is the one with the lowest number of distinct models — you measure that by counting how many model types are chosen. It’s important that no room is left without one of the chosen models, and the choice is a set of distinct models (no duplicates). The specific room-by-model options are shown below.
- **total_detector_models**: 13
- **total_rooms**: 13
| room_id | acceptable_models |
|---|---|
| S1 | A B C G H |
| S2 | A B F G M |
| S3 | A B C D E F G |
| S4 | C E H I K L |
| S5 | A C D E F H J |
| S6 | A C D E F I J L M |
| S7 | A C G |
| S8 | E F I J M |
| S9 | D F I K M |
| S10 | F H J |
| S11 | D K L M |
| S12 | B C E F K L M |
| S13 | B F H K L M |
Also, when you send back your choice, just follow this simple JSON shape so it's easy to parse:
{
""solution"": [""model_id"", ...]
}
Pretty straightforward: ""solution"" is a list (an array) of the detector model identifiers you picked — one per model type. Think of it like a short form where you just list the model labels that should appear in every room's acceptable list. This is just the expected shape, not the actual answer; fill in the real model IDs from the instance when you reply.
Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.4260355029585799, 'sets': [{'id': 1, 'elements': [1, 2, 3, 7, 8]}, {'id': 2, 'elements': [1, 2, 6, 7, 13]}, {'id': 3, 'elements': [1, 2, 3, 4, 5, 6, 7]}, {'id': 4, 'elements': [3, 5, 8, 9, 11, 12]}, {'id': 5, 'elements': [1, 3, 4, 5, 6, 8, 10]}, {'id': 6, 'elements': [1, 3, 4, 5, 6, 9, 10, 12, 13]}, {'id': 7, 'elements': [1, 3, 7]}, {'id': 8, 'elements': [5, 6, 9, 10, 13]}, {'id': 9, 'elements': [4, 6, 9, 11, 13]}, {'id': 10, 'elements': [6, 8, 10]}, {'id': 11, 'elements': [4, 11, 12, 13]}, {'id': 12, 'elements': [2, 3, 5, 6, 11, 12, 13]}, {'id': 13, 'elements': [2, 6, 8, 11, 12, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 2, 'v': 3}, {'u': 2, 'v': 12}, {'u': 12, 'v': 6}, {'u': 12, 'v': 13}, {'u': 13, 'v': 4}, {'u': 13, 'v': 11}, {'u': 3, 'v': 1}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 1, 'v': 5}, {'u': 8, 'v': 5}, {'u': 9, 'v': 11}, {'u': 5, 'v': 10}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0000.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0000.png'}","[3, 8, 13]",3.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'C', 'G', 'H']}, {'id': 'S2', 'elements': ['A', 'B', 'F', 'G', 'M']}, {'id': 'S3', 'elements': ['A', 'B', 'C', 'D', 'E', 'F', 'G']}, {'id': 'S4', 'elements': ['C', 'E', 'H', 'I', 'K', 'L']}, {'id': 'S5', 'elements': ['A', 'C', 'D', 'E', 'F', 'H', 'J']}, {'id': 'S6', 'elements': ['A', 'C', 'D', 'E', 'F', 'I', 'J', 'L', 'M']}, {'id': 'S7', 'elements': ['A', 'C', 'G']}, {'id': 'S8', 'elements': ['E', 'F', 'I', 'J', 'M']}, {'id': 'S9', 'elements': ['D', 'F', 'I', 'K', 'M']}, {'id': 'S10', 'elements': ['F', 'H', 'J']}, {'id': 'S11', 'elements': ['D', 'K', 'L', 'M']}, {'id': 'S12', 'elements': ['B', 'C', 'E', 'F', 'K', 'L', 'M']}, {'id': 'S13', 'elements': ['B', 'F', 'H', 'K', 'L', 'M']}]}","['C', 'H', 'M']",1,markdown_table,names
HSP,HSP,"There’s a stack of reading lists that need clearer labeling, so the librarian wants to keep only a tiny set of subject tags. The trick is to pick as few tags as necessary, but every reading list must include at least one of those kept tags. The “result” is just the count of tags kept — fewer tags is better — and every list has to be covered with no lists left out and each kept tag only counts once. The exact lists and tag options appear below.
- **total_subject_tags**: 13
- **num_reading_lists**: 12
| reading_list_id | tags_in_reading_list |
|---|---|
| S1 | 3 8 9 10 |
| S2 | 2 6 8 |
| S3 | 1 3 4 8 9 10 13 |
| S4 | 4 5 10 |
| S5 | 2 6 8 11 12 |
| S6 | 6 7 8 11 12 |
| S7 | 2 7 9 11 12 |
| S8 | 2 8 9 10 12 13 |
| S9 | 1 4 5 10 |
| S10 | 6 8 11 12 |
| S11 | 6 8 9 12 |
| S12 | 1 3 9 13 |
Oh, and when you reply, please use this little JSON shape so I can read the picks easily:
{
""solution"": [""tag_id"", ...]
}
Think of ""solution"" as the list of tag IDs you decided to keep for the librarian — each entry is just the ID of one tag (the same IDs that show up in the instance). This block is just a sketch of the expected shape, not the actual answer.
Please use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 12, 'density': 0.34615384615384615, 'sets': [{'id': 1, 'elements': [3, 8, 9, 10]}, {'id': 2, 'elements': [2, 6, 8]}, {'id': 3, 'elements': [1, 3, 4, 8, 9, 10, 13]}, {'id': 4, 'elements': [4, 5, 10]}, {'id': 5, 'elements': [2, 6, 8, 11, 12]}, {'id': 6, 'elements': [6, 7, 8, 11, 12]}, {'id': 7, 'elements': [2, 7, 9, 11, 12]}, {'id': 8, 'elements': [2, 8, 9, 10, 12, 13]}, {'id': 9, 'elements': [1, 4, 5, 10]}, {'id': 10, 'elements': [6, 8, 11, 12]}, {'id': 11, 'elements': [6, 8, 9, 12]}, {'id': 12, 'elements': [1, 3, 9, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 4, 'v': 10}, {'u': 5, 'v': 10}, {'u': 13, 'v': 1}, {'u': 6, 'v': 7}, {'u': 6, 'v': 11}, {'u': 6, 'v': 12}, {'u': 1, 'v': 3}, {'u': 1, 'v': 9}, {'u': 8, 'v': 9}, {'u': 8, 'v': 12}, {'u': 9, 'v': 3}, {'u': 10, 'v': 3}, {'u': 11, 'v': 12}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0001.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0001.png'}","[8, 9, 10]",3.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [3, 8, 9, 10]}, {'id': 'S2', 'elements': [2, 6, 8]}, {'id': 'S3', 'elements': [1, 3, 4, 8, 9, 10, 13]}, {'id': 'S4', 'elements': [4, 5, 10]}, {'id': 'S5', 'elements': [2, 6, 8, 11, 12]}, {'id': 'S6', 'elements': [6, 7, 8, 11, 12]}, {'id': 'S7', 'elements': [2, 7, 9, 11, 12]}, {'id': 'S8', 'elements': [2, 8, 9, 10, 12, 13]}, {'id': 'S9', 'elements': [1, 4, 5, 10]}, {'id': 'S10', 'elements': [6, 8, 11, 12]}, {'id': 'S11', 'elements': [6, 8, 9, 12]}, {'id': 'S12', 'elements': [1, 3, 9, 13]}]}","[8, 9, 10]",2,markdown_table,1
HSP,HSP,"We handle talent for a bunch of weekend parties and want to hire as few musicians as possible while still appearing in every lineup somewhere. The job is to choose which people to book so that every scheduled bill has at least one of our hires; plans are compared by simply counting the number of musicians booked — the lower the count, the better. Every event must have at least one booked performer, and a single musician can cover many events but won’t be counted twice to make the roster look smaller. The specific lineups are listed below.
{
""total_musicians"": 18,
""total_parties"": 18,
""sets"": [
{
""party_id"": ""S1"",
""musicians_in_lineup"": [
""A"",
""F"",
""H"",
""P"",
""Q""
]
},
{
""party_id"": ""S2"",
""musicians_in_lineup"": [
""B"",
""C"",
""D"",
""K"",
""O""
]
},
{
""party_id"": ""S3"",
""musicians_in_lineup"": [
""F"",
""J"",
""K""
]
},
{
""party_id"": ""S4"",
""musicians_in_lineup"": [
""D"",
""L"",
""M"",
""P""
]
},
{
""party_id"": ""S5"",
""musicians_in_lineup"": [
""C"",
""E"",
""F"",
""M"",
""N"",
""P""
]
},
{
""party_id"": ""S6"",
""musicians_in_lineup"": [
""A"",
""C"",
""O""
]
},
{
""party_id"": ""S7"",
""musicians_in_lineup"": [
""G"",
""H"",
""K"",
""N"",
""O"",
""Q""
]
},
{
""party_id"": ""S8"",
""musicians_in_lineup"": [
""A"",
""Q""
]
},
{
""party_id"": ""S9"",
""musicians_in_lineup"": [
""A"",
""P"",
""Q"",
""R""
]
},
{
""party_id"": ""S10"",
""musicians_in_lineup"": [
""B"",
""C"",
""D"",
""J"",
""L"",
""M""
]
},
{
""party_id"": ""S11"",
""musicians_in_lineup"": [
""B"",
""C"",
""G""
]
},
{
""party_id"": ""S12"",
""musicians_in_lineup"": [
""D"",
""L""
]
},
{
""party_id"": ""S13"",
""musicians_in_lineup"": [
""D"",
""E"",
""L"",
""M"",
""P"",
""Q""
]
},
{
""party_id"": ""S14"",
""musicians_in_lineup"": [
""C"",
""E"",
""G"",
""K"",
""N""
]
},
{
""party_id"": ""S15"",
""musicians_in_lineup"": [
""E"",
""K"",
""N"",
""O"",
""P"",
""Q""
]
},
{
""party_id"": ""S16"",
""musicians_in_lineup"": [
""A"",
""D"",
""E"",
""I"",
""L"",
""M"",
""O"",
""Q""
]
},
{
""party_id"": ""S17"",
""musicians_in_lineup"": [
""A"",
""E"",
""F"",
""G"",
""I"",
""M"",
""O"",
""P"",
""R""
]
},
{
""party_id"": ""S18"",
""musicians_in_lineup"": [
""I"",
""R""
]
}
]
}
Oh, and when you send back the plan, please follow this simple JSON layout so it's easy to read by whatever's checking our roster:
{
""solution"": [""musician_id"", ...]
}
""solution"" is just the list of musician identifiers you're booking — each string in that array is a placeholder for a musician's id from the event data. Think of it like filling in a short form: list the people you're hiring so every lineup has at least one of them. This JSON is only a sketch of the shape I expect, not the actual answer.
Also, make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 18, 'density': 0.2623456790123457, 'sets': [{'id': 1, 'elements': [1, 6, 8, 16, 17]}, {'id': 2, 'elements': [2, 3, 4, 11, 15]}, {'id': 3, 'elements': [6, 10, 11]}, {'id': 4, 'elements': [4, 12, 13, 16]}, {'id': 5, 'elements': [3, 5, 6, 13, 14, 16]}, {'id': 6, 'elements': [1, 3, 15]}, {'id': 7, 'elements': [7, 8, 11, 14, 15, 17]}, {'id': 8, 'elements': [1, 17]}, {'id': 9, 'elements': [1, 16, 17, 18]}, {'id': 10, 'elements': [2, 3, 4, 10, 12, 13]}, {'id': 11, 'elements': [2, 3, 7]}, {'id': 12, 'elements': [4, 12]}, {'id': 13, 'elements': [4, 5, 12, 13, 16, 17]}, {'id': 14, 'elements': [3, 5, 7, 11, 14]}, {'id': 15, 'elements': [5, 11, 14, 15, 16, 17]}, {'id': 16, 'elements': [1, 4, 5, 9, 12, 13, 15, 17]}, {'id': 17, 'elements': [1, 5, 6, 7, 9, 13, 15, 16, 18]}, {'id': 18, 'elements': [9, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 13, 'v': 4}, {'u': 13, 'v': 12}, {'u': 13, 'v': 16}, {'u': 15, 'v': 3}, {'u': 15, 'v': 5}, {'u': 15, 'v': 6}, {'u': 15, 'v': 14}, {'u': 16, 'v': 5}, {'u': 16, 'v': 17}, {'u': 17, 'v': 1}, {'u': 17, 'v': 6}, {'u': 17, 'v': 9}, {'u': 4, 'v': 10}, {'u': 4, 'v': 12}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 1, 'v': 8}, {'u': 14, 'v': 7}, {'u': 14, 'v': 11}, {'u': 18, 'v': 9}, {'u': 10, 'v': 2}, {'u': 2, 'v': 3}, {'u': 11, 'v': 3}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0002.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0002.png'}","[3, 4, 9, 11, 17]",5.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': ['A', 'F', 'H', 'P', 'Q']}, {'id': 'S2', 'elements': ['B', 'C', 'D', 'K', 'O']}, {'id': 'S3', 'elements': ['F', 'J', 'K']}, {'id': 'S4', 'elements': ['D', 'L', 'M', 'P']}, {'id': 'S5', 'elements': ['C', 'E', 'F', 'M', 'N', 'P']}, {'id': 'S6', 'elements': ['A', 'C', 'O']}, {'id': 'S7', 'elements': ['G', 'H', 'K', 'N', 'O', 'Q']}, {'id': 'S8', 'elements': ['A', 'Q']}, {'id': 'S9', 'elements': ['A', 'P', 'Q', 'R']}, {'id': 'S10', 'elements': ['B', 'C', 'D', 'J', 'L', 'M']}, {'id': 'S11', 'elements': ['B', 'C', 'G']}, {'id': 'S12', 'elements': ['D', 'L']}, {'id': 'S13', 'elements': ['D', 'E', 'L', 'M', 'P', 'Q']}, {'id': 'S14', 'elements': ['C', 'E', 'G', 'K', 'N']}, {'id': 'S15', 'elements': ['E', 'K', 'N', 'O', 'P', 'Q']}, {'id': 'S16', 'elements': ['A', 'D', 'E', 'I', 'L', 'M', 'O', 'Q']}, {'id': 'S17', 'elements': ['A', 'E', 'F', 'G', 'I', 'M', 'O', 'P', 'R']}, {'id': 'S18', 'elements': ['I', 'R']}]}","['C', 'D', 'I', 'K', 'Q']",3,json,names
HSP,HSP,"In the office the goal is to avoid bloated installs by picking a compact set of applications that still lets every user group run at least one compatible package. The decision is which specific packages to install so every group has at least one match. The better pick is always the one with the smaller number of installed packages — evaluate by counting how many distinct programs are chosen. Practical constraints: every group must be covered, duplicates don’t give extra credit, and every picked package must be useful to some group. The concrete instance information appears below.
{
""total_packages_available"": 15,
""total_user_groups"": 14,
""sets"": [
{
""user_group_id"": ""S1"",
""compatible_packages"": [
1,
2,
4,
9,
11,
14
]
},
{
""user_group_id"": ""S2"",
""compatible_packages"": [
3,
4,
6
]
},
{
""user_group_id"": ""S3"",
""compatible_packages"": [
2,
3,
6,
7,
12
]
},
{
""user_group_id"": ""S4"",
""compatible_packages"": [
1,
13,
15
]
},
{
""user_group_id"": ""S5"",
""compatible_packages"": [
3,
4,
10
]
},
{
""user_group_id"": ""S6"",
""compatible_packages"": [
10,
12
]
},
{
""user_group_id"": ""S7"",
""compatible_packages"": [
2,
8,
9,
11,
12,
14
]
},
{
""user_group_id"": ""S8"",
""compatible_packages"": [
8,
9
]
},
{
""user_group_id"": ""S9"",
""compatible_packages"": [
3,
6,
7,
12
]
},
{
""user_group_id"": ""S10"",
""compatible_packages"": [
2,
8,
11
]
},
{
""user_group_id"": ""S11"",
""compatible_packages"": [
2,
4
]
},
{
""user_group_id"": ""S12"",
""compatible_packages"": [
1,
13,
14,
15
]
},
{
""user_group_id"": ""S13"",
""compatible_packages"": [
1,
2,
5,
12,
13,
14,
15
]
},
{
""user_group_id"": ""S14"",
""compatible_packages"": [
5,
13,
14,
15
]
}
]
}
Just drop your chosen package IDs into a tiny JSON object like this when you reply — nice and simple.
{
""solution"": [""package_id"", ...]
}
Here ""solution"" is the list of packages to install (one entry per chosen package). Think of ""package_id"" as a placeholder for whatever identifier the instance uses for a package. This JSON is just a sketch showing the shape I expect, not the actual answer.
Quick reminder: all identifiers you use must match the instance exactly — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 14, 'density': 0.2571428571428571, 'sets': [{'id': 1, 'elements': [1, 2, 4, 9, 11, 14]}, {'id': 2, 'elements': [3, 4, 6]}, {'id': 3, 'elements': [2, 3, 6, 7, 12]}, {'id': 4, 'elements': [1, 13, 15]}, {'id': 5, 'elements': [3, 4, 10]}, {'id': 6, 'elements': [10, 12]}, {'id': 7, 'elements': [2, 8, 9, 11, 12, 14]}, {'id': 8, 'elements': [8, 9]}, {'id': 9, 'elements': [3, 6, 7, 12]}, {'id': 10, 'elements': [2, 8, 11]}, {'id': 11, 'elements': [2, 4]}, {'id': 12, 'elements': [1, 13, 14, 15]}, {'id': 13, 'elements': [1, 2, 5, 12, 13, 14, 15]}, {'id': 14, 'elements': [5, 13, 14, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 4, 'v': 7}, {'u': 4, 'v': 10}, {'u': 4, 'v': 12}, {'u': 13, 'v': 1}, {'u': 12, 'v': 2}, {'u': 14, 'v': 1}, {'u': 14, 'v': 2}, {'u': 9, 'v': 8}, {'u': 10, 'v': 3}, {'u': 10, 'v': 6}, {'u': 15, 'v': 1}, {'u': 11, 'v': 8}, {'u': 5, 'v': 1}, {'u': 8, 'v': 2}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0003.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0003.png'}","[4, 8, 12, 15]",4.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [1, 2, 4, 9, 11, 14]}, {'id': 'S2', 'elements': [3, 4, 6]}, {'id': 'S3', 'elements': [2, 3, 6, 7, 12]}, {'id': 'S4', 'elements': [1, 13, 15]}, {'id': 'S5', 'elements': [3, 4, 10]}, {'id': 'S6', 'elements': [10, 12]}, {'id': 'S7', 'elements': [2, 8, 9, 11, 12, 14]}, {'id': 'S8', 'elements': [8, 9]}, {'id': 'S9', 'elements': [3, 6, 7, 12]}, {'id': 'S10', 'elements': [2, 8, 11]}, {'id': 'S11', 'elements': [2, 4]}, {'id': 'S12', 'elements': [1, 13, 14, 15]}, {'id': 'S13', 'elements': [1, 2, 5, 12, 13, 14, 15]}, {'id': 'S14', 'elements': [5, 13, 14, 15]}]}","[4, 8, 12, 15]",4,json,1
HSP,HSP,"Many people on the committee want a minimal shared reading list: pick a small set of book titles so that each course’s syllabus has at least one of those titles. The decision boils down to which specific titles to pick; one choice beats another if it uses fewer different books while still matching every syllabus. You evaluate a pick by counting the chosen titles — aim for the smallest count — and make sure every course is represented and titles aren’t duplicated in the count. The exact course lists are provided below.
There are 14 distinct titles across 13 course syllabi; the following lines enumerate each course's titles.
For course S1, the syllabus lists: A E H J.
For course S2, the syllabus lists: A B D E J M.
For course S3, the syllabus lists: C I.
For course S4, the syllabus lists: D F K.
For course S5, the syllabus lists: A B E H J.
For course S6, the syllabus lists: B F H L M.
For course S7, the syllabus lists: F G L M N.
For course S8, the syllabus lists: A B D F H J.
For course S9, the syllabus lists: A B E J.
For course S10, the syllabus lists: B D K.
For course S11, the syllabus lists: F G L M.
For course S12, the syllabus lists: B C F N.
For course S13, the syllabus lists: G M.
Aim to choose the smallest number of distinct titles that cover all 13 courses.
Oh, and when you send back the chosen titles, please use this simple JSON shape so it's easy to check:
{
""solution"": [""title_id"", ...]
}
This just means ""solution"" should be an array listing the identifiers for the books you picked (the placeholder ""title_id"" just shows the kind of thing to put there). Think of it like filling in a short form: the array holds the IDs of the selected titles. The JSON above is only a sketch of the expected shape, not the actual answer.
Important: Use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 13, 'density': 0.29120879120879123, 'sets': [{'id': 1, 'elements': [1, 5, 8, 10]}, {'id': 2, 'elements': [1, 2, 4, 5, 10, 13]}, {'id': 3, 'elements': [3, 9]}, {'id': 4, 'elements': [4, 6, 11]}, {'id': 5, 'elements': [1, 2, 5, 8, 10]}, {'id': 6, 'elements': [2, 6, 8, 12, 13]}, {'id': 7, 'elements': [6, 7, 12, 13, 14]}, {'id': 8, 'elements': [1, 2, 4, 6, 8, 10]}, {'id': 9, 'elements': [1, 2, 5, 10]}, {'id': 10, 'elements': [2, 4, 11]}, {'id': 11, 'elements': [6, 7, 12, 13]}, {'id': 12, 'elements': [2, 3, 6, 14]}, {'id': 13, 'elements': [7, 13]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 11, 'v': 4}, {'u': 4, 'v': 2}, {'u': 14, 'v': 7}, {'u': 12, 'v': 3}, {'u': 12, 'v': 13}, {'u': 9, 'v': 3}, {'u': 13, 'v': 6}, {'u': 13, 'v': 7}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 8, 'v': 10}, {'u': 6, 'v': 2}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0004.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0004.png'}","[3, 4, 10, 13]",4.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'E', 'H', 'J']}, {'id': 'S2', 'elements': ['A', 'B', 'D', 'E', 'J', 'M']}, {'id': 'S3', 'elements': ['C', 'I']}, {'id': 'S4', 'elements': ['D', 'F', 'K']}, {'id': 'S5', 'elements': ['A', 'B', 'E', 'H', 'J']}, {'id': 'S6', 'elements': ['B', 'F', 'H', 'L', 'M']}, {'id': 'S7', 'elements': ['F', 'G', 'L', 'M', 'N']}, {'id': 'S8', 'elements': ['A', 'B', 'D', 'F', 'H', 'J']}, {'id': 'S9', 'elements': ['A', 'B', 'E', 'J']}, {'id': 'S10', 'elements': ['B', 'D', 'K']}, {'id': 'S11', 'elements': ['F', 'G', 'L', 'M']}, {'id': 'S12', 'elements': ['B', 'C', 'F', 'N']}, {'id': 'S13', 'elements': ['G', 'M']}]}","['C', 'D', 'J', 'M']",5,nl,names
HSP,HSP,"I run a tiny kitchen and try to keep the pantry as simple as possible: pick the smallest set of staple ingredients so every dish on the menu has at least one of them to call on. The decision is which ingredients to stock, and better choices are the ones that let the shelf list be as short as possible — success is just counting how many different staples are on the shelf. Every recipe has to be covered by at least one stocked item, and stocking the same thing twice doesn’t make the list any shorter. The exact menu and ingredient lists are shown below.
Here are 14 recipes drawn from 14 possible ingredients:
Recipe S1: 0 5 6 7 10 12 — I must stock at least one of these to cover it.
Recipe S2: 1 5 6 9 — I must stock at least one of these to cover it.
Recipe S3: 2 3 5 — I must stock at least one of these to cover it.
Recipe S4: 2 3 4 5 13 — I must stock at least one of these to cover it.
Recipe S5: 2 3 4 5 6 9 13 — I must stock at least one of these to cover it.
Recipe S6: 0 1 2 3 4 12 — I must stock at least one of these to cover it.
Recipe S7: 0 1 4 5 6 10 11 12 — I must stock at least one of these to cover it.
Recipe S8: 0 6 9 10 11 — I must stock at least one of these to cover it.
Recipe S9: 5 9 10 — I must stock at least one of these to cover it.
Recipe S10: 1 5 6 7 8 9 — I must stock at least one of these to cover it.
Recipe S11: 0 7 8 10 12 — I must stock at least one of these to cover it.
Recipe S12: 0 6 7 11 12 — I must stock at least one of these to cover it.
Recipe S13: 0 6 10 11 12 — I must stock at least one of these to cover it.
Recipe S14: 3 4 — I must stock at least one of these to cover it.
That's the menu of 14 dishes from 14 ingredients — time to pick the smallest set of staples for my shelf.
If you want to hand me the pantry pick in a neat little package, just send it back as JSON like this:
{
""solution"": [""ingredient_id"", ...]
}
Think of ""solution"" as the list of staples you'd stock on the shelf. Each entry like ""ingredient_id"" is a placeholder for one ingredient from the menu — when you fill it in, put the exact identifier shown in the instance. This block is just a sketch of the shape I expect, not the actual answer itself.
Please use the identifiers exactly as they appear in the input — no renaming and no new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 14, 'density': 0.35714285714285715, 'sets': [{'id': 1, 'elements': [1, 6, 7, 8, 11, 13]}, {'id': 2, 'elements': [2, 6, 7, 10]}, {'id': 3, 'elements': [3, 4, 6]}, {'id': 4, 'elements': [3, 4, 5, 6, 14]}, {'id': 5, 'elements': [3, 4, 5, 6, 7, 10, 14]}, {'id': 6, 'elements': [1, 2, 3, 4, 5, 13]}, {'id': 7, 'elements': [1, 2, 5, 6, 7, 11, 12, 13]}, {'id': 8, 'elements': [1, 7, 10, 11, 12]}, {'id': 9, 'elements': [6, 10, 11]}, {'id': 10, 'elements': [2, 6, 7, 8, 9, 10]}, {'id': 11, 'elements': [1, 8, 9, 11, 13]}, {'id': 12, 'elements': [1, 7, 8, 12, 13]}, {'id': 13, 'elements': [1, 7, 11, 12, 13]}, {'id': 14, 'elements': [4, 5]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 4, 'v': 5}, {'u': 4, 'v': 14}, {'u': 9, 'v': 10}, {'u': 10, 'v': 6}, {'u': 10, 'v': 11}, {'u': 6, 'v': 2}, {'u': 6, 'v': 5}, {'u': 6, 'v': 7}, {'u': 5, 'v': 3}, {'u': 7, 'v': 1}, {'u': 7, 'v': 11}, {'u': 7, 'v': 13}, {'u': 11, 'v': 8}, {'u': 8, 'v': 1}, {'u': 1, 'v': 12}, {'u': 12, 'v': 13}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0005.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0005.png'}","[1, 4, 6]",3.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [0, 5, 6, 7, 10, 12]}, {'id': 'S2', 'elements': [1, 5, 6, 9]}, {'id': 'S3', 'elements': [2, 3, 5]}, {'id': 'S4', 'elements': [2, 3, 4, 5, 13]}, {'id': 'S5', 'elements': [2, 3, 4, 5, 6, 9, 13]}, {'id': 'S6', 'elements': [0, 1, 2, 3, 4, 12]}, {'id': 'S7', 'elements': [0, 1, 4, 5, 6, 10, 11, 12]}, {'id': 'S8', 'elements': [0, 6, 9, 10, 11]}, {'id': 'S9', 'elements': [5, 9, 10]}, {'id': 'S10', 'elements': [1, 5, 6, 7, 8, 9]}, {'id': 'S11', 'elements': [0, 7, 8, 10, 12]}, {'id': 'S12', 'elements': [0, 6, 7, 11, 12]}, {'id': 'S13', 'elements': [0, 6, 10, 11, 12]}, {'id': 'S14', 'elements': [3, 4]}]}","[0, 3, 5]",6,nl,0
HSP,HSP,"Recently the allotment group decided to downsize the variety in each bed: pick a minimal set of plant types such that every bed has at least one of those types. A simpler setup is better — fewer different species is the goal — so judge options by how many species are kept. Every bed must contain at least one chosen species, and planting duplicates won’t change the score since each species only counts once. The concrete details will be shown below.
- **total_species**: 14
- **num_beds**: 14
| bed_id | bed_species |
|---|---|
| S1 | A C J K |
| S2 | B C D E |
| S3 | A B C E F |
| S4 | B C D |
| S5 | B D |
| S6 | A B I J N |
| S7 | G J L |
| S8 | H K |
| S9 | B C I M |
| S10 | A F G J K L |
| S11 | G H J K L |
| S12 | G L |
| S13 | C I M |
| S14 | F J N |
Oh, and to keep things tidy, please send the final pick in this little JSON shape so I can read it automatically:
{
""solution"": [""plant_type_id"", ...]
}
""solution"" should be the list of plant types you're keeping — each entry is the identifier for a species (matching the labels from the instance). This is just a sketch of the expected shape, not the actual answer.
Please make sure to use the exact identifiers from the input, with no renaming or new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 14, 'density': 0.2602040816326531, 'sets': [{'id': 1, 'elements': [1, 3, 10, 11]}, {'id': 2, 'elements': [2, 3, 4, 5]}, {'id': 3, 'elements': [1, 2, 3, 5, 6]}, {'id': 4, 'elements': [2, 3, 4]}, {'id': 5, 'elements': [2, 4]}, {'id': 6, 'elements': [1, 2, 9, 10, 14]}, {'id': 7, 'elements': [7, 10, 12]}, {'id': 8, 'elements': [8, 11]}, {'id': 9, 'elements': [2, 3, 9, 13]}, {'id': 10, 'elements': [1, 6, 7, 10, 11, 12]}, {'id': 11, 'elements': [7, 8, 10, 11, 12]}, {'id': 12, 'elements': [7, 12]}, {'id': 13, 'elements': [3, 9, 13]}, {'id': 14, 'elements': [6, 10, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 12, 'v': 11}, {'u': 10, 'v': 1}, {'u': 10, 'v': 11}, {'u': 11, 'v': 7}, {'u': 13, 'v': 9}, {'u': 5, 'v': 2}, {'u': 14, 'v': 1}, {'u': 6, 'v': 1}, {'u': 6, 'v': 3}, {'u': 9, 'v': 3}, {'u': 7, 'v': 8}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0006.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0006.png'}","[2, 7, 9, 10, 11]",5.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'J', 'K']}, {'id': 'S2', 'elements': ['B', 'C', 'D', 'E']}, {'id': 'S3', 'elements': ['A', 'B', 'C', 'E', 'F']}, {'id': 'S4', 'elements': ['B', 'C', 'D']}, {'id': 'S5', 'elements': ['B', 'D']}, {'id': 'S6', 'elements': ['A', 'B', 'I', 'J', 'N']}, {'id': 'S7', 'elements': ['G', 'J', 'L']}, {'id': 'S8', 'elements': ['H', 'K']}, {'id': 'S9', 'elements': ['B', 'C', 'I', 'M']}, {'id': 'S10', 'elements': ['A', 'F', 'G', 'J', 'K', 'L']}, {'id': 'S11', 'elements': ['G', 'H', 'J', 'K', 'L']}, {'id': 'S12', 'elements': ['G', 'L']}, {'id': 'S13', 'elements': ['C', 'I', 'M']}, {'id': 'S14', 'elements': ['F', 'J', 'N']}]}","['B', 'G', 'I', 'J', 'K']",7,markdown_table,names
HSP,HSP,"There’s a simple planning task on the table: choose which kinds of vehicles to have available so that every neighborhood can be matched with at least one of them. The trick is to pick as few different kinds as needed — plans are judged by how many unique vehicle types they use, so count the different types to see which plan is leaner. Each neighborhood must be matched by at least one chosen type (no gaps allowed), and duplicates don’t help since only distinct types count. The specific neighborhood-vehicle listings are shown below.
# total_vehicle_types=18
# total_neighborhoods=16
neighborhood_id,neighborhood_vehicle_types
S1,0 1 2 11 12
S2,0 1 7 8 12
S3,0 2 12
S4,12 15
S5,5 9 10 13
S6,6 7 8 16
S7,1 6 7 8 16 17
S8,1 4 6 7 8 9 12 14 16
S9,1 9
S10,1 5 9 13
S11,0 1 3 15
S12,0 1 9 12 15
S13,5 10
S14,8 14
S15,3 11 15
S16,1 7 8 14 17
Oh, and when you send the plan back, just drop it into this simple JSON shape so it's easy to read and check:
{
""solution"": [""vehicle_type_id"", ...]
}
Think of it like a tiny form: ""solution"" is the list of vehicle types you picked so every neighborhood has at least one match. Each entry in the array is a single vehicle-type identifier (just put the exact identifier the instance uses). This JSON is just a sketch of the shape I need — not the final answer itself.
One more thing: use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 16, 'density': 0.22569444444444445, 'sets': [{'id': 1, 'elements': [1, 2, 3, 12, 13]}, {'id': 2, 'elements': [1, 2, 8, 9, 13]}, {'id': 3, 'elements': [1, 3, 13]}, {'id': 4, 'elements': [13, 16]}, {'id': 5, 'elements': [6, 10, 11, 14]}, {'id': 6, 'elements': [7, 8, 9, 17]}, {'id': 7, 'elements': [2, 7, 8, 9, 17, 18]}, {'id': 8, 'elements': [2, 5, 7, 8, 9, 10, 13, 15, 17]}, {'id': 9, 'elements': [2, 10]}, {'id': 10, 'elements': [2, 6, 10, 14]}, {'id': 11, 'elements': [1, 2, 4, 16]}, {'id': 12, 'elements': [1, 2, 10, 13, 16]}, {'id': 13, 'elements': [6, 11]}, {'id': 14, 'elements': [9, 15]}, {'id': 15, 'elements': [4, 12, 16]}, {'id': 16, 'elements': [2, 8, 9, 15, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 3, 'v': 1}, {'u': 4, 'v': 12}, {'u': 14, 'v': 11}, {'u': 7, 'v': 8}, {'u': 12, 'v': 13}, {'u': 12, 'v': 16}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 10, 'v': 2}, {'u': 10, 'v': 11}, {'u': 11, 'v': 6}, {'u': 5, 'v': 18}, {'u': 2, 'v': 9}, {'u': 17, 'v': 8}, {'u': 18, 'v': 9}, {'u': 18, 'v': 15}, {'u': 8, 'v': 9}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0007.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0007.png'}","[2, 6, 9, 13, 16]",5.0,"{'num_elements': 18, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [0, 1, 2, 11, 12]}, {'id': 'S2', 'elements': [0, 1, 7, 8, 12]}, {'id': 'S3', 'elements': [0, 2, 12]}, {'id': 'S4', 'elements': [12, 15]}, {'id': 'S5', 'elements': [5, 9, 10, 13]}, {'id': 'S6', 'elements': [6, 7, 8, 16]}, {'id': 'S7', 'elements': [1, 6, 7, 8, 16, 17]}, {'id': 'S8', 'elements': [1, 4, 6, 7, 8, 9, 12, 14, 16]}, {'id': 'S9', 'elements': [1, 9]}, {'id': 'S10', 'elements': [1, 5, 9, 13]}, {'id': 'S11', 'elements': [0, 1, 3, 15]}, {'id': 'S12', 'elements': [0, 1, 9, 12, 15]}, {'id': 'S13', 'elements': [5, 10]}, {'id': 'S14', 'elements': [8, 14]}, {'id': 'S15', 'elements': [3, 11, 15]}, {'id': 'S16', 'elements': [1, 7, 8, 14, 17]}]}","[1, 5, 8, 12, 15]",8,csv,0
HSP,HSP,"Many people on the merchandising floor are trying to distill the booth’s colors down to the essentials so every outfit has at least one of those essentials showing. The choice is which specific hues make the cut; excellence here is measured by the fewest hues chosen — just count the selected colors and prefer the smaller total. No outfit may be left without one of the kept hues, and picking the same color twice doesn’t help. Full lists of outfits and candidate colors are listed below.
# total_colors=13
# total_outfits=10
outfit_id,colors_in_outfit
S1,0 3 4 5 9 11
S2,1 6 9
S3,0 3 7 8 11
S4,0 9
S5,0 5 10
S6,1 6 9 11
S7,2 3 8 9 11 12
S8,2 3 6 7 8 9 10 11
S9,0 4
S10,0 1 3 8 9
If you're ready to send the chosen hues, just use this little JSON shape so I know exactly where to look:
{
""solution"": [""hue_id"", ...]
}
""solution"" is the list of kept hues for the booth — each entry is a placeholder for one color identifier from the instance. Think of ""hue_id"" as the spot where you drop a real color label; the JSON above is just a sketch of the expected shape, not the actual answer.
Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.
That's all — fill the array with the exact IDs and we'll be set.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 10, 'density': 0.3384615384615385, 'sets': [{'id': 1, 'elements': [1, 4, 5, 6, 10, 12]}, {'id': 2, 'elements': [2, 7, 10]}, {'id': 3, 'elements': [1, 4, 8, 9, 12]}, {'id': 4, 'elements': [1, 10]}, {'id': 5, 'elements': [1, 6, 11]}, {'id': 6, 'elements': [2, 7, 10, 12]}, {'id': 7, 'elements': [3, 4, 9, 10, 12, 13]}, {'id': 8, 'elements': [3, 4, 7, 8, 9, 10, 11, 12]}, {'id': 9, 'elements': [1, 5]}, {'id': 10, 'elements': [1, 2, 4, 9, 10]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 12, 'v': 2}, {'u': 12, 'v': 7}, {'u': 12, 'v': 10}, {'u': 9, 'v': 3}, {'u': 9, 'v': 10}, {'u': 3, 'v': 13}, {'u': 1, 'v': 5}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 8, 'v': 4}, {'u': 4, 'v': 10}, {'u': 6, 'v': 11}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0008.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0008.png'}","[1, 10]",2.0,"{'num_elements': 13, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [0, 3, 4, 5, 9, 11]}, {'id': 'S2', 'elements': [1, 6, 9]}, {'id': 'S3', 'elements': [0, 3, 7, 8, 11]}, {'id': 'S4', 'elements': [0, 9]}, {'id': 'S5', 'elements': [0, 5, 10]}, {'id': 'S6', 'elements': [1, 6, 9, 11]}, {'id': 'S7', 'elements': [2, 3, 8, 9, 11, 12]}, {'id': 'S8', 'elements': [2, 3, 6, 7, 8, 9, 10, 11]}, {'id': 'S9', 'elements': [0, 4]}, {'id': 'S10', 'elements': [0, 1, 3, 8, 9]}]}","[0, 9]",9,csv,0
HSP,HSP,"At the purchasing desk the aim is to assemble a tiny supplier team so every shelf category still has at least one product from someone on that team. What makes one plan superior is simply the headcount of distinct suppliers — smaller is preferable, so tally the unique suppliers to compare options. Every category must be covered at least once, and duplicates don’t improve the score. The concrete supplier-category details are given below.
- **total_suppliers**: 18
- **total_categories**: 17
| category_id | suppliers |
|---|---|
| S1 | 5 12 14 |
| S2 | 1 16 |
| S3 | 2 3 17 |
| S4 | 2 3 7 10 17 |
| S5 | 4 8 9 12 13 |
| S6 | 0 3 4 5 7 12 13 |
| S7 | 6 9 10 |
| S8 | 9 10 15 |
| S9 | 4 8 11 13 |
| S10 | 4 6 7 9 10 15 17 |
| S11 | 3 5 7 9 |
| S12 | 0 1 4 5 9 12 14 16 |
| S13 | 5 8 11 13 |
| S14 | 5 12 14 16 |
| S15 | 7 9 |
| S16 | 1 12 16 |
| S17 | 3 9 17 |
Also, when you give the final pick, please follow this simple JSON shape so it's easy to check what you chose.
{
""solution"": [""supplier_id"", ...]
}
This just means ""solution"" is a list of the supplier IDs you picked to cover every shelf category. Think of ""supplier_id"" as a placeholder — replace it with the actual supplier identifiers from the instance. It's just a sketch of the shape I expect, not the real answer.
Please use the identifiers exactly as they appear in the input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 17, 'density': 0.22875816993464052, 'sets': [{'id': 1, 'elements': [6, 13, 15]}, {'id': 2, 'elements': [2, 17]}, {'id': 3, 'elements': [3, 4, 18]}, {'id': 4, 'elements': [3, 4, 8, 11, 18]}, {'id': 5, 'elements': [5, 9, 10, 13, 14]}, {'id': 6, 'elements': [1, 4, 5, 6, 8, 13, 14]}, {'id': 7, 'elements': [7, 10, 11]}, {'id': 8, 'elements': [10, 11, 16]}, {'id': 9, 'elements': [5, 9, 12, 14]}, {'id': 10, 'elements': [5, 7, 8, 10, 11, 16, 18]}, {'id': 11, 'elements': [4, 6, 8, 10]}, {'id': 12, 'elements': [1, 2, 5, 6, 10, 13, 15, 17]}, {'id': 13, 'elements': [6, 9, 12, 14]}, {'id': 14, 'elements': [6, 13, 15, 17]}, {'id': 15, 'elements': [8, 10]}, {'id': 16, 'elements': [2, 13, 17]}, {'id': 17, 'elements': [4, 10, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 11, 'v': 7}, {'u': 11, 'v': 10}, {'u': 9, 'v': 14}, {'u': 18, 'v': 4}, {'u': 8, 'v': 10}, {'u': 8, 'v': 16}, {'u': 14, 'v': 5}, {'u': 14, 'v': 12}, {'u': 1, 'v': 13}, {'u': 6, 'v': 5}, {'u': 6, 'v': 10}, {'u': 6, 'v': 13}, {'u': 4, 'v': 3}, {'u': 4, 'v': 10}, {'u': 17, 'v': 15}, {'u': 13, 'v': 15}, {'u': 15, 'v': 2}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0009.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0009.png'}","[6, 10, 14, 17, 18]",5.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [5, 12, 14]}, {'id': 'S2', 'elements': [1, 16]}, {'id': 'S3', 'elements': [2, 3, 17]}, {'id': 'S4', 'elements': [2, 3, 7, 10, 17]}, {'id': 'S5', 'elements': [4, 8, 9, 12, 13]}, {'id': 'S6', 'elements': [0, 3, 4, 5, 7, 12, 13]}, {'id': 'S7', 'elements': [6, 9, 10]}, {'id': 'S8', 'elements': [9, 10, 15]}, {'id': 'S9', 'elements': [4, 8, 11, 13]}, {'id': 'S10', 'elements': [4, 6, 7, 9, 10, 15, 17]}, {'id': 'S11', 'elements': [3, 5, 7, 9]}, {'id': 'S12', 'elements': [0, 1, 4, 5, 9, 12, 14, 16]}, {'id': 'S13', 'elements': [5, 8, 11, 13]}, {'id': 'S14', 'elements': [5, 12, 14, 16]}, {'id': 'S15', 'elements': [7, 9]}, {'id': 'S16', 'elements': [1, 12, 16]}, {'id': 'S17', 'elements': [3, 9, 17]}]}","[5, 9, 13, 16, 17]",10,markdown_table,0
HSP,HSP,"Recently the organizing crew decided to streamline bookings by finding the smallest group of headline acts that still appear on every stage’s lineup. The winning plan is whichever uses the fewest distinct hires, and that’s found by counting the booked acts and picking the list with the lowest total. No stage can be left without at least one of those acts on its roster, and an act that appears on several stages only adds one to the total. The detailed stage lineups follow below.
{
""total_unique_acts"": 18,
""stages_count"": 18,
""sets"": [
{
""stage_id"": ""S1"",
""stage_lineup_acts"": [
1,
2,
8,
9,
10
]
},
{
""stage_id"": ""S2"",
""stage_lineup_acts"": [
1,
8,
10,
12,
13,
18
]
},
{
""stage_id"": ""S3"",
""stage_lineup_acts"": [
1,
3,
4,
9,
10,
11
]
},
{
""stage_id"": ""S4"",
""stage_lineup_acts"": [
3,
9
]
},
{
""stage_id"": ""S5"",
""stage_lineup_acts"": [
1,
5,
7,
8
]
},
{
""stage_id"": ""S6"",
""stage_lineup_acts"": [
6,
8
]
},
{
""stage_id"": ""S7"",
""stage_lineup_acts"": [
6,
7,
8
]
},
{
""stage_id"": ""S8"",
""stage_lineup_acts"": [
1,
5,
6,
8
]
},
{
""stage_id"": ""S9"",
""stage_lineup_acts"": [
4,
9,
10,
11
]
},
{
""stage_id"": ""S10"",
""stage_lineup_acts"": [
2,
8,
9,
10
]
},
{
""stage_id"": ""S11"",
""stage_lineup_acts"": [
3,
9,
10
]
},
{
""stage_id"": ""S12"",
""stage_lineup_acts"": [
2,
17,
18
]
},
{
""stage_id"": ""S13"",
""stage_lineup_acts"": [
2,
12,
13,
17
]
},
{
""stage_id"": ""S14"",
""stage_lineup_acts"": [
14,
15,
16,
17
]
},
{
""stage_id"": ""S15"",
""stage_lineup_acts"": [
15,
16
]
},
{
""stage_id"": ""S16"",
""stage_lineup_acts"": [
14,
15,
16,
18
]
},
{
""stage_id"": ""S17"",
""stage_lineup_acts"": [
1,
12,
14,
17,
18
]
},
{
""stage_id"": ""S18"",
""stage_lineup_acts"": [
2,
12,
14,
16,
17
]
}
]
}
Oh, and when you send the actual pick, please stick to this simple JSON layout so it's easy to parse:
{
""solution"": [""act_id"", ...]
}
Here ""solution"" is just the list of headline acts you'll hire — each entry is an act identifier (a placeholder here is shown as ""act_id""). Think of it like a short form where you drop in the exact act labels that cover every stage. This block is just a sketch of the shape I want, not the real answer itself.
Also, a gentle reminder: use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 18, 'density': 0.21604938271604937, 'sets': [{'id': 1, 'elements': [1, 2, 8, 9, 10]}, {'id': 2, 'elements': [1, 8, 10, 12, 13, 18]}, {'id': 3, 'elements': [1, 3, 4, 9, 10, 11]}, {'id': 4, 'elements': [3, 9]}, {'id': 5, 'elements': [1, 5, 7, 8]}, {'id': 6, 'elements': [6, 8]}, {'id': 7, 'elements': [6, 7, 8]}, {'id': 8, 'elements': [1, 5, 6, 8]}, {'id': 9, 'elements': [4, 9, 10, 11]}, {'id': 10, 'elements': [2, 8, 9, 10]}, {'id': 11, 'elements': [3, 9, 10]}, {'id': 12, 'elements': [2, 17, 18]}, {'id': 13, 'elements': [2, 12, 13, 17]}, {'id': 14, 'elements': [14, 15, 16, 17]}, {'id': 15, 'elements': [15, 16]}, {'id': 16, 'elements': [14, 15, 16, 18]}, {'id': 17, 'elements': [1, 12, 14, 17, 18]}, {'id': 18, 'elements': [2, 12, 14, 16, 17]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 14, 'v': 18}, {'u': 11, 'v': 3}, {'u': 17, 'v': 2}, {'u': 17, 'v': 12}, {'u': 17, 'v': 18}, {'u': 1, 'v': 2}, {'u': 1, 'v': 8}, {'u': 1, 'v': 10}, {'u': 2, 'v': 12}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 8, 'v': 5}, {'u': 8, 'v': 7}, {'u': 7, 'v': 6}, {'u': 9, 'v': 4}, {'u': 9, 'v': 10}, {'u': 12, 'v': 13}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0010.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0010.png'}","[8, 9, 16, 17]",4.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [1, 2, 8, 9, 10]}, {'id': 'S2', 'elements': [1, 8, 10, 12, 13, 18]}, {'id': 'S3', 'elements': [1, 3, 4, 9, 10, 11]}, {'id': 'S4', 'elements': [3, 9]}, {'id': 'S5', 'elements': [1, 5, 7, 8]}, {'id': 'S6', 'elements': [6, 8]}, {'id': 'S7', 'elements': [6, 7, 8]}, {'id': 'S8', 'elements': [1, 5, 6, 8]}, {'id': 'S9', 'elements': [4, 9, 10, 11]}, {'id': 'S10', 'elements': [2, 8, 9, 10]}, {'id': 'S11', 'elements': [3, 9, 10]}, {'id': 'S12', 'elements': [2, 17, 18]}, {'id': 'S13', 'elements': [2, 12, 13, 17]}, {'id': 'S14', 'elements': [14, 15, 16, 17]}, {'id': 'S15', 'elements': [15, 16]}, {'id': 'S16', 'elements': [14, 15, 16, 18]}, {'id': 'S17', 'elements': [1, 12, 14, 17, 18]}, {'id': 'S18', 'elements': [2, 12, 14, 16, 17]}]}","[8, 9, 16, 17]",11,json,1
HSP,HSP,"I’m imagining a photographer getting ready for a busy season, trying to decide which lenses to toss in the bag so every type of shoot on the calendar can be handled. The task is to pick a small pile of lenses so that for every shoot type there’s at least one lens in the bag that works — the better the decision, the fewer lenses packed while still covering every shoot. Measure how good a choice is simply by counting how many lenses are included: lower count is better, but a kit only counts as okay if every shoot has at least one suitable lens and there are no pointless duplicates. Concrete details are shown below.
{
""total_distinct_lenses"": 13,
""total_shoot_types"": 12,
""sets"": [
{
""shoot_type_id"": ""S1"",
""compatible_lenses"": [
1,
5,
8,
9
]
},
{
""shoot_type_id"": ""S2"",
""compatible_lenses"": [
0,
3,
4,
7,
10,
12
]
},
{
""shoot_type_id"": ""S3"",
""compatible_lenses"": [
0,
2,
4,
6
]
},
{
""shoot_type_id"": ""S4"",
""compatible_lenses"": [
2,
3,
6,
8,
9,
12
]
},
{
""shoot_type_id"": ""S5"",
""compatible_lenses"": [
1,
5,
8
]
},
{
""shoot_type_id"": ""S6"",
""compatible_lenses"": [
3,
6,
10,
11
]
},
{
""shoot_type_id"": ""S7"",
""compatible_lenses"": [
2,
7
]
},
{
""shoot_type_id"": ""S8"",
""compatible_lenses"": [
2,
5,
8,
9
]
},
{
""shoot_type_id"": ""S9"",
""compatible_lenses"": [
1,
4,
5,
8
]
},
{
""shoot_type_id"": ""S10"",
""compatible_lenses"": [
2,
6,
7,
10,
11
]
},
{
""shoot_type_id"": ""S11"",
""compatible_lenses"": [
7,
10,
11
]
},
{
""shoot_type_id"": ""S12"",
""compatible_lenses"": [
2,
4,
6,
7,
11,
12
]
}
]
}
You can just send back the answer in a tiny JSON snippet like this so it’s easy to read and check.
{
""solution"": [""lens_id"", ...]
}
Here, ""solution"" is the list of lenses you’d pack — each entry is the identifier for a single lens that covers at least one shoot type. Think of it as the names you’d write on a packing list; the JSON is just a simple sketch of the shape I’m expecting, not the real answer itself.
All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 12, 'density': 0.3269230769230769, 'sets': [{'id': 1, 'elements': [2, 6, 9, 10]}, {'id': 2, 'elements': [1, 4, 5, 8, 11, 13]}, {'id': 3, 'elements': [1, 3, 5, 7]}, {'id': 4, 'elements': [3, 4, 7, 9, 10, 13]}, {'id': 5, 'elements': [2, 6, 9]}, {'id': 6, 'elements': [4, 7, 11, 12]}, {'id': 7, 'elements': [3, 8]}, {'id': 8, 'elements': [3, 6, 9, 10]}, {'id': 9, 'elements': [2, 5, 6, 9]}, {'id': 10, 'elements': [3, 7, 8, 11, 12]}, {'id': 11, 'elements': [8, 11, 12]}, {'id': 12, 'elements': [3, 5, 7, 8, 12, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 10, 'v': 2}, {'u': 10, 'v': 6}, {'u': 10, 'v': 9}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 7}, {'u': 3, 'v': 13}, {'u': 4, 'v': 1}, {'u': 11, 'v': 7}, {'u': 11, 'v': 12}, {'u': 13, 'v': 8}, {'u': 9, 'v': 5}, {'u': 8, 'v': 12}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0011.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0011.png'}","[7, 8, 9]",3.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [1, 5, 8, 9]}, {'id': 'S2', 'elements': [0, 3, 4, 7, 10, 12]}, {'id': 'S3', 'elements': [0, 2, 4, 6]}, {'id': 'S4', 'elements': [2, 3, 6, 8, 9, 12]}, {'id': 'S5', 'elements': [1, 5, 8]}, {'id': 'S6', 'elements': [3, 6, 10, 11]}, {'id': 'S7', 'elements': [2, 7]}, {'id': 'S8', 'elements': [2, 5, 8, 9]}, {'id': 'S9', 'elements': [1, 4, 5, 8]}, {'id': 'S10', 'elements': [2, 6, 7, 10, 11]}, {'id': 'S11', 'elements': [7, 10, 11]}, {'id': 'S12', 'elements': [2, 4, 6, 7, 11, 12]}]}","[6, 7, 8]",12,json,0
HSP,HSP,"Someone on the casting team wants to build the smallest possible company of performers that still covers every role category the show needs. The decision to make is which performers to sign; better decisions are those that result in fewer people on the roster. The way to check is just to count hires (smaller is better), and every role category must have at least one of those hires — no role gets skipped and each hire is counted only once. The full breakdown of roles and actors is shown below.
There are 17 available performers and 16 role categories to cover.
Role S1: A H J K.
Role S2: B C D K P Q.
Role S3: B C E K N P.
Role S4: B D Q.
Role S5: C E F O.
Role S6: C E F.
Role S7: G L P.
Role S8: B I N.
Role S9: A J K.
Role S10: A B C K N P.
Role S11: G L N P.
Role S12: D N Q.
Role S13: C G H I K L M N O.
Role S14: E N.
Role S15: B G K L P.
Role S16: B D M Q.
They should aim to hire as few of the 17 performers as will cover all 16 roles.
Oh, and one small thing — when you send back your pick, please follow this simple JSON layout so it's easy to read by the team:
{
""solution"": [""performer_id"", ...]
}
Think of this as a little form: ""solution"" is the list of the performers you'd sign, and each entry in that array should be one performer identifier (just the IDs, nothing else). This is just the shape I expect — not the actual hires yet, just the expected format.
Please use the exact identifiers from the instance input — don't invent new labels or rename them. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 16, 'density': 0.25, 'sets': [{'id': 1, 'elements': [1, 8, 10, 11]}, {'id': 2, 'elements': [2, 3, 4, 11, 16, 17]}, {'id': 3, 'elements': [2, 3, 5, 11, 14, 16]}, {'id': 4, 'elements': [2, 4, 17]}, {'id': 5, 'elements': [3, 5, 6, 15]}, {'id': 6, 'elements': [3, 5, 6]}, {'id': 7, 'elements': [7, 12, 16]}, {'id': 8, 'elements': [2, 9, 14]}, {'id': 9, 'elements': [1, 10, 11]}, {'id': 10, 'elements': [1, 2, 3, 11, 14, 16]}, {'id': 11, 'elements': [7, 12, 14, 16]}, {'id': 12, 'elements': [4, 14, 17]}, {'id': 13, 'elements': [3, 7, 8, 9, 11, 12, 13, 14, 15]}, {'id': 14, 'elements': [5, 14]}, {'id': 15, 'elements': [2, 7, 11, 12, 16]}, {'id': 16, 'elements': [2, 4, 13, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 8, 'v': 11}, {'u': 10, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 4}, {'u': 13, 'v': 17}, {'u': 1, 'v': 11}, {'u': 2, 'v': 9}, {'u': 2, 'v': 14}, {'u': 3, 'v': 5}, {'u': 3, 'v': 14}, {'u': 3, 'v': 15}, {'u': 14, 'v': 11}, {'u': 14, 'v': 16}, {'u': 16, 'v': 7}, {'u': 16, 'v': 12}, {'u': 5, 'v': 6}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0012.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0012.png'}","[5, 7, 11, 14, 17]",5.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['A', 'H', 'J', 'K']}, {'id': 'S2', 'elements': ['B', 'C', 'D', 'K', 'P', 'Q']}, {'id': 'S3', 'elements': ['B', 'C', 'E', 'K', 'N', 'P']}, {'id': 'S4', 'elements': ['B', 'D', 'Q']}, {'id': 'S5', 'elements': ['C', 'E', 'F', 'O']}, {'id': 'S6', 'elements': ['C', 'E', 'F']}, {'id': 'S7', 'elements': ['G', 'L', 'P']}, {'id': 'S8', 'elements': ['B', 'I', 'N']}, {'id': 'S9', 'elements': ['A', 'J', 'K']}, {'id': 'S10', 'elements': ['A', 'B', 'C', 'K', 'N', 'P']}, {'id': 'S11', 'elements': ['G', 'L', 'N', 'P']}, {'id': 'S12', 'elements': ['D', 'N', 'Q']}, {'id': 'S13', 'elements': ['C', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'O']}, {'id': 'S14', 'elements': ['E', 'N']}, {'id': 'S15', 'elements': ['B', 'G', 'K', 'L', 'P']}, {'id': 'S16', 'elements': ['B', 'D', 'M', 'Q']}]}","['E', 'G', 'K', 'N', 'Q']",13,nl,names
HSP,HSP,"We’ve got a pile of master cards and a list of secured areas, and someone has to pick which cards to activate and distribute. The task is to pick a set of cards that between them open every area, and the aim is to use as few unique cards as possible. You measure success simply by counting how many different cards are issued — the lower that count, the better — and every area must be reachable by at least one chosen card, so nothing can be missed and duplicate copies don’t help. The specific assignments are listed below.
We have 16 distinct master cards and 16 secured areas listed below.
For S1 we can use any of these cards: 0 1 4 5 6 11.
For S2 we can use any of these cards: 1 4 5 11 13.
For S3 we can use any of these cards: 2 4 9 12.
For S4 we can use any of these cards: 1 3 4 5 8 9 15.
For S5 we can use any of these cards: 0 2 3 5 6 8 9 10.
For S6 we can use any of these cards: 0 1 3 4 6 7 9.
For S7 we can use any of these cards: 4 5 7 14.
For S8 we can use any of these cards: 6 7.
For S9 we can use any of these cards: 4 8 10.
For S10 we can use any of these cards: 2 3 5 9 12.
For S11 we can use any of these cards: 2 3 4 8 9.
For S12 we can use any of these cards: 1 11.
For S13 we can use any of these cards: 10 12.
For S14 we can use any of these cards: 0 5.
For S15 we can use any of these cards: 6 14.
For S16 we can use any of these cards: 9 10 15.
We'll aim to issue as few of the 16 cards as needed to cover all 16 areas.
Just so we're on the same page, when you send the answer back, please use this simple JSON layout so it's easy to check which cards you picked.
{
""solution"": [""card_id"", ...]
}
This little JSON means: ""solution"" is a list of card IDs — the unique cards you choose to activate and hand out so every area can be opened. Think of each entry in the array as one card label you’re selecting; the JSON is just a sketch of the shape I need, not your final choices.
Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 16, 'density': 0.26171875, 'sets': [{'id': 1, 'elements': [1, 2, 5, 6, 7, 12]}, {'id': 2, 'elements': [2, 5, 6, 12, 14]}, {'id': 3, 'elements': [3, 5, 10, 13]}, {'id': 4, 'elements': [2, 4, 5, 6, 9, 10, 16]}, {'id': 5, 'elements': [1, 3, 4, 6, 7, 9, 10, 11]}, {'id': 6, 'elements': [1, 2, 4, 5, 7, 8, 10]}, {'id': 7, 'elements': [5, 6, 8, 15]}, {'id': 8, 'elements': [7, 8]}, {'id': 9, 'elements': [5, 9, 11]}, {'id': 10, 'elements': [3, 4, 6, 10, 13]}, {'id': 11, 'elements': [3, 4, 5, 9, 10]}, {'id': 12, 'elements': [2, 12]}, {'id': 13, 'elements': [11, 13]}, {'id': 14, 'elements': [1, 6]}, {'id': 15, 'elements': [7, 15]}, {'id': 16, 'elements': [10, 11, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 10, 'v': 3}, {'u': 10, 'v': 5}, {'u': 10, 'v': 11}, {'u': 10, 'v': 13}, {'u': 4, 'v': 5}, {'u': 4, 'v': 9}, {'u': 4, 'v': 11}, {'u': 16, 'v': 11}, {'u': 6, 'v': 1}, {'u': 6, 'v': 5}, {'u': 6, 'v': 7}, {'u': 5, 'v': 2}, {'u': 7, 'v': 8}, {'u': 7, 'v': 15}, {'u': 12, 'v': 2}, {'u': 1, 'v': 2}, {'u': 1, 'v': 14}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0013.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0013.png'}","[2, 6, 7, 10, 11]",5.0,"{'num_elements': 16, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [0, 1, 4, 5, 6, 11]}, {'id': 'S2', 'elements': [1, 4, 5, 11, 13]}, {'id': 'S3', 'elements': [2, 4, 9, 12]}, {'id': 'S4', 'elements': [1, 3, 4, 5, 8, 9, 15]}, {'id': 'S5', 'elements': [0, 2, 3, 5, 6, 8, 9, 10]}, {'id': 'S6', 'elements': [0, 1, 3, 4, 6, 7, 9]}, {'id': 'S7', 'elements': [4, 5, 7, 14]}, {'id': 'S8', 'elements': [6, 7]}, {'id': 'S9', 'elements': [4, 8, 10]}, {'id': 'S10', 'elements': [2, 3, 5, 9, 12]}, {'id': 'S11', 'elements': [2, 3, 4, 8, 9]}, {'id': 'S12', 'elements': [1, 11]}, {'id': 'S13', 'elements': [10, 12]}, {'id': 'S14', 'elements': [0, 5]}, {'id': 'S15', 'elements': [6, 14]}, {'id': 'S16', 'elements': [9, 10, 15]}]}","[1, 5, 6, 9, 10]",14,nl,0
HSP,HSP,"Someone in a neighborhood shop decides to slim down their parts cabinet to just the essentials. The decision is which part types to keep so that for each common fix there’s at least one part available to do the job. One plan beats another if it uses fewer unique parts yet still lets every listed repair be completed with a stocked item; count the distinct parts to compare plans, and don’t leave any repair without coverage. The specific repair-to-part options follow below.
There are 13 distinct spare part types and 13 common repairs to cover:
For repair S1, any one of these parts will do: 1 6.
For repair S2, any one of these parts will do: 0 1 5 11.
For repair S3, any one of these parts will do: 6 12.
For repair S4, any one of these parts will do: 3 5 6 7 8 12.
For repair S5, any one of these parts will do: 3 4 7.
For repair S6, any one of these parts will do: 1 3 5 6 9 10 11.
For repair S7, any one of these parts will do: 0 4 5 6 9 11 12.
For repair S8, any one of these parts will do: 3 4 7 8.
For repair S9, any one of these parts will do: 3 4 6 7 8.
For repair S10, any one of these parts will do: 9 11.
For repair S11, any one of these parts will do: 5 9.
For repair S12, any one of these parts will do: 0 1 5 9 11.
For repair S13, any one of these parts will do: 1 2 5.
Someone will compare plans by counting distinct stocked parts across these 13 repairs to pick the leanest set.
Oh, and just so we stay consistent, please put your answer in this simple JSON shape when you hand it back — nothing fancy, just a list of the parts you’d keep:
{
""solution"": [""part_id"", ...]
}
This means ""solution"" is where you list the part types to keep on the shelf — each entry is a placeholder for a single part identifier. It’s just a sketch of the expected shape, not the actual final pick; replace the placeholders with the real identifiers from the instance.
All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.3076923076923077, 'sets': [{'id': 1, 'elements': [2, 7]}, {'id': 2, 'elements': [1, 2, 6, 12]}, {'id': 3, 'elements': [7, 13]}, {'id': 4, 'elements': [4, 6, 7, 8, 9, 13]}, {'id': 5, 'elements': [4, 5, 8]}, {'id': 6, 'elements': [2, 4, 6, 7, 10, 11, 12]}, {'id': 7, 'elements': [1, 5, 6, 7, 10, 12, 13]}, {'id': 8, 'elements': [4, 5, 8, 9]}, {'id': 9, 'elements': [4, 5, 7, 8, 9]}, {'id': 10, 'elements': [10, 12]}, {'id': 11, 'elements': [6, 10]}, {'id': 12, 'elements': [1, 2, 6, 10, 12]}, {'id': 13, 'elements': [2, 3, 6]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 11, 'v': 10}, {'u': 12, 'v': 2}, {'u': 12, 'v': 6}, {'u': 13, 'v': 3}, {'u': 13, 'v': 7}, {'u': 4, 'v': 5}, {'u': 4, 'v': 7}, {'u': 4, 'v': 9}, {'u': 5, 'v': 8}, {'u': 7, 'v': 2}, {'u': 7, 'v': 6}, {'u': 10, 'v': 6}, {'u': 1, 'v': 2}, {'u': 8, 'v': 9}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0014.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0014.png'}","[5, 6, 7, 10]",4.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [1, 6]}, {'id': 'S2', 'elements': [0, 1, 5, 11]}, {'id': 'S3', 'elements': [6, 12]}, {'id': 'S4', 'elements': [3, 5, 6, 7, 8, 12]}, {'id': 'S5', 'elements': [3, 4, 7]}, {'id': 'S6', 'elements': [1, 3, 5, 6, 9, 10, 11]}, {'id': 'S7', 'elements': [0, 4, 5, 6, 9, 11, 12]}, {'id': 'S8', 'elements': [3, 4, 7, 8]}, {'id': 'S9', 'elements': [3, 4, 6, 7, 8]}, {'id': 'S10', 'elements': [9, 11]}, {'id': 'S11', 'elements': [5, 9]}, {'id': 'S12', 'elements': [0, 1, 5, 9, 11]}, {'id': 'S13', 'elements': [1, 2, 5]}]}","[4, 5, 6, 9]",15,nl,0
HSP,HSP,"Many parents face the same little puzzle: choose a tiny variety of snacks so that every child can spot something they enjoy. The winning approach is the one with the least number of distinct snack types, which can be checked by counting the unique kinds bought. No child can be left without a liked option, and buying multiple of the same kind doesn’t increase how many kids are satisfied. See the list below for who likes which snacks.
There are 13 distinct snack types available and 12 children to satisfy:
Child S1 likes A B C K.
Child S2 likes C H K.
Child S3 likes B C D G.
Child S4 likes A D G L.
Child S5 likes E F.
Child S6 likes F I L.
Child S7 likes D G I J M.
Child S8 likes A B K.
Child S9 likes G M.
Child S10 likes A C H K.
Child S11 likes E G I L M.
Child S12 likes D G J L M.
Pick the smallest set of distinct snack types that gives every child at least one liked option.
Also, when you reply with your choice, please use this simple JSON layout so it's easy to read by whatever's checking it:
{
""solution"": [""snack_id"", ...]
}
Here ""solution"" is the list of snack identifiers you picked — one entry per snack type. ""snack_id"" is just a placeholder name for whatever identifier the instance uses (and the ""..."" means you can list as many ids as needed). This JSON is only a sketch of the shape I expect, not the actual answer.
Please make sure to use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 12, 'density': 0.28205128205128205, 'sets': [{'id': 1, 'elements': [1, 2, 3, 11]}, {'id': 2, 'elements': [3, 8, 11]}, {'id': 3, 'elements': [2, 3, 4, 7]}, {'id': 4, 'elements': [1, 4, 7, 12]}, {'id': 5, 'elements': [5, 6]}, {'id': 6, 'elements': [6, 9, 12]}, {'id': 7, 'elements': [4, 7, 9, 10, 13]}, {'id': 8, 'elements': [1, 2, 11]}, {'id': 9, 'elements': [7, 13]}, {'id': 10, 'elements': [1, 3, 8, 11]}, {'id': 11, 'elements': [5, 7, 9, 12, 13]}, {'id': 12, 'elements': [4, 7, 10, 12, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 7, 'v': 4}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 4, 'v': 3}, {'u': 2, 'v': 1}, {'u': 2, 'v': 8}, {'u': 2, 'v': 11}, {'u': 13, 'v': 10}, {'u': 9, 'v': 5}, {'u': 9, 'v': 6}, {'u': 9, 'v': 12}, {'u': 1, 'v': 3}, {'u': 1, 'v': 11}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0015.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0015.png'}","[6, 7, 11]",3.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'C', 'K']}, {'id': 'S2', 'elements': ['C', 'H', 'K']}, {'id': 'S3', 'elements': ['B', 'C', 'D', 'G']}, {'id': 'S4', 'elements': ['A', 'D', 'G', 'L']}, {'id': 'S5', 'elements': ['E', 'F']}, {'id': 'S6', 'elements': ['F', 'I', 'L']}, {'id': 'S7', 'elements': ['D', 'G', 'I', 'J', 'M']}, {'id': 'S8', 'elements': ['A', 'B', 'K']}, {'id': 'S9', 'elements': ['G', 'M']}, {'id': 'S10', 'elements': ['A', 'C', 'H', 'K']}, {'id': 'S11', 'elements': ['E', 'G', 'I', 'L', 'M']}, {'id': 'S12', 'elements': ['D', 'G', 'J', 'L', 'M']}]}","['F', 'G', 'K']",16,nl,names
HSP,HSP,"At the agency, the whiteboard lists dozens of itineraries and dozens of attractions, and the assignment is straightforward: decide which attraction tickets to buy so each itinerary contains at least one that’s covered. The aim is to buy as few distinct tickets as possible — the plan is evaluated by that ticket count — while guaranteeing every itinerary gets at least one covered attraction and avoiding unnecessary duplicate purchases. The concrete details are shown below.
{
""total_attractions"": 13,
""total_itineraries"": 13,
""sets"": [
{
""itinerary_id"": ""S1"",
""attractions_in_itinerary"": [
3,
5,
6,
8,
9,
10,
11,
12,
13
]
},
{
""itinerary_id"": ""S2"",
""attractions_in_itinerary"": [
2,
4,
6,
7,
9,
12
]
},
{
""itinerary_id"": ""S3"",
""attractions_in_itinerary"": [
1,
3,
6,
9,
10,
12
]
},
{
""itinerary_id"": ""S4"",
""attractions_in_itinerary"": [
2,
7
]
},
{
""itinerary_id"": ""S5"",
""attractions_in_itinerary"": [
1,
2,
4,
6,
13
]
},
{
""itinerary_id"": ""S6"",
""attractions_in_itinerary"": [
1,
2,
4,
5,
10,
11
]
},
{
""itinerary_id"": ""S7"",
""attractions_in_itinerary"": [
2,
4
]
},
{
""itinerary_id"": ""S8"",
""attractions_in_itinerary"": [
1,
10,
11
]
},
{
""itinerary_id"": ""S9"",
""attractions_in_itinerary"": [
1,
4,
9,
12
]
},
{
""itinerary_id"": ""S10"",
""attractions_in_itinerary"": [
3,
5,
6,
10,
11
]
},
{
""itinerary_id"": ""S11"",
""attractions_in_itinerary"": [
1,
3,
6,
10
]
},
{
""itinerary_id"": ""S12"",
""attractions_in_itinerary"": [
1,
3,
6,
9
]
},
{
""itinerary_id"": ""S13"",
""attractions_in_itinerary"": [
1,
4,
6,
10,
13
]
}
]
}
I'll keep the answer shape simple so it's easy to fill in: the reply should be a tiny JSON object listing which tickets (attractions) to buy. Here's the format I expect you to return:
{
""solution"": [""attraction_id"", ...]
}
This means ""solution"" is a list of attraction identifiers — one entry per distinct ticket you plan to buy. Think of each placeholder like a blank on a form where you drop in the actual attraction ID from the instance. The JSON above is just a sketch of the shape I want, not the real answer.
Please make sure you use the exact identifiers from the instance input — do not rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.3609467455621302, 'sets': [{'id': 1, 'elements': [3, 5, 6, 8, 9, 10, 11, 12, 13]}, {'id': 2, 'elements': [2, 4, 6, 7, 9, 12]}, {'id': 3, 'elements': [1, 3, 6, 9, 10, 12]}, {'id': 4, 'elements': [2, 7]}, {'id': 5, 'elements': [1, 2, 4, 6, 13]}, {'id': 6, 'elements': [1, 2, 4, 5, 10, 11]}, {'id': 7, 'elements': [2, 4]}, {'id': 8, 'elements': [1, 10, 11]}, {'id': 9, 'elements': [1, 4, 9, 12]}, {'id': 10, 'elements': [3, 5, 6, 10, 11]}, {'id': 11, 'elements': [1, 3, 6, 10]}, {'id': 12, 'elements': [1, 3, 6, 9]}, {'id': 13, 'elements': [1, 4, 6, 10, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 7, 'v': 4}, {'u': 11, 'v': 1}, {'u': 11, 'v': 8}, {'u': 10, 'v': 1}, {'u': 10, 'v': 8}, {'u': 10, 'v': 13}, {'u': 9, 'v': 2}, {'u': 9, 'v': 6}, {'u': 9, 'v': 12}, {'u': 13, 'v': 5}, {'u': 12, 'v': 3}, {'u': 1, 'v': 3}, {'u': 1, 'v': 6}, {'u': 4, 'v': 2}, {'u': 4, 'v': 5}, {'u': 6, 'v': 5}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0016.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0016.png'}","[1, 2, 10]",3.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [3, 5, 6, 8, 9, 10, 11, 12, 13]}, {'id': 'S2', 'elements': [2, 4, 6, 7, 9, 12]}, {'id': 'S3', 'elements': [1, 3, 6, 9, 10, 12]}, {'id': 'S4', 'elements': [2, 7]}, {'id': 'S5', 'elements': [1, 2, 4, 6, 13]}, {'id': 'S6', 'elements': [1, 2, 4, 5, 10, 11]}, {'id': 'S7', 'elements': [2, 4]}, {'id': 'S8', 'elements': [1, 10, 11]}, {'id': 'S9', 'elements': [1, 4, 9, 12]}, {'id': 'S10', 'elements': [3, 5, 6, 10, 11]}, {'id': 'S11', 'elements': [1, 3, 6, 10]}, {'id': 'S12', 'elements': [1, 3, 6, 9]}, {'id': 'S13', 'elements': [1, 4, 6, 10, 13]}]}","[1, 2, 10]",17,json,1
HSP,HSP,"At a small museum meeting, the brief was clear: put together the smallest possible collection of pieces so that every themed gallery has at least one item from that collection. The job is to choose which artworks make the cut; success is read off the checklist — the fewer pieces on it, the better. Each themed gallery must be represented by at least one chosen artwork, and duplicate entries of the same work don’t help. The detailed gallery-by-artwork information follows below.
There are 14 distinct artworks available and 13 themed galleries to represent.
Gallery S1: 0 3 9
Gallery S2: 0 1 2 4 5 7 11 13
Gallery S3: 0 1 2 3 7 8 9 10 11
Gallery S4: 0 2 3 6 8 9 11
Gallery S5: 1 4 9 12 13
Gallery S6: 1 4 13
Gallery S7: 3 4 9
Gallery S8: 0 1 4 7 8 10
Gallery S9: 2 3 6 7 8 11
Gallery S10: 0 2 4 6 7 8
Gallery S11: 3 4 6 8 11 12
Gallery S12: 1 2 4 11
Gallery S13: 1 4 5 7 12
Choose the fewest artworks that together represent all 13 galleries.
Just a quick note — when you send your final pick, please use this simple JSON layout so it's clear which artworks made the cut.
{
""solution"": [""artwork_id"", ...]
}
""solution"" should be a list of the chosen artwork identifiers (one entry per selected piece). Think of it like a short checklist: each string is the ID of an artwork you picked to represent one or more galleries. This JSON is just a sketch of the expected shape, not the actual answer — replace the placeholder entries with the real IDs from the instance.
Please use the exact identifiers from the instance input — no renaming and no new labels.
for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 13, 'density': 0.3901098901098901, 'sets': [{'id': 1, 'elements': [1, 4, 10]}, {'id': 2, 'elements': [1, 2, 3, 5, 6, 8, 12, 14]}, {'id': 3, 'elements': [1, 2, 3, 4, 8, 9, 10, 11, 12]}, {'id': 4, 'elements': [1, 3, 4, 7, 9, 10, 12]}, {'id': 5, 'elements': [2, 5, 10, 13, 14]}, {'id': 6, 'elements': [2, 5, 14]}, {'id': 7, 'elements': [4, 5, 10]}, {'id': 8, 'elements': [1, 2, 5, 8, 9, 11]}, {'id': 9, 'elements': [3, 4, 7, 8, 9, 12]}, {'id': 10, 'elements': [1, 3, 5, 7, 8, 9]}, {'id': 11, 'elements': [4, 5, 7, 9, 12, 13]}, {'id': 12, 'elements': [2, 3, 5, 12]}, {'id': 13, 'elements': [2, 5, 6, 8, 13]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 10, 'v': 1}, {'u': 10, 'v': 3}, {'u': 10, 'v': 4}, {'u': 6, 'v': 13}, {'u': 6, 'v': 14}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 12}, {'u': 5, 'v': 13}, {'u': 14, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 12}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 11}, {'u': 3, 'v': 9}, {'u': 12, 'v': 9}, {'u': 4, 'v': 9}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0017.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0017.png'}","[4, 5]",2.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 3, 9]}, {'id': 'S2', 'elements': [0, 1, 2, 4, 5, 7, 11, 13]}, {'id': 'S3', 'elements': [0, 1, 2, 3, 7, 8, 9, 10, 11]}, {'id': 'S4', 'elements': [0, 2, 3, 6, 8, 9, 11]}, {'id': 'S5', 'elements': [1, 4, 9, 12, 13]}, {'id': 'S6', 'elements': [1, 4, 13]}, {'id': 'S7', 'elements': [3, 4, 9]}, {'id': 'S8', 'elements': [0, 1, 4, 7, 8, 10]}, {'id': 'S9', 'elements': [2, 3, 6, 7, 8, 11]}, {'id': 'S10', 'elements': [0, 2, 4, 6, 7, 8]}, {'id': 'S11', 'elements': [3, 4, 6, 8, 11, 12]}, {'id': 'S12', 'elements': [1, 2, 4, 11]}, {'id': 'S13', 'elements': [1, 4, 5, 7, 12]}]}","[3, 4]",18,nl,0
HSP,HSP,"There’s a small charity drive where the aim is to assemble a tiny but capable team so that every task has at least one person who can take it on. The choice comes down to which candidates to bring in; the preferable choice is the one that gets every task covered using the fewest recruits. Success is checked by counting how many people end up on the team — the smaller that number, the better — and it’s essential that no task is left without someone and nobody is duplicated on the roster. The full list of tasks and volunteers appears below.
There are 12 tasks to cover and 14 distinct volunteer candidates available.
Task S1: eligible volunteers A B D L.
Task S2: eligible volunteers A B D G L.
Task S3: eligible volunteers D F I L M.
Task S4: eligible volunteers E F G J.
Task S5: eligible volunteers E F G I J.
Task S6: eligible volunteers B C D E F G I.
Task S7: eligible volunteers C G H I.
Task S8: eligible volunteers F G H I.
Task S9: eligible volunteers E F J.
Task S10: eligible volunteers A B D G K M N.
Task S11: eligible volunteers D K L M N.
Task S12: eligible volunteers K L M N.
Select the fewest recruits who together cover all 12 tasks.
Oh, and when you send your pick, please use this little JSON layout so it's easy to read by both people and machines:
{
""solution"": [""volunteer_id"", ...]
}
Think of ""solution"" as the roster — the array should contain the identifiers of the people you’re bringing in. The placeholder ""volunteer_id"" stands in for whatever ID each candidate has in the instance. This block is just a sketch of the shape I expect, not the final answer itself.
Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 12, 'density': 0.3392857142857143, 'sets': [{'id': 1, 'elements': [1, 2, 4, 12]}, {'id': 2, 'elements': [1, 2, 4, 7, 12]}, {'id': 3, 'elements': [4, 6, 9, 12, 13]}, {'id': 4, 'elements': [5, 6, 7, 10]}, {'id': 5, 'elements': [5, 6, 7, 9, 10]}, {'id': 6, 'elements': [2, 3, 4, 5, 6, 7, 9]}, {'id': 7, 'elements': [3, 7, 8, 9]}, {'id': 8, 'elements': [6, 7, 8, 9]}, {'id': 9, 'elements': [5, 6, 10]}, {'id': 10, 'elements': [1, 2, 4, 7, 11, 13, 14]}, {'id': 11, 'elements': [4, 11, 12, 13, 14]}, {'id': 12, 'elements': [11, 12, 13, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 11, 'v': 13}, {'u': 12, 'v': 4}, {'u': 12, 'v': 13}, {'u': 13, 'v': 14}, {'u': 5, 'v': 6}, {'u': 5, 'v': 10}, {'u': 6, 'v': 7}, {'u': 7, 'v': 4}, {'u': 7, 'v': 9}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 3, 'v': 9}, {'u': 8, 'v': 9}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0018.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0018.png'}","[6, 7, 12]",3.0,"{'num_elements': 14, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'D', 'L']}, {'id': 'S2', 'elements': ['A', 'B', 'D', 'G', 'L']}, {'id': 'S3', 'elements': ['D', 'F', 'I', 'L', 'M']}, {'id': 'S4', 'elements': ['E', 'F', 'G', 'J']}, {'id': 'S5', 'elements': ['E', 'F', 'G', 'I', 'J']}, {'id': 'S6', 'elements': ['B', 'C', 'D', 'E', 'F', 'G', 'I']}, {'id': 'S7', 'elements': ['C', 'G', 'H', 'I']}, {'id': 'S8', 'elements': ['F', 'G', 'H', 'I']}, {'id': 'S9', 'elements': ['E', 'F', 'J']}, {'id': 'S10', 'elements': ['A', 'B', 'D', 'G', 'K', 'M', 'N']}, {'id': 'S11', 'elements': ['D', 'K', 'L', 'M', 'N']}, {'id': 'S12', 'elements': ['K', 'L', 'M', 'N']}]}","['F', 'G', 'L']",19,nl,names
HSP,HSP,"A small-town wedding planner is trying to simplify purchases: choose a tiny roster of flower types so that each bouquet design includes at least one type from that roster. The best roster is the one with the fewest different kinds of flowers — simply count the distinct varieties chosen. It’s required that every bouquet design be covered (none can be left without a match), and ordering duplicates of a particular flower doesn’t reduce how many different types are used. The detailed bouquet breakdown is shown below.
- **total_flower_types**: 17
- **total_bouquet_designs**: 17
| bouquet_id | flower_types_in_bouquet |
|---|---|
| S1 | A D E J N Q |
| S2 | B H L |
| S3 | C D I N |
| S4 | A D I J K |
| S5 | A E |
| S6 | F K P Q |
| S7 | G L M P |
| S8 | B P |
| S9 | D I N |
| S10 | A D N |
| S11 | A F K O P Q |
| S12 | B H M P |
| S13 | G M P Q |
| S14 | A C D J |
| S15 | K O |
| S16 | B H L M Q |
| S17 | F L M O P Q |
Oh, and just to keep things tidy, please return your chosen roster in a tiny JSON snippet like this:
{
""solution"": [""flower_type_id"", ...]
}
Think of it like a simple form: ""solution"" is the short list of flower types you're picking for the supplier order, and each item in the array is a placeholder for a flower type identifier from the instance (the ""flower_type_id"" spots). The ""..."" just means you can list as many as needed. This is only the expected shape of the reply — it's a sketch, not the actual answer filled in.
Please use the exact identifiers given in the instance input when you fill that array — don't rename them or invent new labels.
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 17, 'density': 0.23183391003460208, 'sets': [{'id': 1, 'elements': [1, 4, 5, 10, 14, 17]}, {'id': 2, 'elements': [2, 8, 12]}, {'id': 3, 'elements': [3, 4, 9, 14]}, {'id': 4, 'elements': [1, 4, 9, 10, 11]}, {'id': 5, 'elements': [1, 5]}, {'id': 6, 'elements': [6, 11, 16, 17]}, {'id': 7, 'elements': [7, 12, 13, 16]}, {'id': 8, 'elements': [2, 16]}, {'id': 9, 'elements': [4, 9, 14]}, {'id': 10, 'elements': [1, 4, 14]}, {'id': 11, 'elements': [1, 6, 11, 15, 16, 17]}, {'id': 12, 'elements': [2, 8, 13, 16]}, {'id': 13, 'elements': [7, 13, 16, 17]}, {'id': 14, 'elements': [1, 3, 4, 10]}, {'id': 15, 'elements': [11, 15]}, {'id': 16, 'elements': [2, 8, 12, 13, 17]}, {'id': 17, 'elements': [6, 12, 13, 15, 16, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 10, 'v': 4}, {'u': 14, 'v': 3}, {'u': 14, 'v': 4}, {'u': 14, 'v': 9}, {'u': 7, 'v': 16}, {'u': 15, 'v': 11}, {'u': 12, 'v': 2}, {'u': 12, 'v': 8}, {'u': 12, 'v': 16}, {'u': 6, 'v': 17}, {'u': 4, 'v': 1}, {'u': 11, 'v': 1}, {'u': 11, 'v': 17}, {'u': 16, 'v': 13}, {'u': 16, 'v': 17}, {'u': 1, 'v': 5}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0019.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0019.png'}","[1, 4, 12, 15, 16]",5.0,"{'num_elements': 17, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'E', 'J', 'N', 'Q']}, {'id': 'S2', 'elements': ['B', 'H', 'L']}, {'id': 'S3', 'elements': ['C', 'D', 'I', 'N']}, {'id': 'S4', 'elements': ['A', 'D', 'I', 'J', 'K']}, {'id': 'S5', 'elements': ['A', 'E']}, {'id': 'S6', 'elements': ['F', 'K', 'P', 'Q']}, {'id': 'S7', 'elements': ['G', 'L', 'M', 'P']}, {'id': 'S8', 'elements': ['B', 'P']}, {'id': 'S9', 'elements': ['D', 'I', 'N']}, {'id': 'S10', 'elements': ['A', 'D', 'N']}, {'id': 'S11', 'elements': ['A', 'F', 'K', 'O', 'P', 'Q']}, {'id': 'S12', 'elements': ['B', 'H', 'M', 'P']}, {'id': 'S13', 'elements': ['G', 'M', 'P', 'Q']}, {'id': 'S14', 'elements': ['A', 'C', 'D', 'J']}, {'id': 'S15', 'elements': ['K', 'O']}, {'id': 'S16', 'elements': ['B', 'H', 'L', 'M', 'Q']}, {'id': 'S17', 'elements': ['F', 'L', 'M', 'O', 'P', 'Q']}]}","['A', 'D', 'L', 'O', 'P']",20,markdown_table,names
HSP,HSP,"There's a shelf full of different titles and the task is to pick a handful of descriptive keywords so that each title matches at least one of them. The goal is to make that handful as short as possible — measure success by counting the keywords you actually pick. Nothing on the shelf can be left without a matching keyword, and repeats don’t add value. The specific books and keyword options are listed below.
# total_keywords_available=17
# num_books_on_shelf=14
book_id,book_keywords
S1,C F J L
S2,M N
S3,A D F I J
S4,A C D J
S5,E K L O
S6,A C F L O
S7,G L M N O
S8,C D H I
S9,E P Q
S10,A E F N P
S11,B G N
S12,B G L M N
S13,F G L O P Q
S14,E K L P
Also, when you reply, just use this little JSON layout so it's easy to check:
{
""solution"": [""keyword_id"", ...]
}
""solution"" is the list of the keyword IDs you pick from the shelf — one entry for each chosen keyword. Think of it as a simple form: put the exact IDs you select inside that array. This is only a sketch of the shape I expect, not the actual answer itself.
Please use the identifiers exactly as they appear in the instance input — do not rename them and do not invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 14, 'density': 0.24789915966386555, 'sets': [{'id': 1, 'elements': [3, 6, 10, 12]}, {'id': 2, 'elements': [13, 14]}, {'id': 3, 'elements': [1, 4, 6, 9, 10]}, {'id': 4, 'elements': [1, 3, 4, 10]}, {'id': 5, 'elements': [5, 11, 12, 15]}, {'id': 6, 'elements': [1, 3, 6, 12, 15]}, {'id': 7, 'elements': [7, 12, 13, 14, 15]}, {'id': 8, 'elements': [3, 4, 8, 9]}, {'id': 9, 'elements': [5, 16, 17]}, {'id': 10, 'elements': [1, 5, 6, 14, 16]}, {'id': 11, 'elements': [2, 7, 14]}, {'id': 12, 'elements': [2, 7, 12, 13, 14]}, {'id': 13, 'elements': [6, 7, 12, 15, 16, 17]}, {'id': 14, 'elements': [5, 11, 12, 16]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 14, 'v': 7}, {'u': 14, 'v': 13}, {'u': 4, 'v': 3}, {'u': 4, 'v': 9}, {'u': 6, 'v': 1}, {'u': 6, 'v': 12}, {'u': 7, 'v': 12}, {'u': 2, 'v': 13}, {'u': 1, 'v': 3}, {'u': 9, 'v': 8}, {'u': 3, 'v': 10}, {'u': 5, 'v': 15}, {'u': 17, 'v': 11}, {'u': 15, 'v': 11}, {'u': 15, 'v': 12}, {'u': 15, 'v': 16}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0020.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0020.png'}","[4, 12, 14, 16]",4.0,"{'num_elements': 17, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['C', 'F', 'J', 'L']}, {'id': 'S2', 'elements': ['M', 'N']}, {'id': 'S3', 'elements': ['A', 'D', 'F', 'I', 'J']}, {'id': 'S4', 'elements': ['A', 'C', 'D', 'J']}, {'id': 'S5', 'elements': ['E', 'K', 'L', 'O']}, {'id': 'S6', 'elements': ['A', 'C', 'F', 'L', 'O']}, {'id': 'S7', 'elements': ['G', 'L', 'M', 'N', 'O']}, {'id': 'S8', 'elements': ['C', 'D', 'H', 'I']}, {'id': 'S9', 'elements': ['E', 'P', 'Q']}, {'id': 'S10', 'elements': ['A', 'E', 'F', 'N', 'P']}, {'id': 'S11', 'elements': ['B', 'G', 'N']}, {'id': 'S12', 'elements': ['B', 'G', 'L', 'M', 'N']}, {'id': 'S13', 'elements': ['F', 'G', 'L', 'O', 'P', 'Q']}, {'id': 'S14', 'elements': ['E', 'K', 'L', 'P']}]}","['D', 'L', 'N', 'P']",21,csv,names
HSP,HSP,"On a typical day the operations crew has to choose which monitoring agents to install so every service has some watchful eye. The goal is to use as few different agents as possible — success is measured by the total count of agents deployed — while making sure every application ends up monitored at least once, and avoiding unnecessary duplicates that don’t expand coverage. The concrete instance details appear below.
There are 13 distinct monitoring agents available and 11 applications that must each be monitored.
Application S1 can be monitored by agents 2 5 6 7 8 9 13.
Application S2 can be monitored by agents 1 6 9 13.
Application S3 can be monitored by agents 4 11 13.
Application S4 can be monitored by agents 1 2 5 6 8 13.
Application S5 can be monitored by agents 4 7 10 12 13.
Application S6 can be monitored by agents 5 6 8 9.
Application S7 can be monitored by agents 1 2 6 8 9 13.
Application S8 can be monitored by agents 3 4 7 10.
Application S9 can be monitored by agents 3 4 7 10 11 12.
Application S10 can be monitored by agents 3 7 10 11 12 13.
Application S11 can be monitored by agents 1 2 4 6 7 9 12 13.
The operations crew will select agents to cover all 11 applications while keeping the total distinct agent count among the 13 options as small as possible.
Just hand the chosen agents back to me using this little JSON shape so I can read it programmatically:
{
""solution"": [""agent_id"", ...]
}
Think of ""solution"" as the form field that holds the list of agents you'll install. The ""agent_id"" entry is just a placeholder for whatever actual identifiers the instance uses — swap it for the real IDs when you answer. This is only a sketch of the expected shape, not the actual selection.
Please make sure to use the identifiers exactly as they appear in the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 11, 'density': 0.4125874125874126, 'sets': [{'id': 1, 'elements': [2, 5, 6, 7, 8, 9, 13]}, {'id': 2, 'elements': [1, 6, 9, 13]}, {'id': 3, 'elements': [4, 11, 13]}, {'id': 4, 'elements': [1, 2, 5, 6, 8, 13]}, {'id': 5, 'elements': [4, 7, 10, 12, 13]}, {'id': 6, 'elements': [5, 6, 8, 9]}, {'id': 7, 'elements': [1, 2, 6, 8, 9, 13]}, {'id': 8, 'elements': [3, 4, 7, 10]}, {'id': 9, 'elements': [3, 4, 7, 10, 11, 12]}, {'id': 10, 'elements': [3, 7, 10, 11, 12, 13]}, {'id': 11, 'elements': [1, 2, 4, 6, 7, 9, 12, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 12, 'v': 4}, {'u': 12, 'v': 7}, {'u': 12, 'v': 11}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 8, 'v': 6}, {'u': 8, 'v': 9}, {'u': 10, 'v': 4}, {'u': 4, 'v': 7}, {'u': 6, 'v': 1}, {'u': 6, 'v': 5}, {'u': 7, 'v': 13}, {'u': 9, 'v': 1}, {'u': 1, 'v': 2}, {'u': 1, 'v': 13}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0021.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0021.png'}","[6, 7, 11]",3.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [2, 5, 6, 7, 8, 9, 13]}, {'id': 'S2', 'elements': [1, 6, 9, 13]}, {'id': 'S3', 'elements': [4, 11, 13]}, {'id': 'S4', 'elements': [1, 2, 5, 6, 8, 13]}, {'id': 'S5', 'elements': [4, 7, 10, 12, 13]}, {'id': 'S6', 'elements': [5, 6, 8, 9]}, {'id': 'S7', 'elements': [1, 2, 6, 8, 9, 13]}, {'id': 'S8', 'elements': [3, 4, 7, 10]}, {'id': 'S9', 'elements': [3, 4, 7, 10, 11, 12]}, {'id': 'S10', 'elements': [3, 7, 10, 11, 12, 13]}, {'id': 'S11', 'elements': [1, 2, 4, 6, 7, 9, 12, 13]}]}","[6, 7, 11]",22,nl,1
HSP,HSP,"As part of trimming the supervision list, the office must pick teachers to cover all student clubs, making sure each club has at least one supervisor assigned. The goal is to keep the roster short: the better assignment is the one with the smallest number of different teachers, and that is determined by counting how many unique teachers are used. No club can be left out, teachers can supervise multiple clubs, and each teacher is only counted once even if they’re listed for several groups. The particular details are provided below.
{
""total_teachers"": 17,
""total_clubs"": 16,
""sets"": [
{
""club_id"": ""S1"",
""eligible_teachers"": [
1,
11
]
},
{
""club_id"": ""S2"",
""eligible_teachers"": [
2,
4,
10,
11,
15
]
},
{
""club_id"": ""S3"",
""eligible_teachers"": [
3,
5,
10,
12,
14
]
},
{
""club_id"": ""S4"",
""eligible_teachers"": [
2,
4,
11,
13,
15
]
},
{
""club_id"": ""S5"",
""eligible_teachers"": [
3,
6,
9,
12,
13,
15
]
},
{
""club_id"": ""S6"",
""eligible_teachers"": [
3,
15,
16
]
},
{
""club_id"": ""S7"",
""eligible_teachers"": [
8,
11,
13,
17
]
},
{
""club_id"": ""S8"",
""eligible_teachers"": [
2,
9,
10,
12,
14
]
},
{
""club_id"": ""S9"",
""eligible_teachers"": [
9,
10,
13,
14
]
},
{
""club_id"": ""S10"",
""eligible_teachers"": [
1,
2,
4,
8,
13,
15,
17
]
},
{
""club_id"": ""S11"",
""eligible_teachers"": [
3,
5,
14
]
},
{
""club_id"": ""S12"",
""eligible_teachers"": [
2,
7,
10,
11,
13,
15,
17
]
},
{
""club_id"": ""S13"",
""eligible_teachers"": [
3,
9,
14
]
},
{
""club_id"": ""S14"",
""eligible_teachers"": [
2,
3,
6,
11,
13,
15
]
},
{
""club_id"": ""S15"",
""eligible_teachers"": [
6,
16,
17
]
},
{
""club_id"": ""S16"",
""eligible_teachers"": [
5,
6,
8,
11,
13,
17
]
}
]
}
Oh, and when you reply with the chosen supervisors, please stick to this simple JSON shape so I can read it easily:
{
""solution"": [""teacher_id"", ...]
}
This just means ""solution"" should be an array listing the teacher identifiers you picked. Each entry is the exact teacher id from the instance (replace the placeholder teacher_id with the real id). Think of it like a tiny form: the solution array is the roster of teachers who will supervise the clubs. This is only a sketch of the expected shape, not the actual answer.
All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 16, 'density': 0.27205882352941174, 'sets': [{'id': 1, 'elements': [1, 11]}, {'id': 2, 'elements': [2, 4, 10, 11, 15]}, {'id': 3, 'elements': [3, 5, 10, 12, 14]}, {'id': 4, 'elements': [2, 4, 11, 13, 15]}, {'id': 5, 'elements': [3, 6, 9, 12, 13, 15]}, {'id': 6, 'elements': [3, 15, 16]}, {'id': 7, 'elements': [8, 11, 13, 17]}, {'id': 8, 'elements': [2, 9, 10, 12, 14]}, {'id': 9, 'elements': [9, 10, 13, 14]}, {'id': 10, 'elements': [1, 2, 4, 8, 13, 15, 17]}, {'id': 11, 'elements': [3, 5, 14]}, {'id': 12, 'elements': [2, 7, 10, 11, 13, 15, 17]}, {'id': 13, 'elements': [3, 9, 14]}, {'id': 14, 'elements': [2, 3, 6, 11, 13, 15]}, {'id': 15, 'elements': [6, 16, 17]}, {'id': 16, 'elements': [5, 6, 8, 11, 13, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 6, 'v': 5}, {'u': 6, 'v': 16}, {'u': 6, 'v': 17}, {'u': 10, 'v': 2}, {'u': 10, 'v': 9}, {'u': 1, 'v': 8}, {'u': 13, 'v': 2}, {'u': 13, 'v': 4}, {'u': 13, 'v': 11}, {'u': 13, 'v': 15}, {'u': 2, 'v': 7}, {'u': 5, 'v': 3}, {'u': 5, 'v': 15}, {'u': 11, 'v': 8}, {'u': 11, 'v': 17}, {'u': 9, 'v': 3}, {'u': 9, 'v': 14}, {'u': 17, 'v': 15}, {'u': 14, 'v': 12}, {'u': 12, 'v': 3}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0022.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0022.png'}","[11, 14, 15, 17]",4.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [1, 11]}, {'id': 'S2', 'elements': [2, 4, 10, 11, 15]}, {'id': 'S3', 'elements': [3, 5, 10, 12, 14]}, {'id': 'S4', 'elements': [2, 4, 11, 13, 15]}, {'id': 'S5', 'elements': [3, 6, 9, 12, 13, 15]}, {'id': 'S6', 'elements': [3, 15, 16]}, {'id': 'S7', 'elements': [8, 11, 13, 17]}, {'id': 'S8', 'elements': [2, 9, 10, 12, 14]}, {'id': 'S9', 'elements': [9, 10, 13, 14]}, {'id': 'S10', 'elements': [1, 2, 4, 8, 13, 15, 17]}, {'id': 'S11', 'elements': [3, 5, 14]}, {'id': 'S12', 'elements': [2, 7, 10, 11, 13, 15, 17]}, {'id': 'S13', 'elements': [3, 9, 14]}, {'id': 'S14', 'elements': [2, 3, 6, 11, 13, 15]}, {'id': 'S15', 'elements': [6, 16, 17]}, {'id': 'S16', 'elements': [5, 6, 8, 11, 13, 17]}]}","[11, 14, 15, 17]",23,json,1
HSP,HSP,"On the farm today, the decision is which fertilizer types to stock so that every field receives at least one type from the chosen set, but with as few different types on the shopping list as possible. Performance is simple to check: count how many distinct fertilizer types were chosen — lower is better. In practice that means every field must be covered by at least one of the selected types and there’s no benefit to buying duplicate or extra varieties. The specific instance information is provided below.
# total_fertilizer_types=14
# total_fields=13
field_id,applicable_fertilizer_types
S1,0 4 6
S2,1 3 4 11
S3,2 3 4 6 10 13
S4,0 2 3 4 5 6 7 8 11 12 13
S5,0 1 3 6 8 10 11
S6,5 10
S7,0 2 3 8 11
S8,3 7 10 12
S9,3 4 6 11
S10,3 6 7 10 12
S11,1 2 3 4 6 8 9
S12,3 5 12
S13,1 2 3 9 13
Also, when you report which fertilizer types you're choosing, please use this simple JSON layout so it's easy to read and parse:
{
""solution"": [""fertilizer_id"", ...]
}
This shows that ""solution"" is a list of the fertilizer type identifiers you’re picking for the shopping list. The placeholder ""fertilizer_id"" is just an example of the sort of entry each item in the list should be — one identifier per chosen fertilizer type. Think of it like filling out a short form: one field called solution, and inside it a list of the selected fertilizer IDs.
This JSON is only a sketch of the expected shape, not the actual answer.
Please remember to use the exact identifiers from the instance input — do not rename them and do not invent new labels.
For example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 13, 'density': 0.3626373626373626, 'sets': [{'id': 1, 'elements': [1, 5, 7]}, {'id': 2, 'elements': [2, 4, 5, 12]}, {'id': 3, 'elements': [3, 4, 5, 7, 11, 14]}, {'id': 4, 'elements': [1, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14]}, {'id': 5, 'elements': [1, 2, 4, 7, 9, 11, 12]}, {'id': 6, 'elements': [6, 11]}, {'id': 7, 'elements': [1, 3, 4, 9, 12]}, {'id': 8, 'elements': [4, 8, 11, 13]}, {'id': 9, 'elements': [4, 5, 7, 12]}, {'id': 10, 'elements': [4, 7, 8, 11, 13]}, {'id': 11, 'elements': [2, 3, 4, 5, 7, 9, 10]}, {'id': 12, 'elements': [4, 6, 13]}, {'id': 13, 'elements': [2, 3, 4, 10, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 9, 'v': 5}, {'u': 8, 'v': 11}, {'u': 11, 'v': 4}, {'u': 11, 'v': 6}, {'u': 11, 'v': 13}, {'u': 5, 'v': 4}, {'u': 5, 'v': 7}, {'u': 5, 'v': 12}, {'u': 14, 'v': 3}, {'u': 14, 'v': 10}, {'u': 12, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 7}, {'u': 2, 'v': 3}, {'u': 2, 'v': 10}, {'u': 7, 'v': 1}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0023.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0023.png'}","[1, 4, 11]",3.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 4, 6]}, {'id': 'S2', 'elements': [1, 3, 4, 11]}, {'id': 'S3', 'elements': [2, 3, 4, 6, 10, 13]}, {'id': 'S4', 'elements': [0, 2, 3, 4, 5, 6, 7, 8, 11, 12, 13]}, {'id': 'S5', 'elements': [0, 1, 3, 6, 8, 10, 11]}, {'id': 'S6', 'elements': [5, 10]}, {'id': 'S7', 'elements': [0, 2, 3, 8, 11]}, {'id': 'S8', 'elements': [3, 7, 10, 12]}, {'id': 'S9', 'elements': [3, 4, 6, 11]}, {'id': 'S10', 'elements': [3, 6, 7, 10, 12]}, {'id': 'S11', 'elements': [1, 2, 3, 4, 6, 8, 9]}, {'id': 'S12', 'elements': [3, 5, 12]}, {'id': 'S13', 'elements': [1, 2, 3, 9, 13]}]}","[0, 3, 10]",24,csv,0
HSP,HSP,"There’s this classic party puzzle: assemble the tiniest menu that still gives every guest at least one dish they can eat — no guest left without an option. The trick is to select the minimum number of different dishes that together cover every dietary preference; evaluate any menu by counting how many distinct items it contains, and smaller counts are better. Make sure every preference shows up in at least one chosen dish, and don’t count the same dish multiple times. The concrete list of guests’ preferences and dish choices appears below.
{
""total_menu_items"": 18,
""num_guest_preferences"": 16,
""sets"": [
{
""preference_id"": ""S1"",
""acceptable_dishes"": [
""A"",
""H"",
""P"",
""Q""
]
},
{
""preference_id"": ""S2"",
""acceptable_dishes"": [
""B"",
""K"",
""O""
]
},
{
""preference_id"": ""S3"",
""acceptable_dishes"": [
""C"",
""J""
]
},
{
""preference_id"": ""S4"",
""acceptable_dishes"": [
""D"",
""G"",
""P""
]
},
{
""preference_id"": ""S5"",
""acceptable_dishes"": [
""I"",
""J"",
""M""
]
},
{
""preference_id"": ""S6"",
""acceptable_dishes"": [
""D"",
""F""
]
},
{
""preference_id"": ""S7"",
""acceptable_dishes"": [
""D"",
""G"",
""H"",
""L"",
""N"",
""O"",
""P""
]
},
{
""preference_id"": ""S8"",
""acceptable_dishes"": [
""A"",
""B"",
""D"",
""F"",
""G"",
""H"",
""O"",
""P""
]
},
{
""preference_id"": ""S9"",
""acceptable_dishes"": [
""E"",
""I"",
""L"",
""M"",
""N""
]
},
{
""preference_id"": ""S10"",
""acceptable_dishes"": [
""C"",
""I"",
""J"",
""L"",
""M"",
""N""
]
},
{
""preference_id"": ""S11"",
""acceptable_dishes"": [
""I"",
""J"",
""N"",
""R""
]
},
{
""preference_id"": ""S12"",
""acceptable_dishes"": [
""C"",
""G"",
""I"",
""J"",
""L"",
""N""
]
},
{
""preference_id"": ""S13"",
""acceptable_dishes"": [
""B"",
""D"",
""H"",
""K"",
""O""
]
},
{
""preference_id"": ""S14"",
""acceptable_dishes"": [
""A"",
""D"",
""G"",
""H"",
""O""
]
},
{
""preference_id"": ""S15"",
""acceptable_dishes"": [
""A"",
""P""
]
},
{
""preference_id"": ""S16"",
""acceptable_dishes"": [
""L"",
""R""
]
}
]
}
Oh, and when you send your answer, just stick to this little JSON layout so it's easy to read programmatically:
{
""solution"": [""dish_id"", ...]
}
Think of ""solution"" as the tiny menu: it's the list of dish IDs you picked so every guest has at least one thing they can eat. Each ""dish_id"" is a placeholder showing where an actual dish identifier would go — it's just the shape of the reply, not the real menu.
This JSON is only a sketch of the expected shape, not the actual answer. Please use the exact identifiers from the instance input — do not rename them or invent new labels.
for example: ""Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 16, 'density': 0.2326388888888889, 'sets': [{'id': 1, 'elements': [1, 8, 16, 17]}, {'id': 2, 'elements': [2, 11, 15]}, {'id': 3, 'elements': [3, 10]}, {'id': 4, 'elements': [4, 7, 16]}, {'id': 5, 'elements': [9, 10, 13]}, {'id': 6, 'elements': [4, 6]}, {'id': 7, 'elements': [4, 7, 8, 12, 14, 15, 16]}, {'id': 8, 'elements': [1, 2, 4, 6, 7, 8, 15, 16]}, {'id': 9, 'elements': [5, 9, 12, 13, 14]}, {'id': 10, 'elements': [3, 9, 10, 12, 13, 14]}, {'id': 11, 'elements': [9, 10, 14, 18]}, {'id': 12, 'elements': [3, 7, 9, 10, 12, 14]}, {'id': 13, 'elements': [2, 4, 8, 11, 15]}, {'id': 14, 'elements': [1, 4, 7, 8, 15]}, {'id': 15, 'elements': [1, 16]}, {'id': 16, 'elements': [12, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 16, 'v': 1}, {'u': 16, 'v': 8}, {'u': 17, 'v': 1}, {'u': 2, 'v': 11}, {'u': 2, 'v': 15}, {'u': 3, 'v': 14}, {'u': 7, 'v': 8}, {'u': 7, 'v': 10}, {'u': 14, 'v': 10}, {'u': 15, 'v': 8}, {'u': 13, 'v': 9}, {'u': 6, 'v': 4}, {'u': 8, 'v': 4}, {'u': 9, 'v': 5}, {'u': 9, 'v': 10}, {'u': 10, 'v': 12}, {'u': 12, 'v': 18}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0024.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0024.png'}","[4, 10, 12, 15, 16]",5.0,"{'num_elements': 18, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['A', 'H', 'P', 'Q']}, {'id': 'S2', 'elements': ['B', 'K', 'O']}, {'id': 'S3', 'elements': ['C', 'J']}, {'id': 'S4', 'elements': ['D', 'G', 'P']}, {'id': 'S5', 'elements': ['I', 'J', 'M']}, {'id': 'S6', 'elements': ['D', 'F']}, {'id': 'S7', 'elements': ['D', 'G', 'H', 'L', 'N', 'O', 'P']}, {'id': 'S8', 'elements': ['A', 'B', 'D', 'F', 'G', 'H', 'O', 'P']}, {'id': 'S9', 'elements': ['E', 'I', 'L', 'M', 'N']}, {'id': 'S10', 'elements': ['C', 'I', 'J', 'L', 'M', 'N']}, {'id': 'S11', 'elements': ['I', 'J', 'N', 'R']}, {'id': 'S12', 'elements': ['C', 'G', 'I', 'J', 'L', 'N']}, {'id': 'S13', 'elements': ['B', 'D', 'H', 'K', 'O']}, {'id': 'S14', 'elements': ['A', 'D', 'G', 'H', 'O']}, {'id': 'S15', 'elements': ['A', 'P']}, {'id': 'S16', 'elements': ['L', 'R']}]}","['D', 'J', 'L', 'O', 'P']",25,json,names
HSP,HSP,"Picture this: a handful of pallet types on the floor, enough so that every truck load can use at least one of them. The trick is to make that handful as small as possible — quality here is defined by using the fewest distinct pallet types, which is simply counted — and still make sure no outgoing shipment is left without a usable pallet; repeating the same pallet type is redundant. The specific shipments and pallet choices will be listed below.
- **total_pallet_types_available**: 18
- **total_outbound_shipments**: 17
| shipment_id | acceptable_pallet_types |
|---|---|
| S1 | 1 3 5 6 |
| S2 | 6 8 9 |
| S3 | 4 6 |
| S4 | 3 4 5 10 |
| S5 | 1 3 5 6 7 8 |
| S6 | 1 3 5 6 7 9 |
| S7 | 5 6 7 8 |
| S8 | 2 6 9 |
| S9 | 3 10 11 15 |
| S10 | 3 10 17 |
| S11 | 12 13 17 |
| S12 | 12 18 |
| S13 | 14 16 17 |
| S14 | 10 14 15 16 17 18 |
| S15 | 14 16 |
| S16 | 3 10 12 15 |
| S17 | 10 12 13 17 18 |
And hey, when you send back the chosen pallet types, just stick to this little JSON shape so it's easy to read:
{
""solution"": [""pallet_type_id"", ...]
}
Just so it's clear in plain terms: ""solution"" is the list of pallet types you're keeping on the floor so every shipment has at least one usable pallet. Each entry in that array is a placeholder for one pallet type identifier (so replace those placeholders with the actual IDs from the instance). This is just a sketch of the shape I expect, not your final answer.
Please make sure to use the exact identifiers given in the problem input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 17, 'density': 0.20915032679738563, 'sets': [{'id': 1, 'elements': [1, 3, 5, 6]}, {'id': 2, 'elements': [6, 8, 9]}, {'id': 3, 'elements': [4, 6]}, {'id': 4, 'elements': [3, 4, 5, 10]}, {'id': 5, 'elements': [1, 3, 5, 6, 7, 8]}, {'id': 6, 'elements': [1, 3, 5, 6, 7, 9]}, {'id': 7, 'elements': [5, 6, 7, 8]}, {'id': 8, 'elements': [2, 6, 9]}, {'id': 9, 'elements': [3, 10, 11, 15]}, {'id': 10, 'elements': [3, 10, 17]}, {'id': 11, 'elements': [12, 13, 17]}, {'id': 12, 'elements': [12, 18]}, {'id': 13, 'elements': [14, 16, 17]}, {'id': 14, 'elements': [10, 14, 15, 16, 17, 18]}, {'id': 15, 'elements': [14, 16]}, {'id': 16, 'elements': [3, 10, 12, 15]}, {'id': 17, 'elements': [10, 12, 13, 17, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 8, 'v': 2}, {'u': 8, 'v': 6}, {'u': 8, 'v': 9}, {'u': 10, 'v': 3}, {'u': 10, 'v': 11}, {'u': 10, 'v': 17}, {'u': 12, 'v': 13}, {'u': 12, 'v': 18}, {'u': 1, 'v': 5}, {'u': 17, 'v': 15}, {'u': 17, 'v': 18}, {'u': 7, 'v': 6}, {'u': 14, 'v': 15}, {'u': 15, 'v': 16}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 5, 'v': 6}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0025.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0025.png'}","[6, 10, 12, 16]",4.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [1, 3, 5, 6]}, {'id': 'S2', 'elements': [6, 8, 9]}, {'id': 'S3', 'elements': [4, 6]}, {'id': 'S4', 'elements': [3, 4, 5, 10]}, {'id': 'S5', 'elements': [1, 3, 5, 6, 7, 8]}, {'id': 'S6', 'elements': [1, 3, 5, 6, 7, 9]}, {'id': 'S7', 'elements': [5, 6, 7, 8]}, {'id': 'S8', 'elements': [2, 6, 9]}, {'id': 'S9', 'elements': [3, 10, 11, 15]}, {'id': 'S10', 'elements': [3, 10, 17]}, {'id': 'S11', 'elements': [12, 13, 17]}, {'id': 'S12', 'elements': [12, 18]}, {'id': 'S13', 'elements': [14, 16, 17]}, {'id': 'S14', 'elements': [10, 14, 15, 16, 17, 18]}, {'id': 'S15', 'elements': [14, 16]}, {'id': 'S16', 'elements': [3, 10, 12, 15]}, {'id': 'S17', 'elements': [10, 12, 13, 17, 18]}]}","[6, 10, 12, 16]",26,markdown_table,1
HSP,HSP,"We had a group of kids with very specific tastes, and the challenge was to bring the smallest number of different toys that still gives each child at least one option they’d be happy with. The “score” is simply the number of distinct toys chosen, so smaller is better; a single toy can satisfy several kids, but the same toy isn’t counted multiple times. Every child must be covered — none can be left out — and the details of who likes what are shown below.
{
""num_toys"": 18,
""num_children"": 17,
""sets"": [
{
""child_id"": ""S1"",
""liked_toys"": [
1,
7
]
},
{
""child_id"": ""S2"",
""liked_toys"": [
2,
11,
12
]
},
{
""child_id"": ""S3"",
""liked_toys"": [
3,
5,
10,
12,
13,
17
]
},
{
""child_id"": ""S4"",
""liked_toys"": [
1,
4,
7
]
},
{
""child_id"": ""S5"",
""liked_toys"": [
3,
5,
7,
8,
10,
12,
13,
16
]
},
{
""child_id"": ""S6"",
""liked_toys"": [
6,
9,
13,
15
]
},
{
""child_id"": ""S7"",
""liked_toys"": [
1,
4,
7,
10,
13
]
},
{
""child_id"": ""S8"",
""liked_toys"": [
5,
8,
12
]
},
{
""child_id"": ""S9"",
""liked_toys"": [
10,
14,
15
]
},
{
""child_id"": ""S10"",
""liked_toys"": [
1,
4,
5,
10,
12
]
},
{
""child_id"": ""S11"",
""liked_toys"": [
2,
11
]
},
{
""child_id"": ""S12"",
""liked_toys"": [
6,
7,
9,
10,
13,
15,
17
]
},
{
""child_id"": ""S13"",
""liked_toys"": [
14,
15
]
},
{
""child_id"": ""S14"",
""liked_toys"": [
6,
9,
13,
14,
15
]
},
{
""child_id"": ""S15"",
""liked_toys"": [
2,
5,
8,
11,
12,
16
]
},
{
""child_id"": ""S16"",
""liked_toys"": [
3,
5,
17
]
},
{
""child_id"": ""S17"",
""liked_toys"": [
7,
18
]
}
]
}
I'll sketch the shape of the reply in a little JSON — nothing fancy, just the layout I'll follow:
{
""solution"": [""toy_id"", ...]
}
Here ""solution"" will hold an array of the toys we plan to bring (one string per toy). Think of each entry as the exact label for a toy that shows up in the instance — that's what I'll use to say which toys cover all the kids. This block is just a template of the shape I’ll return, not the final selection.
Please use the same identifiers exactly as they appear in the input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 17, 'density': 0.22549019607843138, 'sets': [{'id': 1, 'elements': [1, 7]}, {'id': 2, 'elements': [2, 11, 12]}, {'id': 3, 'elements': [3, 5, 10, 12, 13, 17]}, {'id': 4, 'elements': [1, 4, 7]}, {'id': 5, 'elements': [3, 5, 7, 8, 10, 12, 13, 16]}, {'id': 6, 'elements': [6, 9, 13, 15]}, {'id': 7, 'elements': [1, 4, 7, 10, 13]}, {'id': 8, 'elements': [5, 8, 12]}, {'id': 9, 'elements': [10, 14, 15]}, {'id': 10, 'elements': [1, 4, 5, 10, 12]}, {'id': 11, 'elements': [2, 11]}, {'id': 12, 'elements': [6, 7, 9, 10, 13, 15, 17]}, {'id': 13, 'elements': [14, 15]}, {'id': 14, 'elements': [6, 9, 13, 14, 15]}, {'id': 15, 'elements': [2, 5, 8, 11, 12, 16]}, {'id': 16, 'elements': [3, 5, 17]}, {'id': 17, 'elements': [7, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 14, 'v': 15}, {'u': 4, 'v': 7}, {'u': 10, 'v': 5}, {'u': 10, 'v': 7}, {'u': 10, 'v': 13}, {'u': 5, 'v': 3}, {'u': 5, 'v': 12}, {'u': 8, 'v': 12}, {'u': 9, 'v': 6}, {'u': 9, 'v': 13}, {'u': 9, 'v': 15}, {'u': 3, 'v': 13}, {'u': 3, 'v': 17}, {'u': 7, 'v': 1}, {'u': 2, 'v': 16}, {'u': 16, 'v': 11}, {'u': 16, 'v': 12}, {'u': 1, 'v': 18}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0026.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0026.png'}","[5, 7, 11, 15]",4.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [1, 7]}, {'id': 'S2', 'elements': [2, 11, 12]}, {'id': 'S3', 'elements': [3, 5, 10, 12, 13, 17]}, {'id': 'S4', 'elements': [1, 4, 7]}, {'id': 'S5', 'elements': [3, 5, 7, 8, 10, 12, 13, 16]}, {'id': 'S6', 'elements': [6, 9, 13, 15]}, {'id': 'S7', 'elements': [1, 4, 7, 10, 13]}, {'id': 'S8', 'elements': [5, 8, 12]}, {'id': 'S9', 'elements': [10, 14, 15]}, {'id': 'S10', 'elements': [1, 4, 5, 10, 12]}, {'id': 'S11', 'elements': [2, 11]}, {'id': 'S12', 'elements': [6, 7, 9, 10, 13, 15, 17]}, {'id': 'S13', 'elements': [14, 15]}, {'id': 'S14', 'elements': [6, 9, 13, 14, 15]}, {'id': 'S15', 'elements': [2, 5, 8, 11, 12, 16]}, {'id': 'S16', 'elements': [3, 5, 17]}, {'id': 'S17', 'elements': [7, 18]}]}","[5, 7, 11, 15]",27,json,1
HSP,HSP,"I run a little restaurant and have to decide which ingredients to keep in the pantry so every dish on the menu uses at least one of them. The trick is to make that pantry list as short as possible — you can compare options by counting how many distinct ingredients are on each list, and the shorter the count the better. Every menu item must be covered by at least one stocked ingredient, nothing can be left without a match, and stocking the same ingredient twice doesn’t change the count. The concrete menu and ingredient details are shown below.
# total_ingredients=17
# total_menu_dishes=16
dish_id,dish_ingredients
S1,0 2 14 15
S2,1 4
S3,0 3 9 12 14
S4,2 3 4 5 7
S5,1 3 7 8 14
S6,4 5 13 14
S7,4 6 7
S8,1 3 6 7
S9,1 4 7
S10,9 11
S11,3 10 13
S12,2 16
S13,3 5 10 13
S14,0 2 3 4 5 9 11 14 15
S15,0 2 12 14 16
S16,12 15 16
Oh, and when you send your answer back, just use this little JSON layout so I can read it cleanly:
{
""solution"": [""ingredient_id"", ...]
}
""solution"" is the top-level field, and the array should list the ingredient identifiers you want to keep in the pantry. The item ""ingredient_id"" is just a placeholder showing the shape — replace each placeholder with the exact ingredient identifiers from the instance when you submit your choice. This snippet is only a sketch of the expected shape, not the actual pantry list.
Please make sure all identifiers are used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 16, 'density': 0.23161764705882354, 'sets': [{'id': 1, 'elements': [1, 3, 15, 16]}, {'id': 2, 'elements': [2, 5]}, {'id': 3, 'elements': [1, 4, 10, 13, 15]}, {'id': 4, 'elements': [3, 4, 5, 6, 8]}, {'id': 5, 'elements': [2, 4, 8, 9, 15]}, {'id': 6, 'elements': [5, 6, 14, 15]}, {'id': 7, 'elements': [5, 7, 8]}, {'id': 8, 'elements': [2, 4, 7, 8]}, {'id': 9, 'elements': [2, 5, 8]}, {'id': 10, 'elements': [10, 12]}, {'id': 11, 'elements': [4, 11, 14]}, {'id': 12, 'elements': [3, 17]}, {'id': 13, 'elements': [4, 6, 11, 14]}, {'id': 14, 'elements': [1, 3, 4, 5, 6, 10, 12, 15, 16]}, {'id': 15, 'elements': [1, 3, 13, 15, 17]}, {'id': 16, 'elements': [13, 16, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 11, 'v': 6}, {'u': 2, 'v': 8}, {'u': 9, 'v': 8}, {'u': 7, 'v': 5}, {'u': 1, 'v': 3}, {'u': 10, 'v': 12}, {'u': 10, 'v': 15}, {'u': 15, 'v': 3}, {'u': 15, 'v': 4}, {'u': 16, 'v': 3}, {'u': 16, 'v': 13}, {'u': 5, 'v': 4}, {'u': 5, 'v': 8}, {'u': 6, 'v': 4}, {'u': 6, 'v': 14}, {'u': 17, 'v': 13}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0027.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0027.png'}","[4, 5, 10, 15, 17]",5.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [0, 2, 14, 15]}, {'id': 'S2', 'elements': [1, 4]}, {'id': 'S3', 'elements': [0, 3, 9, 12, 14]}, {'id': 'S4', 'elements': [2, 3, 4, 5, 7]}, {'id': 'S5', 'elements': [1, 3, 7, 8, 14]}, {'id': 'S6', 'elements': [4, 5, 13, 14]}, {'id': 'S7', 'elements': [4, 6, 7]}, {'id': 'S8', 'elements': [1, 3, 6, 7]}, {'id': 'S9', 'elements': [1, 4, 7]}, {'id': 'S10', 'elements': [9, 11]}, {'id': 'S11', 'elements': [3, 10, 13]}, {'id': 'S12', 'elements': [2, 16]}, {'id': 'S13', 'elements': [3, 5, 10, 13]}, {'id': 'S14', 'elements': [0, 2, 3, 4, 5, 9, 11, 14, 15]}, {'id': 'S15', 'elements': [0, 2, 12, 14, 16]}, {'id': 'S16', 'elements': [12, 15, 16]}]}","[3, 4, 9, 14, 16]",28,csv,0
HSP,HSP,"Out in the field, the editor asked for a tight interview roster: pick the smallest set of people who collectively know all the topics we need. The choice is who makes the cut; the better choice is the one with fewer people that still gives every topic at least one expert. You measure a lineup by counting chosen interviewees and ensuring each topic has at least one assigned person, and make sure no topic is missed or duplicated. The concrete details will be shown below.
# total_experts=16
# total_topics=12
topic_id,experts_for_topic
S1,8 12 14
S2,4 5 6 7 13 16
S3,3 9
S4,2 3 4 6 9 10 12 13 15 16
S5,2 4 5 6
S6,2 7 11 13 15
S7,4 9 16
S8,10 12
S9,4 7 11 15
S10,1 10 12 13
S11,2 4 7 10 16
S12,2 3 7 9 13 16
Also, before we dive in, just drop your final pick in this simple JSON shape so it's easy to parse:
{
""solution"": [""person_id"", ...]
}
Here ""solution"" is just the list of chosen interviewees — put each interviewee's identifier in that array. Think of it like filling out a sign-up sheet: each entry is the ID of someone you want on the roster. This JSON is only a sketch of the expected shape, not the actual answer—I'll expect the real IDs from the instance.
Please use the identifiers exactly as they appear in the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 12, 'density': 0.28125, 'sets': [{'id': 1, 'elements': [8, 12, 14]}, {'id': 2, 'elements': [4, 5, 6, 7, 13, 16]}, {'id': 3, 'elements': [3, 9]}, {'id': 4, 'elements': [2, 3, 4, 6, 9, 10, 12, 13, 15, 16]}, {'id': 5, 'elements': [2, 4, 5, 6]}, {'id': 6, 'elements': [2, 7, 11, 13, 15]}, {'id': 7, 'elements': [4, 9, 16]}, {'id': 8, 'elements': [10, 12]}, {'id': 9, 'elements': [4, 7, 11, 15]}, {'id': 10, 'elements': [1, 10, 12, 13]}, {'id': 11, 'elements': [2, 4, 7, 10, 16]}, {'id': 12, 'elements': [2, 3, 7, 9, 13, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 14, 'v': 8}, {'u': 9, 'v': 16}, {'u': 10, 'v': 13}, {'u': 6, 'v': 2}, {'u': 12, 'v': 8}, {'u': 12, 'v': 13}, {'u': 16, 'v': 3}, {'u': 16, 'v': 4}, {'u': 4, 'v': 2}, {'u': 4, 'v': 7}, {'u': 4, 'v': 13}, {'u': 15, 'v': 7}, {'u': 8, 'v': 1}, {'u': 5, 'v': 2}, {'u': 11, 'v': 7}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0028.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0028.png'}","[4, 7, 9, 12]",4.0,"{'num_elements': 16, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [8, 12, 14]}, {'id': 'S2', 'elements': [4, 5, 6, 7, 13, 16]}, {'id': 'S3', 'elements': [3, 9]}, {'id': 'S4', 'elements': [2, 3, 4, 6, 9, 10, 12, 13, 15, 16]}, {'id': 'S5', 'elements': [2, 4, 5, 6]}, {'id': 'S6', 'elements': [2, 7, 11, 13, 15]}, {'id': 'S7', 'elements': [4, 9, 16]}, {'id': 'S8', 'elements': [10, 12]}, {'id': 'S9', 'elements': [4, 7, 11, 15]}, {'id': 'S10', 'elements': [1, 10, 12, 13]}, {'id': 'S11', 'elements': [2, 4, 7, 10, 16]}, {'id': 'S12', 'elements': [2, 3, 7, 9, 13, 16]}]}","[4, 7, 9, 12]",29,csv,1
HSP,HSP,"I’m running the show and trying to put together the tiniest team of understudies so every lead has at least one person who can step in. The job is to choose actual people to hire as understudies (not to pick which roles to cover), make sure no principal is left without backup, and keep the headcount as small as possible — the score is simply how many understudies are on the list. Nobody can be counted twice and every role needs at least one capable understudy. The exact cast list and who can cover which parts are shown below.
{
""total_understudies_available"": 14,
""total_principal_roles"": 13,
""sets"": [
{
""principal_role_id"": ""S1"",
""understudies_who_can_cover"": [
3,
5,
6,
9,
13,
14
]
},
{
""principal_role_id"": ""S2"",
""understudies_who_can_cover"": [
2,
10
]
},
{
""principal_role_id"": ""S3"",
""understudies_who_can_cover"": [
1,
3,
13,
14
]
},
{
""principal_role_id"": ""S4"",
""understudies_who_can_cover"": [
4,
5,
6
]
},
{
""principal_role_id"": ""S5"",
""understudies_who_can_cover"": [
1,
4,
5,
6
]
},
{
""principal_role_id"": ""S6"",
""understudies_who_can_cover"": [
2,
7,
8,
10
]
},
{
""principal_role_id"": ""S7"",
""understudies_who_can_cover"": [
1,
6,
7,
8,
9,
10,
12
]
},
{
""principal_role_id"": ""S8"",
""understudies_who_can_cover"": [
1,
8,
10
]
},
{
""principal_role_id"": ""S9"",
""understudies_who_can_cover"": [
1,
2,
7,
8,
9,
10,
11,
12
]
},
{
""principal_role_id"": ""S10"",
""understudies_who_can_cover"": [
2,
10,
11
]
},
{
""principal_role_id"": ""S11"",
""understudies_who_can_cover"": [
2,
7,
8,
10,
12
]
},
{
""principal_role_id"": ""S12"",
""understudies_who_can_cover"": [
1,
3,
13
]
},
{
""principal_role_id"": ""S13"",
""understudies_who_can_cover"": [
1,
14
]
}
]
}
Also, just to keep things tidy, when you send the answer please use a tiny JSON snippet like this to show who you’d pick.
{
""solution"": [""understudy_id"", ...]
}
This is just a sketch of the shape I want: ""solution"" is the list of understudy identifiers (the people you’d hire as backups). Each entry in that array should be an identifier for a person who can cover at least one lead. Think of it like filling out a short form — nothing fancy, just the IDs.
This JSON is only the expected shape, not the actual solution — don’t put made-up labels or change the IDs. Use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 13, 'density': 0.2967032967032967, 'sets': [{'id': 1, 'elements': [3, 5, 6, 9, 13, 14]}, {'id': 2, 'elements': [2, 10]}, {'id': 3, 'elements': [1, 3, 13, 14]}, {'id': 4, 'elements': [4, 5, 6]}, {'id': 5, 'elements': [1, 4, 5, 6]}, {'id': 6, 'elements': [2, 7, 8, 10]}, {'id': 7, 'elements': [1, 6, 7, 8, 9, 10, 12]}, {'id': 8, 'elements': [1, 8, 10]}, {'id': 9, 'elements': [1, 2, 7, 8, 9, 10, 11, 12]}, {'id': 10, 'elements': [2, 10, 11]}, {'id': 11, 'elements': [2, 7, 8, 10, 12]}, {'id': 12, 'elements': [1, 3, 13]}, {'id': 13, 'elements': [1, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 1, 'v': 6}, {'u': 1, 'v': 8}, {'u': 1, 'v': 13}, {'u': 5, 'v': 6}, {'u': 7, 'v': 2}, {'u': 7, 'v': 10}, {'u': 12, 'v': 2}, {'u': 12, 'v': 10}, {'u': 12, 'v': 11}, {'u': 6, 'v': 4}, {'u': 10, 'v': 8}, {'u': 8, 'v': 9}, {'u': 3, 'v': 13}, {'u': 13, 'v': 14}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0029.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0029.png'}","[1, 6, 10]",3.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [3, 5, 6, 9, 13, 14]}, {'id': 'S2', 'elements': [2, 10]}, {'id': 'S3', 'elements': [1, 3, 13, 14]}, {'id': 'S4', 'elements': [4, 5, 6]}, {'id': 'S5', 'elements': [1, 4, 5, 6]}, {'id': 'S6', 'elements': [2, 7, 8, 10]}, {'id': 'S7', 'elements': [1, 6, 7, 8, 9, 10, 12]}, {'id': 'S8', 'elements': [1, 8, 10]}, {'id': 'S9', 'elements': [1, 2, 7, 8, 9, 10, 11, 12]}, {'id': 'S10', 'elements': [2, 10, 11]}, {'id': 'S11', 'elements': [2, 7, 8, 10, 12]}, {'id': 'S12', 'elements': [1, 3, 13]}, {'id': 'S13', 'elements': [1, 14]}]}","[1, 6, 10]",30,json,1
HSP,HSP,"I run a little museum and I’m trying to put together a team of guides who speak the visitors’ languages. The job is to pick the smallest number of multilingual guides so that every language any visitor might use is spoken by at least one person on the team — you check how well a choice does simply by counting the guides you picked and making sure each language is covered. It’s important nothing gets left out (every language must be supported) and picking extra guides who don’t add new languages is pointless. The concrete details will be shown below.
- **total_guides**: 16
- **total_languages**: 16
| language_id | guide_ids_who_speak |
|---|---|
| S1 | 1 16 |
| S2 | 4 8 13 |
| S3 | 3 4 7 8 |
| S4 | 2 3 4 7 10 12 15 |
| S5 | 2 8 |
| S6 | 1 7 9 10 11 12 16 |
| S7 | 3 4 6 7 11 12 |
| S8 | 2 3 4 5 7 8 13 |
| S9 | 6 16 |
| S10 | 4 7 12 |
| S11 | 6 7 11 12 |
| S12 | 6 7 10 12 16 |
| S13 | 2 5 14 |
| S14 | 2 13 14 |
| S15 | 2 8 15 |
| S16 | 1 6 9 10 16 |
Also, when you send the actual answer, please use this simple JSON layout so it’s easy to read by whatever’s checking it.
{
""solution"": [""guide_id"", ...]
}
Here ""solution"" is just the list of guide IDs — the people you’d pick for the team. Think of each string in that array as the identifier for a chosen guide (just the ID, not a name or extra info). This block is only a sketch of the expected shape, not the actual final answer.
Please make sure to use the identifiers exactly as they appear in the instance input — don’t rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 16, 'density': 0.2578125, 'sets': [{'id': 1, 'elements': [1, 16]}, {'id': 2, 'elements': [4, 8, 13]}, {'id': 3, 'elements': [3, 4, 7, 8]}, {'id': 4, 'elements': [2, 3, 4, 7, 10, 12, 15]}, {'id': 5, 'elements': [2, 8]}, {'id': 6, 'elements': [1, 7, 9, 10, 11, 12, 16]}, {'id': 7, 'elements': [3, 4, 6, 7, 11, 12]}, {'id': 8, 'elements': [2, 3, 4, 5, 7, 8, 13]}, {'id': 9, 'elements': [6, 16]}, {'id': 10, 'elements': [4, 7, 12]}, {'id': 11, 'elements': [6, 7, 11, 12]}, {'id': 12, 'elements': [6, 7, 10, 12, 16]}, {'id': 13, 'elements': [2, 5, 14]}, {'id': 14, 'elements': [2, 13, 14]}, {'id': 15, 'elements': [2, 8, 15]}, {'id': 16, 'elements': [1, 6, 9, 10, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 16, 'v': 1}, {'u': 16, 'v': 6}, {'u': 16, 'v': 9}, {'u': 4, 'v': 3}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 7, 'v': 10}, {'u': 7, 'v': 12}, {'u': 5, 'v': 2}, {'u': 15, 'v': 8}, {'u': 6, 'v': 10}, {'u': 6, 'v': 12}, {'u': 12, 'v': 11}, {'u': 13, 'v': 2}, {'u': 13, 'v': 14}, {'u': 2, 'v': 8}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0030.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0030.png'}","[2, 4, 7, 16]",4.0,"{'num_elements': 16, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [1, 16]}, {'id': 'S2', 'elements': [4, 8, 13]}, {'id': 'S3', 'elements': [3, 4, 7, 8]}, {'id': 'S4', 'elements': [2, 3, 4, 7, 10, 12, 15]}, {'id': 'S5', 'elements': [2, 8]}, {'id': 'S6', 'elements': [1, 7, 9, 10, 11, 12, 16]}, {'id': 'S7', 'elements': [3, 4, 6, 7, 11, 12]}, {'id': 'S8', 'elements': [2, 3, 4, 5, 7, 8, 13]}, {'id': 'S9', 'elements': [6, 16]}, {'id': 'S10', 'elements': [4, 7, 12]}, {'id': 'S11', 'elements': [6, 7, 11, 12]}, {'id': 'S12', 'elements': [6, 7, 10, 12, 16]}, {'id': 'S13', 'elements': [2, 5, 14]}, {'id': 'S14', 'elements': [2, 13, 14]}, {'id': 'S15', 'elements': [2, 8, 15]}, {'id': 'S16', 'elements': [1, 6, 9, 10, 16]}]}","[2, 4, 7, 16]",31,markdown_table,1
HSP,HSP,"I was handed a sketch of a neighborhood and told to figure out which lamp posts to turn on so every crosswalk has at least one light. The job is to pick actual positions from the map so no crosswalk ends up in the dark, and the better plan is the one that uses the fewest lamp positions — you judge plans by counting how many lights are chosen, the smaller the count the better. It’s also important not to pretend to use the same pole twice or leave any crossing unlit. The concrete map and available positions are shown below.
- **total_light_positions**: 15
- **num_crosswalks**: 15
| crosswalk_id | candidate_light_positions |
|---|---|
| S1 | A B H |
| S2 | A D |
| S3 | C E F |
| S4 | E F G I K |
| S5 | E F |
| S6 | C D E G K O |
| S7 | D F G J K L |
| S8 | A H N |
| S9 | D I M O |
| S10 | G J L |
| S11 | B G K N O |
| S12 | D G J L |
| S13 | I M O |
| S14 | B H K N |
| S15 | D F I K |
Also, when you send me the actual plan, please stick to this simple JSON layout so it's easy to read and parse:
{
""solution"": [""lamp_id"", ...]
}
Here ""solution"" is the list of lamp posts you want to turn on — each entry is the identifier of a pole on the map. The example value ""lamp_id"" is just a placeholder to show the shape; swap that out with the real pole identifiers from the instance when you reply. This JSON is only a sketch of the expected shape, not the actual answer.
Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 15, 'density': 0.25333333333333335, 'sets': [{'id': 1, 'elements': [1, 2, 8]}, {'id': 2, 'elements': [1, 4]}, {'id': 3, 'elements': [3, 5, 6]}, {'id': 4, 'elements': [5, 6, 7, 9, 11]}, {'id': 5, 'elements': [5, 6]}, {'id': 6, 'elements': [3, 4, 5, 7, 11, 15]}, {'id': 7, 'elements': [4, 6, 7, 10, 11, 12]}, {'id': 8, 'elements': [1, 8, 14]}, {'id': 9, 'elements': [4, 9, 13, 15]}, {'id': 10, 'elements': [7, 10, 12]}, {'id': 11, 'elements': [2, 7, 11, 14, 15]}, {'id': 12, 'elements': [4, 7, 10, 12]}, {'id': 13, 'elements': [9, 13, 15]}, {'id': 14, 'elements': [2, 8, 11, 14]}, {'id': 15, 'elements': [4, 6, 9, 11]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 11}, {'u': 4, 'v': 15}, {'u': 1, 'v': 8}, {'u': 1, 'v': 14}, {'u': 14, 'v': 2}, {'u': 2, 'v': 11}, {'u': 3, 'v': 5}, {'u': 9, 'v': 13}, {'u': 9, 'v': 15}, {'u': 10, 'v': 12}, {'u': 5, 'v': 6}, {'u': 7, 'v': 12}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0031.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0031.png'}","[1, 6, 7, 8, 9]",5.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'H']}, {'id': 'S2', 'elements': ['A', 'D']}, {'id': 'S3', 'elements': ['C', 'E', 'F']}, {'id': 'S4', 'elements': ['E', 'F', 'G', 'I', 'K']}, {'id': 'S5', 'elements': ['E', 'F']}, {'id': 'S6', 'elements': ['C', 'D', 'E', 'G', 'K', 'O']}, {'id': 'S7', 'elements': ['D', 'F', 'G', 'J', 'K', 'L']}, {'id': 'S8', 'elements': ['A', 'H', 'N']}, {'id': 'S9', 'elements': ['D', 'I', 'M', 'O']}, {'id': 'S10', 'elements': ['G', 'J', 'L']}, {'id': 'S11', 'elements': ['B', 'G', 'K', 'N', 'O']}, {'id': 'S12', 'elements': ['D', 'G', 'J', 'L']}, {'id': 'S13', 'elements': ['I', 'M', 'O']}, {'id': 'S14', 'elements': ['B', 'H', 'K', 'N']}, {'id': 'S15', 'elements': ['D', 'F', 'I', 'K']}]}","['A', 'F', 'G', 'H', 'I']",32,markdown_table,names
HSP,HSP,"In a small town the pharmacist needs to make a practical shopping list: pick a handful of medicines so every common complaint has at least one treatment available. Effectiveness of the list is measured by the count of different medicines — fewer items is preferable — as long as every symptom category still has at least one treatment option. No category can be skipped, and keeping medicines that only duplicate existing coverage is wasteful. The exact symptom categories and possible medicines are given below.
There are 13 distinct medicines available and 10 symptom categories to cover.
For category S1, possible medicines: 0 8.
For category S2, possible medicines: 0 1 3 8.
For category S3, possible medicines: 2 9.
For category S4, possible medicines: 4 8 10 11 12.
For category S5, possible medicines: 1 3 6 8.
For category S6, possible medicines: 2 5 9.
For category S7, possible medicines: 0 1 6 8 9.
For category S8, possible medicines: 2 6 7 9.
For category S9, possible medicines: 4 8 11 12.
For category S10, possible medicines: 4 10 12.
Aim for the fewest medicines that still cover all 10 categories from the 13 available.
If you'd like, just give the final shopping list in a tiny JSON snippet so it's easy to read and reuse. Something like this will do:
{
""solution"": [""medicine_id"", ...]
}
Here ""solution"" is the list of chosen medicines — each entry is a placeholder for a medicine identifier from the instance (so ""medicine_id"" is just a stand-in, not an actual medicine name). Think of it like a simple form: the array holds the items you picked, and that's all the program needs to check coverage.
This JSON is only a sketch of the expected shape, not the actual answer — replace the placeholders with the real identifiers from the instance input.
Please use the identifiers exactly as they appear in the input — do not rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 10, 'density': 0.27692307692307694, 'sets': [{'id': 1, 'elements': [1, 9]}, {'id': 2, 'elements': [1, 2, 4, 9]}, {'id': 3, 'elements': [3, 10]}, {'id': 4, 'elements': [5, 9, 11, 12, 13]}, {'id': 5, 'elements': [2, 4, 7, 9]}, {'id': 6, 'elements': [3, 6, 10]}, {'id': 7, 'elements': [1, 2, 7, 9, 10]}, {'id': 8, 'elements': [3, 7, 8, 10]}, {'id': 9, 'elements': [5, 9, 12, 13]}, {'id': 10, 'elements': [5, 11, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 4, 'v': 2}, {'u': 1, 'v': 7}, {'u': 5, 'v': 9}, {'u': 5, 'v': 11}, {'u': 5, 'v': 12}, {'u': 2, 'v': 7}, {'u': 7, 'v': 9}, {'u': 8, 'v': 3}, {'u': 8, 'v': 6}, {'u': 8, 'v': 10}, {'u': 11, 'v': 13}, {'u': 9, 'v': 10}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0032.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0032.png'}","[9, 10, 13]",3.0,"{'num_elements': 13, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [0, 8]}, {'id': 'S2', 'elements': [0, 1, 3, 8]}, {'id': 'S3', 'elements': [2, 9]}, {'id': 'S4', 'elements': [4, 8, 10, 11, 12]}, {'id': 'S5', 'elements': [1, 3, 6, 8]}, {'id': 'S6', 'elements': [2, 5, 9]}, {'id': 'S7', 'elements': [0, 1, 6, 8, 9]}, {'id': 'S8', 'elements': [2, 6, 7, 9]}, {'id': 'S9', 'elements': [4, 8, 11, 12]}, {'id': 'S10', 'elements': [4, 10, 12]}]}","[8, 9, 12]",33,nl,0
HSP,HSP,"In our building the goal is to pick a compact set of badge profiles so every secured entrance has at least one matching badge. Success is just the number of different profiles chosen — the smaller the number, the more streamlined the solution. Make sure every secured door is covered by at least one selected profile, and don’t treat duplicates as extra coverage because only distinct profiles matter. The exact door-by-profile details follow below.
{
""total_badge_profiles"": 14,
""total_secured_doors"": 13,
""sets"": [
{
""door_id"": ""S1"",
""allowed_badge_profiles"": [
0,
3,
7,
10,
13
]
},
{
""door_id"": ""S2"",
""allowed_badge_profiles"": [
1,
6,
8,
12
]
},
{
""door_id"": ""S3"",
""allowed_badge_profiles"": [
0,
2,
9,
11
]
},
{
""door_id"": ""S4"",
""allowed_badge_profiles"": [
0,
3,
8,
10,
13
]
},
{
""door_id"": ""S5"",
""allowed_badge_profiles"": [
4,
7,
8,
12
]
},
{
""door_id"": ""S6"",
""allowed_badge_profiles"": [
5,
10,
11
]
},
{
""door_id"": ""S7"",
""allowed_badge_profiles"": [
3,
4,
7,
8,
12,
13
]
},
{
""door_id"": ""S8"",
""allowed_badge_profiles"": [
4,
6,
7,
8,
12
]
},
{
""door_id"": ""S9"",
""allowed_badge_profiles"": [
2,
9,
10,
11
]
},
{
""door_id"": ""S10"",
""allowed_badge_profiles"": [
0,
2,
3,
5
]
},
{
""door_id"": ""S11"",
""allowed_badge_profiles"": [
5,
9,
10,
11
]
},
{
""door_id"": ""S12"",
""allowed_badge_profiles"": [
1,
4,
6,
8
]
},
{
""door_id"": ""S13"",
""allowed_badge_profiles"": [
0,
3,
7,
13
]
}
]
}
Also, when you send back the chosen profiles, just stick to this simple JSON layout so it's easy to parse:
{
""solution"": [""badge_profile_id"", ...]
}
Think of it like a one-line form: ""solution"" holds a list of the distinct badge profile IDs you picked to cover every secured entrance. The JSON is just a sketch of the shape I expect — not the actual answer itself.
Please use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 13, 'density': 0.3076923076923077, 'sets': [{'id': 1, 'elements': [1, 4, 8, 11, 14]}, {'id': 2, 'elements': [2, 7, 9, 13]}, {'id': 3, 'elements': [1, 3, 10, 12]}, {'id': 4, 'elements': [1, 4, 9, 11, 14]}, {'id': 5, 'elements': [5, 8, 9, 13]}, {'id': 6, 'elements': [6, 11, 12]}, {'id': 7, 'elements': [4, 5, 8, 9, 13, 14]}, {'id': 8, 'elements': [5, 7, 8, 9, 13]}, {'id': 9, 'elements': [3, 10, 11, 12]}, {'id': 10, 'elements': [1, 3, 4, 6]}, {'id': 11, 'elements': [6, 10, 11, 12]}, {'id': 12, 'elements': [2, 5, 7, 9]}, {'id': 13, 'elements': [1, 4, 8, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 5, 'v': 9}, {'u': 12, 'v': 3}, {'u': 10, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 9}, {'u': 7, 'v': 13}, {'u': 13, 'v': 2}, {'u': 13, 'v': 9}, {'u': 6, 'v': 3}, {'u': 11, 'v': 1}, {'u': 11, 'v': 3}, {'u': 1, 'v': 4}, {'u': 4, 'v': 14}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0033.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0033.png'}","[1, 9, 12]",3.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 3, 7, 10, 13]}, {'id': 'S2', 'elements': [1, 6, 8, 12]}, {'id': 'S3', 'elements': [0, 2, 9, 11]}, {'id': 'S4', 'elements': [0, 3, 8, 10, 13]}, {'id': 'S5', 'elements': [4, 7, 8, 12]}, {'id': 'S6', 'elements': [5, 10, 11]}, {'id': 'S7', 'elements': [3, 4, 7, 8, 12, 13]}, {'id': 'S8', 'elements': [4, 6, 7, 8, 12]}, {'id': 'S9', 'elements': [2, 9, 10, 11]}, {'id': 'S10', 'elements': [0, 2, 3, 5]}, {'id': 'S11', 'elements': [5, 9, 10, 11]}, {'id': 'S12', 'elements': [1, 4, 6, 8]}, {'id': 'S13', 'elements': [0, 3, 7, 13]}]}","[0, 8, 11]",34,json,0
HSP,HSP,"Recently the brand brief boiled down to this: find the smallest crew of influencers that still covers every audience we care about. The winning plan is obvious — it’s the one with the lowest headcount that nevertheless places at least one influencer in front of each demographic, so you judge options by counting selected influencers. Every group must be covered, and repeating the same influencer isn’t helpful. The exact roster and audience mappings follow below.
- **total_influencers**: 18
- **total_demographics**: 18
| demographic_id | influencer_ids |
|---|---|
| S1 | A F M N |
| S2 | B C L M |
| S3 | A M |
| S4 | D E I J P |
| S5 | D E I |
| S6 | A D E F |
| S7 | B D F G J K |
| S8 | C L M |
| S9 | D E F |
| S10 | D F I J K R |
| S11 | G I J K |
| S12 | B H K L M N O R |
| S13 | A B C H K L N |
| S14 | K L M N O |
| S15 | B H L M N |
| S16 | D J P |
| S17 | K L Q R |
| S18 | G J K L N Q |
Oh, and when you hand the roster back, just use this little JSON shape so it's easy to parse:
{
""solution"": [""influencer_id"", ...]
}
Think of it like a simple form: ""solution"" is the list of influencers you picked (each entry is an influencer ID from the input). This block is just a sketch of the shape I expect, not the final selection itself.
Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 18, 'density': 0.25308641975308643, 'sets': [{'id': 1, 'elements': [1, 6, 13, 14]}, {'id': 2, 'elements': [2, 3, 12, 13]}, {'id': 3, 'elements': [1, 13]}, {'id': 4, 'elements': [4, 5, 9, 10, 16]}, {'id': 5, 'elements': [4, 5, 9]}, {'id': 6, 'elements': [1, 4, 5, 6]}, {'id': 7, 'elements': [2, 4, 6, 7, 10, 11]}, {'id': 8, 'elements': [3, 12, 13]}, {'id': 9, 'elements': [4, 5, 6]}, {'id': 10, 'elements': [4, 6, 9, 10, 11, 18]}, {'id': 11, 'elements': [7, 9, 10, 11]}, {'id': 12, 'elements': [2, 8, 11, 12, 13, 14, 15, 18]}, {'id': 13, 'elements': [1, 2, 3, 8, 11, 12, 14]}, {'id': 14, 'elements': [11, 12, 13, 14, 15]}, {'id': 15, 'elements': [2, 8, 12, 13, 14]}, {'id': 16, 'elements': [4, 10, 16]}, {'id': 17, 'elements': [11, 12, 17, 18]}, {'id': 18, 'elements': [7, 10, 11, 12, 14, 17]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 9, 'v': 4}, {'u': 9, 'v': 10}, {'u': 9, 'v': 16}, {'u': 10, 'v': 6}, {'u': 10, 'v': 11}, {'u': 11, 'v': 7}, {'u': 11, 'v': 12}, {'u': 11, 'v': 18}, {'u': 12, 'v': 1}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 13, 'v': 2}, {'u': 13, 'v': 8}, {'u': 13, 'v': 15}, {'u': 8, 'v': 3}, {'u': 1, 'v': 2}, {'u': 1, 'v': 7}, {'u': 2, 'v': 3}, {'u': 14, 'v': 15}, {'u': 14, 'v': 17}, {'u': 17, 'v': 18}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 6, 'v': 7}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0034.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0034.png'}","[4, 11, 13]",3.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': ['A', 'F', 'M', 'N']}, {'id': 'S2', 'elements': ['B', 'C', 'L', 'M']}, {'id': 'S3', 'elements': ['A', 'M']}, {'id': 'S4', 'elements': ['D', 'E', 'I', 'J', 'P']}, {'id': 'S5', 'elements': ['D', 'E', 'I']}, {'id': 'S6', 'elements': ['A', 'D', 'E', 'F']}, {'id': 'S7', 'elements': ['B', 'D', 'F', 'G', 'J', 'K']}, {'id': 'S8', 'elements': ['C', 'L', 'M']}, {'id': 'S9', 'elements': ['D', 'E', 'F']}, {'id': 'S10', 'elements': ['D', 'F', 'I', 'J', 'K', 'R']}, {'id': 'S11', 'elements': ['G', 'I', 'J', 'K']}, {'id': 'S12', 'elements': ['B', 'H', 'K', 'L', 'M', 'N', 'O', 'R']}, {'id': 'S13', 'elements': ['A', 'B', 'C', 'H', 'K', 'L', 'N']}, {'id': 'S14', 'elements': ['K', 'L', 'M', 'N', 'O']}, {'id': 'S15', 'elements': ['B', 'H', 'L', 'M', 'N']}, {'id': 'S16', 'elements': ['D', 'J', 'P']}, {'id': 'S17', 'elements': ['K', 'L', 'Q', 'R']}, {'id': 'S18', 'elements': ['G', 'J', 'K', 'L', 'N', 'Q']}]}","['D', 'K', 'M']",35,markdown_table,names
HSP,HSP,"Around here the idea is to build a tiny, efficient pollinator garden: choose the smallest variety of plants so every pollinator species has at least one flower it likes. The decision is a list of plant varieties to include, and a superior list is simply the one with the fewest different entries. The rule is straightforward — count distinct plant types in the plan; the lower the count the better — but every pollinator must be covered by at least one of those types. Planting multiple of the same type doesn’t make the list smaller, and the concrete details are below.
- **total_plant_varieties**: 16
- **total_pollinator_species**: 14
| pollinator_id | attractive_plant_varieties |
|---|---|
| S1 | A C J K O P |
| S2 | B C D P |
| S3 | A B C J M |
| S4 | B D G |
| S5 | E H J M O |
| S6 | F H I |
| S7 | E F H O |
| S8 | I J L |
| S9 | E F H I L P |
| S10 | F I J L |
| S11 | A C E K O |
| S12 | B N |
| S13 | H K O |
| S14 | A B C D N |
Oh, and when you send back your plant pick, please put it in this little JSON shape so it's easy to read by anything that needs it:
{
""solution"": [""plant_id"", ...]
}
Think of ""solution"" as the short list of plant varieties you picked for the garden, and each ""plant_id"" is just a placeholder for one plant identifier from the instance (one entry per variety). This is just the expected shape — a sketch of the format, not the actual answer.
Please use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 14, 'density': 0.25892857142857145, 'sets': [{'id': 1, 'elements': [1, 3, 10, 11, 15, 16]}, {'id': 2, 'elements': [2, 3, 4, 16]}, {'id': 3, 'elements': [1, 2, 3, 10, 13]}, {'id': 4, 'elements': [2, 4, 7]}, {'id': 5, 'elements': [5, 8, 10, 13, 15]}, {'id': 6, 'elements': [6, 8, 9]}, {'id': 7, 'elements': [5, 6, 8, 15]}, {'id': 8, 'elements': [9, 10, 12]}, {'id': 9, 'elements': [5, 6, 8, 9, 12, 16]}, {'id': 10, 'elements': [6, 9, 10, 12]}, {'id': 11, 'elements': [1, 3, 5, 11, 15]}, {'id': 12, 'elements': [2, 14]}, {'id': 13, 'elements': [8, 11, 15]}, {'id': 14, 'elements': [1, 2, 3, 4, 14]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 12}, {'u': 7, 'v': 4}, {'u': 15, 'v': 5}, {'u': 15, 'v': 13}, {'u': 4, 'v': 2}, {'u': 13, 'v': 1}, {'u': 13, 'v': 11}, {'u': 10, 'v': 3}, {'u': 10, 'v': 8}, {'u': 8, 'v': 5}, {'u': 1, 'v': 3}, {'u': 16, 'v': 2}, {'u': 16, 'v': 3}, {'u': 16, 'v': 14}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0035.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0035.png'}","[2, 9, 15]",3.0,"{'num_elements': 16, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'J', 'K', 'O', 'P']}, {'id': 'S2', 'elements': ['B', 'C', 'D', 'P']}, {'id': 'S3', 'elements': ['A', 'B', 'C', 'J', 'M']}, {'id': 'S4', 'elements': ['B', 'D', 'G']}, {'id': 'S5', 'elements': ['E', 'H', 'J', 'M', 'O']}, {'id': 'S6', 'elements': ['F', 'H', 'I']}, {'id': 'S7', 'elements': ['E', 'F', 'H', 'O']}, {'id': 'S8', 'elements': ['I', 'J', 'L']}, {'id': 'S9', 'elements': ['E', 'F', 'H', 'I', 'L', 'P']}, {'id': 'S10', 'elements': ['F', 'I', 'J', 'L']}, {'id': 'S11', 'elements': ['A', 'C', 'E', 'K', 'O']}, {'id': 'S12', 'elements': ['B', 'N']}, {'id': 'S13', 'elements': ['H', 'K', 'O']}, {'id': 'S14', 'elements': ['A', 'B', 'C', 'D', 'N']}]}","['B', 'I', 'O']",36,markdown_table,names
HSP,HSP,"There’s a practical problem in the data center: which minimal group of maintenance tools should live in the cabinet so every likely outage can be handled by something in that group. A good selection is the one with the fewest different tools, and you check that by counting them — the winning selection is the smallest count that still leaves no failure unhandled. Nothing can be left without a capable tool, and bringing duplicate copies of the same item doesn’t help expand coverage. The concrete details follow below.
# total_tool_types=15
# total_failure_types=15
failure_id,capable_tools
S1,1 2 9 15
S2,1 2 15
S3,3 5 7 10 11
S4,3 7 11 13 15
S5,3 5
S6,6 9
S7,3 4 7
S8,8 9
S9,1 2 6 8
S10,1 3 4 10 11
S11,3 4 11 12 13 14
S12,11 12 13
S13,4 11 12 14
S14,11 12 14
S15,1 10 15
When you tell me which tools to keep in the cabinet, just give it in this little JSON shape so it's easy to read and plug into whatever checks you run next.
{
""solution"": [""tool_id""]
}
Here ""solution"" is just the list of tool identifiers that make up the chosen minimal kit — each entry is the ID of a tool (I used the placeholder tool_id to match the story). Think of it like filling out a short form: the array holds the chosen items. This is only a sketch of the shape I need, not the actual selection.
Please use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 15, 'density': 0.24, 'sets': [{'id': 1, 'elements': [1, 2, 9, 15]}, {'id': 2, 'elements': [1, 2, 15]}, {'id': 3, 'elements': [3, 5, 7, 10, 11]}, {'id': 4, 'elements': [3, 7, 11, 13, 15]}, {'id': 5, 'elements': [3, 5]}, {'id': 6, 'elements': [6, 9]}, {'id': 7, 'elements': [3, 4, 7]}, {'id': 8, 'elements': [8, 9]}, {'id': 9, 'elements': [1, 2, 6, 8]}, {'id': 10, 'elements': [1, 3, 4, 10, 11]}, {'id': 11, 'elements': [3, 4, 11, 12, 13, 14]}, {'id': 12, 'elements': [11, 12, 13]}, {'id': 13, 'elements': [4, 11, 12, 14]}, {'id': 14, 'elements': [11, 12, 14]}, {'id': 15, 'elements': [1, 10, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 7, 'v': 3}, {'u': 7, 'v': 5}, {'u': 8, 'v': 6}, {'u': 13, 'v': 11}, {'u': 13, 'v': 12}, {'u': 13, 'v': 14}, {'u': 9, 'v': 2}, {'u': 9, 'v': 6}, {'u': 15, 'v': 1}, {'u': 15, 'v': 10}, {'u': 11, 'v': 4}, {'u': 10, 'v': 4}, {'u': 2, 'v': 1}, {'u': 3, 'v': 4}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0036.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0036.png'}","[1, 3, 9, 11]",4.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [1, 2, 9, 15]}, {'id': 'S2', 'elements': [1, 2, 15]}, {'id': 'S3', 'elements': [3, 5, 7, 10, 11]}, {'id': 'S4', 'elements': [3, 7, 11, 13, 15]}, {'id': 'S5', 'elements': [3, 5]}, {'id': 'S6', 'elements': [6, 9]}, {'id': 'S7', 'elements': [3, 4, 7]}, {'id': 'S8', 'elements': [8, 9]}, {'id': 'S9', 'elements': [1, 2, 6, 8]}, {'id': 'S10', 'elements': [1, 3, 4, 10, 11]}, {'id': 'S11', 'elements': [3, 4, 11, 12, 13, 14]}, {'id': 'S12', 'elements': [11, 12, 13]}, {'id': 'S13', 'elements': [4, 11, 12, 14]}, {'id': 'S14', 'elements': [11, 12, 14]}, {'id': 'S15', 'elements': [1, 10, 15]}]}","[1, 3, 9, 11]",37,csv,1
HSP,HSP,"There’s a toolbox of available plugins and a list of things the project must do; the plan was to grab just enough plugins so every item on the list is covered by at least one of them, and the simple way to tell which plan wins is by counting how many plugins are in it — less is better — nothing on the requirement list can be skipped and choosing the same plugin twice doesn’t help. The concrete setup is shown below.
The toolbox contains 15 distinct plugins and the project lists 15 requirements.
Requirement S1 can be satisfied by 7 9 10.
Requirement S2 can be satisfied by 2 7.
Requirement S3 can be satisfied by 2 3 4 6 10.
Requirement S4 can be satisfied by 2 4 5 9 10.
Requirement S5 can be satisfied by 4 5 6.
Requirement S6 can be satisfied by 3 4 5 6.
Requirement S7 can be satisfied by 1 2 8 10 11 12.
Requirement S8 can be satisfied by 7 8 9 11 12.
Requirement S9 can be satisfied by 7 8 10 11 15.
Requirement S10 can be satisfied by 1 3 4 6 10 11 15.
Requirement S11 can be satisfied by 3 7 8 9 10 15.
Requirement S12 can be satisfied by 7 8 9 11 13.
Requirement S13 can be satisfied by 8 11.
Requirement S14 can be satisfied by 9 14 15.
Requirement S15 can be satisfied by 10 14 15.
The winning plan is the one with the fewest plugins that covers all 15 requirements.
Oh, and when you send the actual result, keep it in this simple JSON shape so it's easy to read and parse. Something like this:
{
""solution"": [""plugin_id"", ...]
}
""solution"" is just the list of plugins you picked — each entry is the exact identifier of a plugin to include in the plan. Think of it like filling out a short form: put the plugin IDs in that array. This JSON is only a sketch of the shape I expect, not the actual answer.
Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 15, 'density': 0.28444444444444444, 'sets': [{'id': 1, 'elements': [7, 9, 10]}, {'id': 2, 'elements': [2, 7]}, {'id': 3, 'elements': [2, 3, 4, 6, 10]}, {'id': 4, 'elements': [2, 4, 5, 9, 10]}, {'id': 5, 'elements': [4, 5, 6]}, {'id': 6, 'elements': [3, 4, 5, 6]}, {'id': 7, 'elements': [1, 2, 8, 10, 11, 12]}, {'id': 8, 'elements': [7, 8, 9, 11, 12]}, {'id': 9, 'elements': [7, 8, 10, 11, 15]}, {'id': 10, 'elements': [1, 3, 4, 6, 10, 11, 15]}, {'id': 11, 'elements': [3, 7, 8, 9, 10, 15]}, {'id': 12, 'elements': [7, 8, 9, 11, 13]}, {'id': 13, 'elements': [8, 11]}, {'id': 14, 'elements': [9, 14, 15]}, {'id': 15, 'elements': [10, 14, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 2, 'v': 3}, {'u': 3, 'v': 4}, {'u': 3, 'v': 7}, {'u': 4, 'v': 6}, {'u': 4, 'v': 10}, {'u': 5, 'v': 6}, {'u': 1, 'v': 10}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}, {'u': 15, 'v': 9}, {'u': 15, 'v': 14}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 11, 'v': 8}, {'u': 8, 'v': 13}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0037.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0037.png'}","[4, 7, 11, 15]",4.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [7, 9, 10]}, {'id': 'S2', 'elements': [2, 7]}, {'id': 'S3', 'elements': [2, 3, 4, 6, 10]}, {'id': 'S4', 'elements': [2, 4, 5, 9, 10]}, {'id': 'S5', 'elements': [4, 5, 6]}, {'id': 'S6', 'elements': [3, 4, 5, 6]}, {'id': 'S7', 'elements': [1, 2, 8, 10, 11, 12]}, {'id': 'S8', 'elements': [7, 8, 9, 11, 12]}, {'id': 'S9', 'elements': [7, 8, 10, 11, 15]}, {'id': 'S10', 'elements': [1, 3, 4, 6, 10, 11, 15]}, {'id': 'S11', 'elements': [3, 7, 8, 9, 10, 15]}, {'id': 'S12', 'elements': [7, 8, 9, 11, 13]}, {'id': 'S13', 'elements': [8, 11]}, {'id': 'S14', 'elements': [9, 14, 15]}, {'id': 'S15', 'elements': [10, 14, 15]}]}","[4, 7, 11, 15]",38,nl,1
HSP,HSP,"There’s a simple home dilemma: the tool drawer can’t be endless, so which few tools should live on the workbench so any common fix can be started immediately? The aim is to collect as few different tools as possible while making sure each kind of repair has at least one suitable tool available. One selection beats another if it uses fewer distinct tools — measure that by counting the tools chosen — and nothing can be left without a corresponding tool, since duplicates won’t add coverage. The exact breakdown of tools and repair types follows below.
Below are the 14 repair categories drawn from the 14 distinct tool types.
Repair category S1 can be handled by 0 3 4 10 13.
Repair category S2 can be handled by 9 10 13.
Repair category S3 can be handled by 2 4 12.
Repair category S4 can be handled by 0 3 4 11 13.
Repair category S5 can be handled by 0 2 3 6 11 13.
Repair category S6 can be handled by 5 7 12.
Repair category S7 can be handled by 2 5 6 7 12 13.
Repair category S8 can be handled by 5 6 12.
Repair category S9 can be handled by 11 13.
Repair category S10 can be handled by 0 9.
Repair category S11 can be handled by 9 10.
Repair category S12 can be handled by 3 4 6 11.
Repair category S13 can be handled by 2 4 6 7 12.
Repair category S14 can be handled by 0 1 4 6 8.
A minimal collection drawn from the 14 tool types should cover all 14 categories.
And when you send back your pick, keep it in this simple JSON shape so it's easy to check:
{
""solution"": [""tool_id"", ...]
}
Here ""solution"" is just a list of the tool identifiers you want to keep on the workbench — the placeholder ""tool_id"" shows the shape, so swap that out for the actual IDs from the instance. Think of it like filling in a little form: the array is your chosen tools, and fewer entries means a smaller pile on the bench.
This JSON is just a sketch of the expected shape, not the actual answer. Please use the exact identifiers given in the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 14, 'density': 0.2755102040816326, 'sets': [{'id': 1, 'elements': [1, 4, 5, 11, 14]}, {'id': 2, 'elements': [10, 11, 14]}, {'id': 3, 'elements': [3, 5, 13]}, {'id': 4, 'elements': [1, 4, 5, 12, 14]}, {'id': 5, 'elements': [1, 3, 4, 7, 12, 14]}, {'id': 6, 'elements': [6, 8, 13]}, {'id': 7, 'elements': [3, 6, 7, 8, 13, 14]}, {'id': 8, 'elements': [6, 7, 13]}, {'id': 9, 'elements': [12, 14]}, {'id': 10, 'elements': [1, 10]}, {'id': 11, 'elements': [10, 11]}, {'id': 12, 'elements': [4, 5, 7, 12]}, {'id': 13, 'elements': [3, 5, 7, 8, 13]}, {'id': 14, 'elements': [1, 2, 5, 7, 9]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 11, 'v': 2}, {'u': 9, 'v': 4}, {'u': 2, 'v': 1}, {'u': 2, 'v': 10}, {'u': 3, 'v': 7}, {'u': 12, 'v': 4}, {'u': 12, 'v': 5}, {'u': 5, 'v': 7}, {'u': 5, 'v': 14}, {'u': 1, 'v': 14}, {'u': 13, 'v': 6}, {'u': 13, 'v': 7}, {'u': 13, 'v': 8}, {'u': 14, 'v': 4}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0038.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0038.png'}","[5, 10, 12, 13]",4.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [0, 3, 4, 10, 13]}, {'id': 'S2', 'elements': [9, 10, 13]}, {'id': 'S3', 'elements': [2, 4, 12]}, {'id': 'S4', 'elements': [0, 3, 4, 11, 13]}, {'id': 'S5', 'elements': [0, 2, 3, 6, 11, 13]}, {'id': 'S6', 'elements': [5, 7, 12]}, {'id': 'S7', 'elements': [2, 5, 6, 7, 12, 13]}, {'id': 'S8', 'elements': [5, 6, 12]}, {'id': 'S9', 'elements': [11, 13]}, {'id': 'S10', 'elements': [0, 9]}, {'id': 'S11', 'elements': [9, 10]}, {'id': 'S12', 'elements': [3, 4, 6, 11]}, {'id': 'S13', 'elements': [2, 4, 6, 7, 12]}, {'id': 'S14', 'elements': [0, 1, 4, 6, 8]}]}","[4, 9, 11, 12]",39,nl,0
HSP,HSP,"There's a class presentation to set up: students signed up for different project topics, and the challenge is to pick a minimal set of students to go on stage so that every single topic has someone presenting it. The plan is judged by how many students are picked — the lower the number the better — and every topic has to be covered at least once; pick a student only once and see the exact topic-student breakdown below.
# total_students=14
# total_topics=13
topic_id,students_signed_up
S1,1 6 10
S2,2 4 9 12 13 14
S3,5 12
S4,2 4 9 14
S5,3 6 7 10 11 12 13
S6,1 10 14
S7,5 7 13
S8,4 8 11
S9,1 2 5 13
S10,4 8 10 11
S11,2 3 5 8 11
S12,2 5 7 11 13 14
S13,2 4 5 9 10 13 14
Oh, and when you send back the chosen presenters, please follow this simple JSON shape so I can read it reliably:
{
""solution"": [""student_id"", ...]
}
Think of it like a tiny form: ""solution"" is the list of students you're picking to go on stage, and each entry in that array should be the exact identifier for a student (the placeholder ""student_id"" just shows the format). This block is just a sketch of the shape I expect — not the actual answer.
Please use the identifiers exactly as they appear in the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 13, 'density': 0.3131868131868132, 'sets': [{'id': 1, 'elements': [1, 6, 10]}, {'id': 2, 'elements': [2, 4, 9, 12, 13, 14]}, {'id': 3, 'elements': [5, 12]}, {'id': 4, 'elements': [2, 4, 9, 14]}, {'id': 5, 'elements': [3, 6, 7, 10, 11, 12, 13]}, {'id': 6, 'elements': [1, 10, 14]}, {'id': 7, 'elements': [5, 7, 13]}, {'id': 8, 'elements': [4, 8, 11]}, {'id': 9, 'elements': [1, 2, 5, 13]}, {'id': 10, 'elements': [4, 8, 10, 11]}, {'id': 11, 'elements': [2, 3, 5, 8, 11]}, {'id': 12, 'elements': [2, 5, 7, 11, 13, 14]}, {'id': 13, 'elements': [2, 4, 5, 9, 10, 13, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 13, 'v': 5}, {'u': 13, 'v': 7}, {'u': 13, 'v': 14}, {'u': 6, 'v': 1}, {'u': 6, 'v': 10}, {'u': 11, 'v': 3}, {'u': 11, 'v': 5}, {'u': 11, 'v': 12}, {'u': 2, 'v': 4}, {'u': 2, 'v': 9}, {'u': 2, 'v': 14}, {'u': 10, 'v': 5}, {'u': 10, 'v': 14}, {'u': 4, 'v': 12}, {'u': 8, 'v': 12}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0039.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0039.png'}","[4, 5, 10]",3.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [1, 6, 10]}, {'id': 'S2', 'elements': [2, 4, 9, 12, 13, 14]}, {'id': 'S3', 'elements': [5, 12]}, {'id': 'S4', 'elements': [2, 4, 9, 14]}, {'id': 'S5', 'elements': [3, 6, 7, 10, 11, 12, 13]}, {'id': 'S6', 'elements': [1, 10, 14]}, {'id': 'S7', 'elements': [5, 7, 13]}, {'id': 'S8', 'elements': [4, 8, 11]}, {'id': 'S9', 'elements': [1, 2, 5, 13]}, {'id': 'S10', 'elements': [4, 8, 10, 11]}, {'id': 'S11', 'elements': [2, 3, 5, 8, 11]}, {'id': 'S12', 'elements': [2, 5, 7, 11, 13, 14]}, {'id': 'S13', 'elements': [2, 4, 5, 9, 10, 13, 14]}]}","[4, 5, 10]",40,csv,1
HSP,HSP,"On a slow afternoon the team decided to refresh the window display by selecting a tiny stack of books that together showcase every genre in the shop. The decision is which exact titles to include, and the better selection is the one that covers all genres using as few books as possible — compare by counting how many books are chosen, with the smaller count winning. Be sure no genre is skipped and avoid duplicating a title on the display. The exact details of genres and candidate titles are listed below.
{
""total_titles"": 15,
""num_genres"": 14,
""sets"": [
{
""genre_id"": ""S1"",
""candidate_titles"": [
0,
2,
8,
10
]
},
{
""genre_id"": ""S2"",
""candidate_titles"": [
1,
8
]
},
{
""genre_id"": ""S3"",
""candidate_titles"": [
1,
2,
8
]
},
{
""genre_id"": ""S4"",
""candidate_titles"": [
3,
4,
5,
6
]
},
{
""genre_id"": ""S5"",
""candidate_titles"": [
3,
4,
5
]
},
{
""genre_id"": ""S6"",
""candidate_titles"": [
3,
4,
6,
7,
14
]
},
{
""genre_id"": ""S7"",
""candidate_titles"": [
3,
5,
6,
7,
13,
14
]
},
{
""genre_id"": ""S8"",
""candidate_titles"": [
7,
13,
14
]
},
{
""genre_id"": ""S9"",
""candidate_titles"": [
0,
2,
11,
14
]
},
{
""genre_id"": ""S10"",
""candidate_titles"": [
0,
9,
11,
12
]
},
{
""genre_id"": ""S11"",
""candidate_titles"": [
0,
9,
14
]
},
{
""genre_id"": ""S12"",
""candidate_titles"": [
9,
11,
12
]
},
{
""genre_id"": ""S13"",
""candidate_titles"": [
6,
13
]
},
{
""genre_id"": ""S14"",
""candidate_titles"": [
5,
6,
7,
10,
14
]
}
]
}
If you want to send back your choice, please put it in a tiny JSON snippet like this so it's easy to read and check:
{
""solution"": [""book_id"", ...]
}
Here ""solution"" is the list of chosen book identifiers for the window display — each entry is the id of a title you'd like to include. Think of this as a simple form: just drop the exact ids into that array. This JSON is only a sketch of the expected shape, not the real answer itself.
All identifiers must be used exactly as they appear in the instance input — no renaming, no new labels.
For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 14, 'density': 0.24285714285714285, 'sets': [{'id': 1, 'elements': [1, 3, 9, 11]}, {'id': 2, 'elements': [2, 9]}, {'id': 3, 'elements': [2, 3, 9]}, {'id': 4, 'elements': [4, 5, 6, 7]}, {'id': 5, 'elements': [4, 5, 6]}, {'id': 6, 'elements': [4, 5, 7, 8, 15]}, {'id': 7, 'elements': [4, 6, 7, 8, 14, 15]}, {'id': 8, 'elements': [8, 14, 15]}, {'id': 9, 'elements': [1, 3, 12, 15]}, {'id': 10, 'elements': [1, 10, 12, 13]}, {'id': 11, 'elements': [1, 10, 15]}, {'id': 12, 'elements': [10, 12, 13]}, {'id': 13, 'elements': [7, 14]}, {'id': 14, 'elements': [6, 7, 8, 11, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 3, 'v': 1}, {'u': 6, 'v': 4}, {'u': 6, 'v': 7}, {'u': 11, 'v': 9}, {'u': 11, 'v': 15}, {'u': 4, 'v': 5}, {'u': 8, 'v': 7}, {'u': 8, 'v': 14}, {'u': 15, 'v': 7}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 9, 'v': 1}, {'u': 9, 'v': 10}, {'u': 1, 'v': 2}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0040.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0040.png'}","[6, 9, 12, 14, 15]",5.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [0, 2, 8, 10]}, {'id': 'S2', 'elements': [1, 8]}, {'id': 'S3', 'elements': [1, 2, 8]}, {'id': 'S4', 'elements': [3, 4, 5, 6]}, {'id': 'S5', 'elements': [3, 4, 5]}, {'id': 'S6', 'elements': [3, 4, 6, 7, 14]}, {'id': 'S7', 'elements': [3, 5, 6, 7, 13, 14]}, {'id': 'S8', 'elements': [7, 13, 14]}, {'id': 'S9', 'elements': [0, 2, 11, 14]}, {'id': 'S10', 'elements': [0, 9, 11, 12]}, {'id': 'S11', 'elements': [0, 9, 14]}, {'id': 'S12', 'elements': [9, 11, 12]}, {'id': 'S13', 'elements': [6, 13]}, {'id': 'S14', 'elements': [5, 6, 7, 10, 14]}]}","[5, 8, 11, 13, 14]",41,json,0
HSP,HSP,"A small team faced a classic trade-off: there are lots of possible security measures and several vulnerability buckets, and the objective was to keep the chosen measures to an absolute minimum while still touching every bucket at least once. Judging any candidate list is just a matter of counting the measures — the smaller the count, the better — and it must cover every vulnerability category without unnecessary repeats or omissions. The specific vulnerabilities and available measures are listed below.
# total_measures_available=13
# total_vulnerability_categories=11
vulnerability_category_id,measures_list_for_vulnerability
S1,A J L
S2,B D I K L
S3,E G M
S4,H K
S5,C F G M
S6,F H L
S7,C F H M
S8,D G H J L
S9,B K
S10,D K
S11,A D F J L
You can just return the chosen measures in a tiny JSON snippet like this.
{
""solution"": [""measure_id"", ...]
}
""solution"" is where you list the minimal set of security measures that touch every vulnerability bucket. Each entry in the array is a placeholder for a measure identifier (so ""measure_id"" is just showing the shape — replace it with the actual IDs from the instance when you answer). This JSON is just a sketch of the expected shape, not the actual solution.
Please make sure all identifiers you use match the instance exactly — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 11, 'density': 0.26573426573426573, 'sets': [{'id': 1, 'elements': [1, 10, 12]}, {'id': 2, 'elements': [2, 4, 9, 11, 12]}, {'id': 3, 'elements': [5, 7, 13]}, {'id': 4, 'elements': [8, 11]}, {'id': 5, 'elements': [3, 6, 7, 13]}, {'id': 6, 'elements': [6, 8, 12]}, {'id': 7, 'elements': [3, 6, 8, 13]}, {'id': 8, 'elements': [4, 7, 8, 10, 12]}, {'id': 9, 'elements': [2, 11]}, {'id': 10, 'elements': [4, 11]}, {'id': 11, 'elements': [1, 4, 6, 10, 12]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 4, 'v': 2}, {'u': 4, 'v': 12}, {'u': 5, 'v': 3}, {'u': 5, 'v': 7}, {'u': 5, 'v': 13}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 1, 'v': 10}, {'u': 8, 'v': 12}, {'u': 10, 'v': 12}, {'u': 9, 'v': 11}, {'u': 11, 'v': 2}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0041.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0041.png'}","[11, 12, 13]",3.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': ['A', 'J', 'L']}, {'id': 'S2', 'elements': ['B', 'D', 'I', 'K', 'L']}, {'id': 'S3', 'elements': ['E', 'G', 'M']}, {'id': 'S4', 'elements': ['H', 'K']}, {'id': 'S5', 'elements': ['C', 'F', 'G', 'M']}, {'id': 'S6', 'elements': ['F', 'H', 'L']}, {'id': 'S7', 'elements': ['C', 'F', 'H', 'M']}, {'id': 'S8', 'elements': ['D', 'G', 'H', 'J', 'L']}, {'id': 'S9', 'elements': ['B', 'K']}, {'id': 'S10', 'elements': ['D', 'K']}, {'id': 'S11', 'elements': ['A', 'D', 'F', 'J', 'L']}]}","['K', 'L', 'M']",42,csv,names
HSP,HSP,"There’s a straightforward scheduling problem in the merch team: match product lines to all the different customer segments without bloating the catalog. The choice to make is which product lines to offer so each segment has at least one item they can buy. Success is simply measured by counting the selected product lines — the lower that count, the better the result. Make sure no segment is left without a match, and don’t double-count the same line. The concrete details follow below.
- **num_product_lines**: 13
- **num_customer_segments**: 12
| segment_id | available_product_lines |
|---|---|
| S1 | 0 2 6 10 12 |
| S2 | 1 4 7 |
| S3 | 5 6 10 |
| S4 | 3 4 7 9 |
| S5 | 1 3 6 7 |
| S6 | 2 5 10 |
| S7 | 2 4 6 7 |
| S8 | 0 1 4 |
| S9 | 1 4 7 8 |
| S10 | 7 9 |
| S11 | 2 11 |
| S12 | 0 2 10 11 |
Also, when you send back your pick, please use a tiny JSON layout so it's easy to read and process. Something like this:
{
""solution"": [""product_line_id"", ...]
}
This just means ""solution"" is the list of chosen product lines (one placeholder per selected line). The ""product_line_id"" text is a placeholder for whatever IDs you actually pick from the instance. Think of it like filling out a short form — list the IDs you want to offer so every customer segment has at least one match.
This JSON is only a sketch of the expected shape, not the actual answer — replace the placeholder entries with the real IDs from the instance.
Please use the identifiers exactly as they appear in the input — no renaming and no new labels.
for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 12, 'density': 0.26282051282051283, 'sets': [{'id': 1, 'elements': [1, 3, 7, 11, 13]}, {'id': 2, 'elements': [2, 5, 8]}, {'id': 3, 'elements': [6, 7, 11]}, {'id': 4, 'elements': [4, 5, 8, 10]}, {'id': 5, 'elements': [2, 4, 7, 8]}, {'id': 6, 'elements': [3, 6, 11]}, {'id': 7, 'elements': [3, 5, 7, 8]}, {'id': 8, 'elements': [1, 2, 5]}, {'id': 9, 'elements': [2, 5, 8, 9]}, {'id': 10, 'elements': [8, 10]}, {'id': 11, 'elements': [3, 12]}, {'id': 12, 'elements': [1, 3, 11, 12]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 3, 'v': 1}, {'u': 3, 'v': 11}, {'u': 3, 'v': 13}, {'u': 11, 'v': 6}, {'u': 10, 'v': 4}, {'u': 9, 'v': 5}, {'u': 12, 'v': 13}, {'u': 4, 'v': 8}, {'u': 7, 'v': 1}, {'u': 7, 'v': 8}, {'u': 8, 'v': 5}, {'u': 5, 'v': 2}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0042.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0042.png'}","[3, 5, 8, 11]",4.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [0, 2, 6, 10, 12]}, {'id': 'S2', 'elements': [1, 4, 7]}, {'id': 'S3', 'elements': [5, 6, 10]}, {'id': 'S4', 'elements': [3, 4, 7, 9]}, {'id': 'S5', 'elements': [1, 3, 6, 7]}, {'id': 'S6', 'elements': [2, 5, 10]}, {'id': 'S7', 'elements': [2, 4, 6, 7]}, {'id': 'S8', 'elements': [0, 1, 4]}, {'id': 'S9', 'elements': [1, 4, 7, 8]}, {'id': 'S10', 'elements': [7, 9]}, {'id': 'S11', 'elements': [2, 11]}, {'id': 'S12', 'elements': [0, 2, 10, 11]}]}","[2, 4, 7, 10]",43,markdown_table,0
HSP,HSP,"Imagine a lab tech with a checklist of symptom clusters and a drawer of tests where each test checks certain clusters — the task is to select tests that together touch every cluster. The smartest pick is the smallest collection of different tests that still covers every cluster; judge any selection by how many tests are chosen, smaller totals are preferred. No cluster can be left out, and repeating tests is pointless, so each chosen test counts once. The specific clusters and which tests cover them are shown below.
# total_tests_available=16
# total_symptom_clusters=16
cluster_id,tests_covering_cluster
S1,0 1 6 14
S2,0 6 8 10 11
S3,5 8 15
S4,3 6 10
S5,4 7 10 11 13
S6,5 8
S7,0 1 3 9 10 11
S8,4 10 11 13
S9,1 2 8 15
S10,6 10
S11,0 4 7 9 10 11 13 14 15
S12,0 1 4 7 10 11 13
S13,1 10
S14,4 7 10 13
S15,0 10 14
S16,1 2 8 10 12 15
If you want to send back your chosen tests, just drop them in a tiny JSON like this — super simple and easy for me to read:
{
""solution"": [""test_id"", ...]
}
""solution"" is the list of tests you'd pick from the drawer; each ""test_id"" is a placeholder for an actual test identifier from the instance. Think of this JSON as just the form you should fill in, not the actual answer itself.
Please be sure to use the exact identifiers shown in the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 16, 'density': 0.26953125, 'sets': [{'id': 1, 'elements': [1, 2, 7, 15]}, {'id': 2, 'elements': [1, 7, 9, 11, 12]}, {'id': 3, 'elements': [6, 9, 16]}, {'id': 4, 'elements': [4, 7, 11]}, {'id': 5, 'elements': [5, 8, 11, 12, 14]}, {'id': 6, 'elements': [6, 9]}, {'id': 7, 'elements': [1, 2, 4, 10, 11, 12]}, {'id': 8, 'elements': [5, 11, 12, 14]}, {'id': 9, 'elements': [2, 3, 9, 16]}, {'id': 10, 'elements': [7, 11]}, {'id': 11, 'elements': [1, 5, 8, 10, 11, 12, 14, 15, 16]}, {'id': 12, 'elements': [1, 2, 5, 8, 11, 12, 14]}, {'id': 13, 'elements': [2, 11]}, {'id': 14, 'elements': [5, 8, 11, 14]}, {'id': 15, 'elements': [1, 11, 15]}, {'id': 16, 'elements': [2, 3, 9, 11, 13, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 3, 'v': 6}, {'u': 3, 'v': 9}, {'u': 8, 'v': 12}, {'u': 4, 'v': 7}, {'u': 16, 'v': 2}, {'u': 16, 'v': 9}, {'u': 5, 'v': 12}, {'u': 14, 'v': 12}, {'u': 12, 'v': 11}, {'u': 11, 'v': 1}, {'u': 11, 'v': 2}, {'u': 11, 'v': 7}, {'u': 10, 'v': 7}, {'u': 2, 'v': 13}, {'u': 15, 'v': 1}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0043.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0043.png'}","[7, 9, 11]",3.0,"{'num_elements': 16, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [0, 1, 6, 14]}, {'id': 'S2', 'elements': [0, 6, 8, 10, 11]}, {'id': 'S3', 'elements': [5, 8, 15]}, {'id': 'S4', 'elements': [3, 6, 10]}, {'id': 'S5', 'elements': [4, 7, 10, 11, 13]}, {'id': 'S6', 'elements': [5, 8]}, {'id': 'S7', 'elements': [0, 1, 3, 9, 10, 11]}, {'id': 'S8', 'elements': [4, 10, 11, 13]}, {'id': 'S9', 'elements': [1, 2, 8, 15]}, {'id': 'S10', 'elements': [6, 10]}, {'id': 'S11', 'elements': [0, 4, 7, 9, 10, 11, 13, 14, 15]}, {'id': 'S12', 'elements': [0, 1, 4, 7, 10, 11, 13]}, {'id': 'S13', 'elements': [1, 10]}, {'id': 'S14', 'elements': [4, 7, 10, 13]}, {'id': 'S15', 'elements': [0, 10, 14]}, {'id': 'S16', 'elements': [1, 2, 8, 10, 12, 15]}]}","[6, 8, 10]",44,csv,0
HSP,HSP,"There’s a short trip coming up with several activities on the agenda, and the goal is to pack as few different things as possible while making sure none of the activities is left without something to use. The job is to pick which items to take so each activity has at least one match; the score is simply the number of different items carried — smaller numbers win. Each activity needs at least one packed item, the same item can often cover more than one activity, and bringing unnecessary extra copies should be avoided. The specific activities and possible items appear below.
{
""total_unique_items"": 13,
""total_activities"": 12,
""sets"": [
{
""activity_id"": ""S1"",
""items_that_cover_activity"": [
0,
4,
5,
6,
11
]
},
{
""activity_id"": ""S2"",
""items_that_cover_activity"": [
1,
9,
10
]
},
{
""activity_id"": ""S3"",
""items_that_cover_activity"": [
4,
5
]
},
{
""activity_id"": ""S4"",
""items_that_cover_activity"": [
0,
4,
5,
8,
11
]
},
{
""activity_id"": ""S5"",
""items_that_cover_activity"": [
3,
4,
5,
11
]
},
{
""activity_id"": ""S6"",
""items_that_cover_activity"": [
1,
2,
5,
6,
8,
11
]
},
{
""activity_id"": ""S7"",
""items_that_cover_activity"": [
0,
5,
6
]
},
{
""activity_id"": ""S8"",
""items_that_cover_activity"": [
7,
9,
10,
12
]
},
{
""activity_id"": ""S9"",
""items_that_cover_activity"": [
5,
8
]
},
{
""activity_id"": ""S10"",
""items_that_cover_activity"": [
9,
10
]
},
{
""activity_id"": ""S11"",
""items_that_cover_activity"": [
0,
1,
4,
5,
9,
11
]
},
{
""activity_id"": ""S12"",
""items_that_cover_activity"": [
7,
9,
12
]
}
]
}
Oh, and when you send back the pick, just stick to a tiny JSON shape so it's easy to read and check. Something like this:
{
""solution"": [""item_id"", ...]
}
Here ""solution"" is the list of items you'll pack — each entry should be an identifier for one of the things that can cover activities. Think of it like filling out a short form: the array lists the item IDs you choose to bring. This JSON is only a sketch of the shape I expect, not the actual answer.
Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 12, 'density': 0.28846153846153844, 'sets': [{'id': 1, 'elements': [1, 5, 6, 7, 12]}, {'id': 2, 'elements': [2, 10, 11]}, {'id': 3, 'elements': [5, 6]}, {'id': 4, 'elements': [1, 5, 6, 9, 12]}, {'id': 5, 'elements': [4, 5, 6, 12]}, {'id': 6, 'elements': [2, 3, 6, 7, 9, 12]}, {'id': 7, 'elements': [1, 6, 7]}, {'id': 8, 'elements': [8, 10, 11, 13]}, {'id': 9, 'elements': [6, 9]}, {'id': 10, 'elements': [10, 11]}, {'id': 11, 'elements': [1, 2, 5, 6, 10, 12]}, {'id': 12, 'elements': [8, 10, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 10, 'v': 2}, {'u': 10, 'v': 11}, {'u': 13, 'v': 11}, {'u': 3, 'v': 5}, {'u': 2, 'v': 12}, {'u': 6, 'v': 1}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 12}, {'u': 9, 'v': 4}, {'u': 7, 'v': 1}, {'u': 11, 'v': 8}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0044.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0044.png'}","[6, 10]",2.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [0, 4, 5, 6, 11]}, {'id': 'S2', 'elements': [1, 9, 10]}, {'id': 'S3', 'elements': [4, 5]}, {'id': 'S4', 'elements': [0, 4, 5, 8, 11]}, {'id': 'S5', 'elements': [3, 4, 5, 11]}, {'id': 'S6', 'elements': [1, 2, 5, 6, 8, 11]}, {'id': 'S7', 'elements': [0, 5, 6]}, {'id': 'S8', 'elements': [7, 9, 10, 12]}, {'id': 'S9', 'elements': [5, 8]}, {'id': 'S10', 'elements': [9, 10]}, {'id': 'S11', 'elements': [0, 1, 4, 5, 9, 11]}, {'id': 'S12', 'elements': [7, 9, 12]}]}","[5, 9]",45,json,0
HSP,HSP,"There’s a small editorial team trying to keep reviewer fatigue low: pick the leanest group of reviewers that still covers every incoming manuscript. Success is simple to check — count the reviewers you chose; the lower that number, the smarter the pick. At the same time, each submission must have at least one of those chosen reviewers who can handle it, and nothing should be left without a match (and repeating names won’t change the count). The concrete details are given below.
There are 15 distinct reviewers available and 14 manuscripts to cover.
Manuscript S1: qualified reviewers A C M — include at least one of them in your chosen team.
Manuscript S2: qualified reviewers B L M — include at least one of them in your chosen team.
Manuscript S3: qualified reviewers D F G J K N — include at least one of them in your chosen team.
Manuscript S4: qualified reviewers E F G — include at least one of them in your chosen team.
Manuscript S5: qualified reviewers D E F G J N — include at least one of them in your chosen team.
Manuscript S6: qualified reviewers D F G — include at least one of them in your chosen team.
Manuscript S7: qualified reviewers D F G I J O — include at least one of them in your chosen team.
Manuscript S8: qualified reviewers E F G H I M O — include at least one of them in your chosen team.
Manuscript S9: qualified reviewers F H J N — include at least one of them in your chosen team.
Manuscript S10: qualified reviewers D N — include at least one of them in your chosen team.
Manuscript S11: qualified reviewers B L M O — include at least one of them in your chosen team.
Manuscript S12: qualified reviewers I L M N O — include at least one of them in your chosen team.
Manuscript S13: qualified reviewers D F H I J K M N — include at least one of them in your chosen team.
Manuscript S14: qualified reviewers C I J L M N O — include at least one of them in your chosen team.
Pick the smallest reviewer team that still covers all 14 manuscripts from the 15 available.
Also, when you reply with your pick, just use this little JSON sketch so it's easy to check:
{
""solution"": [""reviewer_id"", ...]
}
Think of it like a tiny form: ""solution"" holds the list of reviewers you chose, and each ""reviewer_id"" is a placeholder for whatever reviewer label appears in the problem instance. It's just showing the shape I expect — not the real answer.
Please be careful to use the exact identifiers from the instance input — don't rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 14, 'density': 0.319047619047619, 'sets': [{'id': 1, 'elements': [1, 3, 13]}, {'id': 2, 'elements': [2, 12, 13]}, {'id': 3, 'elements': [4, 6, 7, 10, 11, 14]}, {'id': 4, 'elements': [5, 6, 7]}, {'id': 5, 'elements': [4, 5, 6, 7, 10, 14]}, {'id': 6, 'elements': [4, 6, 7]}, {'id': 7, 'elements': [4, 6, 7, 9, 10, 15]}, {'id': 8, 'elements': [5, 6, 7, 8, 9, 13, 15]}, {'id': 9, 'elements': [6, 8, 10, 14]}, {'id': 10, 'elements': [4, 14]}, {'id': 11, 'elements': [2, 12, 13, 15]}, {'id': 12, 'elements': [9, 12, 13, 14, 15]}, {'id': 13, 'elements': [4, 6, 8, 9, 10, 11, 13, 14]}, {'id': 14, 'elements': [3, 9, 10, 12, 13, 14, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 14, 'v': 8}, {'u': 14, 'v': 10}, {'u': 14, 'v': 15}, {'u': 15, 'v': 9}, {'u': 15, 'v': 13}, {'u': 13, 'v': 3}, {'u': 13, 'v': 12}, {'u': 8, 'v': 6}, {'u': 8, 'v': 9}, {'u': 9, 'v': 7}, {'u': 2, 'v': 12}, {'u': 11, 'v': 10}, {'u': 4, 'v': 6}, {'u': 4, 'v': 10}, {'u': 1, 'v': 3}, {'u': 5, 'v': 7}, {'u': 6, 'v': 7}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0045.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0045.png'}","[6, 13, 14]",3.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'M']}, {'id': 'S2', 'elements': ['B', 'L', 'M']}, {'id': 'S3', 'elements': ['D', 'F', 'G', 'J', 'K', 'N']}, {'id': 'S4', 'elements': ['E', 'F', 'G']}, {'id': 'S5', 'elements': ['D', 'E', 'F', 'G', 'J', 'N']}, {'id': 'S6', 'elements': ['D', 'F', 'G']}, {'id': 'S7', 'elements': ['D', 'F', 'G', 'I', 'J', 'O']}, {'id': 'S8', 'elements': ['E', 'F', 'G', 'H', 'I', 'M', 'O']}, {'id': 'S9', 'elements': ['F', 'H', 'J', 'N']}, {'id': 'S10', 'elements': ['D', 'N']}, {'id': 'S11', 'elements': ['B', 'L', 'M', 'O']}, {'id': 'S12', 'elements': ['I', 'L', 'M', 'N', 'O']}, {'id': 'S13', 'elements': ['D', 'F', 'H', 'I', 'J', 'K', 'M', 'N']}, {'id': 'S14', 'elements': ['C', 'I', 'J', 'L', 'M', 'N', 'O']}]}","['F', 'M', 'N']",46,nl,names
HSP,HSP,"There’s a photographer trying to schedule a day to shoot many different subjects with limited time, so they want to minimize how many stops to make. The choice is which shooting locations to include so that every kind of subject has at least one place among the selected spots where it can be photographed. The idea is simple: fewer stops are better — the outcome is just the number of locations picked, and the aim is to keep that number as small as possible. No subject type can be skipped, and selecting the same location multiple times isn’t useful. The specific subjects and available locations appear below.
- **num_locations**: 15
- **num_subject_types**: 15
| subject_id | available_locations |
|---|---|
| S1 | A B D E H |
| S2 | A B D |
| S3 | A B F H J |
| S4 | A B D E F G |
| S5 | F H I N |
| S6 | C D E F H I J K N |
| S7 | C J L |
| S8 | A G H I M O |
| S9 | E F H N |
| S10 | C F H J K L M N O |
| S11 | C F G J K L O |
| S12 | G J K N O |
| S13 | H J M N |
| S14 | F H I J K |
| S15 | H J K L M N |
Oh, and when you send the final answer, please use this simple JSON layout so it's easy to read and parse:
{
""solution"": [""location_id"", ...]
}
""solution"" should be the list of chosen shooting locations (by their IDs). The string location_id is just a placeholder showing the kind of entries expected — in your actual reply you would list the real location IDs from the instance. This JSON is just a sketch of the shape I want, not the final selection.
Please be sure to use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 15, 'density': 0.36, 'sets': [{'id': 1, 'elements': [1, 2, 4, 5, 8]}, {'id': 2, 'elements': [1, 2, 4]}, {'id': 3, 'elements': [1, 2, 6, 8, 10]}, {'id': 4, 'elements': [1, 2, 4, 5, 6, 7]}, {'id': 5, 'elements': [6, 8, 9, 14]}, {'id': 6, 'elements': [3, 4, 5, 6, 8, 9, 10, 11, 14]}, {'id': 7, 'elements': [3, 10, 12]}, {'id': 8, 'elements': [1, 7, 8, 9, 13, 15]}, {'id': 9, 'elements': [5, 6, 8, 14]}, {'id': 10, 'elements': [3, 6, 8, 10, 11, 12, 13, 14, 15]}, {'id': 11, 'elements': [3, 6, 7, 10, 11, 12, 15]}, {'id': 12, 'elements': [7, 10, 11, 14, 15]}, {'id': 13, 'elements': [8, 10, 13, 14]}, {'id': 14, 'elements': [6, 8, 9, 10, 11]}, {'id': 15, 'elements': [8, 10, 11, 12, 13, 14]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 6, 'v': 3}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 10}, {'u': 7, 'v': 3}, {'u': 7, 'v': 11}, {'u': 11, 'v': 10}, {'u': 11, 'v': 12}, {'u': 10, 'v': 14}, {'u': 8, 'v': 5}, {'u': 8, 'v': 9}, {'u': 8, 'v': 14}, {'u': 12, 'v': 15}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 15, 'v': 14}, {'u': 2, 'v': 4}, {'u': 14, 'v': 13}, {'u': 4, 'v': 3}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0046.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0046.png'}","[1, 8, 10]",3.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'D', 'E', 'H']}, {'id': 'S2', 'elements': ['A', 'B', 'D']}, {'id': 'S3', 'elements': ['A', 'B', 'F', 'H', 'J']}, {'id': 'S4', 'elements': ['A', 'B', 'D', 'E', 'F', 'G']}, {'id': 'S5', 'elements': ['F', 'H', 'I', 'N']}, {'id': 'S6', 'elements': ['C', 'D', 'E', 'F', 'H', 'I', 'J', 'K', 'N']}, {'id': 'S7', 'elements': ['C', 'J', 'L']}, {'id': 'S8', 'elements': ['A', 'G', 'H', 'I', 'M', 'O']}, {'id': 'S9', 'elements': ['E', 'F', 'H', 'N']}, {'id': 'S10', 'elements': ['C', 'F', 'H', 'J', 'K', 'L', 'M', 'N', 'O']}, {'id': 'S11', 'elements': ['C', 'F', 'G', 'J', 'K', 'L', 'O']}, {'id': 'S12', 'elements': ['G', 'J', 'K', 'N', 'O']}, {'id': 'S13', 'elements': ['H', 'J', 'M', 'N']}, {'id': 'S14', 'elements': ['F', 'H', 'I', 'J', 'K']}, {'id': 'S15', 'elements': ['H', 'J', 'K', 'L', 'M', 'N']}]}","['A', 'H', 'J']",47,markdown_table,names
HSP,HSP,"Recently the band tried trimming their playlist and the challenge was to select the smallest number of songs that still hit every mood people expect. The choice is which tracks to include so each mood has at least one representative, and the best pick is the one with the fewest songs. You can compare lineups by counting the selected songs—fewer equals better—while ensuring every mood is covered and not choosing the same track twice. The full list of moods and candidate tracks is below.
{
""total_songs_available"": 15,
""total_target_moods"": 14,
""sets"": [
{
""mood_id"": ""S1"",
""tracks_representing_mood"": [
""D"",
""G"",
""N""
]
},
{
""mood_id"": ""S2"",
""tracks_representing_mood"": [
""G"",
""K"",
""M""
]
},
{
""mood_id"": ""S3"",
""tracks_representing_mood"": [
""C"",
""E"",
""L""
]
},
{
""mood_id"": ""S4"",
""tracks_representing_mood"": [
""A"",
""D"",
""G"",
""M"",
""N"",
""O""
]
},
{
""mood_id"": ""S5"",
""tracks_representing_mood"": [
""C"",
""E"",
""H"",
""L"",
""O""
]
},
{
""mood_id"": ""S6"",
""tracks_representing_mood"": [
""F"",
""H"",
""O""
]
},
{
""mood_id"": ""S7"",
""tracks_representing_mood"": [
""B"",
""F"",
""H"",
""I"",
""K"",
""M"",
""O""
]
},
{
""mood_id"": ""S8"",
""tracks_representing_mood"": [
""C"",
""E"",
""G"",
""H"",
""L"",
""O""
]
},
{
""mood_id"": ""S9"",
""tracks_representing_mood"": [
""D"",
""G"",
""I""
]
},
{
""mood_id"": ""S10"",
""tracks_representing_mood"": [
""E"",
""L""
]
},
{
""mood_id"": ""S11"",
""tracks_representing_mood"": [
""E"",
""H"",
""J"",
""L""
]
},
{
""mood_id"": ""S12"",
""tracks_representing_mood"": [
""B"",
""D"",
""G"",
""I"",
""M"",
""O""
]
},
{
""mood_id"": ""S13"",
""tracks_representing_mood"": [
""A"",
""D"",
""N""
]
},
{
""mood_id"": ""S14"",
""tracks_representing_mood"": [
""D"",
""E"",
""F"",
""G"",
""M"",
""O""
]
}
]
}
Oh, and when you reply with your chosen lineup, please stick to this little JSON layout so it's easy to read:
{
""solution"": [""track_id"", ...]
}
Here ""solution"" is just the place to list the IDs of the songs you picked — one ID per entry — and the ellipsis just means you can add as many as needed. This is only a sketch of the shape I expect, not the actual answer.
Please use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 14, 'density': 0.2857142857142857, 'sets': [{'id': 1, 'elements': [4, 7, 14]}, {'id': 2, 'elements': [7, 11, 13]}, {'id': 3, 'elements': [3, 5, 12]}, {'id': 4, 'elements': [1, 4, 7, 13, 14, 15]}, {'id': 5, 'elements': [3, 5, 8, 12, 15]}, {'id': 6, 'elements': [6, 8, 15]}, {'id': 7, 'elements': [2, 6, 8, 9, 11, 13, 15]}, {'id': 8, 'elements': [3, 5, 7, 8, 12, 15]}, {'id': 9, 'elements': [4, 7, 9]}, {'id': 10, 'elements': [5, 12]}, {'id': 11, 'elements': [5, 8, 10, 12]}, {'id': 12, 'elements': [2, 4, 7, 9, 13, 15]}, {'id': 13, 'elements': [1, 4, 14]}, {'id': 14, 'elements': [4, 5, 6, 7, 13, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 6, 'v': 15}, {'u': 15, 'v': 7}, {'u': 15, 'v': 8}, {'u': 8, 'v': 5}, {'u': 7, 'v': 4}, {'u': 7, 'v': 9}, {'u': 7, 'v': 13}, {'u': 10, 'v': 12}, {'u': 4, 'v': 1}, {'u': 14, 'v': 1}, {'u': 11, 'v': 13}, {'u': 2, 'v': 13}, {'u': 12, 'v': 5}, {'u': 5, 'v': 3}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0047.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0047.png'}","[4, 5, 13, 15]",4.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['D', 'G', 'N']}, {'id': 'S2', 'elements': ['G', 'K', 'M']}, {'id': 'S3', 'elements': ['C', 'E', 'L']}, {'id': 'S4', 'elements': ['A', 'D', 'G', 'M', 'N', 'O']}, {'id': 'S5', 'elements': ['C', 'E', 'H', 'L', 'O']}, {'id': 'S6', 'elements': ['F', 'H', 'O']}, {'id': 'S7', 'elements': ['B', 'F', 'H', 'I', 'K', 'M', 'O']}, {'id': 'S8', 'elements': ['C', 'E', 'G', 'H', 'L', 'O']}, {'id': 'S9', 'elements': ['D', 'G', 'I']}, {'id': 'S10', 'elements': ['E', 'L']}, {'id': 'S11', 'elements': ['E', 'H', 'J', 'L']}, {'id': 'S12', 'elements': ['B', 'D', 'G', 'I', 'M', 'O']}, {'id': 'S13', 'elements': ['A', 'D', 'N']}, {'id': 'S14', 'elements': ['D', 'E', 'F', 'G', 'M', 'O']}]}","['D', 'E', 'M', 'O']",48,json,names
HSP,HSP,"Recently the household realized the pet has several ways it likes to play, and the puzzle is which minimal set of toys will cover them all. The better move is obvious: keep the bag as small as possible — success is simply the number of toys bought, and lower is better. It’s essential that none of the play styles are left without a toy, and getting duplicate copies of a toy doesn’t help cover new behaviors. The specific items and play-style requirements are listed below.
The household has 13 distinct toy options and must satisfy 13 play styles.
Play style S1: satisfied by any of the toys A E H.
Play style S2: satisfied by any of the toys B I.
Play style S3: satisfied by any of the toys C D L.
Play style S4: satisfied by any of the toys C D E J K L M.
Play style S5: satisfied by any of the toys D E J.
Play style S6: satisfied by any of the toys I L.
Play style S7: satisfied by any of the toys J K.
Play style S8: satisfied by any of the toys E J.
Play style S9: satisfied by any of the toys J M.
Play style S10: satisfied by any of the toys D G H I K M.
Play style S11: satisfied by any of the toys E G J K.
Play style S12: satisfied by any of the toys C D F L.
Play style S13: satisfied by any of the toys I J.
Keep the bag as small as possible — fewer toys is better; make sure all 13 play styles are covered.
Also, when you send the pick, please use a tiny JSON snippet so it's easy to read and reuse. Something like this:
{
""solution"": [""toy_id"", ...]
}
""solution"" is just the list of toy identifiers you'd buy to cover every play style. Keep each entry as the exact identifier from the instance (think of them like the toy's short code or SKU) — the JSON above is only the expected shape, a sketch rather than the final selection.
Make sure all identifiers are used exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.2485207100591716, 'sets': [{'id': 1, 'elements': [1, 5, 8]}, {'id': 2, 'elements': [2, 9]}, {'id': 3, 'elements': [3, 4, 12]}, {'id': 4, 'elements': [3, 4, 5, 10, 11, 12, 13]}, {'id': 5, 'elements': [4, 5, 10]}, {'id': 6, 'elements': [9, 12]}, {'id': 7, 'elements': [10, 11]}, {'id': 8, 'elements': [5, 10]}, {'id': 9, 'elements': [10, 13]}, {'id': 10, 'elements': [4, 7, 8, 9, 11, 13]}, {'id': 11, 'elements': [5, 7, 10, 11]}, {'id': 12, 'elements': [3, 4, 6, 12]}, {'id': 13, 'elements': [9, 10]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 3, 'v': 2}, {'u': 3, 'v': 9}, {'u': 4, 'v': 9}, {'u': 4, 'v': 10}, {'u': 4, 'v': 13}, {'u': 5, 'v': 1}, {'u': 5, 'v': 8}, {'u': 5, 'v': 10}, {'u': 12, 'v': 6}, {'u': 12, 'v': 9}, {'u': 10, 'v': 11}, {'u': 11, 'v': 7}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0048.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0048.png'}","[5, 9, 10, 12]",4.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'E', 'H']}, {'id': 'S2', 'elements': ['B', 'I']}, {'id': 'S3', 'elements': ['C', 'D', 'L']}, {'id': 'S4', 'elements': ['C', 'D', 'E', 'J', 'K', 'L', 'M']}, {'id': 'S5', 'elements': ['D', 'E', 'J']}, {'id': 'S6', 'elements': ['I', 'L']}, {'id': 'S7', 'elements': ['J', 'K']}, {'id': 'S8', 'elements': ['E', 'J']}, {'id': 'S9', 'elements': ['J', 'M']}, {'id': 'S10', 'elements': ['D', 'G', 'H', 'I', 'K', 'M']}, {'id': 'S11', 'elements': ['E', 'G', 'J', 'K']}, {'id': 'S12', 'elements': ['C', 'D', 'F', 'L']}, {'id': 'S13', 'elements': ['I', 'J']}]}","['E', 'I', 'J', 'L']",49,nl,names
HSP,HSP,"I’m trying to pack a tiny emergency kit for a bunch of unlikely but possible situations — the trick is to pick a handful of items so that every situation has at least one thing that would help. The decision is which specific items to put in the bag, and a better choice is simply one that uses fewer items while still giving every scenario at least one relevant item. To judge a choice, just count how many different items end up in the kit — the smaller that number, the better — and don’t include duplicates or leave any situation without something useful. The exact list of scenarios and candidate items is shown below.
I’m counting 18 distinct candidate items across 18 scenarios.
For S1, I’d pack one useful option from 0 2 3 5 14.
For S2, I’d pack one useful option from 0 1 2 4 11 14.
For S3, I’d pack one useful option from 1 4 6 7 8 9 17.
For S4, I’d pack one useful option from 3 4.
For S5, I’d pack one useful option from 0 1 2 3 4 5.
For S6, I’d pack one useful option from 0 3 4.
For S7, I’d pack one useful option from 2 6 9 17.
For S8, I’d pack one useful option from 2 7 9.
For S9, I’d pack one useful option from 0 2 6 7 8 17.
For S10, I’d pack one useful option from 7 8 9 17.
For S11, I’d pack one useful option from 11 12 13.
For S12, I’d pack one useful option from 10 11 12 13 14.
For S13, I’d pack one useful option from 10 11 12 13 15.
For S14, I’d pack one useful option from 10 11 12 13 15 16.
For S15, I’d pack one useful option from 1 11 12 14.
For S16, I’d pack one useful option from 13 16.
For S17, I’d pack one useful option from 15 16.
For S18, I’d pack one useful option from 6 8 9 17.
I’ll judge kits by how many distinct items they use — fewer is better.
Also, when you give the actual pick, please put it in a tiny JSON snippet like this so it's easy to read:
{
""solution"": [""kit_item_id"", ...]
}
""solution"" is the list of item IDs you'll pack — each entry is the identifier for one thing in the kit. I used ""kit_item_id"" here as a placeholder to match the emergency-kit story; it's just to show the shape I expect, not the actual answer.
Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 18, 'density': 0.23765432098765432, 'sets': [{'id': 1, 'elements': [1, 3, 4, 6, 15]}, {'id': 2, 'elements': [1, 2, 3, 5, 12, 15]}, {'id': 3, 'elements': [2, 5, 7, 8, 9, 10, 18]}, {'id': 4, 'elements': [4, 5]}, {'id': 5, 'elements': [1, 2, 3, 4, 5, 6]}, {'id': 6, 'elements': [1, 4, 5]}, {'id': 7, 'elements': [3, 7, 10, 18]}, {'id': 8, 'elements': [3, 8, 10]}, {'id': 9, 'elements': [1, 3, 7, 8, 9, 18]}, {'id': 10, 'elements': [8, 9, 10, 18]}, {'id': 11, 'elements': [12, 13, 14]}, {'id': 12, 'elements': [11, 12, 13, 14, 15]}, {'id': 13, 'elements': [11, 12, 13, 14, 16]}, {'id': 14, 'elements': [11, 12, 13, 14, 16, 17]}, {'id': 15, 'elements': [2, 12, 13, 15]}, {'id': 16, 'elements': [14, 17]}, {'id': 17, 'elements': [16, 17]}, {'id': 18, 'elements': [7, 9, 10, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 18, 'v': 10}, {'u': 12, 'v': 13}, {'u': 12, 'v': 15}, {'u': 13, 'v': 11}, {'u': 13, 'v': 14}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 5}, {'u': 2, 'v': 15}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 14, 'v': 16}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 7, 'v': 10}, {'u': 8, 'v': 9}, {'u': 9, 'v': 10}, {'u': 16, 'v': 17}]}, 'viz_instance': 'generated_data/HSP/viz/HSP_M/instance_0049.png', 'viz_solution': 'generated_data/HSP/viz/HSP_M/solution_0049.png'}","[3, 4, 12, 17, 18]",5.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [0, 2, 3, 5, 14]}, {'id': 'S2', 'elements': [0, 1, 2, 4, 11, 14]}, {'id': 'S3', 'elements': [1, 4, 6, 7, 8, 9, 17]}, {'id': 'S4', 'elements': [3, 4]}, {'id': 'S5', 'elements': [0, 1, 2, 3, 4, 5]}, {'id': 'S6', 'elements': [0, 3, 4]}, {'id': 'S7', 'elements': [2, 6, 9, 17]}, {'id': 'S8', 'elements': [2, 7, 9]}, {'id': 'S9', 'elements': [0, 2, 6, 7, 8, 17]}, {'id': 'S10', 'elements': [7, 8, 9, 17]}, {'id': 'S11', 'elements': [11, 12, 13]}, {'id': 'S12', 'elements': [10, 11, 12, 13, 14]}, {'id': 'S13', 'elements': [10, 11, 12, 13, 15]}, {'id': 'S14', 'elements': [10, 11, 12, 13, 15, 16]}, {'id': 'S15', 'elements': [1, 11, 12, 14]}, {'id': 'S16', 'elements': [13, 16]}, {'id': 'S17', 'elements': [15, 16]}, {'id': 'S18', 'elements': [6, 8, 9, 17]}]}","[2, 3, 11, 16, 17]",50,nl,0
|