Friday's Coding Challenge

[realJSOP]

//assumptions
// n = 2
int[] sample = new int[]{8,1,9,3,2};
int[] sample2 = new int[2];

//code
Array.Sort(sample);
sample2 = sample.Take(sample2.Length).ToArray();

".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass." - Dale Earnhardt, 1997

[BobJanova]

Seems 'sort and take the first N' is the consensus on the algorithm, I think everyone's code does the same thing.

[S Houghtelin]

Chris Maunder wrote:

The hamsters involved are currently taking some time off to spend more time with their families.

How did they escape? You forgot to lock the door again... :D

It was broke, so I fixed it.

[Jason Hooper]

Does the language have to already exist?

Jason

[OriginalGriff]

"GIMMEE CODEZ!!!" in Q&A should do it...

Ideological Purity is no substitute for being able to stick your thumb down a pipe to stop the water

[BobJanova]

Well, if not, it is obviously possible to invent a language where one symbol does this operation :P. Since "sort and take" seems to be how to do it, it would be easy to conceive of a language where putting two symbols for "take" and "sort" next to each other would create a composite function that did it, making two characters the sensible theoretical minimum.

[PIEBALDconsult]

Chris Maunder wrote:

How does SQL handle them?

You tell me how you want them handled and I'll tell SQL how. It's SQL, not LISP.

[PIEBALDconsult]

f(x)

[Jason Hooper]

Yeah exactly. Since I'm the first (i think) to propose it but I don't feel like spending 5 hours creating an interpreter, let's just pretend I'm the winner.

Jason

[BobJanova]

I could easily modify my Rowan interpreter (what I posted my solution in) to implement sort as a single symbol, but it isn't worth it just for something like this :-\ . I don't allow composition of functions by juxtaposition like that though because it's confusing (see J).

[Rajesh R Subramanian]

std::list li; //A list, so that it can be sorted in ascending order.
int i = 0, /*i is increment counter*/ n = 3; //n denotes how many small numbers to print.
while(i++<5) li.push_back(i*3); //fill the list with dummy data.
li.sort(); //Small numbers will go to the end in ascending order.
std::list::iterator it = li.begin();

**while(n-- && it!=li.end()) std::cout << \*(it++) << std::endl;** //This is the line you're looking for. :)

"Real men drive manual transmission" - Rajesh.

[Roger Wright]

X| If we're allowed to cheat by using third party software, I'd 1. Copy and paste to Minitab 2. Click on Graphs/Stem and Leaf The top line of numbers in the displayed graph are the smallest values in the set, ordered ascending. :-D

Will Rogers never met me.

[Gary Wheeler]

You win the "We Can't Judge Your Submission Because It's Incomprehensible" award.

Software Zen: delete this;

[parths]

void find_n_in_m(int *mData, int *nData, unsigned int m, unsigned int n)
{
unsigned int ctr, ctr2 = 0;
for(unsigned int i = 0; i < n; i++)
nData[i] = mData[i];
m--;
while (((ctr = m) && (m >= n))
&& ((mData[ctr] >= nData[ctr2]) ?
((++ctr2 < n) || (ctr2 = 0) || m--) :
(((mData[ctr] ^= nData[ctr2]) && (nData[ctr2] ^= mData[ctr]) && (mData[ctr] ^= nData[ctr2]) && (ctr2 = 0)) || 1)
));
}

- Doesn't give a sorted list - Modifies the input array (nothing mentioned against that in the specification but that can be avoided by adding an input argument for an temp / scratch buffer of the same size as the source buffer) - Tried it on VS2008 Express Ed and with a few basic data so I don't know if it's correct for all inputs. - What it does is fill the destination with the first n elements then goes about trying to see if it can place the elements from n to m into the new array. Thought I'd post it while I'm trying to improve ( :~ ) it.

"It was when I found out I could make mistakes that I knew I was on to something." -Ornette Coleman "Philosophy is a study that lets us be unhappy more intelligently." -Anon.

[Single Step Debugger]

void Test()
{
int arr[] = {1, 4, 6, 8, 9};
int nNumToGet = 3;

int \*arr2 = ReturnLowerN(arr, sizeof(arr)/sizeof(int), nNumToGet);

}

int* ReturnLowerN(int *arr, int arrSize, int nNum)
{
std::sort(arr, arr + 5, std::greater<int>());

return(arr + arrSize - nNum);

}

Of course if you want to use qsort instead, here is an article from someone you may know. :-D Using qsort on arrays of sequential data[^]

There is only one Vera Farmiga and Salma Hayek is her prophet! Advertise here – minimum three posts per day are guaranteed.

[Daniel Grunwald]

BobJanova wrote:

Well, if not, it is obviously possible to invent a language where one symbol does this operation

Why one symbol? If you're inventing a new language, you might as well invent one where the empty program solves this challenge.

[Roger Wright]

I wasn't aware that the Betty Ford Clinic has a hamster wing. How very nice. I hope they enjoy the rest. :-D

Will Rogers never met me.

[Luc Pattyn]

I was thinking about APL too. It has been over 30 years I touched it though. :)

Luc Pattyn [My Articles] Nil Volentibus Arduum

[YvesDaoust]

My attempt in plain C:

for (i= 0; i < m; i++)
{
int r= 0;
for (j= 0; j < m; j++)
r+= a[j] < a[i];
if (r < n)
printf("%d\n", a[i]);
}

It simply evaluates the rank of every element. Unfortunately, this method cannot meet the specs in case of equal elements. Actually, it reports all elements with rank less than n.

[YvesDaoust]

Slightly modified Straight Selection Sort will do the trick (moves n lowest elements first):

for (int i= 0; i < n; i++)
{
int k = i;
for (int j= i; j < m; j++)
{
if (a[k] > a[j])
{
k = j;
}
}

int swap= a\[i\]; a\[i\]= a\[k\]; a\[k\]= swap;

}

IMHO, allowing function calls makes the challenge nonsensical, as the solutions reduces to S(a, m, n), where S is the function that does just that.