Игорь Пашев

#!/usr/bin/node


function gcd2(a, b) {
    return b == 0 ? a : gcd2(b, a % b);
}

// Don't use parseInt() itself in map() - it used to have 2 arguments
var nums = process.argv.map(
        function(s) {return parseInt(s)}
    ).filter( // It will not work if this script or node itself is named as number ;-)
        function(t) {return !isNaN(t)}
    );

if (nums.length > 0) {
    var GCD = nums.reduce(gcd2); // Yeah, we could use lambda here
    console.log(GCD);
}

/*
 SYNOPSIS:

 With GCC >= 4.6:
 # gccgo gcd.go -o gcd-go
 # ./gcd-go 11 22 33 44 121

 With Google Go (6g for amd64, 8g for x86):
 # 6g -o gcd-go.o  gcd.go
 # 6l -o gcd-go-6g gcd-go.o
 # ./gcd-go-6g 11 22 33 44 121

 GCC makes dynamically linked binary,
 but Google Go - statically linked

*/

package main

// Both Google Go and GCC issue an error "imported and not used",
// if imported and not used :-)
import "fmt"
import "flag"
import "strconv"

func gcd2 (a, b uint) uint {
    if b == 0 {
        return a
    }
    /* 6g issues an error "function ends without a return statement",
       if we use if ... {... return} else {... return}.
       But GCC doesn't.
    */
    return gcd2(b, a % b)
}

func gcdn (ns []uint) uint {
    var r uint // zero by default
    for i := range ns {
        r = gcd2(r, ns[i])
    }
    return r
}

func main() {
    flag.Parse() // without this 6g will give flag.NArg() = 0 next (WTF?)
    n := flag.NArg()
    if n > 0 {
        ns := make([]uint, n) // We have garbage collector!

        // Or: for i := range ns, since range of ns is equal to flag.NArg()
        for i := 0; i < n; i++ {
            // Drop the second return value (error code):
            ns[i], _ = strconv.Atoui(flag.Arg(i))
        }

        g  := gcdn(ns)
        fmt.Printf("%v\n", g)
    }
}

--- gcd-x86-linux.s	2011-07-04 00:33:43.000000000 +0400
+++ gcd-x86-solaris.s	2011-07-14 20:31:09.000000000 +0400
@@ -68,12 +68,15 @@
     
     # printing the number:
     mov $4,   %eax # syscall `write'
-    mov $1,   %ebx # write to stdout
-    mov %edi, %ecx # first character to write
     mov $buf_end, %edx
     sub %edi, %edx # edx is a number of characters to write (buf_end - edi)
     inc %edx       # + new line
-    int $0x80      # do syscall (print the number)
+    push %edx
+    push %edi # first character to write
+    push $1   # write to stdout
+    push $0   # dummy
+    int $0x91 # do syscall (print the number)
+    add $16, %esp # clean stack 16 = 4 * 4 (32 bits!)
 
     ret
 
@@ -133,6 +136,7 @@
 
 exit:
     mov $1,   %eax  # exit syscall
-    xor %ebx, %ebx  # exit code = 0
-    int $0x80
+    push $0       # exit code = 0
+    push $0       # dummy
+    int $0x91
 

#!/usr/bin/env ruby

def gcd2 a, b
    if b == 0
        a
    else
        gcd2 b, a % b
    end
end

# http://railspikes.com/2008/8/11/understanding-map-and-reduce
def gcdn ns
    ns.reduce{ |a, b| gcd2 a, b }
end

puts gcdn ARGV.collect{ |s| s.to_i }

! SYNOPSIS:
!
! # gfortran -o gcd-f gcd.f03
! # ./gcd-f 11 22 33 121
!

program GCD
implicit none

integer, allocatable :: ns(:)
integer :: i, n
character*20 :: tmpstr

n = command_argument_count()

allocate(ns(n)) ! allocate memory for numbers given in command line

do i = 1, n
    call get_command_argument(i, tmpstr)
    ns(i) = str2int(tmpstr)
end do

print *,  gcdn(ns)

deallocate(ns)


