Questo script prevede l’installazione di blat.

@echo.
@echo.
@echo Versione 1.1 del 30/04/2010 Guion Matteo
@echo Procedura di Salvataggio del Server
@echo -------------------------------------------

rsm refresh /lf"Hewlett Packard DAT72 drive"
sleep 30

C:\WINDOWS\system32\ntbackup.exe backup "@C:\Documents and Settings\pinco_pallino\Impostazioni locali\Dati applicazioni\Microsoft\Windows NT\NTBackup\data\backup_notturno.bks" /j "Backup" /v:yes /r:no /l:s /m normal /rs:no /hc:on /p "4mm DDS" /UM

@echo off
:::::::::::::: Inizializzazione variabili ::::::::::::::::
set email=email@email.it
set server=-serverSMTP 192.xxx.xxx.xxx
set subject1=-s "BACKUP Server 2003"
set subject2=-s "Sono accorsi alcuni errori sul server 2003"
set tof=-to %email% -f %email%
set attach=-attach "C:\Documents and Settings\pinco_pallino\Impostazioni locali\Dati applicazioni\Microsoft\Windows NT\NTBackup\data\*.log"
set msg1=-body "Vedere allegato per dettagli backup"
set msg2=-body "ATTENZIONE ##### Non e' stato torvato il file di log . Il backup potrebbe essere fallito!!!!!"

::::::::::::::::: Esecuzione di Blat!  :::::::::::::::::::
IF EXIST "C:\Documents and Settings\pinco_pallino\Impostazioni locali\Dati applicazioni\Microsoft\Windows NT\NTBackup\data\*.log" (blat %msg1% %tof% %subject1% %server% %attach%) ELSE (blat %msg2% %tof% %subject2% %server% %attach% )

:::::::::: Copia files di log in un unico file :::::::::::
set mese=%DATE:~3,2%
set giorno=%DATE:~0,2%
set anno=%DATE:~-4%

echo %giorno%
echo %mese%
echo %anno%

copy "C:\Documents and Settings\pinco_pallino\Impostazioni locali\Dati applicazioni\Microsoft\Windows NT\NTBackup\data\*.log" "E:\backup\log\backup.log"

::::::::::::::::: Cancellazione file di Log ::::::::::::::
IF EXIST "E:\backup\log\backup.log" (del "C:\Documents and Settings\pinco_pallino\Impostazioni locali\Dati applicazioni\Microsoft\Windows NT\NTBackup\data\*.log")

ren "E:\backup\log\backup.log" backup_%giorno%_%mese%_%anno%.log

Definisci in Scheme un programma su una procedura ricorsiva di coda, più eventuali procedure non ricorsive, per trovare minimo e massimo da una lista.

(define mix
  (lambda (m n)
    (if (< m n)
        m
        n)
    ))

(define max
  (lambda (m n)
    (if (> m n)
        m
        n)
    ))

(define f
  (lambda (txt)
    (f-tr txt (car txt) (car txt))
    ))

(define f-tr
  (lambda (t m n)
    (if (null?  (cdr t)) (list m n)
    (f-tr (cdr t) (mix m (mix (car t) (cadr t))) (man n (man (car t) (cadr t))))
    )))

(f '(2 3 4 1 5 4 3 7 9 10))

Altra soluzione assai più esigua che utilizza molto l’ingegno ;)

(define min-max
  (lambda (nums)
    (min-max-tr (car nums) (car nums) (cdr nums))
    ))

(define min-max-tr
  (lambda (min max nums)
    (if (null? nums)
        (list min max)
        (min-max-tr
         (if (< (car nums) min) (car nums) min)
         (if (> (car nums) max) (car nums) max)
         (cdr nums))
        )))

Definiamo in Scheme una procedura a valori procedurali cycle-funzione che data una lista restituisce una funzione periodica e restituisce il valore alla posizione indicata della lista:

(define cycle-fun
(lambda (n)
(lambda (count)
(if (= count 0)
(car n)
(if (> count 7) ((cycle-fun n)
(- count 8))
(list-ref n count)
)
)
)))

