高级程序员进化史

package fac

func Factorial(n int) int {
 res := 1

for i := 1; i <= n; i++ {
 res *= i
 }

return res
}

package fac

func Factorial(n int) int {
if n == 0 {
return 1
 } else {
return Factorial(n - 1) * n
 }
}

package fac

func Factorial(n interface{}) interface{} {
 v, valid := n.(int)
if !valid {
return 0
 }

 res := 1

for i := 1; i <= v; i++ {
 res *= i
 }

return res
}

package fac

import "sync"

func Factorial(n int) int {
var (
 left, right = 1, 1
 wg sync.WaitGroup
 )

 wg.Add(2)

 pivot := n / 2

go func() {
for i := 1; i < pivot; i++ {
 left *= i
 }

 wg.Done()
 }()

go func() {
for i := pivot; i <= n; i++ {
 right *= i
 }

 wg.Done()
 }()

 wg.Wait()

return left * right
}

package fac

func Factorial(n int) <-chan int {
 ch := make(chan int)

go func() {
 prev := 1

for i := 1; i <= n; i++ {
 v := prev * i

 ch <- v

 prev = v
 }

close(ch)
 }()

return ch
}

package fac

/**
 * @see https://en.wikipedia.org/wiki/Factorial
 */
type IFactorial interface {
 CalculateFactorial() int
}

// FactorialImpl implements IFactorial.
var _ IFactorial = (*FactorialImpl)(nil)

/**
 * Used to find factorial of the n.
 */
type FactorialImpl struct {
/**
 * The n.
 */
 n int
}

/**
 * Constructor of the FactorialImpl.
 *
 * @param n the n.
 */
func NewFactorial(n int) *FactorialImpl {
return &FactorialImpl{
 n: n,
 }
}

/**
 * Gets the n to use in factorial function.
 *
 * @return int.
 */
func (this *FactorialImpl) GetN() int {
return this.n
}

/**
 * Sets the n to use in factorial function.
 *
 * @param n the n.
 * @return void.
 */
func (this *FactorialImpl) SetN(n int) {
this.n = n
}

/**
 * Returns factorial of the n.
 *
 * @todo remove "if" statement. Maybe we should use a factory or somthing?
 *
 * @return int.
 */
func (this *FactorialImpl) CalculateFactorial() int {
if this.n == 0 {
return 1
 }

 n := this.n
this.n = this.n - 1

return this.CalculateFactorial() * n
}

package fac

// Factorial returns n!.
func Factorial(n int) int {
 res := 1

for i := 1; i <= n; i++ {
 res *= i
 }

return res
}

package fac

// Factorial returns n!.
func Factorial(n int) int {
 res := 1

for i := 1; i <= n; i++ {
 res *= i
 }

return res
}

 10 PRINT "HELLO WORLD"
20 END

 program Hello(input, output)
 begin
 writeln('Hello World')
end.

 (defun hello
 (print
 (cons 'Hello (list 'World))))

 #include <stdio.h>
void main(void)
{
char *message[] = {"Hello ", "World"};
int i;

for(i = 0; i < 2; ++i)
printf("%s", message[i]);
printf("\n");
 }

 #include <iostream.h>
#include <string.h>

class string
 {
private:
int size;
char *ptr;

string() : size(0), ptr(new char[1]) { ptr[0] = 0; }

string(const string &s) : size(s.size)
 {
 ptr = new char[size + 1];
strcpy(ptr, s.ptr);
 }

 ~string()
 {
delete [] ptr;
 }

friend ostream &operator <<(ostream &, const string &);
string &operator=(const char *);
 };

 ostream &operator<<(ostream &stream, const string &s)
 {
return(stream << s.ptr);
 }

string &string::operator=(const char *chrs)
 {
if (this != &chrs)
 {
delete [] ptr;
 size = strlen(chrs);
 ptr = new char[size + 1];
strcpy(ptr, chrs);
 }
return(*this);
 }

int main()
{
string str;

 str = "Hello World";
cout << str << endl;

return(0);
 }

 [
 uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
 ]
 library LHello
 {
// bring in the master library
 importlib("actimp.tlb");
 importlib("actexp.tlb");

// bring in my interfaces
#include "pshlo.idl"

 [
 uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
 ]
 cotype THello
 {
 interface IHello;
 interface IPersistFile;
 };
 };

 [
 exe,
 uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
 ]
 module CHelloLib
 {

// some code related header files
 importheader(<windows.h>);
 importheader(<ole2.h>);
 importheader(<except.hxx>);
 importheader("pshlo.h");
 importheader("shlo.hxx");
 importheader("mycls.hxx");

// needed typelibs
 importlib("actimp.tlb");
 importlib("actexp.tlb");
 importlib("thlo.tlb");

 [
 uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
 aggregatable
 ]
 coclass CHello
 {
 cotype THello;
 };
 };


