Denommus

integral :: (Fractional a, Ord a) => (a -> a) -> Integer -> a -> a -> a
integral f p a b
    | a==b = 0
    | otherwise = total 0 a
    where dx = (b-a)/fromInteger p
          total t x | x2>b      = t
                    | otherwise = total (t+(dx*(f x+(4*f ((x+x2)/2))+f x2)/6)) x2
              where x2 = x+dx

Denommus

#!/usr/bin/sbcl --script

(defmacro time-methods (&body list)
  (let ((number (gensym)))
    `(progn
       ,@(loop for (key value) on list by #'cddr
               collect `(defun ,key (,number)
                          (* ,number ,value))))))

(time-methods seconds 1 minutes 60 hours 3600 days 86400)

Denommus

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

int main() {
  char a[] = "abcd";
  memmove(a, a+1, 3);
  a[3] = 0;
  printf(a);
  return 0;
}

Denommus

#!/usr/bin/sbcl --script

(loop for n = (read t)
      for stack = (list n) then (cons n stack)
      until (member n '(exit quit))
      do (unless (numberp n)
           (cond
             ((endp (nthcdr 2 stack))
              (format t "Not enough numbers in stack~%")
              (pop stack))

Denommus

(let ((counter 0))
  (defun increment-counter ()
    (incf counter))

  (defun reset-counter ()
    (setf counter 0))

  (defun get-counter ()
    counter))

Denommus

#!/usr/bin/sbcl --script

(with-open-file (in (car (last *posix-argv*)))
  (let ((total-cases (read in)))
    (with-open-file (out "A.out" :direction :output :if-exists :supersede)
      (loop for i from 1 to total-cases do
           (let* ((n (read in))
                  (v1 (loop for j from 0 below n collect (read in)))
                  (v2 (loop for j from 0 below n collect (read in))))
             (format out "Case #~D: ~D~%" i

Denommus

#!/usr/bin/sbcl --script

(defun count-unique (alist)
  (let ((hash (make-hash-table :test #'equal)))
    (map 'nil
         (lambda (i)
           (setf (gethash i hash) 1))
         alist)
    (hash-table-count hash)))

Denommus

#!/usr/bin/sbcl --script

(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))
(require 'cl-ppcre)

(with-open-file (in (car (last *posix-argv*)))
  (let* ((l (read in))
         (d (read in))
         (n (read in))
         (words (loop repeat d

Denommus

(defun byte-array-to-ui-32-bit-array (octet-array)
  (declare (optimize (speed 3))
           (type (simple-array (unsigned-byte 8) (*)) octet-array))
  (if (/= (mod (length octet-array) 4) 0)
      (make-array 0 :element-type '(unsigned-byte 32))
      (make-array (/ (length octet-array) 4)
                  :element-type '(unsigned-byte 32)
                  :initial-contents
                  (loop for i from 0 below (length octet-array) by 4
                     for j = 0 then (1+ j)

Denommus

import java.util.concurrent.atomic.AtomicReference;

public abstract class TestClosure {
  public abstract int execute(int a);
}

public class MainClass {
	public static void main(String[] args) {
		final AtomicReference<Integer> x = new AtomicReference<Integer>(4);
		TestClosure testClosure = new TestClosure() {