什么是最好的编程语言？(怎样才能爱上编程呢？)

#!/usr/bin/env sh
l="1"
while [ "$l" -le 5 ]
  do
  m="1"
  while [ "$m" -le "$l" ]
    do
    printf "*"
    m=`expr "$m" + 1`
  done
  echo
  l=`expr "$l" + 1`
done

int next_pidmap(struct pid_namespace *pid_ns, unsigned int last)
{
    int offset;
    struct pidmap *map, *end;
    if (last >= PID_MAX_LIMIT)
        return -1;
    offset = (last + 1) & BITS_PER_PAGE_MASK;
   map = &pid_ns->pidmap[(last + 1)/BITS_PER_PAGE];
   end = &pid_ns->pidmap[PIDMAP_ENTRIES];
   for (; map < end; map++, offset = 0) {
       if (unlikely(!map->page))
           continue;
       offset = find_next_bit((map)->page, BITS_PER_PAGE, offset);
       if (offset < BITS_PER_PAGE)
           return mk_pid(pid_ns, map, offset);
   }
   return -1;
}

#include
#include
#include
int main( int argc , char** argv )
{
    int linecount = 0;
    std::string line;
    std::ifstream infile( argv[ 1 ] );
    if( infile )
    {
        while( getline( infile , line ) )
        {
            std::cout << linecount << ": " << line << '\n';
            linecount++;
        }
    }
    infile.close();
    return 0;
}

