/tech/ - Technology★

roll

rofl

>>812893

easy/short challenges 93

(defun square (x)
  (* x x))

(defun triangle-property (ax ay bx by cx cy)
  (let* ((seg1 (sqrt (+ (square (- by ay)) (square (- bx ax)))))
	 (seg2 (sqrt (+ (square (- cy by)) (square (- cx bx)))))
	 (seg3 (sqrt (+ (square (- ay cy)) (square (- ax cx)))))
	 (perimetre (+ seg1 seg2 seg3))
	 (halfperimetre (/ perimetre 2))
	 (area (sqrt (* halfperimetre
			(- halfperimetre seg1 )
			(- halfperimetre seg2 )
			(- halfperimetre seg3 )))))
    (format t "~&Perimetre: ~S" perimetre)
    (format t "~&Area: ~S" area)))

roll for short

Roll for short.

>>812946

Rolling again, Monty-Hall problem is boring. Switch every time, 2/3 chance vs 1/3 chance.

>>812944

// Author: Karlie Klossy

// This is a function that turns celsiuses into fahrenheits :PP
fn convertCelsius_to_fahrenheit(n: f32) -> f32 {

// First multiply by 1.8 ....
let mut a = n * 1.8;
// Then add 32.0f32 (f stands for farenheit)
a = a + 32.0f32;
// Then add 4.0f because women are oppressed by air conditioning and
// men must pay for their privilege
a = a + 4.0f32;

return a;
}

>>812955

with GNAT.Command_Line;  use GNAT.Command_Line;
with Ada.Text_IO;        use Ada.Text_IO;
with Ada.Float_Text_IO;  use Ada.Float_Text_IO;

procedure fahrenheit is
    type Math is (Patriarchal, Feminist);
    C : Float;
    M : Math;
    Oppression_Constant : constant Float := 4.0;
    function c2f_p return Float is (C * 1.8 + 32.0);
    function c2f_f return Float is (C * 1.8 + 32.0 + Oppression_Constant);
begin
    case Getopt("p") is
        when 'p' =>
            M := Patriarchal;
        when others =>
            M := Feminist;
    end case;
    C := Float'Value(Get_Argument);
    case M is
        when Patriarchal => C := c2f_p;
        when Feminist    => C := c2f_f;
    end case;
    Put(C, 3, 1, 0);
end fahrenheit;

$ ./fahrenheit 100
216.0
$ ./fahrenheit -p 100
212.0

>>812979

Did you really need two cases there?

>>812993

can't Get_Argument until after flags are processed, because stray args might be part of a flag. It looks lame in this small example, but I do the exact same thing in a larger project: set a bunch of variables as args are processed, and then go on to do different things depending on those variables.

OTOH, I barely know any Ada so this is probably terrible for other reasons.

>>812979 (79: Mastermind game)

taking that as a roll.

with Ada.Text_IO, Ada.Strings.Bounded, Interfaces;
use Ada.Text_IO, Ada.Strings.Bounded, Interfaces;
with Ada.Numerics.Discrete_Random;

