Les commandes Unix/Linux

Outils de partitionnement : 

Fdisk cfdisk pdisk Norton Partition Magic Les types de Partitions: Partition primaire (Principale): Nbre Max = 4 / Partition étendue: Nbre Max = 1
Kernel (noyau) : gestion du système de fichier,du processeur, de la mémoire centrale et despériphériques
Shell : interpréteur de commande (bash, ksh,csh, zsh, etc.)

Le système de fichiers:

- Ext3fs: Journalisé (récupération rapide en cas d'arrêt brutal).Utile pour gros disques durs
– Quotas disponibles
 – ACL supportés
– Passage d'Ext2fs à ext3fs facile / ReiserFS/ ext2fs

L'arborescence du système linux:

/bin contient les exécutables essentiels au système,employés par tous les utilisateurs
/boot contient les fichiers permettant à Linux dedémarrer (Modules du noyau)
/dev contient les points d'entrée des périphériques
/etc contient les commandes et les fichiers nécessairesà l'administateur du système
/home répertoire personnel des utilisateurs
/opt contient des packages d'applicationssupplémentaires

Commandes de Base :

«ls» : lister le contenu d’un répertoire
«rm» : supprimer un fichier
«cp» : copier un fichier
«ln» : créer un lien sur un fichier
«man» : afficher l’aide d’une commande
«mv» : déplacer un fichier
«cd» : changer de répertoire
«mkdir» : créer un répertoire
«rmdir» : supprimer un répertoire
«pwd» : afficher le répertoire courant
«cat» : afficher le contenu d’un fichier
«file» : afficher le type de contenu du fichier
«locate» : localiser un fichier sur le disque
«adduser» : ajouter un utilisateur
«deluser» : supprimer un utilisateur
«usermode» : changer les propriétés d’un compte
«passwd» : changer le mot de passe
cat nom_fichier affiche le contenu du fichier
cat fich1 fich2 Affiche deux fichiers à la fois
cat > nom_fichier créer un nouveau fichier si'il n'existe pas sinon son contenu sera écrasé fin de saisie par "ctrl+d"
cat fich1 > fich2 : envoie fich1 à fich2 si fich2 existe il sera ecrasé, sinon il sera créé
cat fich1 >> fich2 : ajoute le contenu de fich1 à celui de fich2
cat >> fich2 ajoute le texte saisie à fich2
more : visualisation par page (descente seule)
less : visualisation par page (montée et descente)
head : partie sup. d'un fichier
tail : Partie inf d'un fichier
wc : Comptage du nombre de mots, lignes ouCaractères
file : Afficher le type d'un fichier
diff : Différences entre deux fichiers
sort : Tri du contenu d'un fichier
file : Afficher le type d'un fichier
grep : Rechercher un mot dans un fichier
chmod : Changer les permissions
umask affiche le masque de l'utilisateur actif
umask Saffiche les permissions correspondantesau masque, sous forme symbolique.
umask masque fixe les permissions ultérieures decréation des fichiers de l'utilisateur actif,
chgrp : Changer le groupe
ls > essai– envoie le résultat de ls dans essai
ls >> essai2– envoie le résultat de ls dans essai2 avec concaténation
ls –z 2> essai3– le message d'erreur sera envoyé à essai 3
cat < essai4– affiche
cat < essai4 >> essai1
&> redirige la sortie standard et la sortie d’erreur
2> redirige la sortie d’erreur
>> concatène la sortie standard
> redirige la sortie standard
< redirige l’entrée standard

vi nom_fichier

APPELL

vi –R nom_fichier : pour éditer un fichier en
lecture seule
vi : Pour ouvrir un nouveau fichier sans nom

RENSIEGNEMENT

:se ts=n fixe la tabula

tion à n caractère
( par défaut = 8)
:se nu Affiche les numéros de ligne
:se nonu Supprime les numéros de lignes
:.= affiche le numéro de la ligne courante
<ctrl>+g ou :f affiche l’état du fichier
: e! réedite le fichier tel qu’il est sur le disque

DEPLACEMENT

<ctrl> + b Page précédente (back)
<ctrl> + f Page précédente ( Forward)
G Dernière ligne
nG Ligne n
H Haut de l’écran ( high )
M Milieu de l’écran ( Middle )
L Bas de l’écran
n <espace> n caractères vers la droite
0 Début de la ligne^ Premier caractère non blanc
$ dernier caractère de la ligne
ou k Ligne précédente
ou j Ligne suivante
ou l vers la droite
ou h vers la gauche
n <Return> n lignes vers
+ ou <Return> début de la ligne suivante / - début de la ligne précédente

RECHERCHE

/motif <return> Recherche motif vers l’avant
?motif <return> Recherche motif vers l’arrière
n Répète la dernière commande de recherche

INSERTION

i ….. <ESC> Avant le curseur
I ….. <ESC> Au début de la ligne courante
a ….. <ESC> Après le curseur
A ….. <ESC> En fin de la ligne courante
o ….. <ESC> Au dessous de la ligne courante
O ….. <ESC> Au dessus de la ligne courante

MODIF ET REMPLACEMENT

<ctrl>+u Annule le texte inséré de la ligne courante
<ctrl>+v Insère le caractère spécial qui suit
<ctrl>+l Insère un saut de page
r # Remplace le caractère courant par #
R ….<ESC> Remplace la chaine de caractères
courante par la chaine entre R et <ESC>
~ Bascule de Majuscule en minuscule et inversement
. Répète la dernière commande modifiant le texte

Effacements:

x Effacement du caractère sous le curseur
3x de 3 caractères à partir de la position ducurseur
dd de la ligne où se trouve le curseur
4dd de 4 lignes à partir de la ligne du curseur

Restitution :

u Restitution de la dernière modification(undo)
U La ligne courante avant modification (sauf dd)
P dernière commande d'effacement

MOUVEMENTS DE LIGNE

J joint la ligne courante et la suivante
r<Return> brise en 2 lignes à partir de la position du curseur
yy Place la ligne courante dans le tampon de travail
dd idem avec effacement de la ligne
10yy Place 10 lignes courante dans le tampon de travail
10dd idem avec effacement

DECALAGE

>> (ou <<) décalage vers la droite(ou vers la gauche) de toute la ligne de m positions, m étant définit par la commande set sw=m( par défaut m=8)
n>> (ou <<) décalage des n lignes suivantes
: n1, n2 >> ( ou n1,n2<<) décalage des lignes n1à n2

SUBSTITUTIONS

:s/old/new/p substitution du 1er "old" de la ligne courante par "new"
:s/old/new/gp Substitution de tous les old de la ligne courant par new
i,j s/old/new/p substitution des 1ers old des lignes i à j par new
i,j s/old/new/gp substitution de tous les old des lignes i à j par new
:u annule la plus récente substitution réalisée

INSERTIONS DE FICHIERS

:nr nom_fichier insère le fichier nommé après la ligne n
:r nom_fichier insère le fichier nommé après la ligne courante

shell

echo, affiche son argument texte la sortie standard.
l'option e pour insérer les caractères spéciaux : \n (saut ligne), \b (retour arrière), \t (tabulation), \a (alarme), \c (fin sans saut de ligne) echo"Bonjour à tous !" echo e"Bonjour \nà toutes \net à tous ! "
read, permet l'affectation directe par lecture de la valeur,
echo "Donnez votre nom et prénom "  read prenom nom  echo "Bonjour $prenom $nom"
set affichera la liste des variables actuelles ainsi que leurs valeurs
unset pour supprimer une variable (a=Bon b=jour  echo $a$b echo $asoir echo ${a}soir Bonjour)
alias: affiche la liste de tous les alias / alias la=‘ls –al’ : pour remplacer la commande « ls –al » par la
fonction shell Sortie() / { / clear / echo déconnexion / exit / } .
à appel d un Shell sh nom_script ./ nom_script
variables spéciales
$0 est le nom dans lequel le script est appelé
$# est le nombre de paramètres passés en argument
$* est la liste des paramètres passés en argument
$? est le code de retour de la dernière commande (0 :si la commande a été correctement exécutée
$1, $2, …, $9: représentent les arguments du script
Exemple ( <<vi my_script>> création : echo $0 a été appelé avec $# paramètres echo qui sont :$* )
Exécution :(<<sh my_script a b c d>> my_script a été appele avec 4 paramètre qui sont : a b c d )

L'instruction

If commande then commandes fi (exemple : if grep –i "tarik" /etc/passwd  then echo L\'utilsateur tarik est connu du système fi )
If commande then commandes else commande fi

Exercices java

Exercices Java :

EXERCICE 1 afficher une saisie
Ecrire un programme qui demande à l’utilisateur de saisir un nom au clavier. Puis le
programme affiche bonjour suivi du nom de la personne.
***************

EXERCICE 2 : afficher une saisie
Ecrire un programme qui demande à l’utilisateur de saisir le mot monsieur ou madame.
Ensuite, il devra saisir son nom. Puis le programme affiche Bonjour suivi de monsieur ou
madame selon la saisie suivi du nom saisi
***************
EXERCICE 3 afficher une table de multiplication
Ecrire un programme qui demande à l'utilisateur d’entrer un nombre entier. Puis le
programme affiche la table de multiplication de ce nombre de 0 à 10
Rappel :
la fonction System.out.println() affiche tel quel ce qui est entre double crochets (" ") et affiche
le contenu de la variable qui n' est pas entre crochet.
***************
EXERCICE 4 : inverso
Ecrire un programme qui affiche l'inverse des nombres entiers allant de -3 à +3.
Rappel :
En effet, l’inverse de zéro n’existe pas. Car la division par zéro est impossible.
***************
EXERCICE 5 : afficher le carré d’une série de nombres
Ecrire un programme qui affiche le carré des nombres entiers pairs allant de 0 à 10 inclus
***************
EXERCICE 6 : trier un nombre au hasard dans un intervalle précis.
Ecrire un programme qui affiche au hasard un nombre entier compris entre 0 et 50. Puis le
programme affiche au hasard un nombre compris entre 11 et 25. Puis le programme affiche un
nombre au hasard entre - 10 et + 25.
Rappel :
Math.random() fournit un nombre pris au hasard dans l' intervalle fermée à 0 et ouvert à 1.
**********
EXERCICE 7 : trier 2 nombres au hasard
Ecrire un programme qui affiche deux nombres entiers pris au hasard entre 0 et 50 avec la
condition que l’un doit forcément être le double de l’autre.
**********
EXERCICE 8 : mettre fin au programme grâce à une saisie
Ecrire un programme qui demande à l’utilisateur d’entrer un caractère Puis le programme
affiche ce caractère. Ainsi de suite ! Le programme s’arrête seulement si l’utilisateur entre le
caractère 't'. A ce moment, le programme affiche : fin du programme.
Rappel :
sc.nextLine().charAt(i) ; est la méthode permettant de saisir un caractère.
**********
EXERCICE 9 : le maximum d’une série de valeurs entrées au clavier
Ecrire un programme qui demande à l’utilisateur de saisir une série de nombres entiers
positifs. Pour arrêter la saisie, on entre la valeur zéro. Puis le programme affiche la plus
grande des valeurs.
**********
EXERCICE 10 : le minimum d’une série de valeurs
Ecrire un programme qui demande à l’utilisateur de saisir une série de nombres entiers
positifs. Pour arrêter la saisie, on entre la valeur zéro. Puis le programme affiche la plus petite
des valeurs.
L’instruction break permet de sortir de la boucle.
**********
EXERCICE 11 : somme d’une série de valeurs entrées au clavier
Ecrire un programme qui demande à l’utilisateur de saisir une série de nombres entiers
positifs. Pour arrêter la saisie, on entre la valeur zéro. Puis le programme affiche la somme
des valeurs.
Rappel :
somme += saisie; <=> somme = somme + saisie; Donc, ancienne valeur de somme = nouvelle
valeur de somme + valeur de saisie. Ainsi de suite, on accumule la somme des valeurs jusqu' à
la fin de la saisie. D' où l’affichage de la somme.
*********
EXERCICE 12 : moyenne d’une série de valeurs entrées au clavier
Ecrire un programme qui demande à l’utilisateur de saisir une série de nombres réels non
nuls. Pour arrêter la saisie, on entre la valeur zéro. Puis le programme affiche la moyenne des
valeurs. Attention, la valeur zéro entrée pour terminer la saisie ne fera pas partie de la saisie.
*********
EXERCICE 13 : Nombre secret
Ecrire un programme qui tire au hasard un nombre entier compris entre 1 et 10. Ce nombre
(secret) n’est pas affiché. Puis le programme demande à l’utilisateur d’entrer un nombre entier
au hasard entre 1 et 10. Si le nombre de l’utilisateur est supérieur au nombre secret, le
programme lui indique en lui demandant d’entrer un nouveau nombre. De même si le nombre
est inférieur. Puis, lorsque l’utilisateur trouve, le programme lui dit qu’il a gagné en lui
indiquant le nombre de fois qu’il lui a fallu pour trouver le nombre.
*********
EXERCICE 14 : résoudre une équation du second degré à une inconnue
Ecrire un programme qui permet de résoudre une équation de 2nd degré à une inconnue : ax2
+ bx + c. L’utilisateur entre les trois paramètres de l’équation : a, b et c. Puis le programme
affiche la solution.
Rappel :
Math.sqrt() est une fonction qui fournit la racine carrée du nombre qui se trouve dans ses
parenthèses.
*********
EXERCICE 15 : Nombre de jours dans un mois.
Ecrire un programme qui demande à l’utilisateur de saisir le mois et l’année. Puis le
programme affiche le nombre de jours de ce mois.
Rappel : Janvier, Mars, Mai, Juillet, Août, Octobre et Décembre ont toujours 31 jours quelque
soit l’année. Avril, Juin, Septembre et Novembre ont toujours 30 jours quelque soit l’année.
Le nombre de jours de février est égal à 28. Sauf les années bissextiles. Une année est
bissextile lorsqu' elle est divisible par 4 et non par 100. Ou alors, elle est divisible par 400.
Rappel :
Le switch n’accepte que les variables de type int (ou des types dont la conversion peut être
implicite, char, byte et short).
System.exit() permet de sortir d' un programme. c’est la fonction (méthode) exit() de la classe
System.
*********
EXERCICE 16 : Présence d’un caractère dans une chaine
Ecrire un programme qui demande à l’utilisateur de saisir un caractère. Puis le programme
affiche le nombre de fois où l’on trouve ce caractère dans une chaine préenregistrée.
Rappel :
nombre de caractères : chaine.length().
La méthodecharAt(i) renvoie le caractère situé à la position i.
**********
EXERCICE 17 : Somme des n premiers nombres entiers
Ecrire un programme qui demande à l’utilisateur de saisir un nombre entier n, positif et non
nul. Puis le programme affiche la somme des n premiers nombres entiers positifs non nuls.
Exemple : on saisit 4 et le programme affiche 10. Car 1 + 2 + 3 + 4 = 10.
Testez différents nombres, vous verrez.
Rappel : <= veut dire inférieur ou égal.
**********
EXERCICE 18 : produit des n premiers nombres entiers
Ecrire un programme qui demande à l’utilisateur de saisir un nombre entier n positif et non
nul. Puis le programme affiche le produit des n premiers nombres entiers positifs non nuls.
Exemple : on saisit 4 et le programme affiche 24. Car 1 * 2 * 3 * 4 = 24.

EXERCICE 19 : factoriel d’un entier positif non nul
Ecrire un programme qui demande à l’utilisateur de saisir un nombre entier positif non nul.
Puis le programme affiche la valeur du factoriel de ce nombre.

EXERCICE 20 : combinaison de p dans n
Ecrire un programme qui demande à l' utilisateur de saisir deux entiers positifs non nuls p et
n. p étant bien sûr inférieur à n. Puis le programme affiche la combinaison de p dans n.
Rappel : combinaison de p dans n = factoriel de n divisé par (factoriel de p multiplié par
factoriel de n moins p) = n!/p! * (n-p)!

SQL Saturday #273 Tampa - I'm speaking!

I'll be speaking at SQL Saturday #273 in Tampa on February 22, 2014.



If you work in an organization that is finding it increasingly difficult to allow SQL Server DBAs 24x7x365 sysadmin access to your Production servers, then I think you will find my session "SQL Server Security Easy Button" very interesting.

Attendees will learn how to define a permission set with a single script that allows database administrators to do routine work without sysadmin permission and how to elevate permissions quickly to respond to production emergencies.

Attendees will leave this session with a complete script that provides the minimum necessary access database administrators require to maintain the database server without granting access to business data.

In addition, I�ll talk about our real world experience with reduced permissions.



I'm looking forward to SQL Saturday #273 in Tampa.



Hope to see you there!

Exercices corrigés en algorithmique : Instructions répétitives - les boucles

Exercice 1 :

Ecrire un algorithme permettant de lire une suite de nombres réels sur le clavier. Le dernier élément à lire est un zéro.
L’algorithme doit afficher le plus petit élément de la suite ainsi que la somme des éléments lus.


Correction exercice 1 :

Algorithme  lire_une_suite;
Var
            a,s : réels ;
Debut
              Repeter
                        Ecrire(‘entrer un  nombre: ‘) ;
                        Lire(a) ;
                        S<-- s+a ;
              Jusqu'à (a=0)
              Ecrire(‘la somme des nombres est :  ‘,s) ;
fin


Exercice 2 :

Ecrire un algorithme qui lit les noms des athlètes désirant participer à un marathon et s’arrête lorsqu’il rencontre deux noms consécutifs identiques.
L’algorithme doit afficher , à la fin , le nombre de participants.


Correction exercice 2 :

Algorithme  lire_une_suite;
Var
            Nom1,nom2 : chaine de 30 caractères ;
            Compteur  i  :entier ;
Debut
                Ecrire(‘entrer un nom d’athlète   : ‘) ;
                Lire(nom1) ;
                Ecrire(‘entrer un nom d’athlète   : ‘) ;
                Lire (nom2) ;
                i <--  2 ;
              Tantque(nom1 <> nom2)
                        Nom1 <--  nom2 ;
                        Ecrire(‘entrer un  nom d’athlète  : ‘) ;
                        Lire(nom2) ;
                        i<-- i+1;
              Fintantque
              Ecrire(‘le nombre des participants est :  ‘,i) ;
fin


Exercice 3 :

Dans un cinéma , on désire calculer la moyenne  d’âges de personnes s’intéressant à voir un film particulier.
Pour finir, l’utilisateur doit répondre par ‘N’ à la question posée par l’algorithme :
‘’ Encore une autre personne (O/N) ? ’’
Et on doit afficher la moyenne d’âges des personnes à l’ecran.


Correction exercice 3 :

Algorithme  moyenne_age;
Var
            i ,age,som :entier ;
Debut
                i <--  0 ;
                age <--  0 ;
                Repeter
                        Ecrire(‘ entrer l’age du personne ’) ;
                        Lire(‘age’ ) ;
                          i<--  i+1 ;
                        Som <--  som+ age ;
                          Ecrire(‘Encore une autre personne (O/N) ?’)
                          Lire(rep) ;
                Jusqu'à (rep=’N’)
              Ecrire(‘la moyenne d’âges des personnes  est :  ‘,som/i) ;
fin


Exercice 4 :

Ecrire un algorithme permettant de calculer la factorielle d’un nombre entier positif N.
N ! = 1*2*3*……..*N


Correction exercice 4 :

Algorithme  factorielle;
Var
              i ,N,fact:entier ;
Debut
                fact<--  1 ;
                pour i=1 à N faire
                             fact<-- fact*i ;
                Finpour  i
              Ecrire(‘ la factorielle de  ’ ,N,’  est   : ‘,fact  ) ;
fin


Exercice 5 :

Pour avoir une idée sur le niveau des éleves d’une classe, on a décidé de calculer la moyenne  de la classe à partir des moyennes générales de tous les élèves qui sont au nombre de 30.
         Moy =
Ecrire un algorithme de résolution.


Correction exercice 5 :

Algorithme  moyenne_classe;
Var
              i   :entier ;
                NT ,som: réels
const
                nb=30 ;
Debut
                Som <--  0 ;
                pour i=1 à N faire
                            Ecrire(‘ entrer la note N°’,i,’ :’) ;
                            Lire(NT) ;
                            Som<-- som+NT ;
                Finpour  i
              Ecrire(‘ la moyenne de la classe est : ‘,som/nb ) ;
fin


Exercice 6 :

Ecrire un algorithme qui permet de retrouver le maximum, le minimum ainsi que la somme d’une liste de nombres positifs saisis par l’utilisateur. La fin de la liste est indiquée par un nombre négatif. La longueur  de la liste n’est pas limitée.
Exemple :              si la liste des éléments est : 7   3   20     15    2      6    5   -1
                                Le maximum est 20  , le minimum est 2 .


Correction exercice 6 :

Algorithme  moyenne_age;
Var
            i ,n,som :entier ;
Debut
                Ecrire(‘ entrer un nombre ’) ;
              Lire(‘n’ ) ;
                max<--  n ;
                min <--  n ;
                som <--  n ;
                Tantque n>0  faire
                        Ecrire(‘ entrer  un nombre’) ;
                        Lire(‘n’ ) ;
                         Si min>n  alors
                                Min <--  n ;
                         Finsi
             Si max<n  alors
                                 Max <--  n ;
                          Finsi
                fintantque
              Ecrire(‘Le maximum est  ‘,max ,’ le minimum est ‘,min) ;
fin

Exercices corrigés en algorithmique : Les tableaux

Exercice 1 :

Ecrire un algorithme permettant  d’entrer cinq valeurs réelles au clavier,les stocker dans un tableau, calculer leur somme et les afficher avec leur somme à l’ecran.

Correction exercice 1 :

Algorithme  tableau_somme;
Var
              V   : tableau [1..5] de réels ;
              S   :  réel ;
i  :entier;
Debut
                (*lecture  des élements  du tableau*)
                Pour i <--  1 à 5 faire
                               Ecrire(‘entrer l’element  N° ’,i);
                               Lire(V[i]) ;
                Finpour i
                (*calcul de la somme des élements du tableau *)
                S <--  0 ;
Pour i <--  1 à 5 faire
                               S <--  S + V[i] ;
                Finpour i
(*afficher des éléments du tableau *)
                Pour i <--  1 à 5 faire
                               Ecrire(‘l’’element  N° ’,i,’est : ‘,V[i]);
                Finpour i
                Ecrire(‘la somme des éléments du tableau est :‘,S) ;
fin


Exercice 2 :

Ecrire un algorithme permettant  de saisir et d’afficher N éléments d’un tableau.


Correction exercice 2 :

Algorithme  saisie_affichage;
Var
              T   : tableau [1..100] de réels ;
              N,i   :  réel ;
Debut
                Ecrire(‘entrer le nombre d’éléments du tableau :’) ;
                Lire(N) ;
                (*lecture  des élements  du tableau*)
                Pour i <--  1 à N faire
                               Ecrire(‘entrer l’element  N° ’,i);
                               Lire(T[i]) ;
                Finpour i
(*afficher des éléments du tableau *)
                Pour i <--  1 à N faire
                               Ecrire(‘l’’element  T[’,i,’] est : ‘,T[i]);
                Finpour i
Fin


Exercice 3 :

Ecrire un algorithme permettant  de calculer la somme,produit et moyenne des  éléments d’un tableau.


Correction exercice 3 :

Algorithme  somme_produit_moyenne;
Var
              T   : tableau [1..100] de réels ;
              N,i   :  entiers ;
                S,P,M :  réels ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                         S <--  0 ;
                         P <--  1 ;
                         Pour i <--  1 à N faire
                               S <--  S+T[i] ;
                               P <--  P * T[i] ;
                           Finpour i
                           M <--  S/N ;
                            Ecrire(‘la somme des éléments du tableau est : ‘,S);
                Ecrire(‘le produit des éléments du tableau est : ‘,P);
                Ecrire(‘la  moyenne des éléments du tableau est : ‘,M);
Finsi
Fin


Exercice 4 :

Ecrire un algorithme permettant  de consulter un  élément d’un tableau.

Correction exercice 4 :

Algorithme  consultation;
Var
              T   : tableau [1..100] de réels ;
              N,P   :  entiers ;
Debut
                Si N=0 alors
                        Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer l’’indice de l’’élément à consulter :’) ;
                        Lire(P) ;
                        Si (P<1) ou (P>N) alors
                                Ecrire(‘Position hors limites du tableau ‘)
                        Sinon
                                Ecrire(‘l’’élément à consulter est :’,T[P]) ;
                         Finsi
                Finsi
Fin


Exercice 5 :

Ecrire un algorithme permettant  de chercher toutes les occurrences d’un  élément  dans un tableau.


Correction exercice 5 :

Algorithme  recherche_toutes_occurences ;
Var
              T   : tableau [1..100] de réels ;
              N,i   :  entiers ;
                X : réel ;
                Existe : booléen ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        Existe <--  Faux ;
                        Pour i <--  1  à N  Faire
                                Si T[i] = X alors
                                               Existe <--  Vrai ;
                                               Ecrire(‘l’’élément à chercher apparait à la position : ‘,i) ;
                                Finsi
                         Finpour i
                         Si Existe = Faux alors
                                   Ecrire(‘l’’élément n’’apparait pas dans ce tableau ‘) ;
                           Finsi
                 Finsi
Fin


Exercice 6 :

Ecrire un algorithme permettant  de chercher  la première occurrence d’un élément dans un tableau.


Correction exercice 6 :

Algorithme  recherche_première_occurence ;
Var
T   : tableau [1..100] de réels ;
             P, N,i   :  entiers ;
                X : réel ;
                Existe : booléen ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        Existe <--  Faux ;
                        i <--  1 ;
                        tantque  (i<=N) et (Existe=Faux) Faire
                                Si T[i] = X alors
                                               Existe <--  Vrai ;
                                               P<--  i ;
                                Sinon
                                               i ßi+1 ;
                                Finsi
                       Fintantque
                       Si Existe = vrai alors
                                Ecrire(‘la première occurrence de l’élément dans ce tableau est :’,P) ;
                       Sinon
                                Ecrire(‘l’’élément n’’apparait pas dans ce tableau ‘) ;
                      Finsi
                Finsi
Fin


Exercice 7 :

Ecrire un algorithme permettant  de chercher  la dernière occurrence d’un élément dans un tableau.


Correction exercice 7 :

Algorithme  recherche_derniere_occurence ;
Var
T   : tableau [1..100] de réels ;
             P, N,i   :  entiers ;
                X : réel ;
                Existe : booléen ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        Existe <--  Faux ;
                        i <--  N ;
                        tantque  (i>=1) et (Existe=Faux) Faire
                                Si T[i] = X alors
                                               Existe <--  Vrai ;
                                               P<--  i ;
                                Sinon
                                               i <-- i-1 ;
                                Finsi
                       Fintantque
                       Si Existe = vrai alors
                                Ecrire(‘la dernière occurrence de l’élément dans ce tableau est :’,P) ;
                       Sinon
                                Ecrire(‘l’’élément n’’apparait pas dans ce tableau ‘) ;
                      Finsi
                Finsi
Fin


Exercice 8 :

Ecrire un algorithme permettant  de calculer le nombre de fois pour lesquelles un  élément  apparait dans un tableau.


Correction exercice 8 :

Algorithme  frequence;
Var
              T   : tableau [1..100] de réels ;
              N,i,F   :  entiers ;
                X : réel ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                        Ecrire(‘entrer la valeur de l’’élément à chercher  :’) ;
                        Lire(X) ;
                        F <--  0 ;
                        Pour i <--  1  à N  Faire
                                Si T[i] = X alors
                                               F <--  F+1 ;
                                Finsi
                         Finpour i
                                   Ecrire(‘l’’élément  apparait : ‘, F,’fois dans ce tableau ‘) ;
                 Finsi
Fin


Exercice 9 :

Ecrire un algorithme permettant  d’ajouter un élément a la fin d’un tableau.


Correction exercice 9 :

Algorithme  Ajout;
Var
              T   : tableau [1..100] de réels ;
              N :  entiers ;
                X : réel ;
                Rep : caractère ;
Debut
                Ecrire(‘entrer la valeur de l’’élément à ajouter   :’) ;
                Lire(X) ;
                 Ecrire(‘Confirmer l’ajout (O/N) :’) ;
                 Lire(Rep) ;
                Si Rep =’O’ alors  (*la valeur ‘o’ pour ‘oui’ ! et ‘N’ pour ‘Non’ *)                    
                               N<--  N+1 ;(* il y aura un élément en plus *)
                                T[N] <--  X ;
                 Finsi
Fin


Exercice 10 :

Ecrire un algorithme permettant  de modifier  un élément  dans un tableau.


Correction exercice 10 :

Algorithme Modification;
Var
              T   : tableau [1..100] de réels ;
              N ,P:  entiers ;
                X : réel ;
                Rep : caractère ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                Ecrire(‘entrer l’indice de l’’élément à  modifier :’) ;
                Lire(P) ;
                      Si (P<1) ou (P>N) alors
                                Ecrire(‘Position hors limites du tableau ‘)
                       Sinon
                                Ecrire(‘L’ancienne valeur dans cette position est :’,T[p]) ;
                                Ecrire(‘Entrer la nouvelle valeur :’) ;
                                Lire(X) ;
                                Ecrire(‘Confirmer  la modification (O/N) ‘) ;
                                Lire(Rep) ;
                                Si Rep=’O’ Alors
                                          T[P]<--  X ;
                                Finsi
                       Finsi
                Finsi
Fin


Exercice 11 :

Ecrire un algorithme permettant  d’insérer  un élément  dans un tableau  (au début , au milieu ou  à la fin).


Correction exercice 11 :

Algorithme  insertion;
Var
              T   : tableau [1..100] de réels ;
              N ,P,i:  entiers ;
                X : réel ;
                Rep : caractère ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                Ecrire(‘entrer la valeur de l’’élément à insérer  :’) ;
                Lire(X) ;
                 Ecrire(‘ Entrer la position d’insertion :’) ;
                 Lire(P) ;
                      Si (P<1) ou (P>N) alors
                                Ecrire(‘Position hors limites du tableau ‘)
                       Sinon
                                Ecrire(‘Confirmer l’insertion (O/N) ‘) ;
                                Lire(Rep) ;
                                Si Rep=’O’ Alors
                                               N <--  N+1 ;
                                               Pour i <--  N à P+1 Faire
                                                               T[i] <--  T[i-1] ;
                                               Finpour i
                                               T[P]<--  X ;
                                Finsi
                       Finsi
                Finsi
Fin


Exercice 12 :

Ecrire un algorithme permettant  de supprimer  un élément  dans un tableau.


Correction exercice 12 :

Algorithme  suppression;
Var
              T   : tableau [1..100] de réels ;
              N ,P,i:  entiers ;
                Rep : caractère ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                                Ecrire(‘entrer l’indice  de l’’élément à supprimer  :’) ;
                                Lire(P) ;
                               Si (P<1) ou (P>N) alors
                                        Ecrire(‘Position hors limites du tableau ‘)
                              Sinon
                                         Ecrire(‘la valeur dans cette position est :‘,T[P]) ;
                                         Ecrire(‘Confirmer la suppression  (O/N) ‘) ;
                                         Lire(Rep) ;
                                         Si Rep=’O’ Alors
                                                 N <--  N+1 ;
                                                 Pour i <--  P à N-1 Faire
                                                               T[i] <--  T[i+1] ;
                                                 Finpour i
                                                  N <--  N-1; (*il y aura un élément en moins*)
                                           Finsi
                            Finsi
                Finsi
Fin


Exercice 13 :

Ecrire un algorithme permettant  de trier  par ordre croissant les éléments  d’un tableau.


Correction exercice 13 :

Algorithme  tri_Croissant;
Var
              T   : tableau [1..100] de réels ;
              N ,i,j:  entiers ;
                Aux: réel ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                          Pour i <--  1 à N-1 Faire
                                               Pour j <--  i+1 à N  Faire
                                                           Si T[i] > T[j]  alors
                                                                    Aux <--  T[i] ;
                                                                    T[i] <--  T[j] ;
                                                                    T[j] <--  Aux ;
                                                               Finsi
                                             Finpour j
                           Finpour i
                Finsi
Fin


Exercice 14 :

Ecrire un algorithme permettant  de trier  par ordre décroissant les éléments  d’un tableau.


Correction exercice 14 :

Algorithme  tri_Décroissant;
Var
              T   : tableau [1..100] de réels ;
              N ,i,j:  entiers ;
                Aux: réel ;
Debut
                Si N=0 alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                          Pour i <--  1 à N-1 Faire
                                               Pour j <--  i+1 à N  Faire
                                                           Si T[i] < T[j]  alors
                                                                    Aux <--  T[i] ;
                                                                    T[i] <--  T[j] ;
                                                                    T[j] <--  Aux ;
                                                               Finsi
                                             Finpour j
                           Finpour i
                Finsi
Fin


Exercice 15 :

Ecrire un algorithme permettant  de fusionner les éléments  de deux tableaux T1 et T2 dans un autre tableau T.
N.B :
 N : nombre des éléments  du tableau T1
M : nombre des éléments du tableau T2


Correction exercice 15 :

Algorithme  fusion_deux_tableaux;
Var
              T1,T2   : tableau [1..100] de réels ;
                T   : tableau [1..200] de réels ;
              N ,M,i:  entiers ;
Debut
                Si  (N=0)  et (M=0) alors
                               Ecrire(‘le tableau est vide ‘) ;
                Sinon
                          Pour i <--  1 à N Faire
                                T[i] <--  T1[i] ;
                           Finpour i
                           Pour i <--  1 à M Faire
                                T[N+i] <--  T2[i] ;
                           Finpour i

                Finsi
Fin


Exercice 16 :

Ecrire un algorithme permettant  de saisir les données d’un tableau à deux dimensions (10,4), de faire leur somme, produit et moyenne et de les afficher avec les résultats de calcul à l’écran.


Correction exercice 16 :

Algorithme  tableau_deux_dimension;
Var
              T : tableau [1..10,1..4] de réels ;
              I,j:  entiers ;
                S,P,M : réels ;
Debut
                 (*saisie des éléments du tableau *)
                 Pour i <--  1 à 10 Faire
                                 Pour j<--  1 à 4 Faire
                                              Ecrire(‘entrer l’’element T[‘,i,’,’,j,’] :’;
                                                Lire(T[i,j]) ;
                                Finpour j;
                Finpour i
 (*calcul de la somme ,produit et moyenne *)
S <-- 0 ;
P <--  1 ;
                Pour i <--  1 à 10 Faire
                                Pour j<--  1 à 4 Faire
                                             S <--  S+T[i,j] ;
                                             P <--  P + T[i,j] ;
                                Finpour j;
                Finpour i
                M <--  S/40 ; (*40 : nombre d’élément du tableau = 10x4 *)
                (* Affichage des éléments du tableau et des résultats *)
                Pour i <--  1 à 10 Faire
                                Pour j<--  1 à 4 Faire
                                             Ecrire(‘l’’élément T[‘,i,’,’,j,’] = ‘, T[i,j]);
                                Finpour j;
                Finpour i
                Ecrire(‘la somme des éléments du tableau est :’,S) ;
                Ecrire(‘le produit des éléments du tableau est :’,P) ;
                Ecrire(‘la moyenne  des éléments du tableau est :’,M) ;
Fin


Exercice 17 :

Ecrire un algorithme qui calcule la somme des éléments de la diagonale d’une matrice carrée M(n,n) donnée.


Correction exercice 17:

Algorithme  diagonale_de_matrice;
Const
                N=8 ;
Var
              M : tableau [1..8,1..8] d’entiers;
              i,j:  entiers ;
                Sdiag: entiers;
Debut
                 (*saisie des éléments de la matrice*)
                 Pour i <--  1 à n  Faire
                                 Pour j<--  1 à n Faire
                                              Ecrire(‘entrer l’’element M[‘,i,’,’,j,’] :’;
                                                Lire(M[i,j]) ;
                                Finpour j;
                Finpour i
 (*calcul de la somme  des éléments de la diagonale  *)
Sdiag <--  0 ;
                Pour i <--  1 à n Faire
                                Sdiag <--  Sdiag +M[i,j] ;
                Finpour i
                Ecrire(‘la somme des éléments  de la diagonale est :’,Sdiag) ;
Fin


Exercice 18 :

Ecrire un algorithme permettant d’effectuer le produit  des matrices A(n,m) et B(m,p) .
n ,m et p données (par exemple n=4,m=5,p=3 ).
N.B :
            Pour pouvoir faire le produit de deux matrices, il faut absolument que le nombre de colonnes
            de la première soit égal au nombre de lignes de la deuxième.


Correction exercice 18 :

Algorithme  produit_matrices;
Const
            n=4;
m=5;
p=3;
Var
              A : tableau [1..n,1..p] de réels;
              B : tableau [1..p,1..m] de réels;
              C : tableau [1..n,1..m] de réels;
  i,j:  entiers ;
Debut
                 (*lecture  des éléments des deux matrices*)
                 Pour i <--  1 à n  Faire
                                 Pour j<-- 1 à p Faire
                                              Ecrire(‘entrer l’’element A[‘,i,’,’,j,’] :’);
                                                Lire(A[i,j]) ;
                                Finpour j;
                Finpour i
                 Pour i <--  1 à p  Faire
                                 Pour j<--  1 à m Faire
                                              Ecrire(‘entrer l’’element B[‘,i,’,’,j,’] :’);
                                                Lire(B[i,j]) ;
                                Finpour j;
                Finpour i
 (*calcul de produit des deux matrices*)
                Pour i <--  1 à n  Faire
                                 Pour j<--  1 à m Faire
                                              C[i,j] <--  0 ;
                                               Pour k <--  1 à p faire
                                                               C[i,j] <--   C[i,j] + A[i,k] *B[k,j] ;
                                                Finpour k
                                Finpour j;
                Finpour i
                (*Affichage de la matrice produit*)
                 Pour i <--  1 à n  Faire
                                 Pour j<--  1 à m Faire
                                              Ecrire(‘l’’element C[‘,i,’,’,j,’] =’,C[i,j]);
                                Finpour j;
                Finpour i
Fin


Exercice 19 :

Ecrire un algorithme permettant  de construire dans une matrice carrée P et d’afficher le triangle de PASCAL  de degré N.
N.B :
            On poura utiliser cette relation pour les éléments de triangle de PASCAL :
                                                       Pi,j = Pi-1,j-1 + Pi-1,j
             Exemple : triangle de pascal de degré 5 :
N=0              -        1
N=1              -        1     1
N=2              -        1     2       1
N=3              -        1     3       3       1
N=4              -        1     4       6       4       1
N=5              -        1     5      10     10    15    1


Correction exercice 19 :

Algorithme  triangle_pascal;
Var
               P: tableau [1..100,1..100] de réels;
  i,j,n:  entiers ;
Debut
                Ecrire(‘entrer l’ordre du  triangle de pascal que vous voulez :’) ;
                Lire(n) ;
                (*remplissage du triangle de Pascal*)
                P[1,1] <--  1 ;
                 Pour i <-- 2 à n+1  Faire
                               P[i,1] <--  1 ;
                                 Pour j<-- 2 à i-1 Faire
                                           P[i,j]  <-- P[i-1,j-1] + P[i-1,j]
                                Finpour j;
                                P[i,j] <-- 1 ;
                Finpour i
                (* affichagedu triangle de Pascal*)
                 Pour i <--  1 à n+1  Faire
                                 Pour j<--  1 à i Faire
                                              Ecrire(P[i,j] ,’           ‘);
                                Finpour j;
                                 (*retour a la ligne *)
                Finpour i
Fin

Vitakridrinda the croc and croc phylogeny

Hi everyone.  With Lori "done", let's try to get more blog posts up this year.  First is something Molnar told me about last year and gave me permission to discuss since he wasn't going to write it up.  So I wrote about it in the Database in September, then forgot to mention it once I uploaded the revised pages on New Years.  Without further ado...

Figure 1. Comparison between Vitakridrinda syntype snout MSM-155-19 (top; from Malkani, 2010) and Pabwehshi holotype snout GSP-UM 2000 (bottom; from Wilson et al., 2001).  Both in sagittal section.

Vitakridrinda's syntype snout (originally described as abelisaurian by Malkani) is a really good match for the baurusuchid crocodyliform Pabwehshi.  Pabwehshi is from the same formation and about 50% larger, though the latter measurement will vary based on how far down the snout each cross section is. The nasal diverticulum seen in Vitakridrinda is listed by Wilson et al. (2001) as an autapomorphy of Pabwehshi, but the internal anatomy of other baurusuchid snouts is poorly known, though Baurusuchus, Stratiotosuchus and Wargosuchus at least lack evidence of it in the external naris. Under Molnar's interpretation, Malkani's dorsal palatal process (dpp above) is the secondary palate, the ventral palatal process (vpp) is the mandible, the cavity between these is the oral cavity, and the cavity in the ventral palatal process is the Meckelian canal. This leaves almost all of Malkani's supposed lateral surface as matrix which needs to be prepared to expose bone. Thus his supposed bite punctures are merely grooves excavated in the matrix, while his 'combat teeth' are tooth cross sections ventral to the dentary. Malkani's scenario of intraspecific combat causing these features is thus exposed as being fanciful. While most features of Vitakridrinda's snout as described by Malkani are based on misinterpretation, it should be noted Pabwehshi has labiolingually compressed tooth crowns with mesial and distal serrations and a more convex mesial edge as in abelisaurids.

I think this is a really good observation, and have since learned that Molnar heard it from Wilson, one of Pabwehshi's coauthors.  In November, Malkani himself independently contacted me for advice with manuscripts, one of which also uses Wilson's suggestion.  He came to different taxonomic conclusions than I did, but agrees on the basic point of the snout being from a croc, which further strengthens the idea.

This of course leads to the question of what the rest of the Vitakridrinda type material belongs to.  The limb bone (femur?) segments (MSM-59-19, 60-19) are possibly theropod due to their supposed inturned head, distinct neck, and hollowness, though Malkani (2009) states a section "has fibrous bone network in the hollow", so perhaps they are not actually hollow. The stated lack of an anterior trochanter may support a crocodiliform identity, or may be due to preservation. The supposed braincase (MSM-61-19) matches Baurusuchus as poorly and ambiguously as it does abelisaurids, so remains an unidentified object. The supposed tooth cross section (MSM-62-19) works as well for Pabwehshi as it does for abelisaurids.  So the basic answer is that the published data is too crummy to tell.  This is unfortunate because exactly what specimen the name Vitakridrinda should be connected to is uncertain.  Malkani refers to all of the type material as the holotype, as he thought they all belonged to one individual.  Since the ?braincase and ?femora were found 100 meters away from each other, this seems unlikely, and one (or the snout) should really be selected as a lectotype.  Malkani's manuscript will clarify some of this if it is published, but I fear without further preparation and better photography, Vitakridrinda's possible synonymy with Pabwehshi and syntypic identification will remain uncertain.

What is Pabwehshi?

Finally, because it's me, some phylogenetic tests!  I thought it would be simple to just add Vitakridrinda/Pabwehshi to the baurusuchid part of my croc tree, but then saw a more recent paper (Montefeltro et al., 2011) examining baurusuchid phylogeny excluded it from the family.  Those authors referenced another paper (Larsson and Sues, 2007; top tree in figure 2) that found it sister to a clade of sebecids and peirosaurids instead.  They named this clade Sebecia, and noted similarity between Pabwehshi and the peirosaurid Hamadasuchus in particular, which had not been included in prior analyses that found Pabwehshi to be a baurusuchid.  And so I had to enter the confusing and conflicting world of croc phylogeny.

What I found was interesting.  First, Larsson and Sues excluded Pabwehshi a priori because "it has a sagittal torus on its maxillary palatal shelves, absent in the putative baurusuchids".  So they didn't test it themselves, and indeed if added to their matrix, Pabwehshi comes out sister to other baurusuchids.  Second, adding Hamadasuchus to those earlier analyses that placed Pabwehshi in Baurusuchidae does make Sebecia more likely than before (by 1-4 steps), though it is still unparsimonious.  Sebecia takes 8 extra steps to enforce in these early analyses.  But in none of those cases does Pabwehshi move to Sebecia, needing 1-4 additional steps to go there once Sebecia is enforced.  As analyses get larger and more recent, it takes increasing numbers of extra steps to move it, and it's always closer to sebecids than to Hamadasuchus.

Figure 2. Comparison of Larsson and Sues' (2007) topology at top to Pol et al.'s (2012) below.  Note the top one has orange sebecids sister to green peirosaurids to make Sebecia, while the bottom one based on a much larger analysis has sebecids sister to red baurusuchids instead.  They also differ in that the top one has blue neosuchians sister to Sebecia, whereas sebecians are interspersed throughout the other taxa in the bottom one to form a huge Notosuchia to leave neosuchians basal instead.  Red Pahwehshi is a sebecian on top, but a baurusuchid on bottom.

The most recent analysis (Pol et al., 2012; bottom tree in figure 2) is much larger (347 characters, 88 taxa) than Larsson and Sues' (158 characters, 33 taxa) and includes a ton more postcranial characters, and postcranial codings for taxa like Baurusuchus, Sebecus, Notosuchus and Araripesuchus that were not coded postcranially by Larsson and Sues due to a lack of material/description.  It takes 4 extra steps to move Pabwehshi to Sebecia if the latter is forced to exist, and again is close to sebecids in that case.  Forcing Sebecia to exist in the first place though only takes 5 extra steps, which isn't too bad.  However, it ends up in that uruguaysuchid+pierosaurid clade which is sister to other notosuchians.  To get it to be sister to the blue neosuchians like in Larsson and Sues' tree takes 16 more steps, so seems unlikely.  As Pol et al. describe in their paper, this is due to all of the new characters and codings for Sebecus et al.'s postcrania, so while Sebecia itself isn't dead, Larsson and Sues' placement for it may be.

Importantly, even when Sebecia is enforced, Pabwehshi still clades with baurusuchids and most analyses (including the largest ones) take 4 extra steps to move it into Sebecia. This suggests there is no sebecian signal in Pabwehshi, as does the lack of a particular position within Sebecia when it is forced to be there (sister to either Bretesuchus, Iberosuchus, or a wildcard basal sebecid). Notably it is always attracted to sebecids though, which are sister to baurusuchids in non-sebecian phylogenies, as opposed to being isolated or close to Hamadasuchus as in Larsson and Sues' paper. While Hamadasuchus is important for making Sebecia itself more likely (by 1-6 extra steps), it only made Pabwehshi more likely to be a sebecian in one analysis, and then only by one step.

And there ends our foray into croc phylogeny.  See more detail on the material and analyses at the Database entry.  I'd love to add more taxa to Pol et al.'s analysis, like the large number of notosuchians that were left out, and the newly redescribed Shartegosuchidae that seems to be basal to Neosuchia+Notosuchia, so are probably important for settling the basal relationships of those clades.  But there's only so much time, and based on the rampant miscodings and poorly defined characters in theropod analyses, I'm not confident croc analyses are any better.  Which means checking matrices, which means acquiring literature past my current 372 croc pdfs, which means lots of work, so next time it's back to theropods.

References- Wilson, Malkani and Gingerich, 2001. New crocodyliform (Reptilia, Mesoeucrocodylia) from the Upper Cretaceous Pab Formation of Vitakri, Balochistan (Pakistan). Contributions from the Museum of Paleontology. The University of Michigan. 30(12), 321-336.

Larsson and Sues, 2007. Cranial osteology and phylogenetic relationships of Hamadasuchus rebouli (Crocodyliformes: Mesoeucrocodylia) from the Cretaceous of Morocco. Zoological Journal of the Linnean Society. 149, 533-567.

Malkani, 2009. New Balochisaurus (Balochisauridae, Titanosauria, Sauropoda) and Vitakridrinda (Theropoda) remains from Pakistan. Sindh University Research Journal (Science Series). 41(2), 65-92. 

Montefeltro, Larsson and Langer, 2011. A new baurusuchid (Crocodyliformes, Mesoeucrocodylia) from the Late Cretaceous of Brazil and the phylogeny of Baurusuchidae. PLoS ONE. 6, e21916.

Pol, Leardi, Lecuone and Krause, 2012. Postcranial anatomy of Sebecus icaeorhinus (Crocodyliformes, Sebecidae) from the Eocene of Patagonia. Journal of Vertebrate Paleontology. 32, 328-354.