#include "ipfix.hxx"

 extern HANDLE hEvent;

 class CHello : public CHelloBase
 {
 public:
 IPFIX(CLSID_CHello);

 CHello(IUnknown *pUnk);
 ~CHello();

 HRESULT __stdcall PrintSz(LPWSTR pwszString);

 private:
 static int cObjRef;
 };


#include <windows.h>
#include <ole2.h>
#include <stdio.h>
#include <stdlib.h>
#include "thlo.h"
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"

int CHello::cObjRef = 0;

 CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
 {
 cObjRef++;
return;
 }

 HRESULT __stdcall CHello::PrintSz(LPWSTR pwszString)
 {
printf("%ws
", pwszString);
return(ResultFromScode(S_OK));
 }


 CHello::~CHello(void)
 {

// when the object count goes to zero, stop the server
 cObjRef--;
if( cObjRef == 0 )
 PulseEvent(hEvent);

return;
 }

#include <windows.h>
#include <ole2.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"

 HANDLE hEvent;

int _cdecl main(
int argc,
 char * argv[]
 ) {
 ULONG ulRef;
 DWORD dwRegistration;
 CHelloCF *pCF = new CHelloCF();

 hEvent = CreateEvent(, FALSE, FALSE, );

// Initialize the OLE libraries
 CoInitializeEx(, COINIT_MULTITHREADED);

 CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
 REGCLS_MULTIPLEUSE, &dwRegistration);

// wait on an event to stop
 WaitForSingleObject(hEvent, INFINITE);

// revoke and release the class object
 CoRevokeClassObject(dwRegistration);
 ulRef = pCF->Release();

// Tell OLE we are going away.
 CoUninitialize();

return(0); }

 extern CLSID CLSID_CHello;
 extern UUID LIBID_CHelloLib;

 CLSID CLSID_CHello = { /* 2573F891-CFEE-101A-9A9F-00AA00 */
0x2573F891,
0xCFEE,
0x101A,
 { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
 };

 UUID LIBID_CHelloLib = { /* 2573F890-CFEE-101A-9A9F-00AA00 */
0x2573F890,
0xCFEE,
0x101A,
 { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
 };

#include <windows.h>
#include <ole2.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "clsid.h"

int _cdecl main(
int argc,
 char * argv[]
 ) {
 HRESULT hRslt;
 IHello *pHello;
 ULONG ulCnt;
 IMoniker * pmk;
 WCHAR wcsT[_MAX_PATH];
 WCHAR wcsPath[2 * _MAX_PATH];

// get object path
 wcsPath[0] = '\0';
 wcsT[0] = '\0';
if( argc > 1) {
 mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
 wcsupr(wcsPath);
 }
else {
 fprintf(stderr, "Object path must be specified\n");
return(1);
 }

 // get print string
if(argc > 2)
 mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
else
 wcscpy(wcsT, L"Hello World");

printf("Linking to object %ws\n", wcsPath);
printf("Text String %ws\n", wcsT);

// Initialize the OLE libraries
 hRslt = CoInitializeEx(, COINIT_MULTITHREADED);

if(SUCCEEDED(hRslt)) {


 hRslt = CreateFileMoniker(wcsPath, &pmk);
if(SUCCEEDED(hRslt))
 hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);

if(SUCCEEDED(hRslt)) {

// print a string out
 pHello->PrintSz(wcsT);

 Sleep(2000);
 ulCnt = pHello->Release();
 }
else
printf("Failure to connect, status: %lx", hRslt);

// Tell OLE we are going away.
 CoUninitialize();
 }

return(0);
 }

 #!/usr/local/bin/perl
 $msg="Hello, world.\n";
if ($#ARGV >= 0) {
while(defined($arg=shift(@ARGV))) {
 $outfilename = $arg;
open(FILE, ">" . $outfilename) || die "Can't write $arg: $!\n";
print (FILE $msg);
close(FILE) || die "Can't close $arg: $!\n";
 }
 } else {
print ($msg);
 }
1;

 #include <stdio.h>
#define S "Hello, World\n"
 main(){exit(printf(S) == strlen(S) ? 0 : 1);}

 % cc -o a.out ~/src/misc/hw/hw.c
 % a.out

 % echo "Hello, world."

 10 PRINT "HELLO WORLD"
20 END

 mail -s "Hello, world." bob@b12
 Bob, could you please write me a program that prints "Hello, world."?
 I need it by tomorrow.
 ^D

 % zmail jim
 I need a "Hello, world." program by this afternoon.

 % letter
 letter: Command not found.
 % mail
 To: ^X ^F ^C
 % help mail
 help: Command not found.
 % damn!
 !: Event unrecognized
 % logout