corehello

def qsort(arr): 
    if len(arr) <= 1:
        return arr
    else:
        # construct array with [(values bigger than pivot), pivot, (values smaller than pivot)]
        return qsort([x for x in arr[1:] if x > arr[0]]) + \
               [arr[0]] + \
               qsort([x for x in arr[1:] if x <= arr[0]])

corehello

(defun fib3 (n)
  (cond ((= n 1) 1)
        ((= n 2) 2)
        ((= n 3) 4)
        (t (+ (fib3 (- n 1))
              (fib3 (- n 2))
              (fib3 (- n 3))))))

corehello

// these aren't _quite_ functional tests,
// and should all be compile_fail,
// but may be illustrative

#[test]
fn concurrent_set() {
    use std::sync::Arc;
    let x = Arc::new(Cell::new(42));
    let x1 = Arc::clone(&x);
    std::thread::spawn(move || {

corehello

(defun collatz-conjecture (n)
	(progn
	  (print n)
	  (cond
	    ((= n 1) n)
	    ((= (mod n 2) 0) (collatz-conjecture (/ n 2)))
	    ((= (mod n 2) 1) (collatz-conjecture (+ 1 (* n 3)))))))

corehello

package main

import (
	"crypto/tls"
	"flag"
	"io"
	"log"
	"net"
	"net/http"
	"time"

corehello

(defun split-nums (n)
	   (if (>= n 0)
	       (if (= n 0)
		   '((0) NIL)
		   (if (oddp n)
		       (map 'list #'append `(NIL (,n)) (split-nums (- n 1)))
		       (map 'list #'append `((,n) NIL) (split-nums (- n 1)))))))

corehello

#include <stdio.h>

/*
  You can define the size of Queens
*/
#define QUEEN 8

int row[QUEEN+1];
int l[2*QUEEN];
int r[2*QUEEN];

corehello

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

int main (int ac, char* av[])
{
    int number = atoi(av[1]);
    //number = 5;
    int i=0,j=0;
    int direction=0;
    /*

corehello

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

typedef struct {
  size_t         width;
  size_t         height;
  unsigned char *data;
} Image;

corehello

Latency Comparison Numbers
--------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD