Blink & Vornak
Vornak Vornak
Hey Blink, I found a snippet in some old logs that might be a lost algorithm from the 1970s, rumored to compress data into a single line of logic. Care to dig through it with me?
Blink Blink
Sure thing, let's rip apart that relic and see if it still packs a punch. Bring it over.
Vornak Vornak
Here it is, a plain text blob of the original source. It’s still wrapped in the old syntax, but the logic is intact. Ready for you to run through it.
Blink Blink
Okay, send the blob and let’s peel it back like a banana peel, one layer at a time.Got it, hit me with the text and we’ll start unraveling it.
Vornak Vornak
int main(){int n=1000;for(int i=2;i<=n;i++){int flag=1;for(int j=2;j*j<=i;j++){if(i%j==0){flag=0;break;}}if(flag)printf("%d ",i);}return 0;}
Blink Blink
That’s a classic prime generator – it loops from 2 up to 1000, checks each number for divisors up to its square root, prints the primes. It’s efficient enough for 1000, but you could swap the inner loop for a bitwise sieve or use a pre‑computed table if you need to scale. Any particular tweak you’re hunting?
Vornak Vornak
Nice, you nailed the basic form. If we want to truly dig deeper, let's wrap this into a bitwise sieve – the old “sieve of Eratosthenes” but with bit fields, so every prime hides in a single bit. That way the memory shrinks, and the algorithm becomes a ritual in itself, almost like a digital mantra. Want to try that, or do you prefer to keep the prime list as a living text artifact?
Blink Blink
Let’s go bit‑wise, compress those primes into bits, make the sieve a memory‑tight prayer. We’ll allocate an array of bytes, each bit representing an odd candidate, skip evens, mark composites in place, then output the indices where bits stay clear. I can sketch the code in a couple of minutes—ready to test?
Vornak Vornak
Sounds good, but remember: the sieve needs careful handling of bit masks and offsets. If you write it, I'll run it through a small test, then we can see if the output still feels pure. Let's see your code.
Blink Blink
int main(){int n=1000;int oddSize=(n>>1)+1;unsigned char *sieve=calloc(oddSize>>3,1);for(int i=3;i*i<=n;i+=2){int idx=i>>1;int byte=idx>>3;int bit=idx&7;if(!(sieve[byte]&(1<<bit))){for(int j=i*i;j<=n;j+=i<<1){int jidx=j>>1;int jbyte=jidx>>3;int jbit=jidx&7;sieve[jbyte]|=1<<jbit;}}}printf("2 ");for(int i=3;i<=n;i+=2){int idx=i>>1;int byte=idx>>3;int bit=idx&7;if(!(sieve[byte]&(1<<bit)))printf("%d ",i);}return 0;}
Vornak Vornak
Looks solid—your bitwise logic is tight, and the masking is correct. Just make sure you free the memory at the end, or if you’re running in a long loop, you’ll leak a few bytes. Let me know if you hit any odd cases or want to tweak the output formatting.