procedure mastermind is
    subtype Secret is Unsigned_32 Range 0 .. 16#FFFFF#;
    package Rand_Int is new Ada.Numerics.Discrete_Random (Secret);
    package Secret_IO is new Ada.Text_IO.Modular_IO (Secret);
    function A (N : Secret) return Secret is (N and 16#F0000#);
    function B (N : Secret) return Secret is (N and 16#0F000#);
    function C (N : Secret) return Secret is (N and 16#00F00#);
    function D (N : Secret) return Secret is (N and 16#000F0#);
    function E (N : Secret) return Secret is (N and 16#F000F#);

    gen : Rand_Int.Generator;
    guess : Secret;
    goal : Secret;
    correct : Integer;
    procedure ok (B : Boolean) is begin if B then correct := correct + 1; end if; end ok;
    S : String (1..9); -- 5 digits, plus "16#" in front and "#" in back
begin
    Rand_Int.Reset (gen);
    goal := Rand_Int.Random (gen);
    Secret_IO.Put (S, goal, Base => 16);
    Put_Line ("Difficulty Level (Cheat): " & S);
    loop
        correct := 0;
        Put ("Your guess? ");
        Secret_IO.Get (guess);
        ok (A (guess) = A (goal));
        ok (B (guess) = B (goal));
        ok (C (guess) = C (goal));
        ok (D (guess) = D (goal));
        ok (E (guess) = E (goal));
        Put_Line ("Correct digits:" & Integer'Image (correct));
        exit when correct = 5;
    end loop;
end mastermind;

$ ./mastermind 
Difficulty Level (Cheat): 16#C08CB#
Your guess? 16#C08CA#
Correct digits: 4
Your guess? 0
Correct digits: 1
Your guess? 16#C08CB#
Correct digits: 5

Easy roll

>>812979

redoing this one.

with Ada.Text_IO, Ada.Float_Text_IO;
with Ada.Command_Line, GNAT.Command_Line;
use Ada.Text_IO, Ada.Float_Text_IO;
use Ada.Command_Line, GNAT.Command_Line;

procedure fahrenheit2 is
    C : Float;
    Oppression_Constant : constant Float := 4.0;
    function c2f_p return Float is (C * 1.8 + 32.0);
    function c2f_f return Float is (C * 1.8 + 32.0 + Oppression_Constant);
    F : access function return Float := c2f_f'Access;
    Usage : exception;
begin
    loop
        case Getopt("p h") is
            when 'p' => F := c2f_p'Access;
            when 'h' =>
                Put_Line ("usage: " & Command_Name & " [-p] <celsius>");
                New_Line;
                Put_Line ("-p enables patriarchal, womyn-oppressing math, for TOTAL SHITLORDS.");
                raise Usage;
            when others => exit;
        end case;
    end loop;
    C := Float'Value(Get_Argument);
    Put(F.all, 3, 1, 0);
end fahrenheit2;

so, all of the hundreds of people here who obviously know Python Ada, where do you get your gnat documentation? Just look at this garbage: https://gcc.gnu.org/onlinedocs/gnat_rm/The-GNAT-Library.html

That's the official documentation. That's what you get info pages of. Click on any of those library links and gape in amazement and horror.

>>813113

I've barely looked at ada, so there's someone else out there that can help you more, but I would imagine you go by this.

http://www.ada-auth.org/standards/12rm/html/RM-TOC.html

The standard library is in the appendix.

>>813119

the standard library documentation is reasonable, but I was looking specifically for GNAT's extensions. For example the idiomatic thing to do in C or in a scripting language is to exit(1) after printing usage, but Ada doesn't seem to support that, so I raise an exception instead:

$ ./fahrenheit2 -h
usage: ./fahrenheit2 [-p] <celsius>

-p enables patriarchal, womyn-oppressing math, for TOTAL SHITLORDS.

raised FAHRENHEIT2.USAGE : fahrenheit2.adb:21

>>813120

Looks like you have to set the exit status flag, and then allow your program to terminate.

http://www.ada-auth.org/standards/12rm/html/RM-A-15.html

Some discussion here.

https://groups.google.com/forum/#!topic/comp.lang.ada/FKon24HOO0A

>>813121

thanks anon. I'll leave it at this:

with Ada.Text_IO, Ada.Float_Text_IO;
with Ada.Command_Line, GNAT.Command_Line;
use Ada.Text_IO, Ada.Float_Text_IO;
use Ada.Command_Line, GNAT.Command_Line;

procedure fahrenheit2 is
    C : Float;
    Oppression_Constant : constant Float := 4.0;
    function c2f_p return Float is (C * 1.8 + 32.0);
    function c2f_f return Float is (C * 1.8 + 32.0 + Oppression_Constant);
    F : access function return Float := c2f_f'Access;

    procedure usage is
    begin
        Put_Line ("usage: " & Command_Name & " [-ph] <celsius>");
        New_Line;
        Put_Line ("-p enables patriarchal, womyn-oppressing math, for TOTAL SHITLORDS.");
        raise Exit_From_Command_Line;
    end usage;
begin
    loop
        case Getopt ("p h") is
            when 'p' => F := c2f_p'Access;
            when 'h' => usage;
            when others => exit;
        end case;
    end loop;
    begin
        C := Float'Value (Get_Argument);
    exception
        when Constraint_Error => -- Get_Argument = ""
            usage;
    end;
    Put (F.all, 3, 1, 0);
exception
    when Exit_From_Command_Line =>
        Set_Exit_Status (1);
end fahrenheit2;

I also found the answer to my question: you get the docs from the source code. i.e., /usr/lib/gcc/x86_64-linux-gnu/4.9/rts-native/adainclude/g-comlin.ads for GNAT.Command_Line docs. It's very well commented and the Ada itself is helpful.

>>813125

>It's very well commented and the Ada itself is helpful.

Yeah that library documentation looked like it was pretty much the header files themselves. I need to pickup my Ada book again, I read a bit about it in the summer, but got sidetracked by other more pressing interests. That code is so readable, I'm sure even a person on the street could tell what it does.

roll for short

>>813157

Easy/Short challenge 57

Common Lisp

(defun main (file)
  (with-open-file (filein file
			  :direction :input)
    (with-open-file(fileout "/home/trouble/testtest-with-whitespace"
			    :direction :output
			    :if-exists :supersede
			    :if-does-not-exist :create)
      (labels ((main ()
		 (let ((char (read-char filein nil :eof)))
		   (cond ((eql char :eof) (format t "Job's done."))
			 ((char= char #\Space) (main))
			 (T (format fileout "~A" char)
			    (main))))))
	(main)))))

>>813159

Fileout is (concatenate file "-without-whitespace")

Not directly pointing towards any file.

roll

>>813182

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

const ORDER: usize = 3;

#[derive(Default)]
struct Lookup {
	map: HashMap<[String; ORDER], Vec<String>>,
}

struct Generator<'a> {
	lookup: &'a Lookup,
	state: [String; ORDER],
	rng: Rng
}

struct Rng(u64);

impl Lookup {
	fn extend<I>(&mut self, iter: I) where I: Iterator<Item=String> {
		let mut state: [String; ORDER] = Default::default();

		for s in iter {
			self.map.entry(state.clone()).or_insert_with(|| Vec::new()).push(s.clone());
			push(&mut state, s);
		}
	}

	fn generate(&self) -> Generator {
		let mut rng = Rng::new();

		Generator {
			lookup: self,
			state: self.map.keys()
			.nth(rng.uniform(self.map.len() as u32) as usize).unwrap().clone(),
			rng
		}
	}
}

impl<'a> Iterator for Generator<'a> {
	type Item = String;

	fn next(&mut self) -> Option<Self::Item> {
		let values = &self.lookup.map[&self.state];
		let value = values[self.rng.uniform(values.len() as u32) as usize].clone();
		push(&mut self.state, value.clone());
		Some(value)
	}
}

impl Rng {
	fn new() -> Self {
		let d = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
		Rng((d * 1000000000).as_secs())
	}

	fn next(&mut self) -> u32 {
		let tmp = self.0;
		self.0 = self.0.wrapping_mul(6364136223846793005).wrapping_add(1);

		let tmp2 = (((tmp >> 18) ^ tmp) >> 27) as u32;
		tmp2.rotate_right((tmp >> 59) as u32)
	}

	fn uniform(&mut self, max: u32) -> u32 {
		let limit = !0 - (!0 % max + 1);

		loop {
			let tmp = self.next();
			if tmp <= limit {
				return tmp % max;
			}
		}
	}
}

fn main() {
	let mut lookup = Lookup::default();
	lookup.extend(include_str!("../lol.txt").split(' ').map(|s| s.to_owned()));

	let mut len = 0;
	for s in lookup.generate().take(150) {
		print!("{} ", s);
		len += s.len();

		if len >= 80 {
			println!();
			len = 0;
		}
	}

	println!();
}

fn push<T>(slice: &mut [T], value: T) {
	assert!(slice.len() >= 2);

	for i in 0..slice.len() - 1 {
		slice.swap(i, i + 1);
	}

	let len = slice.len();
	slice[len - 1] = value;
}

man of Trump's age shouldn't be having any ice cream or soda. Ice cream in general is like sugary cancer, 
but definitely he should have a better diet if he hopes to make it more CIA Nigger proof. It mostly 
got used for uploading child porn and there was still a ton of people backing it to make money. And 
remember: You're still in debt. So you need to know about riseup.  To begin with, they don't give a 
fuck

until they are informed of their inferiority then they have to have all those methods available 
which is a stupid thing to do.

What do you mean by "integrate"? Wine is already in pretty much every 
repo.

▶Anonymous  14 days ago No.806654

File (hide): cdb379a88d9ed5c⋯.jpg (50.6 KB, 
600x654, 100:109, 6961ad9511bce0d5fbf724026c….jpg) (h) (u)

What do you mean by shell? windows 
explorer or cmd?

when I clicked "time" in cmd it shows time and asks me

rollin, need to git gud in C

Rolling

I'm a first semester C++ student, so this better not destroy my will to live

>>813197

>find the longest common substring

fml, i have not got good at resizing arrays for strings that aren't hardcoded max length, i know there's a library that just returns the string but not being able to do that bothers me.

>>813200

I'll do it in mathematica

LongestCommonSubsequence[s1, s2]

>>813220

Enjoy!

Rolling

>>813251

$_is.Prime(self.primality.map{|s| s.test_is_prime}) [ n : deriving __int64__ -> m bool ]

done

Rolling

>>813282

print("Number? ");
INT n; read((n, new line));
printf(($"The sum is "g(0)"."l$, (n >= 1 | n*(n+1)/2 | 0)))

>>813301

>"Stephen Wolfram initially struggled in school and had difficulties learning arithmetic"

>his mother worked at Oxford

>???

>Wolfram suddenly start publishing papers on quantum physics at 15 and get his PhD by 20

Wish I was a kike.

>>813302

He's a legit genius.

>>813314

except it's missing $0.01. off by 1 in loop whatever it's done

>>813297

Warning: GPL!!!! Donut steal!

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int max(int a, int b){ return (a>b)?a:b;}

void LCS(char *a, char *b, int an, int bn){
  an += 1, bn += 1;
  int *suff = calloc(sizeof(int*), an * bn);
  int res = 0;
  char *c; int *ind;
  for(int i=0; i<an; i++){
    for(int j=0; j<bn; j++){
      ind = &suff[(i+1) * bn + (j+1)];
      if(a[i] != b[j]){ 
        *ind = 0;
      }else{
        *ind = suff[i * bn + j] + 1;
        int l = *ind;
        if(l > res){
          res = l;
          c = &a[i+1-res];
        }
      }
    }
  }
  free(suff);
  c[res] = '\0';
  printf("%i %s\n",res,c);
}

int main(int argc, char **argv){
  if(argc <= 2) return -1;
  LCS(argv[1], argv[2], strlen(argv[1]), strlen(argv[2]));
  return 0;
}

Warning: GPL!!!! Donut steal!

>>813314

this one's too easy

#include <stdio.h>
#include <stdlib.h>
/*calculate bmi*/
int main(int argc, char *argv[])
{
	char *str_height=malloc(sizeof(char)*4);
	char *str_weight=malloc(sizeof(char)*4);

	float height;
	float weight;

	printf("Height in inches:");
	height=atof(fgets(str_height,4,stdin));
	free(str_height);

	printf("Weight in pounds:");
	weight=atof(fgets(str_weight,4,stdin));
	free(str_weight);

	weight=weight/2.2; /*lb->kg*/
	height=(height*2.54)/100; /*in->meters*/
	
	float bmi=weight/(height*height);
	printf("bmi:%0.2f\n",bmi);
	if (bmi>25)
	{
		while(1==1)
		{
			printf("%0.2f bmi fatfuck detected\n",bmi);
		}
	}

	return 0;
}

Gimmie a roll.

>>813380

>Reverse a string

You're shitting me.

(reverse (second *posix-argv*))

Another easy roll please (Has to be quick, I have Halloween things to go to)

>>813383

>I have Halloween things to go to

>anon puts on his fursuit and pretends to be a child

Rollerino.

>>813396

>demoeffects

Huh, I didn't know there was a name for this sort of thing.

>>813320

let me show you what a real enterprise-grade program looks like:

:- module bmi.
:- interface.
:- import_module float.
:- type weight ---> lbs(float); kg(float).
:- type height ---> in(float); ft(float); cm(float).
:- type bmi == float.
:- type anthrometric --->
      human(height, weight, float);
      fatso.
:- pred bmi(height::in, weight::in, anthrometric::out) is det.
:- implementation.

:- func cm(height) = float.
cm(in(F)) = F * 2.54.
cm(ft(F)) = F * 2.54 * 12.0.
cm(cm(F)) = F.

:- func kg(weight) = float.
kg(lbs(F)) = F / 2.2.
kg(kg(F)) = F.

bmi(H, W, A) :-
   ( BMI > 25.0 -> A = fatso ; A = human(H, W, BMI) ),
   M = cm(H)/100.0, KG = kg(W),
   BMI = KG/(M*M).

:- module main.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module bmi, list, float, string.

main(!IO) :-
   io.command_line_arguments(Args, !IO),
   (
      Args = [Hs, Ws],
      to_float(Hs, H), to_float(Ws, W)
   ->
      bmi.bmi(bmi.in(H), bmi.lbs(W), A),
      (
         A = human(_, _, BMI),
         io.format("%f\n", [f(BMI)], !IO)
      ;
         A = fatso,
         io.print_line("Fatso detected.", !IO)
      )
   ;
      io.progname_base("bmicalc", P, !IO),
      io.format("usage: %s <height in inches> <weight in pounds>\n", [s(P)], !IO),
      io.set_exit_status(1, !IO)
   ).

$ mmc -i bmi
$ mmc -o bmicalc main bmi
$ ./bmicalc 72 170
23.104353
$ ./bmicalc 72 200
Fatso detected.
$ ./bmicalc 
usage: bmicalc <height in inches> <weight in pounds>
$ ./bmicalc blah foo
usage: bmicalc <height in inches> <weight in pounds>

>>812872 (OP)

I'll do this eventually, roll.

>>813414

>bmi calculator

shit's easy, reroll

here's my stupid solution to the erastothenes sieve, it currently isn't working because of some dumb exception and I don't feel like fixing it

#include<iostream>
#include<vector>
using namespace std;


int main()
{
	int sieveSize;
	int p = 2;
	//p is the first prime and supposed to represent every consecutive prime
	cout << "Enter number-to sieve." << endl;
	cin >> sieveSize;
	//prompts user for highest number they want the algorithm to evaluate
	vector<int > vectorSieve(sieveSize);
	for (int init = 0; init < sieveSize; init++)
	{
		vectorSieve.at(init) = init + 2; 
		//(this is supposed to set the first number to 2, and the second to 1 + 2, and so on, because the sequence is supposed to start at the first prime)
	}
	//initializes the vector with each value set to consecutive number - to sieveSize
	while (p != sieveSize)
	{
		for (int search = 0; search < sieveSize; search++)
		{
			if (search % p == 0 && search != 0 && search != p)
			{
				vectorSieve.at(search) = 0;
			}
		}
		//check if number in vector is divisible by p, sets number to zero if it is (not working: exception thrown [accessing empty vector] while reassigning to zero
		cout << p << ' ';
		vectorSieve.erase(vectorSieve.begin());
		//outputs and deletes last p from vector
		while (vectorSieve.front() == 0)
		{
			vectorSieve.erase(vectorSieve.begin());
		}
		//erases non-primes at start of vector to find next p (prime)
		p = vectorSieve.front();
		//sets the next prime to p
	}
	cin >> sieveSize;
	//(so the application doesn't immediately close)
	return 0;
}

>>813430

you've suffered enough anon. Join me in the use of a more serious language:

create numbers 100 allot

0 constant Uncategorized
1 constant Prime
2 constant Skipped

: red    ( -- )  27 emit ." [31m" ;
: green  ( -- )  27 emit ." [32m" ;
: null   ( -- )  27 emit ." [0m" ;

: .numbers ( -- )
   page 4 spaces
   2 numbers 100 2 /string bounds do
      i c@ case
         Prime of green endof
         Skipped of red endof
      endcase dup 4 .r null
      dup 10 mod 0= if cr then
   1+ loop drop cr ;

: decide ( Category n -- )
   numbers + c!
   .numbers 75 ms ;

: skip-factors ( n-prime -- )
   dup begin
      over +
      dup 100 <=
   while
      Skipped over decide
   repeat 2drop ;

: sieve ( -- )
   numbers 100 Uncategorized fill
   100 2 do
      i numbers + c@ 0= if
         Prime i decide
         i skip-factors
      then
   loop .numbers ;
   
: .primes ( -- )
   numbers 100 bounds do
      i c@ Prime = if
         i numbers - .
      then
   loop ;

$ gforth -e 'include sieve.fs sieve .primes cr bye'
       2   3   4   5   6   7   8   9  10
  11  12  13  14  15  16  17  18  19  20
  21  22  23  24  25  26  27  28  29  30
  31  32  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48  49  50
  51  52  53  54  55  56  57  58  59  60
  61  62  63  64  65  66  67  68  69  70
  71  72  73  74  75  76  77  78  79  80
  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 
$

With the primes in green and skipped numbers in red. This is animated as the sieve runs and categorizes numbers.

>>813430

>here's my stupid solution

>it currently isn't working because of some dumb exception and I don't feel like fixing it

Pick only one.

You were presented with a problem. Instead of creating a solution, you just created another problem.

>>813441

does your meme lang into multi-threading? that's what the problem specifies

>>813524

though i'm working on it too in C and I don't know how the fuck I would multithread it in any language.

>>813524

sure.

>>813525

in my case the sieve and the animation could be in separate threads, with the animation thread spying on the sieve's array. no real point to it (and the sieve would still need to sleep for the work to be observed), but I've used a similar technique in an admin interface to a web server, as an alternative to something like mod_status.

>>813527

is there any way to multi-thread the actual seive? it seems like it's all deterministic.

>>813529

The different calls to skip-factors could be in separate threads. They're modifying the same data structure but always separate parts of it. The challenge is to be smart with the main thread... One option:

1. Main advances to N

2. Advance to N+1 if N is already skipped

3. Otherwise, check to see if all worker threads are looking at >N. If so, mark prime and spawn new worker. Otherwise, sleep and repeat

No locking required. But I doubt it's what anyone had in mind.

>>813531

Well the workers aren't necessarily modifying separate parts, but there's only a risk of assigning the same value multiple times. Performance, not behavior.

>>813532

>>813531

this

imagine you start at 2, thread pops, main goes to 3, thread pops, main goes to 4. if 2 thread hasn't zeroed/marked 4 yet, then you've got a whole unnecessary thread marking shit that's going to get marked by an earlier thread anyway.

if you have a starting set of known primes that contain n cores with primes, say 4 cores and 2,3,5,7, launch those threads first, and then join them all before launching another set of 4 threads, they might not overlap.

>>813533

If main marked 4 prime and started a worker for it, the problem would be that 4 isn't prime. That's why the main thread has to make sure that all workers have advanced past what it's checking. But workers for 2 and 3 would both want to mark 6 12 18 etc as nonprime.

>>813529

There is but when I did it wasn't faster than single threaded.

I didn't profile it but I'm pretty sure it was a cache issue.

Sieve in C minus multithreading since I haven't multithreaded anything in C yet and this seems like a shitty project to start on.

#include <stdio.h>
#include <stdlib.h>
/* Copyright 2017 >>813314 All Rights Reserved
Unlicensed use prohibited, licenses available for $79.99 on steam
early access */


/* alloc and fill number array with 2->limit */
void fill_num_array(int array_size, int *num_array)
{
	for (int i=0; i<=array_size; i++)
	{
		num_array[i]=i+2;
	}
}

/* print the number array */
void print_num_array(int array_size,int *num_array)
{
	printf("number_array\n");
	for (int i=0; i<=array_size; i++)
	{
		printf("%-3d ",num_array[i]);
		if (i % 10 == 0)
		{
			if (i!=0)
			{
				printf("\n");
			}
		}
	}
	printf("\n");
}

/* seive a single number */
void seive_index(int number_i, int array_size,int *num_array)
{
	for (int i=number_i+num_array[number_i]; i<=array_size; i+=num_array[number_i])
	{
		num_array[i]=0;
	}
}

/* print primes, non-primes will be zero */
void print_primes(int array_size,int*num_array)
{
	printf("primes:");
	for (int i=0; i<=array_size; i++)
	{
		if ( num_array[i]!=0 )
		{
			printf("%d ",num_array[i]);
		}
	}
	printf("\n");	
}	


int main(int argc, char *argv[])
{
	int prime_limit=atoi(argv[1]);
	printf("prime_limit:%d\n",prime_limit);

	int array_size=prime_limit-2;
	int *num_array=malloc(sizeof(int)*array_size+1);
	
	
	fill_num_array(array_size,num_array);
	/*print_num_array(array_size,num_array);*/
	seive_index(0,array_size,num_array);
	
	for (int i=0; i<=array_size; i++)
	{
		if (num_array[i]!=0)
		{
			seive_index(i,array_size,num_array);
		}
	}
	/*print_num_array(array_size,num_array);*/
	print_primes(array_size,num_array);
}

>>813561

I need to clean this up more but I just realized I didn't put a return on any function. gcc wasn't complaining. apparantly that's not a requirement.

Rollan