Download docker_space/frontier_cs_1/examples/gpt5_low.cpp from JustinTX/shinka-backup: direct link, hf CLI and curl.
- Browser
- Download file 8.67 kB
-
https://huggingface.co/JustinTX/shinka-backup/resolve/main/docker_space/frontier_cs_1/examples/gpt5_low.cpp
- Command line
-
hf download hf://JustinTX/shinka-backup/docker_space/frontier_cs_1/examples/gpt5_low.cpp
-
curl -L -o gpt5_low.cpp https://huggingface.co/JustinTX/shinka-backup/resolve/main/docker_space/frontier_cs_1/examples/gpt5_low.cpp
8.67 kB
| using namespace std; | |
| struct Item { | |
| string name; | |
| long long q, v, m, l; | |
| }; | |
| struct Solution { | |
| vector<long long> x; | |
| long long value; | |
| long long remM, remL; | |
| }; | |
| static const long long CAP_M = 20LL * 1000000LL; // mg | |
| static const long long CAP_L = 25LL * 1000000LL; // uL | |
| void skipSpaces(const string& s, size_t& i){ | |
| while(i < s.size() && isspace((unsigned char)s[i])) i++; | |
| } | |
| bool parseString(const string& s, size_t& i, string& out){ | |
| skipSpaces(s, i); | |
| if(i >= s.size() || s[i] != '"') return false; | |
| i++; | |
| string res; | |
| while(i < s.size() && s[i] != '"'){ | |
| // no escape handling needed for given problem | |
| res.push_back(s[i]); | |
| i++; | |
| } | |
| if(i >= s.size() || s[i] != '"') return false; | |
| i++; | |
| out = res; | |
| return true; | |
| } | |
| bool parseInt(const string& s, size_t& i, long long& val){ | |
| skipSpaces(s, i); | |
| bool neg = false; | |
| if(i < s.size() && (s[i] == '-' || s[i] == '+')){ | |
| neg = (s[i]=='-'); | |
| i++; | |
| } | |
| skipSpaces(s, i); | |
| if(i >= s.size() || !isdigit((unsigned char)s[i])) return false; | |
| long long v = 0; | |
| while(i < s.size() && isdigit((unsigned char)s[i])){ | |
| v = v*10 + (s[i]-'0'); | |
| i++; | |
| } | |
| val = neg ? -v : v; | |
| return true; | |
| } | |
| bool parseArray4(const string& s, size_t& i, array<long long,4>& arr){ | |
| skipSpaces(s, i); | |
| if(i >= s.size() || s[i] != '[') return false; | |
| i++; | |
| for(int k=0;k<4;k++){ | |
| skipSpaces(s, i); | |
| // potential newlines/commas | |
| long long x; | |
| if(!parseInt(s, i, x)) return false; | |
| arr[k]=x; | |
| skipSpaces(s, i); | |
| if(k<3){ | |
| if(i >= s.size()) return false; | |
| // allow trailing commas and newlines/spaces | |
| if(s[i] == ','){ i++; } | |
| } | |
| } | |
| skipSpaces(s, i); | |
| // allow trailing commas/newlines inside array | |
| while(i < s.size() && s[i] != ']'){ | |
| // consume potential commas or spaces/newlines | |
| if(s[i]==','){ i++; } | |
| else if(isspace((unsigned char)s[i])) i++; | |
| else break; | |
| } | |
| if(i >= s.size() || s[i] != ']') return false; | |
| i++; | |
| return true; | |
| } | |
| vector<Item> parseInput(const string& s){ | |
| vector<Item> items; | |
| size_t i=0; | |
| skipSpaces(s,i); | |
| if(i<s.size() && s[i]=='{') i++; | |
| while(i < s.size()){ | |
| skipSpaces(s,i); | |
| if(i < s.size() && s[i]=='}'){ i++; break; } | |
| string key; | |
| if(!parseString(s,i,key)) break; | |
| skipSpaces(s,i); | |
| if(i >= s.size() || s[i] != ':') break; | |
| i++; | |
| array<long long,4> arr; | |
| if(!parseArray4(s,i,arr)) break; | |
| items.push_back({key, arr[0], arr[1], arr[2], arr[3]}); | |
| skipSpaces(s,i); | |
| if(i < s.size() && s[i]==','){ i++; continue; } | |
| } | |
| return items; | |
| } | |
| long long ceil_div(long long a, long long b){ | |
| if (a <= 0) return 0; | |
| return (a + b - 1) / b; | |
| } | |
| Solution greedyFill(const vector<Item>& items, const vector<int>& order){ | |
| int n = items.size(); | |
| Solution sol; | |
| sol.x.assign(n,0); | |
| sol.remM = CAP_M; | |
| sol.remL = CAP_L; | |
| sol.value = 0; | |
| for(int idx : order){ | |
| const auto& it = items[idx]; | |
| if (it.m > CAP_M || it.l > CAP_L) continue; | |
| long long byM = sol.remM / it.m; | |
| long long byL = sol.remL / it.l; | |
| long long take = min({it.q, byM, byL}); | |
| if(take <= 0) continue; | |
| sol.x[idx] += take; | |
| sol.remM -= take * it.m; | |
| sol.remL -= take * it.l; | |
| sol.value += take * it.v; | |
| } | |
| return sol; | |
| } | |
| void tryDirectFill(const vector<Item>& items, const vector<int>& order, Solution& sol){ | |
| for(int idx : order){ | |
| const auto& it = items[idx]; | |
| if (it.m > CAP_M || it.l > CAP_L) continue; | |
| long long canq = it.q - sol.x[idx]; | |
| if(canq <= 0) continue; | |
| long long byM = sol.remM / it.m; | |
| long long byL = sol.remL / it.l; | |
| long long take = min({canq, byM, byL}); | |
| if(take <= 0) continue; | |
| sol.x[idx] += take; | |
| sol.remM -= take * it.m; | |
| sol.remL -= take * it.l; | |
| sol.value += take * it.v; | |
| } | |
| } | |
| bool improveOneSwap(const vector<Item>& items, Solution& sol){ | |
| int n = items.size(); | |
| // attempt adding one of item a, removing t of item b | |
| for(int a=0;a<n;a++){ | |
| const auto& ia = items[a]; | |
| if(sol.x[a] >= ia.q) continue; | |
| if (ia.m > CAP_M || ia.l > CAP_L) continue; | |
| long long needM = max(0LL, ia.m - sol.remM); | |
| long long needL = max(0LL, ia.l - sol.remL); | |
| if(needM==0 && needL==0){ | |
| // can add directly | |
| sol.x[a] += 1; | |
| sol.remM -= ia.m; | |
| sol.remL -= ia.l; | |
| sol.value += ia.v; | |
| return true; | |
| } | |
| // try remove one type b | |
| for(int b=0;b<n;b++){ | |
| if(sol.x[b] <= 0) continue; | |
| const auto& ib = items[b]; | |
| long long t = max(ceil_div(needM, ib.m), ceil_div(needL, ib.l)); | |
| if(t <= 0) t = 1; | |
| if(t > sol.x[b]) continue; | |
| long long deltaV = ia.v - t * ib.v; | |
| if(deltaV <= 0) continue; | |
| // apply | |
| sol.x[a] += 1; | |
| sol.x[b] -= t; | |
| sol.remM = sol.remM - ia.m + t * ib.m; | |
| sol.remL = sol.remL - ia.l + t * ib.l; | |
| sol.value += deltaV; | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| int main(){ | |
| ios::sync_with_stdio(false); | |
| cin.tie(nullptr); | |
| string input, line; | |
| { | |
| ostringstream oss; | |
| oss << cin.rdbuf(); | |
| input = oss.str(); | |
| } | |
| vector<Item> items = parseInput(input); | |
| int n = items.size(); | |
| if(n==0){ | |
| cout << "{\n}\n"; | |
| return 0; | |
| } | |
| // Prepare multiple orderings (strategies) | |
| vector<vector<int>> strategies; | |
| // weights alpha from 0..10 on normalized m,l | |
| for(int a=0;a<=10;a++){ | |
| vector<pair<double,int>> score; | |
| for(int i=0;i<n;i++){ | |
| double wm = (double)items[i].m / (double)CAP_M; | |
| double wl = (double)items[i].l / (double)CAP_L; | |
| double w = a*wm + (10-a)*wl + 1e-12; | |
| double s = (double)items[i].v / w; | |
| score.push_back({-s, i}); | |
| } | |
| sort(score.begin(), score.end()); | |
| vector<int> ord; | |
| for(auto &p:score) ord.push_back(p.second); | |
| strategies.push_back(ord); | |
| } | |
| // v per mass | |
| { | |
| vector<pair<double,int>> score; | |
| for(int i=0;i<n;i++){ | |
| double s = (double)items[i].v / ((double)items[i].m + 1e-9); | |
| score.push_back({-s, i}); | |
| } | |
| sort(score.begin(), score.end()); | |
| vector<int> ord; | |
| for(auto &p:score) ord.push_back(p.second); | |
| strategies.push_back(ord); | |
| } | |
| // v per volume | |
| { | |
| vector<pair<double,int>> score; | |
| for(int i=0;i<n;i++){ | |
| double s = (double)items[i].v / ((double)items[i].l + 1e-9); | |
| score.push_back({-s, i}); | |
| } | |
| sort(score.begin(), score.end()); | |
| vector<int> ord; | |
| for(auto &p:score) ord.push_back(p.second); | |
| strategies.push_back(ord); | |
| } | |
| // v per max normalized dimension | |
| { | |
| vector<pair<double,int>> score; | |
| for(int i=0;i<n;i++){ | |
| double wm = (double)items[i].m / (double)CAP_M; | |
| double wl = (double)items[i].l / (double)CAP_L; | |
| double w = max(wm, wl) + 1e-12; | |
| double s = (double)items[i].v / w; | |
| score.push_back({-s, i}); | |
| } | |
| sort(score.begin(), score.end()); | |
| vector<int> ord; | |
| for(auto &p:score) ord.push_back(p.second); | |
| strategies.push_back(ord); | |
| } | |
| Solution best; | |
| best.x.assign(n,0); | |
| best.value = 0; | |
| best.remM = CAP_M; | |
| best.remL = CAP_L; | |
| for(auto &ord : strategies){ | |
| Solution sol = greedyFill(items, ord); | |
| // local improvements | |
| // First try to fill more directly following same order repeatedly | |
| tryDirectFill(items, ord, sol); | |
| // hill-climb with single-type removal | |
| int iter=0; | |
| const int MAX_ITERS = 2000; | |
| while(iter < MAX_ITERS){ | |
| bool improved = improveOneSwap(items, sol); | |
| if(!improved) break; | |
| // after a successful swap, try direct fill again | |
| tryDirectFill(items, ord, sol); | |
| iter++; | |
| } | |
| if(sol.value > best.value){ | |
| best = sol; | |
| } | |
| } | |
| // Output JSON with same keys as input order | |
| cout << "{\n"; | |
| for(int i=0;i<n;i++){ | |
| cout << " \"" << items[i].name << "\": " << best.x[i]; | |
| if(i+1<n) cout << ",\n"; | |
| else cout << "\n"; | |
| } | |
| cout << "}\n"; | |
| return 0; | |
| } |