24:I[269714,["/_next/static/chunks/2l5rg41i-vynk.js","/_next/static/chunks/1xmel-lyj02m3.js","/_next/static/chunks/317kxiph4vlhj.js","/_next/static/chunks/3inp7a9dy7gcc.js","/_next/static/chunks/031jaxpwqxouu.js","/_next/static/chunks/12j2gis4et6lk.js","/_next/static/chunks/37dbmmahihrw4.js","/_next/static/chunks/1t3dv3xzjv--f.js","/_next/static/chunks/2bxlxntuxh130.js","/_next/static/chunks/1fedli0_p-lr-.js","/_next/static/chunks/41obvvrcq5e4x.js","/_next/static/chunks/3ejx6wa6d9-xc.js","/_next/static/chunks/1bibmca89k3hg.js","/_next/static/chunks/3m9qqzrm_w3kt.js","/_next/static/chunks/2ki9rmvcyamti.js","/_next/static/chunks/05d15o41yftwd.js","/_next/static/chunks/2gi_iaqe6xs3r.js","/_next/static/chunks/23rqr4t2hw_ll.js","/_next/static/chunks/25dqg5ssc5oiw.js","/_next/static/chunks/1pm3dpjiz1p-0.js","/_next/static/chunks/313fl6x-ua876.js"],"SidebarTrigger"] 25:I[765918,["/_next/static/chunks/2l5rg41i-vynk.js","/_next/static/chunks/1xmel-lyj02m3.js","/_next/static/chunks/317kxiph4vlhj.js","/_next/static/chunks/3inp7a9dy7gcc.js","/_next/static/chunks/031jaxpwqxouu.js","/_next/static/chunks/12j2gis4et6lk.js","/_next/static/chunks/37dbmmahihrw4.js","/_next/static/chunks/1t3dv3xzjv--f.js","/_next/static/chunks/2bxlxntuxh130.js","/_next/static/chunks/1fedli0_p-lr-.js","/_next/static/chunks/41obvvrcq5e4x.js","/_next/static/chunks/3ejx6wa6d9-xc.js","/_next/static/chunks/1bibmca89k3hg.js","/_next/static/chunks/3m9qqzrm_w3kt.js","/_next/static/chunks/2ki9rmvcyamti.js","/_next/static/chunks/05d15o41yftwd.js","/_next/static/chunks/2gi_iaqe6xs3r.js","/_next/static/chunks/23rqr4t2hw_ll.js","/_next/static/chunks/25dqg5ssc5oiw.js","/_next/static/chunks/1pm3dpjiz1p-0.js","/_next/static/chunks/313fl6x-ua876.js"],"Separator"] 26:I[529205,["/_next/static/chunks/2l5rg41i-vynk.js","/_next/static/chunks/1xmel-lyj02m3.js","/_next/static/chunks/317kxiph4vlhj.js","/_next/static/chunks/3inp7a9dy7gcc.js","/_next/static/chunks/031jaxpwqxouu.js","/_next/static/chunks/12j2gis4et6lk.js","/_next/static/chunks/37dbmmahihrw4.js","/_next/static/chunks/1t3dv3xzjv--f.js","/_next/static/chunks/2bxlxntuxh130.js","/_next/static/chunks/1fedli0_p-lr-.js","/_next/static/chunks/41obvvrcq5e4x.js","/_next/static/chunks/3ejx6wa6d9-xc.js","/_next/static/chunks/1bibmca89k3hg.js","/_next/static/chunks/3m9qqzrm_w3kt.js","/_next/static/chunks/2ki9rmvcyamti.js","/_next/static/chunks/05d15o41yftwd.js","/_next/static/chunks/2gi_iaqe6xs3r.js","/_next/static/chunks/23rqr4t2hw_ll.js","/_next/static/chunks/25dqg5ssc5oiw.js","/_next/static/chunks/1pm3dpjiz1p-0.js","/_next/static/chunks/313fl6x-ua876.js"],"default"] 27:I[742008,["/_next/static/chunks/2l5rg41i-vynk.js","/_next/static/chunks/1xmel-lyj02m3.js","/_next/static/chunks/317kxiph4vlhj.js","/_next/static/chunks/3inp7a9dy7gcc.js","/_next/static/chunks/031jaxpwqxouu.js","/_next/static/chunks/12j2gis4et6lk.js","/_next/static/chunks/37dbmmahihrw4.js","/_next/static/chunks/1t3dv3xzjv--f.js","/_next/static/chunks/2bxlxntuxh130.js","/_next/static/chunks/1fedli0_p-lr-.js","/_next/static/chunks/41obvvrcq5e4x.js","/_next/static/chunks/3ejx6wa6d9-xc.js","/_next/static/chunks/1bibmca89k3hg.js","/_next/static/chunks/3m9qqzrm_w3kt.js","/_next/static/chunks/2ki9rmvcyamti.js","/_next/static/chunks/05d15o41yftwd.js","/_next/static/chunks/2gi_iaqe6xs3r.js","/_next/static/chunks/23rqr4t2hw_ll.js","/_next/static/chunks/25dqg5ssc5oiw.js","/_next/static/chunks/1pm3dpjiz1p-0.js","/_next/static/chunks/313fl6x-ua876.js"],"PracticeWorkspace"] 28:T192c, // ───────────────────────────────────────────────────────────────────────────── // Generated harness. Reads the argument list from stdin, calls your function, // and prints the result. Do not edit below this line. // ───────────────────────────────────────────────────────────────────────────── namespace hy { inline string trim(const string& s) { size_t a = s.find_first_not_of(" \t\r\n"); if (a == string::npos) return ""; size_t b = s.find_last_not_of(" \t\r\n"); return s.substr(a, b - a + 1); } inline vector splitOn(const string& line, char sep) { vector args; int depth = 0; bool inStr = false, esc = false; string cur; for (char ch : line) { if (!esc && !inStr && ch == sep && depth == 0) { args.push_back(trim(cur)); cur.clear(); continue; } if (esc) { cur += ch; esc = false; continue; } if (inStr) { cur += ch; if (ch == '\\') esc = true; else if (ch == '"') inStr = false; continue; } if (ch == '"') { inStr = true; cur += ch; continue; } if (ch == '[' || ch == '{' || ch == '(') depth++; if (ch == ']' || ch == '}' || ch == ')') depth--; cur += ch; } args.push_back(trim(cur)); while (args.size() > 1 && args.back().empty()) args.pop_back(); if (args.size() == 1 && args[0].empty()) args.clear(); return args; } /** Newline-separated arguments win over comma-separated; see argument-list.ts. */ inline vector split(const string& line) { vector byLine = splitOn(line, '\n'); if (byLine.size() > 1) return byLine; return splitOn(line, ','); } /** Strip one layer of surrounding brackets. */ inline string inner(const string& s) { string t = trim(s); if (t.size() >= 2 && t.front() == '[' && t.back() == ']') return t.substr(1, t.size() - 2); return t; } inline int toInt(const string& s) { return stoi(trim(s)); } inline long long toLong(const string& s) { return stoll(trim(s)); } inline double toDouble(const string& s) { return stod(trim(s)); } inline bool toBool(const string& s) { return trim(s) == "true"; } inline void appendUtf8(string& out, unsigned cp) { if (cp <= 0x7f) { out += (char)cp; return; } if (cp <= 0x7ff) { out += (char)(0xc0 | (cp >> 6)); out += (char)(0x80 | (cp & 0x3f)); return; } out += (char)(0xe0 | (cp >> 12)); out += (char)(0x80 | ((cp >> 6) & 0x3f)); out += (char)(0x80 | (cp & 0x3f)); } /** * Decode a JSON string literal. The escape table must match the one in * argument-list.ts (which uses JSON.parse) or the same stored row yields a * different string here than in JavaScript or Python. */ inline string toString(const string& s) { string t = trim(s); if (t.size() >= 2 && t.front() == '"' && t.back() == '"') { string out; size_t end = t.size() - 1; for (size_t i = 1; i < end; i++) { if (t[i] != '\\' || i + 1 >= end) { out += t[i]; continue; } char e = t[++i]; if (e == 'n') out += '\n'; else if (e == 't') out += '\t'; else if (e == 'r') out += '\r'; else if (e == 'b') out += '\b'; else if (e == 'f') out += '\f'; else if (e == 'u' && i + 4 < end) { appendUtf8(out, (unsigned)stoul(t.substr(i + 1, 4), nullptr, 16)); i += 4; } else out += e; } return out; } return t; } template vector toVec(const string& s, F f) { vector out; string in = trim(inner(s)); if (in.empty()) return out; for (const auto& part : split(in)) out.push_back(f(part)); return out; } template vector> toVec2(const string& s, F f) { vector> out; string in = trim(inner(s)); if (in.empty()) return out; for (const auto& part : split(in)) out.push_back(toVec(part, f)); return out; } inline string ser(bool v) { return v ? "true" : "false"; } inline string ser(int v) { return to_string(v); } inline string ser(long long v) { return to_string(v); } /** Inverse of toString. Control characters MUST re-escape, or a string that * round-trips in Python prints raw bytes here and the grader disagrees. */ inline string ser(const string& v) { string out = "\""; for (unsigned char c : v) { if (c == '"' || c == '\\') { out += '\\'; out += (char)c; } else if (c == '\n') out += "\\n"; else if (c == '\r') out += "\\r"; else if (c == '\t') out += "\\t"; else if (c == '\b') out += "\\b"; else if (c == '\f') out += "\\f"; else if (c < 0x20) { char _hy_buf[8]; snprintf(_hy_buf, sizeof(_hy_buf), "\\u%04x", c); out += _hy_buf; } else out += (char)c; } return out + "\""; } inline string ser(double v) { if (v == (long long)v) return to_string((long long)v); char buf[64]; snprintf(buf, sizeof(buf), "%.6f", v); string s(buf); while (!s.empty() && s.back() == '0') s.pop_back(); if (!s.empty() && s.back() == '.') s.pop_back(); return s; } template string ser(const vector& v) { string out = "["; for (size_t i = 0; i < v.size(); i++) { if (i) out += ","; out += ser(v[i]); } return out + "]"; } } // namespace hy // Every std name below is qualified and every local is _hy-prefixed: the // generated argument declarations are named after the SIGNATURE's parameters, so // a parameter called "cout" or "vector" would otherwise shadow the thing the // surrounding lines depend on. int main() { std::ios::sync_with_stdio(false); // Preserve newlines: they may separate arguments. std::string _hy_line, _hy_all; bool _hy_first = true; while (std::getline(std::cin, _hy_line)) { if (!_hy_first) _hy_all += '\n'; _hy_all += _hy_line; _hy_first = false; } std::vector _hy_args = hy::split(_hy_all); int n = hy::toInt(_hy_args[0]); auto _hy_result = Solution().checkEvenOdd(n); std::cout << _hy_result; return 0; } 29:T2547, // ───────────────────────────────────────────────────────────────────────────── // Generated harness. Reads the argument list from stdin, calls your function, // and prints the result. Do not edit below this line. // ───────────────────────────────────────────────────────────────────────────── final class Hy { static String trim(String s) { return s == null ? "" : s.trim(); } /** Newline-separated arguments win over comma-separated; see argument-list.ts. */ static java.util.List split(String line) { java.util.List byLine = splitOn(line, '\n'); if (byLine.size() > 1) return byLine; return splitOn(line, ','); } static java.util.List splitOn(String line, char sep) { java.util.List args = new java.util.ArrayList<>(); int depth = 0; boolean inStr = false, esc = false; StringBuilder cur = new StringBuilder(); for (char ch : line.toCharArray()) { if (!esc && !inStr && ch == sep && depth == 0) { args.add(cur.toString().trim()); cur.setLength(0); continue; } if (esc) { cur.append(ch); esc = false; continue; } if (inStr) { cur.append(ch); if (ch == '\\') esc = true; else if (ch == '"') inStr = false; continue; } if (ch == '"') { inStr = true; cur.append(ch); continue; } if (ch == '[' || ch == '{' || ch == '(') depth++; if (ch == ']' || ch == '}' || ch == ')') depth--; cur.append(ch); } args.add(cur.toString().trim()); while (args.size() > 1 && args.get(args.size() - 1).isEmpty()) args.remove(args.size() - 1); if (args.size() == 1 && args.get(0).isEmpty()) args.clear(); return args; } static String inner(String s) { String t = trim(s); if (t.length() >= 2 && t.charAt(0) == '[' && t.charAt(t.length() - 1) == ']') return t.substring(1, t.length() - 1); return t; } static int toInt(String s) { return Integer.parseInt(trim(s)); } static long toLong(String s) { return Long.parseLong(trim(s)); } static double toDouble(String s) { return Double.parseDouble(trim(s)); } static boolean toBool(String s) { return "true".equals(trim(s)); } /** * Decode a JSON string literal. The escape table must match the one in * argument-list.ts (which uses JSON.parse) or the same stored row yields a * different string here than in JavaScript or Python. */ static String toString_(String s) { String t = trim(s); if (t.length() >= 2 && t.charAt(0) == '"' && t.charAt(t.length() - 1) == '"') { StringBuilder out = new StringBuilder(); int end = t.length() - 1; for (int i = 1; i < end; i++) { char c = t.charAt(i); if (c != '\\' || i + 1 >= end) { out.append(c); continue; } char e = t.charAt(++i); if (e == 'n') out.append('\n'); else if (e == 't') out.append('\t'); else if (e == 'r') out.append('\r'); else if (e == 'b') out.append('\b'); else if (e == 'f') out.append('\f'); else if (e == 'u' && i + 4 < end) { out.append((char) Integer.parseInt(t.substring(i + 1, i + 5), 16)); i += 4; } else out.append(e); } return out.toString(); } return t; } static java.util.List parts(String s) { String in = trim(inner(s)); if (in.isEmpty()) return new java.util.ArrayList<>(); return split(in); } static int[] toIntArray(String s) { java.util.List p = parts(s); int[] a = new int[p.size()]; for (int i = 0; i < a.length; i++) a[i] = toInt(p.get(i)); return a; } static long[] toLongArray(String s) { java.util.List p = parts(s); long[] a = new long[p.size()]; for (int i = 0; i < a.length; i++) a[i] = toLong(p.get(i)); return a; } static double[] toDoubleArray(String s) { java.util.List p = parts(s); double[] a = new double[p.size()]; for (int i = 0; i < a.length; i++) a[i] = toDouble(p.get(i)); return a; } static boolean[] toBoolArray(String s) { java.util.List p = parts(s); boolean[] a = new boolean[p.size()]; for (int i = 0; i < a.length; i++) a[i] = toBool(p.get(i)); return a; } static String[] toStringArray(String s) { java.util.List p = parts(s); String[] a = new String[p.size()]; for (int i = 0; i < a.length; i++) a[i] = toString_(p.get(i)); return a; } static int[][] toIntArray2(String s) { java.util.List p = parts(s); int[][] a = new int[p.size()][]; for (int i = 0; i < a.length; i++) a[i] = toIntArray(p.get(i)); return a; } static long[][] toLongArray2(String s) { java.util.List p = parts(s); long[][] a = new long[p.size()][]; for (int i = 0; i < a.length; i++) a[i] = toLongArray(p.get(i)); return a; } static double[][] toDoubleArray2(String s) { java.util.List p = parts(s); double[][] a = new double[p.size()][]; for (int i = 0; i < a.length; i++) a[i] = toDoubleArray(p.get(i)); return a; } static boolean[][] toBoolArray2(String s) { java.util.List p = parts(s); boolean[][] a = new boolean[p.size()][]; for (int i = 0; i < a.length; i++) a[i] = toBoolArray(p.get(i)); return a; } static String[][] toStringArray2(String s) { java.util.List p = parts(s); String[][] a = new String[p.size()][]; for (int i = 0; i < a.length; i++) a[i] = toStringArray(p.get(i)); return a; } static String ser(boolean v) { return v ? "true" : "false"; } static String ser(int v) { return Integer.toString(v); } static String ser(long v) { return Long.toString(v); } static String ser(double v) { if (v == Math.rint(v) && !Double.isInfinite(v)) return Long.toString((long) v); String s = String.format("%.6f", v); while (s.endsWith("0")) s = s.substring(0, s.length() - 1); if (s.endsWith(".")) s = s.substring(0, s.length() - 1); return s; } /** Inverse of toString_. Control characters MUST re-escape, or a string that * round-trips in Python prints raw bytes here and the grader disagrees. */ static String ser(String v) { StringBuilder out = new StringBuilder("\""); for (char c : v.toCharArray()) { if (c == '"' || c == '\\') { out.append('\\').append(c); } else if (c == '\n') out.append("\\n"); else if (c == '\r') out.append("\\r"); else if (c == '\t') out.append("\\t"); else if (c == '\b') out.append("\\b"); else if (c == '\f') out.append("\\f"); else if (c < 0x20) out.append(String.format("\\u%04x", (int) c)); else out.append(c); } return out.append('"').toString(); } static String ser(Object v) { if (v == null) return "null"; if (v instanceof String) return ser((String) v); if (!v.getClass().isArray()) return String.valueOf(v); int n = java.lang.reflect.Array.getLength(v); StringBuilder out = new StringBuilder("["); for (int i = 0; i < n; i++) { if (i > 0) out.append(','); Object e = java.lang.reflect.Array.get(v, i); if (e instanceof Integer) out.append(ser((int) (Integer) e)); else if (e instanceof Long) out.append(ser((long) (Long) e)); else if (e instanceof Double) out.append(ser((double) (Double) e)); else if (e instanceof Boolean) out.append(ser((boolean) (Boolean) e)); else out.append(ser(e)); } return out.append(']').toString(); } } public class Main { // Every local here is _hy-prefixed. The generated argument declarations below // are named after the SIGNATURE's parameters, and validateSignature rejects // only _hy-prefixed identifiers — so an unprefixed local like "args" or // "first" would collide with a perfectly legal parameter of the same name // and fail to compile. public static void main(String[] _hyArgv) throws Exception { java.io.BufferedReader _hyReader = new java.io.BufferedReader(new java.io.InputStreamReader(System.in, java.nio.charset.StandardCharsets.UTF_8)); StringBuilder _hyBuffer = new StringBuilder(); String _hyLine; // Preserve newlines: they may separate arguments. boolean _hyFirst = true; while ((_hyLine = _hyReader.readLine()) != null) { if (!_hyFirst) _hyBuffer.append('\n'); _hyBuffer.append(_hyLine); _hyFirst = false; } java.io.PrintStream _hyOut = new java.io.PrintStream(System.out, true, "UTF-8"); java.util.List _hyArgs = Hy.split(_hyBuffer.toString()); int n = Hy.toInt(_hyArgs.get(0)); String _hyResult = new Solution().checkEvenOdd(n); _hyOut.print(_hyResult); } } 2a:Ta17, // ───────────────────────────────────────────────────────────────────────────── // Generated harness. Reads the argument list from stdin, calls your function, // and prints the result. Do not edit below this line. // ───────────────────────────────────────────────────────────────────────────── function _hySplit(line) { // Newline-separated arguments take precedence over comma-separated: a // newline-separated argument may itself contain commas inside an array. const byLine = _hySplitOn(line, "\n"); return byLine.length > 1 ? byLine : _hySplitOn(line, ","); } function _hySplitOn(line, sep) { const args = []; let depth = 0, inStr = false, esc = false, cur = ""; for (const ch of line) { if (esc) { cur += ch; esc = false; continue; } if (inStr) { cur += ch; if (ch === "\\") esc = true; else if (ch === '"') inStr = false; continue; } if (ch === '"') { inStr = true; cur += ch; continue; } if (ch === "[" || ch === "{" || ch === "(") depth++; if (ch === "]" || ch === "}" || ch === ")") depth--; if (ch === sep && depth === 0) { args.push(cur.trim()); cur = ""; continue; } cur += ch; } args.push(cur.trim()); while (args.length > 1 && args[args.length - 1] === "") args.pop(); return args.length === 1 && args[0] === "" ? [] : args; } function _hyParse(lit) { const t = lit.trim(); if (t === "true") return true; if (t === "false") return false; if (t === "null") return null; try { return JSON.parse(t); } catch (e) { return t; } } function _hySer(v) { if (v === null || v === undefined) return "null"; if (typeof v === "boolean") return v ? "true" : "false"; if (typeof v === "number") { if (Number.isInteger(v)) return String(v); if (!Number.isFinite(v)) return String(v); return v.toFixed(6).replace(/0+$/, "").replace(/\.$/, ""); } if (typeof v === "string") return JSON.stringify(v); if (Array.isArray(v)) return "[" + v.map(_hySer).join(",") + "]"; return String(v); } (function () { const _hyData = require("fs").readFileSync(0, "utf8").trim(); const _hyArgs = _hyData ? _hySplit(_hyData).map(_hyParse) : []; const _hyResult = checkEvenOdd(..._hyArgs); process.stdout.write(_hyResult == null ? "null" : String(_hyResult)); })(); 2b:Tbe8, # ───────────────────────────────────────────────────────────────────────────── # Generated harness. Reads the argument list from stdin, calls your function, # and prints the result. Do not edit below this line. # ───────────────────────────────────────────────────────────────────────────── import sys as _hy_sys import json as _hy_json def _hy_split(line): # Two encodings exist in the bank: comma-separated on one line, and # newline-separated. Newlines win when present, because a newline-separated # argument may itself contain commas inside an array. by_line = _hy_split_on(line, "\n") if len(by_line) > 1: return by_line return _hy_split_on(line, ",") def _hy_split_on(line, sep): args = [] depth = 0 in_str = False esc = False cur = "" for ch in line: if esc: cur += ch esc = False continue if in_str: cur += ch if ch == "\\": esc = True elif ch == '"': in_str = False continue if ch == '"': in_str = True cur += ch continue if ch in "[{(": depth += 1 if ch in "]})": depth -= 1 if ch == sep and depth == 0: args.append(cur.strip()) cur = "" continue cur += ch args.append(cur.strip()) while len(args) > 1 and args[-1] == "": args.pop() return [] if len(args) == 1 and args[0] == "" else args def _hy_parse(lit): t = lit.strip() if t == "true": return True if t == "false": return False if t == "null": return None try: return _hy_json.loads(t) except Exception: # A few stored rows hold bare strings (LOVELY rather than "LOVELY"). return t def _hy_ser(v): if v is None: return "null" # bool before int: bool is a subclass of int in Python. if isinstance(v, bool): return "true" if v else "false" if isinstance(v, float): if v == int(v): return str(int(v)) return ("%.6f" % v).rstrip("0").rstrip(".") if isinstance(v, int): return str(v) if isinstance(v, str): return _hy_json.dumps(v, ensure_ascii=False) if isinstance(v, (list, tuple)): return "[" + ",".join(_hy_ser(x) for x in v) + "]" return str(v) def _hy_main(): _hy_data = _hy_sys.stdin.read().strip() global _hy_args _hy_args = [_hy_parse(a) for a in _hy_split(_hy_data)] if _hy_data else [] _hy_result = Solution().checkEvenOdd(*_hy_args) _hy_sys.stdout.write("null" if _hy_result is None else str(_hy_result)) _hy_main() 2c:T21de, /* -------------------------------------------------------------------------- * Generated harness. Reads the argument list from stdin, calls your function, * and prints the result. Do not edit below this line. * -------------------------------------------------------------------------- */ #include #include typedef struct { char **data; size_t length; } HyCodegenParts; static void *hy_codegen_alloc(size_t bytes) { if (bytes == 0) return NULL; void *value = malloc(bytes); if (value == NULL) { fputs("Function harness: out of memory.\n", stderr); exit(1); } return value; } static char *hy_codegen_copy(const char *text) { size_t length = strlen(text); char *copy = (char *)hy_codegen_alloc(length + 1); memcpy(copy, text, length + 1); return copy; } static char *hy_codegen_trim(char *text) { while (*text != '\0' && isspace((unsigned char)*text)) text++; size_t length = strlen(text); while (length > 0 && isspace((unsigned char)text[length - 1])) { text[--length] = '\0'; } return text; } static HyCodegenParts hy_codegen_split_on(char *text, char separator) { HyCodegenParts out = {NULL, 0}; size_t capacity = strlen(text) + 1; out.data = (char **)hy_codegen_alloc(capacity * sizeof(*out.data)); int depth = 0; bool in_string = false; bool escaped = false; char *current = text; for (char *cursor = text; ; cursor++) { char ch = *cursor; if (ch == '\0') { out.data[out.length++] = hy_codegen_trim(current); break; } if (!escaped && !in_string && ch == separator && depth == 0) { *cursor = '\0'; out.data[out.length++] = hy_codegen_trim(current); current = cursor + 1; continue; } if (escaped) { escaped = false; continue; } if (in_string) { if (ch == '\\') escaped = true; else if (ch == '"') in_string = false; continue; } if (ch == '"') { in_string = true; continue; } if (ch == '[' || ch == '{' || ch == '(') depth++; if (ch == ']' || ch == '}' || ch == ')') depth--; } while (out.length > 1 && out.data[out.length - 1][0] == '\0') out.length--; if (out.length == 1 && out.data[0][0] == '\0') out.length = 0; return out; } /* Newline-separated arguments win over comma-separated; see argument-list.ts. */ static HyCodegenParts hy_codegen_split(char *text) { char *probe = hy_codegen_copy(text); HyCodegenParts by_line = hy_codegen_split_on(probe, '\n'); bool use_newlines = by_line.length > 1; free(by_line.data); free(probe); return hy_codegen_split_on(text, use_newlines ? '\n' : ','); } static char *hy_codegen_inner(char *text) { char *trimmed = hy_codegen_trim(text); size_t length = strlen(trimmed); if (length >= 2 && trimmed[0] == '[' && trimmed[length - 1] == ']') { trimmed[length - 1] = '\0'; return hy_codegen_trim(trimmed + 1); } return trimmed; } static int hy_codegen_hex(char ch) { if (ch >= '0' && ch <= '9') return ch - '0'; if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10; if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10; return -1; } static size_t hy_codegen_write_utf8(char *out, unsigned codepoint) { if (codepoint <= 0x7f) { out[0] = (char)codepoint; return 1; } if (codepoint <= 0x7ff) { out[0] = (char)(0xc0 | (codepoint >> 6)); out[1] = (char)(0x80 | (codepoint & 0x3f)); return 2; } out[0] = (char)(0xe0 | (codepoint >> 12)); out[1] = (char)(0x80 | ((codepoint >> 6) & 0x3f)); out[2] = (char)(0x80 | (codepoint & 0x3f)); return 3; } static int hy_codegen_parse_int(char *text) { return (int)strtol(hy_codegen_trim(text), NULL, 10); } static long long hy_codegen_parse_long(char *text) { return strtoll(hy_codegen_trim(text), NULL, 10); } static double hy_codegen_parse_double(char *text) { return strtod(hy_codegen_trim(text), NULL); } static bool hy_codegen_parse_bool(char *text) { return strcmp(hy_codegen_trim(text), "true") == 0; } static char *hy_codegen_parse_string(char *text) { char *trimmed = hy_codegen_trim(text); size_t length = strlen(trimmed); bool quoted = length >= 2 && trimmed[0] == '"' && trimmed[length - 1] == '"'; size_t start = quoted ? 1 : 0; size_t end = quoted ? length - 1 : length; char *out = (char *)hy_codegen_alloc(length + 1); size_t written = 0; for (size_t i = start; i < end; i++) { char ch = trimmed[i]; if (ch != '\\' || i + 1 >= end) { out[written++] = ch; continue; } char escaped = trimmed[++i]; if (escaped == 'n') out[written++] = '\n'; else if (escaped == 'r') out[written++] = '\r'; else if (escaped == 't') out[written++] = '\t'; else if (escaped == 'b') out[written++] = '\b'; else if (escaped == 'f') out[written++] = '\f'; else if (escaped == 'u' && i + 4 < end) { int a = hy_codegen_hex(trimmed[i + 1]); int b = hy_codegen_hex(trimmed[i + 2]); int c = hy_codegen_hex(trimmed[i + 3]); int d = hy_codegen_hex(trimmed[i + 4]); if (a >= 0 && b >= 0 && c >= 0 && d >= 0) { unsigned codepoint = (unsigned)((a << 12) | (b << 8) | (c << 4) | d); written += hy_codegen_write_utf8(out + written, codepoint); i += 4; } else { out[written++] = escaped; } } else { out[written++] = escaped; } } out[written] = '\0'; return out; } static void hy_codegen_write_int(int value) { printf("%d", value); } static void hy_codegen_write_long(long long value) { printf("%lld", value); } static void hy_codegen_write_double(double value) { if (value == 0.0) { putchar('0'); return; } if (isnan(value)) { fputs("NaN", stdout); return; } if (isinf(value)) { fputs(value < 0 ? "-Infinity" : "Infinity", stdout); return; } char buffer[512]; snprintf(buffer, sizeof(buffer), "%.6f", value); size_t length = strlen(buffer); while (length > 0 && buffer[length - 1] == '0') buffer[--length] = '\0'; if (length > 0 && buffer[length - 1] == '.') buffer[--length] = '\0'; fputs(buffer, stdout); } static void hy_codegen_write_bool(bool value) { fputs(value ? "true" : "false", stdout); } static void hy_codegen_write_string(const char *value) { if (value == NULL) { fputs("null", stdout); return; } putchar('"'); for (const unsigned char *cursor = (const unsigned char *)value; *cursor; cursor++) { unsigned char ch = *cursor; if (ch == '"' || ch == '\\') { putchar('\\'); putchar((int)ch); } else if (ch == '\n') fputs("\\n", stdout); else if (ch == '\r') fputs("\\r", stdout); else if (ch == '\t') fputs("\\t", stdout); else if (ch == '\b') fputs("\\b", stdout); else if (ch == '\f') fputs("\\f", stdout); else if (ch < 0x20) printf("\\u%04x", ch); else putchar((int)ch); } putchar('"'); } static char *hy_codegen_read_all(void) { size_t capacity = 4096; size_t length = 0; char *buffer = (char *)hy_codegen_alloc(capacity); int ch; while ((ch = fgetc(stdin)) != EOF) { if (length + 1 >= capacity) { capacity *= 2; char *grown = (char *)realloc(buffer, capacity); if (grown == NULL) { free(buffer); fputs("Function harness: out of memory.\n", stderr); exit(1); } buffer = grown; } buffer[length++] = (char)ch; } buffer[length] = '\0'; return buffer; } int main(void) { char *hy_codegen_input = hy_codegen_read_all(); HyCodegenParts hy_codegen_args = hy_codegen_split(hy_codegen_input); if (hy_codegen_args.length != 1) { fprintf(stderr, "Function harness: expected 1 argument(s), got %zu.\n", hy_codegen_args.length); return 1; } int hy_codegen_arg_0 = hy_codegen_parse_int(hy_codegen_args.data[0]); char * hy_codegen_result = checkEvenOdd(hy_codegen_arg_0); fputs(hy_codegen_result == NULL ? "null" : hy_codegen_result, stdout); /* Candidate returns may alias inputs, static storage, or allocations. */ return 0; } 9:[["$","header",null,{"className":"flex justify-between h-16 w-full shrink-0 items-center gap-2 transition-[width,height] ease-linear group-has-data-[collapsible=icon]/sidebar-wrapper:h-12 mb-4","children":[["$","div",null,{"className":"flex items-center gap-2 px-4","children":[["$","$L24",null,{"className":"-ml-1"}],["$","$L25",null,{"orientation":"vertical","className":"mr-2 data-[orientation=vertical]:h-4"}],["$","nav",null,{"aria-label":"breadcrumb","data-slot":"breadcrumb","children":["$","ol",null,{"data-slot":"breadcrumb-list","className":"text-muted-foreground flex flex-wrap items-center gap-1.5 text-sm wrap-break-word sm:gap-2.5","children":[["$","$1","0",{"children":[false,["$","li","0",{"data-slot":"breadcrumb-item","className":"items-center gap-1.5 hidden md:block","data-umami-event":"breadcrumb-Practice-button","children":["$","a",null,{"ref":"$undefined","data-slot":"breadcrumb-link","className":"transition-colors max-w-xs truncate hover:text-primary hover:underline","href":"/practice","title":"$undefined","children":"Practice"}]}]]}],["$","$1","1",{"children":[["$","li",null,{"data-slot":"breadcrumb-separator","role":"presentation","aria-hidden":"true","className":"[&>svg]:size-3.5 hidden md:block","children":["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-chevron-right","aria-hidden":"true","children":[["$","path","mthhwq",{"d":"m9 18 6-6-6-6"}],"$undefined"]}]}],["$","li","1",{"data-slot":"breadcrumb-item","className":"items-center gap-1.5 hidden md:block","data-umami-event":"breadcrumb-Integers-button","children":["$","a",null,{"ref":"$undefined","data-slot":"breadcrumb-link","className":"transition-colors max-w-xs truncate hover:text-primary hover:underline","href":"/practice/topic/Integers","title":"$undefined","children":"Integers"}]}]]}],["$","$1","2",{"children":[["$","li",null,{"data-slot":"breadcrumb-separator","role":"presentation","aria-hidden":"true","className":"[&>svg]:size-3.5 hidden md:block","children":["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-chevron-right","aria-hidden":"true","children":[["$","path","mthhwq",{"d":"m9 18 6-6-6-6"}],"$undefined"]}]}],["$","li","2",{"data-slot":"breadcrumb-item","className":"items-center gap-1.5 hidden md:block","data-umami-event":"breadcrumb-Check Even or Odd-button","children":["$","a",null,{"ref":"$undefined","data-slot":"breadcrumb-link","className":"transition-colors max-w-xs truncate hover:text-primary hover:underline","href":"/practice/a9f71346-d696-4bb7-bf9b-0c88319c43f7","title":"$undefined","children":"Check Even or Odd"}]}]]}]]}]}]]}],["$","div",null,{"className":"flex justify-center px-4","children":["$","$L26",null,{}]}],["$","div",null,{"className":"lg:flex items-center justify-end gap-2 px-4 hidden","children":null}]]}],["$","div",null,{"className":"px-2","children":["$","$L27",null,{"problem":{"id":"a9f71346-d696-4bb7-bf9b-0c88319c43f7","title":"Check Even or Odd","description":"### Description\nWrite a function that takes an integer as input and returns \"Even\" if the number is even and \"Odd\" if the number is odd.\n\n### Constraints\n-10^6 <= n","difficulty":"EASY","topic":["Conditionals","MATH","Integers"],"hint":["Use modulus operator to check for remainder when divided by 2."],"supportedLanguagesIds":["50","54","62","63","71"],"stubs":[{"id":"01160810-2bb3-4f8a-92fe-c59479b8c61b","language":"C++ (GCC 9.2.0)","languageId":"54","code":"#include \nusing namespace std;\n\nclass Solution {\npublic:\n string checkEvenOdd(int n) {\n // Write your code here\n return {};\n }\n};\n","executionCode":"$28"},{"id":"1f156de5-0250-4fe1-a175-b80f3beaa947","language":"Java (OpenJDK 13.0.1)","languageId":"62","code":"class Solution {\n public String checkEvenOdd(int n) {\n // Write your code here\n return null;\n }\n}\n","executionCode":"$29"},{"id":"11e00d40-3986-4e33-a6b8-69fad24400e9","language":"JavaScript (Node.js 12.14.0)","languageId":"63","code":"/**\n * @param {number} n\n * @return {string}\n */\nvar checkEvenOdd = function(n) {\n // Write your code here\n};\n","executionCode":"$2a"},{"id":"a94245ff-d21a-40e9-bb1f-1456091c1ee6","language":"Python (3.8.1)","languageId":"71","code":"class Solution:\n def checkEvenOdd(self, n):\n # Write your code here\n pass\n","executionCode":"$2b"},{"id":"1171ff31-1d85-4f53-877e-fb96bfb1f814","language":"C (GCC 9.2.0)","languageId":"50","code":"#include \n#include \n#include \n#include \n#include \n\n/*\n * Inputs are harness-owned for this call. Returned strings and arrays may alias\n * inputs, use static storage, or be allocated; the harness serializes them\n * immediately and never frees candidate returns.\n */\nchar * checkEvenOdd(int n) {\n // Write your code here\n return NULL;\n}\n","executionCode":"$2c"}],"sampleTestCases":[{"id":"97d49761-6851-4a00-a79c-82b2d94522e8","input":"4","output":"Even"}],"totalTestCases":3,"userProgress":null},"adjacentProblems":{"prev":{"id":"c6455fc0-4a74-4ccb-94ee-e82d0dcb90e0","title":"Check Divisibility"},"next":null,"topicName":"Integers"},"lastSubmissionCodes":{},"playlistSlug":"$undefined","topicId":"Integers"}]}]]

Check Even or Odd

Description

Constraints

Examples

Hint 1