#include <stdio.h>

int main() {
    int n;

    for(n=0; n < 10; n++) {
        printf("Hello %d!\n", n);
    }

    return 0;
}

using System;

class MainClass
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hello World!");
    }
}

#include <iostream>

using namespace std;

int main(int argc, char **argv) {
    for(int n=0; n < 10; n++) {
        cout << "Hello " << n << '!' << endl;
    }

    return 0;
}

public class Hello {

   public static void main(String[] args) {

       for(int i = 1; i < 10000; i++) {
           System.out.println("Hello " + i);
       }
   }
}

#!/usr/bin/perl

for $n (0..9) {
    print "Hello $n!\n";
}

#!/usr/bin/python

for n in range(10):
    print "Hello %d!" % n

#!/usr/bin/ruby

10.times { |n| puts "Hello #{n}!" }

% Testprogrammet
-module(test1).
-export(test_pgm1/0).
% test_pgm1/0
test_pgm1() ->
   test_pgm1(10).
% Antal argument är viktigt.  test_pmg/0 och test_pgm/1 är olika funktioner
% test_pgm1/1
test_pgm1(0) -> % basfall, vi är klar
   ok.
test_pgm1(N) -> % rekursionsfall, vi anropar test_pgm1/1 igen med nästa värde
   N1 = N - 1,
   io:format("N = ~w~n", [N]),
   test_pgm1(N1).

% Supervanligt typ av exempel.
kind(Alex).
kind(Jan).
kind(Lars).

handsome(Lars).
handsome(Sven)

funny(Alex).
funny(Lars).

perfect(X) :- kind(X), handsome(X), funny(X).

% Svårare exempel
% Några ord.
words0(["TUTOR","EARLY","HOOEY","DODGE", "DITTO"]).
words1(["DITCH","TUTOR","EARLY","HOOEY","DODGE", "DITTO", "DITCH","TUTOR","EARLY","HOOEY","DODGE", "DITTO"]).
words2(["DITCH","TUTOR","EARLY","HOOEY","DODGE", "DITTO", "RITAR", "HEJSAN"]).
words3(["DITCH","TUTOR","EARLY","HOOEY","DODGE", "DITTO", "APRON", "ALLAH", "HELLO", "LOLIN", "ROLIL", "NANRO"]).

% Andra Prologlaborationen i kursen Programmeringsparadigm 2008

% crossword/2 tar en lista med strängar (om fem tecken) som indata och unifierar
% dessa till ett passande korsord
crossword(Fa,R) :-   select(T1,Fa,Fb),
         select(T2,Fb,Fc),
              first(T1, A), first(T2, A),
         select(T3,Fc,Fd),
              third(T1, B), first(T3, B),
         select(T4,Fd,Fe),
         fifth(T1, C), first(T4, C),
         select(T5,Fe,Ff),
         third(T2, D), first(T5, D),
         third(T3, F), third(T5, F),
         third(T4, H), fifth(T5, H),
         select(T6,Ff,_),
         fifth(T2, E), first(T6, E),      
         fifth(T3, G), third(T6, G),
         fifth(T4, I), fifth(T6, I),

         R = [T1,T2,T3,T4,T5,T6].    % Sätter allt i en lista

% write_crossword/1 får en lista som den skriver ut
write_crossword(R) :-   first(R,T1), second(R, T2), third(R, T3),
         fourth(R,T4), fifth(R, T5), sixth(R,T6),

         format(T1,[]),nl,
         second(T2,Aa), second(T3, Ab), second(T4,Ac),
         format([Aa,32,Ab,32,Ac],[]),nl,

         format(T5,[]),nl,

         fourth(T2,Ba), fourth(T3, Bb), fourth(T4,Bc),
         format([Ba,32,Bb,32,Bc],[]),nl,

         format(T6,[]),nl.
% Genväg till "new line".
nl :- format("\n",[]).

% Returnerar första-sjätte värdet i en lista.
first([A|_], A).
second([_|A], B) :- first(A,B).
third([_|A], B)  :- second(A,B).
fourth([_|A], B) :- third(A,B).
fifth([_|A], B)  :- fourth(A,B).
sixth([_|A], B)  :- fifth(A,B).

sudo apt-get install swi-prolog

sudo apt-get install gprolog

-- Snabbt exempel
-- Rekrusiv metod för att beräkna Fibonaccital
fib :: Integer -> Integer   --För att klara stora tal används Integer
fib n   | n <= 0   = 0   -- är n = 0 så returneras 0
   | n == 1   = 1   -- är n = 1 så returneras 1
   | otherwise   = fib(n-1)+fib(n-2) -- rekrusiv bit

-- Svårare exempel
-- Hitta längsta ordet i en mening
import Char

maxord :: String -> Int
maxord s   = help 0 0 s

help :: Int -> Int -> String -> Int
help n m []   | m > n       = m -- Fallet för tom lista
      | otherwise = n

help n m (c:s)    | isAlpha c    = help n (m+1) s
      | m > n    = help m 0 s
      | otherwise    = help n 0

sudo apt-get install ghc

sudo apt-get install hugs

(+ 1 1) => 2
(* (+ 1 2) (+ 4 5)) => 27
(apply str (reverse "Hello, world!")) => "!dlrow ,olleH"

; (graphics -> nil) -> javax.swing.JPanel
(defn panel [render-fn]
  (proxy [JPanel] []
    (paint [g] (render-fn g))))

; (graphics -> nil) -> javax.swing.JFrame
(defn frame-with-panel [render-fn]
  (doto (new JFrame)
    (.setContentPane (panel render-fn))
    (.show)))

(frame-with-panel (view-scene scene1))

(take 3 (repeat 1)) => (1 1 1)

(take 3 (iterate inc 1)) => (1 2 3)

; number-a number-b -> number-sequence
(defn fib-seq [a b]
 (cons (+ a b) (lazy-seq (fib-seq (+ a b) a))))

=> (take 5 (fib-seq 1 1))
(2 3 5 8 13)

(def fibs (concat [1 1] (fib-seq 1 1)))

Vid bruk märks alltså skillnaden:

=> (time (dorun (take 100000 fibs)))   
"Elapsed time: 8521.250263 msecs"
=> (time (dorun (take 100000 fibs)))   
"Elapsed time: 141.765916 msecs"

import std.algorithm;
import std.array;
import std.file;
import std.stdio;
import std.string;
import std.process;
import core.sys.posix.sys.stat; // for stat.st_mode

bool isExecutable(string p)
{
  return isfile(p) && (getAttributes(p) & S_IXUSR);
}

string[] entries(in string p, SpanMode m = SpanMode.shallow)
{
  auto r = appender!(string[]);
  foreach (string x; dirEntries(p, m)) r.put(x);
  return r.data();
}

string[] executables(string[] dirs)
{
  auto r = appender!(string[]);
  foreach (x; dirs) r.put( filter!(isExecutable)( entries(x) ));
  return r.data();
}

int main(string[] args)
{
  string[] paths = getenv("PATH").split(":");
  writeln( executables(paths).join("\n") );
  return 0;
}