namespace rosettacode
{
  template class queue
  {
  public:
    queue();
    ~queue();
    void push(T const& t);
    T pop();
    bool empty();
  private:
    void drop();
    struct node;
    node* head;
    node* tail;
  };
  template struct queue::node
  {
    T data;
    node* next;
    node(T const& t): data(t), next(0) {}
  };
  template
   queue::queue():
    head(0)
  {
  }
  template
   inline void queue::drop()
  {
    node* n = head;
    head = head->next;
    delete n;
  }
  template
   queue::~queue()
  {
    while (!empty())
      drop();
  }
  template
   void queue::push(T const& t)
  {
    node*& next = head? tail->next : head;
    next = new node(t);
    tail = next;
  }
  template
   T queue::pop()
  {
    T tmp = head->data;
    drop();
    return tmp;
  }
  template
   bool queue::empty()
  {
    return head == 0;
  }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
class Program
{
    static SortedDictionary GetFrequencies(IEnumerable items)
    {
        var dictionary = new SortedDictionary();
        foreach (var item in items)
        {
            if (dictionary.ContainsKey(item))
            {
                dictionary[item]++;
            }
            else
            {
                dictionary[item] = 1;
            }
        }
        return dictionary;
    }
    static void Main(string[] arguments)
    {
        var file = arguments.FirstOrDefault();
        if (File.Exists(file))
        {
            var text = File.ReadAllText(file);
            foreach (var entry in GetFrequencies(text))
            {
                Console.WriteLine("{0}: {1}", entry.Key, entry.Value);
            }
        }
    }
}

char bytes[] = "some data";
NSString *string = [[NSString alloc] initWithBytes:bytes length:9 encoding:NSASCIIStringEncoding];

#import
typedef NSArray *(^SOfN)(id);
SOfN s_of_n_creator(int n) {
  NSMutableArray *sample = [[NSMutableArray alloc] initWithCapacity:n];
  __block int i = 0;
  return ^(id item) {
    i++;
    if (i <= n) {
      [sample addObject:item];
    } else if (rand() % i < n) {
      sample[rand() % n] = item;
    }
    return sample;
  };
}
int main(int argc, const char *argv[]) {
  @autoreleasepool {
    NSCountedSet *bin = [[NSCountedSet alloc] init];
    for (int trial = 0; trial < 100000; trial++) {
      SOfN s_of_n = s_of_n_creator(3);
      NSArray *sample;
      for (int i = 0; i < 10; i++) {
        sample = s_of_n(@(i));
      }
      [bin addObjectsFromArray:sample];
    }
    NSLog(@"%@", bin);
  }
  return 0;
}

(defn divides? [k n] (= (rem n k) 0))
    (defn prime? [n]
      (if (< n 2)
        false
        (empty? (filter #(divides? % n) (take-while #(<= (* % %) n) (range 2 n))))))
Lisp形式的队列的定义代码：
    (defn make-queue []
      (atom []))
    (defn enqueue [q x]
      (swap! q conj x))
    (defn dequeue [q]
      (if (seq @q)
        (let [x (first @q)]
          (swap! q subvec 1)
          x)
        (throw (IllegalStateException. "Can't pop an empty queue."))))
    (defn queue-empty? [q]
      (empty? @q))

uint grayEncode(in uint n) pure nothrow {
    return n ^ (n >> 1);
}
uint grayDecode(uint n) pure nothrow {
    auto p = n;
    while (n >>= 1)
        p ^= n;
    return p;
}
void main() {
    import std.stdio;
    " N     N2      enc     dec2 dec".writeln;
    foreach (immutable n; 0 .. 32) {
        immutable g = n.grayEncode;
        immutable d = g.grayDecode;
        writefln("%2d: %5b => %5b => %5b: %2d", n, n, g, d, d);
        assert(d == n);
    }
}

[9, 4, 3, 8, 5].reduce!max.writeln;

-module(hw).
-export([start/0]).
start() ->
   [ spawn(fun() ->  say(self(), X) end) || X <- ['Enjoy', 'Rosetta', 'Code'] ],
   wait(2),
   ok.
say(Pid,Str) ->
   io:fwrite("~s~n",[Str]),
   Pid ! done.
wait(N) ->
   receive
       done -> case N of
           0 -> 0;
           _N -> wait(N-1)
       end
   end.

package main
import (
    "fmt"
    "math/rand"
    "time"
)
func main() {
    words := []string{"Enjoy", "Rosetta", "Code"}
    rand.Seed(time.Now().UnixNano())
    q := make(chan string)
    for _, w := range words {
        go func(w string) {
            time.Sleep(time.Duration(rand.Int63n(1e9)))
            q <- w
        }(w)
    }
    for i := 0; i < len(words); i++ {
        fmt.Println(<-q)
    }
}

binarySearch :: Integral a => (a -> Ordering) -> (a, a) -> Maybe a
binarySearch p (low,high)
  | high < low = Nothing
  | otherwise =
      let mid = (low + high) `div` 2 in
      case p mid of
        LT -> binarySearch p (low, mid-1)
        GT -> binarySearch p (mid+1, high)
        EQ -> Just mid

import java.util.List;
import java.nio.charset.Charset;
import java.nio.file.*;
public class ReadAll {
    public static List readAllLines(String filesname){
        Path file = Paths.get(filename);
        return Files.readAllLines(file, Charset.defaultCharset());
    }
   public static byte[] readAllBytes(String filename){
       Path file = Paths.get(filename);
       return Files.readAllBytes(file);
   }
}

var characters = [
  { 'name': 'barney',  'age': 36 },
  { 'name': 'fred',    'age': 40 },
  { 'name': 'pebbles', 'age': 1 }
];
var youngest = _.chain(characters)
    .sortBy('age')
    .map(function(chr) { return chr.name + ' is ' + chr.age; })
    .first()
    .value();

brush:text;toolbar:false;]let n_arrays_iter ~f = function
 | [] -> ()
 | x::xs as al ->
     let len = Array.length x in
     let b = List.for_all (fun a -> Array.length a = len) xs in
     if not b then invalid_arg "n_arrays_iter: arrays of different length";
     for i = 0 to pred len do
       let ai = List.map (fun a -> a.(i)) al in
       f ai
              done

function hashJoin($table1, $index1, $table2, $index2) {
    foreach ($table1 as $s)
        $h[$s[$index1]][] = $s;
    foreach ($table2 as $r)
      foreach ($h[$r[$index2]] as $s)
        $result[] = array($s, $r);
    return $result;
}
$table1 = array(array(27, "Jonah"),
           array(18, "Popeye"),
           array(28, "Alan"));
$table2 = array(array("Jonah", "Whales"),
           array("Jonah", "Spiders"),
           array("Alan", "Ghosts"),
           array("Bob", "foo"));
foreach (hashJoin($table1, 1, $table2, 0) as $row)
    print_r($row);

from itertools import islice
def hamming2():
    '''\
    A text documenting this function (stripped)
    '''
    h = 1
    _h=[h]    # memoized
    multipliers  = (2, 3, 5)
    multindeces  = [0 for i in multipliers] # index into _h for multipliers
    multvalues   = [x * _h for x,i in zip(multipliers, multindeces)]
    yield h
    while True:
        h = min(multvalues)
        _h.append(h)
        for (n,(v,x,i)) in enumerate(zip(multvalues, multipliers, multindeces)):
            if v == h:
                i += 1
                multindeces[n] = i
                multvalues[n]  = x * _h
        # cap the memoization
        mini = min(multindeces)
        if mini >= 1000:
            del _h[:mini]
            multindeces = [i - mini for i in multindeces]
        #
        yield h

hamming = Enumerator.new do |yielder|
  next_ham = 1
  queues = { 2 => [], 3 => [], 5 => [] }
  loop do
    yielder << next_ham   # or: yielder.yield(next_ham)
    [2,3,5].each {|m| queues[m]<< (next_ham * m)}
    next_ham = [2,3,5].collect {|m| queues[m][0]}.min
    [2,3,5].each {|m| queues[m].shift if queues[m][0]== next_ham}
  end
end
idx = 1
hamming.each do |ham|
  case idx
  when (1..20), 1691
    p [idx, ham]
  when 1_000_000
    p [idx, ham]
    break
  end
  idx += 1
end

object HofstadterQseq extends App {
  val Q: Int => Int = n => {
    if (n <= 2) 1
    else Q(n-Q(n-1))+Q(n-Q(n-2))
  }
  (1 to 10).map(i=>(i,Q(i))).foreach(t=>println("Q("+t._1+") = "+t._2))
  println("Q("+1000+") = "+Q(1000))
}

;;! Recursive map that applies function to each node
(define (map** f l)
  (cond
   ((null? l) '())
   ((not (pair? l)) (f l))
   (else
    (cons (f (map** f (car l))) (f (map** f (cdr l)))))))
;;! Explicit currying of an arbitrary function
(define (curry fun arg1 . args)
  (if (pair? args)
      (let ((all-args (cons arg1 args)))
        (lambda x
          (apply fun (append all-args x))))
      (lambda x
        (apply fun (cons arg1 x)))))
;;! Implementation of filter, with the match macro
(define (filter p lst)
  (match lst
   ('() '())
   (((? p) . tl) (cons (car lst) (filter/match p tl)))
   ((hd . tl) (filter/match p tl))))