(define f (cycle-fun '(0 -1 -2 -1 0 1 2 1)))

;esempi di lancio della procedura
; f di 2 -> -2
; f di 11 -> -1
(f 2)
(f 11)

Soluzione “matematica” alternativa più complessa (secondo il mio punto di vista)

(define cycle-fun
  (lambda (p)
    (lambda (x)  ; x >= 0
      (list-ref p (remainder x (length p)))
      )))

Soluzione del problema con Scheme implementata da me:


(define shared
 (lambda (g h)
 (shared_com g h null )
 ))

(define shared_com
 (lambda (u v t)
 (cond ((=(length u) 0) t)
 ((=(length v) 0) t)
 ((= (car u) (car v)) (append t (list(car u)) (shared_com (cdr u) (cdr v) t)))
 ((> (car u) (car v)) (shared_com u (cdr v) t))
 ((< (car u) (car v)) (shared_com (cdr u) v t))
 )
 ))

(shared '(1 3 5 6 7 8 9 10) '(0 1 2 3 4 5 7 9))
Soluzione del problema proposta a lezione
(define shared
  (lambda (u v)
    (cond ((or (null? u) (null? v)) null)
          ((< (car u) (car v)) (shared (cdr u) v))
          ((> (car u) (car v)) (shared u (cdr v)))
          (else (cons (car u) (shared (cdr u) (cdr v))))
          )))

Valori procedurali in scheme:

(define tab-fun ; valore: procedura
(lambda (args vals) ; args, vals: liste di uguale lunghezza
(lambda (n)
(if (= n (car args))
(car vals)
((tab-fun (cdr args) (cdr vals)) n)
))
))

(define f (tab-fun '(0 1 2 3 4 5) '(2 3 5 7 11 13)))

(f 2)

Vedi un esempio dell’albero di Steinhaus con Scheme (lisp Language):

(define nxt
(lambda (sq op)
(let ((n (string-length sq)))
(if (= n 1)
""
(string-append
(if (op (string-ref sq 0) (string-ref sq 1))
(string-append (string #\0) (nxt (substring sq 1) op))
(string-append (string #\1) (nxt (substring sq 1) op))
)
)
))))

(define tri
(lambda (sq op)
(if (= (string-length sq) 1)
(list sq)
(cons sq (tri (nxt sq op) op))
)))

(tri "1101" char=? )

Altra soluzione potrebbe essere questa, più complessa da capire, ma più semplice da implementare!

(define nxt
(lambda (sq op)
(let ((n (string-length sq)))
(if (= n 1)
""
(string-append
(op (string-ref sq 0) (string-ref sq 1))
(nxt (substring sq 1) op))
))))

(define tri
(lambda (sq op)
(if (= (string-length sq) 1)
(list sq)
(cons sq (tri (nxt sq op) op))
)))
(tri "1101" (lambda (u v) (if (char=? u v) "0" "1")))

Da oggi ho reso disponibile un comodo pulsante in fondo agli articoli per poter condividere il contenuto sul vostro profilo di Facebook o Twitter in stile Social Network.
Il codice da inserire all’interno del file single.php e index.php del vostro tema di wordpress è il seguente:

 Condividi su:

 
 
 
 
 

Spero con questo di aumentare il numero di lettori di questo piccolo Site; inoltre spero di far cosa gradita ad alcuni visitatori sporadici ;)

Vediamo ora le differenze tra la programmazione in Scheme e Java; partiamo da una funzione semplice semplice che permette il reverse di una stringa (alfanumerica) e la vedremo nei vari linguaggi di programmazione:
1) In Scheme:

(define revi
(lambda (txt)
(if (= (string-length txt) 0)
txt
(string-append (string (string-ref txt (- (string-length txt) 1))) (revi (substring txt 0 (- (string-length txt) 1))))
)
))

Il concetto di base della funzione è la RICORSIONE, cioè richiamo la stessa funzione fino al termine del caso base.

2) Vediamo la stessa ricorsione in Java:

class rev
{
public static String revi (String parola)
{
int k = parola.length();
if (k < 1)
return parola;
else
{
parola = parola.charAt(k-1) + rev.revi (parola.substring (0, k-1));
}
return parola;
}
}

3) Vediamo la stessa funzione in Java con un ciclo:

class ribalta {

public static String ribalto (String testo) { int rigth ; rigth = testo.length(); StringBuffer dest = new StringBuffer(rigth); for (int index = (rigth -1); index >= 0; index--) dest.append(testo.charAt(index)); return dest.toString(); } }

AutoIt è un programma, o meglio un piccolo ambiente di macro-programmazione, attraverso il quale sarà possibile automatizzare delle procedure in ambiente Windows (o DOS). È particolarmente indicato per realizzare procedure automatiche di installazione per quei software che non ne posseggono una propria, per svolgere delle piccole procedure sul proprio PC o (al limite) su un gruppo di PC.
AutoIt è essenzialmente un interprete: esso eseguirà dunque tutte le azioni che noi avremo inserito, utilizzando il macro linguaggio messoci a disposizione, all’interno di opportuni file di testo (script). Tramite questi script è possibile far eseguire ad AutoIt un gran numero di funzioni quali ad esempio:
– esecuzione di applicazioni (applicazioni Windows, comandi DOS, etc.);
– simulazione della pressione dei tasti della tastiera o del mouse;
– gestione delle finestre di Windows (minimizzare, nascondere, massimizzare, chiudere, attendere apertura/chiusura, …);
– gestione della Clipboard.
Cosa molto importante: L’eseguibile di AutoIt è self contained e dunque non avrà bisogno né di DLL né di un programma di installazione per poter funzionare.
Inoltre grazie all’utility Aut2Exe è possibile, a partire dagli script di AutoIt, creare dei programmi direttamente eseguibili in ambiente Windows!
A questo link potete trovare del materiale.