1
2
3
4
5
6
7
8
9
                                          : #define :
                                          ;
#define __MAX_COLOR__   6
                                          ; __MAX_COLOR__
 
#define color   __MAX_COLOR__
                                          ; ' max ' color = 5
 
#define cyan    48
 ...

1
2
3
open System
let f (x:'a seq) : string = String.Join (" ", seq.ofArray x)
printfn "%A" (f [3; 4; 8])

1
2
3
open System
let f (x:'a seq) : string = String.Join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
3
open System
let f x : 'a seq->string = String.Join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
3
open System
let f x : 'a seq->string = string.Join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
let f x : 'a seq->string = string.join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
let f x : 'a seq->string = string.join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
let f x : 'a seq->string = String.Join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
let f x : 'a seq->string = string.Join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
let f x:IEnumerable<'a>->string = string.Join (" ", x)
printfn "%A" (f [3; 4; 8])

1
2
let f x:IEnumerable->string = string.Join (" ", x)
printfn "%A" (f [3; 4; 8])

1
let x =1

1
2
3
4
5
6
7
8
9
let inverseFizzBuzz input =
    let lcmWord, lcmNumber = "fizzbuzz", 15
    let partialResultMap =
        [0 .. lcmNumber] |> List.choose (fun n ->
            match n % 3, n % 5 with
            | 0, 0 -> Some("fizzbuzz", n)
            | 0, _ -> Some("fizz", n)
            | _, 0 -> Some("buzz", n)
            | _ -> None)
 ...

1
2
3
4
5
6
7
8
9
 
 
class ReadPalindrome
{
public static  boolean is_Palindrome(int x)
{
return (x==Palindrome(x)? true: false);
}
public static int Palindrome(int num)
 ...

1
2
3
4
5
6
7
8
9
import java.io.*;
 
class ReadPalindrome
{
public static  boolean is_Palindrome(int x)
{
return (x==Palindrome(x)? true: false);
}
public static int Palindrome(int num)
 ...

1
2
3
4
5
6
7
8
9
import java.io.*;
 
class ReadPalindrome
{
public static  boolean is_Palindrome(int x)
{
return (x==Palindrome(x)? true: false);
}
public static int Palindrome(int num)
 ...

1
2
3
4
5
6
7
8
9
import java.io.*;
 
 class ReadPalindrome
{
public static  boolean is_Palindrome(int x)
{
return (x==Palindrome(x)? true: false);
}
public static int Palindrome(int num)
 ...

1
2
3
4
5
6
7
open System
 
let mutable num = System.Console.ReadLine()
while not(System.String.Equals(num, "42", System.StringComparison.CurrentCultureIgnoreCase)) do
    System.Console.Write(num)
    num <- System.Console.ReadLine()
    System.Console.WriteLine()

1
2
3
4
5
6
7
open System
 
[<EntryPoint>]
let main a = 
    let w = if a.Length > 0 then String.Join(" ", a) else "roll"
    Console.WriteLine("{0} {1:000}", w, (new Random()).Next(1000))
    0

1
2
3
4
5
6
7
#light
open System
open System.Numerics
 
let fac n : BigInteger = Seq.fold (*) 1I {1I..n}
let f = (fac 9000I).ToString().Length
System.Console.Write f

1
2
3
4
5
6
7
open System
 
let mutable num = System.Console.ReadLine()
while not(System.String.Equals(num, "42", System.StringComparison.CurrentCultureIgnoreCase)) do
    System.Console.Write(num)
    num <- System.Console.ReadLine()
    System.Console.WriteLine()

1
2
3
4
5
6
7
8
9
open System
open System.Diagnostics
 
type complex = C of float*float
 
let check (n: int) = true
 
let sum (a: complex) (b: complex) =
    match a, b with
 ...

1
2
3
4
5
6
7
8
9
open System
open System.Diagnostics
 
type complex = C of float*float
 
let check (n: int) = true
 
let sum (a: complex) (b: complex) =
    match a, b with
 ...

1
2
3
4
5
6
7
8
9
open System
open System.Diagnostics
 
type complex = C of float*float
 
let check (n: int) = true
 
let sum (a: complex) (b: complex) =
    match a, b with
 ...

1
2
3
4
5
6
7
8
9
type LinkedList<'T> =
  Cons of 'T * LinkedList<'T>
| Nil
 
let rec map f = function
  Cons (head, tail) -> Cons (f head, map tail)
| Nil               -> Nil
 
let start = Cons (1, Cons (2, Cons (3, Nil)))
 ...

1
2
3
4
5
6
7
8
9
type LinkedList<'T> =
  Cons of 'T * LinkedList<'T>
| Nil
 
let map f = function
  Cons (head, tail) -> Cons (f head, map tail)
| Nil               -> Nil
 
let start = Cons (1, Cons (2, Cons (3, Nil)))
 ...

1
2
3
4
5
6
7
8
type LinkedList<'T> =
  Cons of 'T * LinkedList<'T>
| Nil
 
module LinkedList =
  let map f = function
    Cons (head, tail) -> Cons (f head, map tail)
  | Nil               -> Nil
 ...

1
2
3
4
5
6
7
8
type LinkedList<'T> =
  Cons of 'T * LinkedList<'T>
| Nil
 
module LinkedList =
  let map f = function
    Cons (head, tail) -> Cons (f head, map tail)
  | Nil               -> Nil
 ...

1
type LinkedList<'T> = Cons of 'T * LinkedList<'T> | Nil

1
2
3
4
5
6
7
open System.Collections.Generic
 
let dick = new Dictionary<string,List<string>>()
dick.Add("yoba", new List<string>())
dick.["yoba"].Add("nahuy yobu! Zig Hail")
dick.["yoba"].Add("shel bi ti otsuda, petushok")
printf dick