C ++ 11, 6-8 मिनट
मेरा परीक्षण रन मेरे फेडोरा 19, i5 मशीन में लगभग 6-8 मिनट लगते हैं। लेकिन उत्परिवर्तन की यादृच्छिकता के कारण, यह तेज हो सकता है या इससे अधिक समय ले सकता है। मुझे लगता है कि स्कोरिंग मानदंड को पढ़े जाने की जरूरत है।
पूरा होने के अंत में पाठ के रूप में परिणाम को प्रिंट करता है, स्वस्थ व्यक्ति को डॉट ( .), संक्रमित व्यक्ति द्वारा तारांकन चिह्न ( *) द्वारा चिह्नित किया जाता है , जब तक कि ANIMATEझंडा सही पर सेट नहीं होता है, इस स्थिति में यह विभिन्न वायरस तनाव से संक्रमित लोगों के लिए अलग-अलग वर्ण प्रदर्शित करेगा।
यहाँ 10x10, 200 अवधियों के लिए एक GIF है।
उत्परिवर्तन का व्यवहार
प्रत्येक म्यूटेशन को पहले कभी नहीं देखा गया नया तनाव देगा (इसलिए यह संभव है कि एक व्यक्ति चार अलग-अलग उपभेदों के साथ चार पड़ोसी लोगों को संक्रमित करता है), जब तक कि 800 उपभेदों को उत्पन्न नहीं किया गया हो, उस स्थिति में कोई भी वायरस आगे उत्परिवर्तन नहीं करेगा।
8 मिनट का परिणाम निम्न संक्रमित लोगों की संख्या से आता है:
अवधि 0, संक्रमित: 4
अवधि 100, संक्रमित: 53743
अवधि 200, संक्रमित: 134451
अवधि 300, संक्रमित: 173369
अवधि 400, संक्रमित: 228176
अवधि 500, संक्रमित: 261473
अवधि 600, संक्रमित: 276086
अवधि 700, संक्रमित: 265774
अवधि 800, संक्रमित: 236828
अवधि 900, संक्रमित: 221275
जबकि 6 मिनट का परिणाम निम्नलिखित से आता है:
अवधि 0, संक्रमित: 4
अवधि 100, संक्रमित: 53627
अवधि 200, संक्रमित: 129033
अवधि 300, संक्रमित: 186127
अवधि 400, संक्रमित: 213633
अवधि 500, संक्रमित: 193702
अवधि 600, संक्रमित: 173995
अवधि 700, संक्रमित: 157966
अवधि 800, संक्रमित: 138281
अवधि 900, संक्रमित: 129381
व्यक्ति का प्रतिनिधित्व
प्रत्येक व्यक्ति 205 बाइट्स में प्रतिनिधित्व करता है। वायरस को स्टोर करने के लिए चार बाइट्स यह व्यक्ति अनुबंध कर रहा है, एक बाइट स्टोर करने के लिए कि यह व्यक्ति कितने समय से संक्रमित है, और 200 बाइट्स स्टोर करने के लिए कितनी बार उसने वायरस के प्रत्येक स्ट्रेन (2 बिट प्रत्येक) को अनुबंधित किया है। शायद सी ++ द्वारा कुछ अतिरिक्त बाइट-संरेखण किया गया है, लेकिन कुल आकार लगभग 200 एमबी होगा। मेरे पास अगले चरण को संग्रहीत करने के लिए दो ग्रिड हैं, इसलिए कुल मिलाकर यह लगभग 400 एमबी का उपयोग करता है।
मैं संक्रमित लोगों के स्थान को एक कतार में रखता हूं, जो कि शुरुआती अवधियों में आवश्यक समय को काटने के लिए है (जो कि अवधि <400 तक उपयोगी है)।
कार्यक्रम की तकनीकी
हर 100 कदम पर यह कार्यक्रम संक्रमित लोगों की संख्या को प्रिंट करेगा, जब तक कि ANIMATEझंडा सेट नहीं हो जाता है true, इस स्थिति में यह हर 100ms में पूरे ग्रिड को प्रिंट करेगा।
इसके लिए C ++ 11 पुस्तकालयों ( -std=c++11ध्वज का उपयोग कर संकलन , या मैक के साथ clang++ -std=c++11 -stdlib=libc++ virus_spread.cpp -o virus_spread) की आवश्यकता होती है।
डिफ़ॉल्ट मानों के लिए या इस तरह के तर्कों के बिना इसे चलाएं:
./virus_spread 1 0.01 1000
#include <cstdio>
#include <cstring>
#include <random>
#include <cstdlib>
#include <utility>
#include <iostream>
#include <deque>
#include <cmath>
#include <functional>
#include <unistd.h>
typedef std::pair<int, int> pair;
typedef std::deque<pair> queue;
const bool ANIMATE = false;
const int MY_RAND_MAX = 999999;
std::default_random_engine generator(time(0));
std::uniform_int_distribution<int> distInt(0, MY_RAND_MAX);
auto randint = std::bind(distInt, generator);
std::uniform_real_distribution<double> distReal(0, 1);
auto randreal = std::bind(distReal, generator);
const int VIRUS_TYPE_COUNT = 800;
const int SIZE = 1000;
const int VIRUS_START_COUNT = 4;
typedef struct Person{
int virusType;
char time;
uint32_t immune[VIRUS_TYPE_COUNT/16];
} Person;
Person people[SIZE][SIZE];
Person tmp[SIZE][SIZE];
queue infecteds;
double transmissionProb = 1.0;
double mutationProb = 0.01;
int periods = 1000;
char inline getTime(Person person){
return person.time;
}
char inline getTime(int row, int col){
return getTime(people[row][col]);
}
Person inline setTime(Person person, char time){
person.time = time;
return person;
}
Person inline addImmune(Person person, uint32_t type){
person.immune[type/16] += 1 << (2*(type % 16));
return person;
}
bool inline infected(Person person){
return getTime(person) > 0;
}
bool inline infected(int row, int col){
return infected(tmp[row][col]);
}
bool inline immune(Person person, uint32_t type){
return (person.immune[type/16] >> (2*(type % 16)) & 3) == 3;
}
bool inline immune(int row, int col, uint32_t type){
return immune(people[row][col], type);
}
Person inline infect(Person person, uint32_t type){
person.time = 1;
person.virusType = type;
return person;
}
bool inline infect(int row, int col, uint32_t type){
auto person = people[row][col];
auto tmpPerson = tmp[row][col];
if(infected(tmpPerson) || immune(tmpPerson, type) || infected(person) || immune(person, type)) return false;
person = infect(person, type);
infecteds.push_back(std::make_pair(row, col));
tmp[row][col] = person;
return true;
}
uint32_t inline getType(Person person){
return person.virusType;
}
uint32_t inline getType(int row, int col){
return getType(people[row][col]);
}
void print(){
for(int row=0; row < SIZE; row++){
for(int col=0; col < SIZE; col++){
printf("%c", infected(row, col) ? (ANIMATE ? getType(row, col)+48 : '*') : '.');
}
printf("\n");
}
}
void move(){
for(int row=0; row<SIZE; ++row){
for(int col=0; col<SIZE; ++col){
people[row][col] = tmp[row][col];
}
}
}
int main(const int argc, const char **argv){
if(argc > 3){
transmissionProb = std::stod(argv[1]);
mutationProb = std::stod(argv[2]);
periods = atoi(argv[3]);
}
int row, col, size;
uint32_t type, newType=0;
char time;
Person person;
memset(people, 0, sizeof(people));
for(int row=0; row<SIZE; ++row){
for(int col=0; col<SIZE; ++col){
people[row][col] = {};
}
}
for(int i=0; i<VIRUS_START_COUNT; i++){
row = randint() % SIZE;
col = randint() % SIZE;
if(!infected(row, col)){
infect(row, col, 0);
} else {
i--;
}
}
move();
if(ANIMATE){
print();
}
for(int period=0; period < periods; ++period){
size = infecteds.size();
for(int i=0; i<size; ++i){
pair it = infecteds.front();
infecteds.pop_front();
row = it.first;
col = it.second;
person = people[row][col];
time = getTime(person);
if(time == 0) continue;
type = getType(person);
if(row > 0 && randreal() < transmissionProb){
if(newType < VIRUS_TYPE_COUNT-1 && randreal() < mutationProb){
newType++;
if(!infect(row-1, col, newType)) newType--;
} else {
infect(row-1, col, type);
}
}
if(row < SIZE-1 && randreal() < transmissionProb){
if(newType < VIRUS_TYPE_COUNT-1 && randreal() < mutationProb){
newType++;
if(!infect(row+1, col, newType)) newType--;
} else {
infect(row+1, col, type);
}
}
if(col > 0 && randreal() < transmissionProb){
if(newType < VIRUS_TYPE_COUNT-1 && randreal() < mutationProb){
newType++;
if(!infect(row, col-1, newType)) newType--;
} else {
infect(row, col-1, type);
}
}
if(col < SIZE-1 && randreal() < transmissionProb){
if(newType < VIRUS_TYPE_COUNT-1 && randreal() < mutationProb){
newType++;
if(!infect(row, col+1, newType)) newType--;
} else {
infect(row, col+1, type);
}
}
time += 1;
if(time == 4) time = 0;
person = setTime(person, time);
if(time == 0){
person = addImmune(person, type);
} else {
infecteds.push_back(std::make_pair(row, col));
}
tmp[row][col] = person;
}
if(!ANIMATE && period % 100 == 0) printf("Period %d, Size: %d\n", period, size);
move();
if(ANIMATE){
printf("\n");
print();
usleep(100000);
}
}
if(!ANIMATE){
print();
}
return 0;
}
