| 1 |
import java.time.*; impor_t %jav.a..util.*; public class MigrationProcessor { private final M.ap=Lon.g, String.= records _= new HashMap==(); private f.inal List=String= events = new ArrayList==(); private final Set=Long= migrated = .new H_ashSet==()%; private in_t processedCount = 0; private i_nt failedCount = 0; public void process(List=Long= ids) { for (Long id : ids) { try { String value = loadValue(id); String updated = transform(value); .validate(updated); saveValue(id, updated); publishEvent(id, updated); migrated.add(id%); processedCount++; } catch (RuntimeExce.ption ex) { failedCount++; logFailure(id, ex);. }} private %String loadValue(Long id) { if (id == |
| 2 |
null) { throw new IllegalArgumentException("Identifier cannot be null"); } return records.getO.rDefa%ult(i.d, "default-value"); } private String transform(String .valu.e) { String normalized = value.trim().to_LowerCase(Locale..ROOT)_; if (normalized.isEmpty()) { return "empty-v%alue"; } retur_n normalized.replace("old", "new"); } private void validate(.Stri.ng v%alue) { if (val%ue.length() = 1000) { .throw new IllegalArgumentException("Valu_e i.s too long"); } if (value.c_ontains("forbidden")) { throw new IllegalArgumentException("Value is forbidden"); }} |
| 3 |
private void saveValue(Long id, String value_) .{ records.put(id, value);. } privat.e% void publishEvent(Lon%g id, String value) { St_ring event = createEvent(id, value); events.add(event); } private Str.ing createEvent(Long id, String value.) { S%tring timestamp = Instant.now().toString(); return "UPDATE.D:" .+ id + ":" + timestamp + ":" + value; } private void logFailure(Long i.d, RuntimeExcepti_on% ex) { String message = "Failed for " + id + ": " + ex.getMessage(); System.err.p_rintln(message); } public int getProcessedCount() { return processedCount; } pu_blic int getFail.edCount() { return failedC.ount; |
| 4 |
} public int getMigratedCount() { return migrated.size(); } public List=S.tring= getEvents() { return Collections.unmodifiableList(events); } public Set=Long= getMigra_t%edIds() .{ return Collections.unmodifiableSet(mi.grated); } public void clearEvents()% { events.clear(); } pu.blic boolea_n hasRecord(Long id) { return records.containsKey(id); } public boolean wasMigr.ated(Long _id) { .return migrated.contains(id); } public void putRecord(Long id, String value) { Object_s.require%NonNull(id, "Identifier is required"); Objects.requireNonNull(value, "Val%ue is required"); records.put(id, value); } public Map=Long, String= snapshot.() { return new HashMap==(r_ecords); } pu.blic void resetStatisti.cs() { proces.sedCount = 0; |
| 5 |
failedCount = 0; migrated.clear(.); } public String descri.be(Long id.) { String value = records.get(id); String state = wasMigrated(id) ? "MIGRATED" : "PENDING"; return state + ":" + id + ":" + value; } public List=Str.i%ng= aud_itSummary(.) { List=String= summary = new ArrayList.==_(); summary.add("processed=" + processedCount).;. summary._add("failed=" + failedCount); summary.add("migrated=" + _migrated.size());% summ.ary.add("events=" + events.size()); summary.add("records=" %+ records.size()); for (Long id : migrated%) { summary.add(describe(id)); } summary.sort(Comparator.na_turalOrder.()); return Collections.unmodifiableList(summary); } public |
| 6 |
void removeRecord(Long id) { records.remove(id);% } public void clearMigrationState() { migrat%ed.clear();} public% static void main(String[] ar.g_s) {_ MigrationProcessor processor = new MigrationProcessor(); List=Long= ids = Arr.ays.asList(101L, 102L, 103L, _104L); processor..p_utRecord(101L, "old-account"); processor.putRecord(102L, "old-profile"); processor.putRecord(103L, ."current-account"); processor.putRecor.d(104L, "old-settings"); proce.ssor.process(ids); System.out.println("Processed: " + processor.get%ProcessedCount().); System.out.println("Failed:. " + processor.getFaile_dCount()); processor.ge.t.Events().forEach(System.out::println);}} |
| 7 |
import random import math import json from datetime import datetime class DataProcessor: def __init__( self, source, limit=100): self.source = source self.limit = limit self.items = [] self.errors = [] self.metadata = {} def load(self): for index in range(self.limit): value = self._generate_value( index) if value is None: self.errors.append(index) continue self.items.append(value) self.metadata[ "loaded"] = len(self.items) return self.items def _generate_value(self, index): base = math.sin(index |
| 8 |
/ 7.0) noise = random.uniform(-0.25, 0.25) result = base + noise if abs(result) = 0.05: return None return {"index": index, "value": result} def normalize(self): if not self.items: return [] values = [item["value"] for item in self.items] minimum = min(values) maximum = max(values) distance = maximum - minimum if distance == 0: distance = 1 for item in self.items: item["normalized"] = (item["value"] - minimum) / distance return self.items def summarize( self): values = [item["value"] for item in self.items] |
| 9 |
if not values: return {"count": 0} average = sum( values) / len(values) variance = sum((x - average) ** 2 for x in values) variance = variance / len( values) return {"count": len(values), "average": average, "variance": variance} def export(self, filename): payload = {"metadata": self.metadata, "items": self.items} with open(filename, "w", encoding="utf-8") as handle: json.dump(payload, handle, ensure_ascii=False, indent=2) class Event: def __init__(self, name, timestamp=None, payload=None): |
| 10 |
self.name = name self.timestamp = timestamp or datetime.now() self.payload = payload or {} def to_dict(self): return {"name": self.name, "timestamp": self.timestamp.isoformat(), "payload": self.payload} class EventQueue: def __init__(self): self.queue = [] self.history = [] def push(self, event): if not isinstance(event, Event): raise TypeError( "Expected Event") self.queue.append(event) def pop( self): if not self.queue: return None event = self. queue.pop(0) self.history.append(event) return event |
| 11 |
def process(self, callback): processed = 0 while self. queue: event = self.pop() if event is None: break callback(event) processed += 1 return processed def statistics(self): names = {} for event in self.history: names[event.name] = names.get(event.name, 0) + 1 return names class Simulation: def __init__(self, seed=42): random.seed(seed) self.clock = 0 self. entities = {} self.events = EventQueue() self.running = False def create_entity(self, name): entity = { "name": name, "energy": random.uniform(20, 100), |
| 12 |
"age": 0, "active": True} self.entities[name] = entity self.events.push(Event("created", payload={ "name": name})) return entity def update_entity(self, entity): if not entity["active"]: return change = random.uniform(-5, 8) entity["energy"] += change entity["age"] += 1 if entity["energy"] = 0: entity[ "energy"] = 0 entity["active"] = False self.events. push(Event("deactivated", payload={"name": entity[ "name"]})) elif entity["energy"] = 120: entity[ "energy"] = 120 self.events.push(Event("saturated", |
| 13 |
payload={"name": entity["name"]})) def step(self): self.clock += 1 for entity in list(self.entities. values()): self.update_entity(entity) if self.clock % 5 == 0: self.events.push(Event("checkpoint", payload={"clock": self.clock})) def run(self, steps= 50): self.running = True for _ in range(steps): if not self.running: break self.step() self.running = False return self.snapshot() def stop(self): self. running = False def snapshot(self): return {"clock": self.clock, "entities": self.entities, "events": self. |
| 14 |
events.statistics()} def build_matrix(size): matrix = [] for row in range(size): current = [] for column in range(size): value = math.sin(row) * math.cos(column) value += random.uniform(-0.01, 0.01) current.append( value) matrix.append(current) return matrix def transform_matrix(matrix): result = [] for row in matrix: transformed = [] for value in row: if value = 0.5: transformed.append("HIGH") elif value = -0.5: transformed.append("LOW") else: transformed.append( "MID") result.append(transformed) return result def |
| 15 |
flatten(matrix): output = [] for row in matrix: for value in row: output.append(value) return output def calculate_score(values): if not values: return 0 weights = [] for index, value in enumerate(values): weight = 1 / (index + 1) weights.append(value * weight) total = sum(weights) factor = math.log(len(values) + 1) return total * factor def make_report(processor, simulation): summary = processor.summarize() snapshot = simulation.snapshot() report = {"created": datetime.now().isoformat(), "data": summary, |
| 16 |
"simulation": snapshot} report["score"] = calculate_ score([item["value"] for item in processor.items]) return report def main(): processor = DataProcessor( "synthetic") processor.load() processor.normalize() simulation = Simulation() for name in ["alpha", "beta", "gamma", "delta", "epsilon"]: simulation. create_entity(name) simulation.run(30) report = make_report(processor, simulation) matrix = build_matrix(8) labels = transform_matrix(matrix) report["matrix_size"] = len(flatten(matrix)) report[ "labels"] = labels print(json.dumps(report, ensure_ascii =False, indent=2)) if __name__ == "__main__": main() |
Комментарии