! If we declare functions first,
! we have to specify its types within
! the `program' section.
! See http://en.wikibooks.org/wiki/Fortran/Fortran_procedures_and_functions
contains

pure integer function str2int (s)
    character*(*), intent(in) :: s
    read (s, *) str2int
end function

pure recursive integer function gcd2 (a, b) result(GCD)
    integer, intent(in) :: a, b
    if (b == 0) then
        GCD = a
    else
        GCD = gcd2(b, mod(a, b))
    end if
end function gcd2

pure integer function gcdn(n)
    integer, intent(in) :: n(:) ! n is an array
    integer :: i
    gcdn = n(1)
    do i = 2, size(n)
        gcdn = gcd2(gcdn, n(i))
    end do
end function

end program

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

char n[] = "00";

void next (char *n)
{
    ++(*n);
    while (*n > '9') {
        *n = '0';
        ++n;
        if (*n != '\0')
            ++(*n);
        else
            break;
    }
}


int happy (char n[], size_t l)
{
    size_t i;
    int s = 0;
    for (i = 0; i < l/2; ++i)
        s += n[i];
    for (i = l/2; i < l; ++i)
        s -= n[i];
    return s;
}

int main ()
{
    int i;
    size_t l;
    size_t count = 0;;
    l = strlen(n);
    for (i = 0; i < pow(10, l); ++i) {
        printf("%s -> ", n);
        if (0 == happy(n, l)) {
            printf("happy :-)\n");
            ++count;
        }
        else
            printf("usual :-(\n");
        next(n);
    }

    printf ("Total happy: %lu\n", (unsigned long)count);
    return EXIT_SUCCESS;
}

#!/usr/bin/env lua

-- SYNOPSIS:
-- # chmod +x gcd.lua; ./gcd.lua 121 22 33 44
-- # lua gcd.lua 121 33 22

-- http://www.lua.org/pil/6.3.html
function gcd2(a, b)
    if b == 0 then
        return a
    else
        return gcd2(b, a % b)
    end
end

function gcdn(ns)
    r = ns[1]
    local r = ns[1]
    for i = 2, table.maxn(ns) #ns do
        r = gcd2(r, ns[i])
    end
    return r
end

print(gcdn(arg))

#!/usr/bin/env python3
#coding: utf8

import io

class Modem:
    def __init__(self, dev='/dev/ttyUSB1'):
        self.stream = io.open(dev, 'w+b', 0)

    def __write(self, s):
        self.stream.write(str.encode('{}\r\n'.format(s)))

    def close(self):
        self.stream.close()

    def ussd(self, code):
        self.__write('AT+CUSD=1,{},15'.format(code))

    def balance(self, code='*100#'):
        self.ussd(code)
        for l in self.stream:
            if l.startswith(b'+CUSD'):
                msg = l[10:l.rfind(b'"')].decode('ascii')
                return bytes.fromhex(msg).decode('utf-16-be')

    def sendSMS(self, phone, msg):
        self.__write('AT+CMGS="{}"'.format(phone))
        self.__write('{}\x1a'.format(msg))



modem = Modem()
modem.sendSMS('+7XXXXXXXXXX', 'test')

#!/usr/bin/env python3
#coding: utf8
import time, io

class Modem:
    p = None
    def __init__(self, dev='/dev/ttyUSB1'):
        self.open(dev)

    def open(self, dev):
        #self.close()
        self.p = io.open(dev, 'w+b', 0)
    
    def write(self, s):
        self.p.write(str.encode(s) + b'\r\n')
        time.sleep(0.1)

    def close(self):
        self.p.close()

    def ussd(self, code):
        self.write('AT+CPBS="SM"')
        self.write('AT+CPMS="SM","SM",""')
        self.write('AT+ZSNT=0,0,2')
        self.write('AT+CUSD=1,' + code + ',15')

        for ln in self.p:
            if ln.startswith(b'+CUSD'):
                msg = ln[10:ln.rfind(b'"')].decode('ascii')
                return bytes.fromhex(msg).decode('utf-16-be')

    def balance(self, code='*100#'):
        return self.ussd(code)

modem = Modem()
print(modem.balance())