什么是最好的編程語言？(怎樣才能愛上編程呢？)

• Assmbly：機器語言

• C：形式化語言

• Javascript：網編編程語言

• Scheme：與C和Javascript相比，更輕巧，嵌入性更好，是極其靈活的編程語言

合適的語言

Ada

  function Best_Shuffle(S: String) return String is
    T: String(S'Range) := S;
    Tmp: Character;
  begin
    for I in S'Range loop
      for J in S'Range loop
        if I /= J and S(I) /= T(J) and S(J) /= T(I) then
          Tmp  := T(I);
          T(I) := T(J);
          T(J) := Tmp;
        end if;
      end loop;
    end loop;
    return T;
  end Best_Shuffle;

Bourne (Again) Shell

         #!/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

C

     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;
        }

C++

 #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;
          }
        }

C#

 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);
                }
            }
        }
    }

Objective-C

     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;
        }   

Clojure

     (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))

D

     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;

Erlang

     -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.

Go

     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)
            }
        }

Haskell

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

Java

     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);
           }
        }

Javascript

     function Car(brand, weight) {
          this.brand = brand;
          this.weight = weight || 1000;
        }
        Car.prototype.getPrice = function() {
          return this.price;
        }
        function Truck(brand, size) {
          this.constructor(brand, 2000);
          this.size = size;
        }
        Truck.prototype = new Car;
        var cars = [
          new Car("Mazda"),
          new Truck("Volvo", 2)
        ];
        for (var i=0; i
            console.log(cars[i]);
            console.log("brand: "+cars[i].brand+". weight: "+cars[i].weight+"." + (( cars[i].hasOwnProperty('size') ) ? " size: "+cars[i].size : ""));
            console.log("Car: %s. Truck: %s\n", cars[i] instanceof Car, cars[i] instanceof Truck);
        }

     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();

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[i] 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[i]
                # 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))))