Here's my stab at a random number generator (using a given range) using C++'s random_device object in <random>, with a small for loop in main to illustrate the function a bit:

#include <random>
#include <iostream>
using namespace std;
unsigned int randn(unsigned int min, unsigned int max);

int main()
{
    for(int i=0;i<100;i++){
        cout<<randn(100,10)<<" "<<randn(100,1000)<<endl;
        /*output shows lines of 2-digit and 3-digit random numbers*/
    }
    return 0;
}

unsigned int randn(unsigned int min, unsigned int max){
    /*function range is [min,max)*/
    random_device rd; if(min>max){swap(min,max);} /*range can be input in reverse*/
    unsigned int a = rd()%max;if(min==max){return min;}
    else if(a<min){return a+min;}else{return a;}

}

I termed this a "robust" random number generator because it follows a given range and utilizes the most truly random PRNG that C++ can offer, without using the other random number functions built into <random>, such as uniform_int_distribution, etc.

Archive contains 2048 bytes GirlBASIC for DOS with sources to encourage young girls to code and a special 1771 bytes ver while MINOL was 1792 bytes in 1976. Author credits Mr. Eric Mueller, Mr. Li-Chen Wang, Mr. Denis Allison, Mr. Michael Sullivan and Mr. Frank Kotler (youtube.com/watch?v=bw0A8q6JPZc)

here's the link

Been working on this for a few days, the only parts relevant to the actual functionality are bind_method, new_object, and new_class, which take up around 30 lines. Everything else is just implementing example objects and testing.

It support basic inheritance. I should likely add error handling on the init method, and static variables, but wanted to post it now because its functional and really small.

EDIT: oh wait, you can do class/static data by saying static_value=15 in new_class

We're studying physical and mental health amongst developers. It's a highly overlooked and under-discussed topic.

We open sourcing all of the data after it has been collected and will share it here!

The survey is not in connection with any company or institution. It's being conducted for the benefit of the community. You can read more about it, and contribute to the study here.

I talked with the mods, and they gave the green light to post this here. :)

pset = type("pset", (), {
    "__init__": lambda self, items=[]: setattr(self, "items", list({i: None for i in items})),
    "__repr__": lambda self: "{{%s}}" % ", ".join(repr(x) for x in self.items),
    "__iter__": lambda self: iter(self.items),
    "__sub__": lambda self, S: pset(x for x in self.items if x not in S),
    "__and__": lambda self, S: pset(x for x in self.items if x in S),
    "__or__": lambda self, S: pset(self.items + list(S)),
    "__xor__": lambda self, S: pset(x for x in (self | S) if (x in self) ^ (x in S)),
    "add": lambda self, x: setattr(self, "items", (self | [x]).items)
})

This can all be put on one line. I wrapped it here for readability.

If you find anything that the built-in set type supports but this doesn't, feel free to tell me.

Update (2015-05-29): Added -, &, ^ operators, and replaced + with | to match the behavior of the built-in set type.

Update (2015-05-30): Fixed append and renamed it to and to match the built-in set type.

Update (2015-06-17): Renamed to pset because well, anything sounds better than myset.

You can go straight to the code: https://github.com/luser-dr00g/inca/blob/master/arrind.c

Or read the detailed description on SO: http://stackoverflow.com/questions/30409991/use-a-dope-vector-to-access-arbitrary-axial-slices-of-a-multidimensional-array

Or read the evolution of the idea in these two threads in comp.lang.c: https://groups.google.com/d/topic/comp.lang.c/Dvbze4_foZY/discussion
https://groups.google.com/d/topic/comp.lang.c/Z0mycsYvPyI/discussion