Quizz of the Day

Question 1:

What is the simple difference between the Bugatti Veyron and Jad Berro's Car?

Hints - The Veyron has a Top Speed of 401 Km/h, 1001 HP, and an 8.0 litre W16 engine with sixteen cylinders in two banks of eight, equivalent to two narrow-angle V8 engines mated in a "W" configuration.

<?php

$customer_number = 65;
showplate($customer_number);

function showplate($customer_number) {
	$number = $customer_number-1;
	$plate=array();
	$plate[1]= floor(($number/(26*26*26*10*10))%10);
	$plate[2]= floor(($number/(26*26*26*10))%10);
	$plate[3]= floor(($number/(26*26*10))%10);
	$plate[4]= toletters(floor(($number/(26*26))%26));
	$plate[5]= toletters(floor(($number/26)%26));
	$plate[6]= toletters($number%26);
	$plate_number = implode($plate,"");
	echo $plate_number;
}

// this function prints the ascii value of the letters
function toletters($num) {
	return "&#".($num+65).";";
}

?>

ayman are you sure N=1mil is impossible?
it should be anything above 10*10*10*26*26*26 = 17,576,000

airthma made use of recursive calls and conditionals, which you noted was prohibited :)
and the no-conditionals rule was behind the reason I didn't check for 'impossible' numbers

Only one if statement is allowed to be used, this is the condition in which you have to print "Impossible".

define node as {int data; ref node next;} // contains a data member and a reference to the next node

void reverse_list(ref node n){
  ref node current = break_last(n); // declaration
  while( (ref node last = break_last(n)) != null ){
    current.next = last;
    current = last;
  }
}

ref node break_last(ref node n){
  while(n.next != null && n.next.next != null) n = n.next;

  if(n.next == null) return n;
  
  ref node result = n.next;
  n.next = null;
  return result;
}

Reverse a single connected linked list. Best optimized algo (performance first, then memory usage) wins.

struct node{ int data ; node * next }

node* reverse (node * list) {

           node *pt , *temp ;

           pt = list.next ;
           list.next = null ;
           while (pt != null){
                  temp = pt.next ;
                  pt.next = list ;
                  list = pt ;
                  pt = temp ;
           }
           return list ;
}

void reverse_recursive( node * & rev, node * rest ){
	if(rest == 0) return;

	node * next = rest->next;
	rest->next = rev;
	rev = rest;
	reverse_recursive(rev, next);
}

#include <iostream>
using namespace std;

struct node {
	int data;
	node * next;
};

node* reverse (node * list) {
	node *pt , *temp ;

	pt = list->next ;
	list->next = 0 ;
	while (pt != 0){
		temp = pt->next ;
		pt->next = list ;
		list = pt ;
		pt = temp ;
	}
	return list ;
}

void reverse_recursive( node * & rev, node * rest ){
	if(rest == 0) return;

	node * next = rest->next;
	rest->next = rev;
	rev = rest;
	reverse_recursive(rev, next);
}

void spit_list(node * p){
	while(p != 0) {
		cout << p->data << endl;
		p = p->next;
	}
}

void main(){
	node a = {1, 0};
	node b = {2, 0};
	node c = {3, 0};
	node d = {4, 0};

	a.next = &b;
	b.next = &c;
	c.next = &d;

	node * p = reverse(&a);
	spit_list(p);

	node * reverse = 0;
	reverse_recursive(reverse, p);
	spit_list(reverse);
}

public void reverseList() 
{
    ListNode current = head;
    head = null;
    while (current != null) 
    {
        ListNode ptr = current;
        current = current.next;
        ptr.next = head;
        head = ptr;
    }
}

A happy number is defined by the following process. Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers, while those that do not end in 1 are unhappy numbers (or sad numbers[1]).

let f x =
    x.ToString().ToCharArray()
    |> Seq.map (fun c -> pown ((int c) - 48) 2)
    |> Seq.sum

let happy n next =
    let rec compare a b =
        match a = b with
        | true -> a
        | false -> compare (next a) (next (next b))
    compare n (next n)

Code: [7;20;92;487] |> Seq.map (fun x -> happy x f = 1)

Output:  [true; false; false; true]

Code: [1 .. 1000] |> Seq.map (fun x -> happy x f) |> Seq.filter (fun x -> x = 1 ) |> Seq.sum

Output: 143