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

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