package clase;

public class principal {

public static void main(String[] args) {

vector v1=new vector(5);
v1.insertar(!");
v1.insertar(#!1);
v1.insertar($!#);
v1.insertar(%1!$);
v1.insertar(%&!);
v1.imprimir();
v1.ma'or(menor();
v1.insertarn(1! &&&);
v1.imprimir();

)

)
package clase;
public class vector {

int[] vectorcito;
int tamano;
private int *;
public vector()
{
vectorcito=new int[1];
tamano=1;
)

public vector(int t)
{
vectorcito=new int [t];
tamano=t;

)
public void insertar(int valor!int posicion)
{
vectorcito[posicion]=valor;

)
public void imprimir()
{
+or(int *=";*,tamano;*--)
{
S'stem.out.print(. .- vectorcito[*]);

)

)


public void ma'or(menor()
{
int ma'or;
int menor;
i+(vectorcito["]/vectorcito[1])
{
ma'or=vectorcito["];
menor=vectorcito[1];
)
else
{
ma'or=vectorcito[1];
menor=vectorcito["];
)

+or(int *=";*,tamano;*--)
{
i+ (ma'or,vectorcito[*])
{
ma'or=vectorcito[*] ;

)
else
{
i+(menor/vectorcito[*])
{
menor=vectorcito[*];

)
)
)
S'stem.out.println(.el valor ma*imo es0 . -ma'or);
S'stem.out.println(.el valor minimo es0 . -menor);
)
public void insertarn(int pos!int valor)
{
int au*;
+or(*=pos;*,tamano;*--)
{
au*=vectorcito[*];
vectorcito[*]=valor;
valor=au* ;
)

)
)
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((((
public class matri1 {
22 atributos
public int +ila!columna;
public int 3atri11[][];
22!!!constructores
public matri1(){
+ila=#;
columna=#;
3atri11=new int[#][#];
)
22 0000000000000000modi+icadores0000000000000000000
public void matri1(int +! int c)
{
+ila=+;
columna=c;
3atri11=new int[+][c];
)
public void imprimir()
{
+or(int *=";*,+ila;*--)
{
+or(int '=";',columna;'--)
{
S'stem.out.print(. . -3atri11[*][']);
)
S'stem.out.print(..);
)
)
222 a insertar
public void insertar(int +il!int col!int val)
{
3atri11[+il][col]=val;
)
22 cantidad
public int contarcantidad(int buscado)
{
int veces;
veces=";
+or(int *=";*,+ila;*--)
{
+or(int '=";',columna;'--)
{
i+(3atri11 [*][']==buscado)

veces--;


)

)
return veces ;
)
)
public class principal {
public static void main(String[] args) {
matri1 m1=new matri1();

m1.insertar("!"! #);
m1.insertar("! 1! 1);
m1.insertar(1! "! #);
m1.insertar(1! #! 1);

m1.imprimir();

S'stem.out.println(.el numero 4 se repite es0 . - m1.contarcantidad(#) - .veces.);
)

)
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((
public class 5vector(1 {
22 estructura pear
22 atributos
public int atamano;
public int avector[];

22 contructures
public 5vector(1(){
t6is.atamano=1;
t6is.avector = new int[1];

)
public 5vector(1( int ptamano){
t6is.atamano=ptamano;
t6is.avector= new int[ptamano];
)
public void mostrar(){
+or(int i="; i,atamano; i-- )
S'stem.out.print(. .- avector[i]);
)
public void ingresar(int i! int pos){
avector[pos]=i;
)
public void ma*imo(minimo(){
int minimo=avector["];
int ma* =avector["];
+or(int i="; i,atamano%1; i--)
{
i+(ma*,avector[i-1])

ma*=avector[i-1];

+or(int 7="; 7,atamano%1; 7--)
{
i+( minimo/avector[i-1])

minimo=avector[i-1];

)
)
S'stem.out.println(. el ma*imo es .-ma*);
S'stem.out.println(. el minimo es .-minimo);
)
public void ma'or(menor(){
int ma'or = avector["]!menor = avector["];

i+( avector["]/avector[1])
{
ma'or= avector["];
menor= avector[1];
)
else
{
ma'or= avector[1];
menor= avector["];
)
+or(int i="; i,atamano; i--)
{
i+(ma'or,avector[i])
{
ma'or= avector[i];
)
else
{
i+(menor/ avector[i])
{
menor= avector[i];
)
)
)
S'stem.out.println(.==== el ma'or es==== . - ma'or);
S'stem.out.println(.==== 8l menor es==== . - menor);
)
public boolean e*iste8lemento(int p8lemento){
boolean e*iste= +alse;
int k= ";
w6ile(k,atamano99 :e*iste){
i+(p8lemento==avector[k])
e*iste= true;
k--;
)
return e*iste;
)
public class ;pp5vector(1 {

public static void main(String[] args) {
5vector(1 v1 = new 5vector(1(1");
S'stem.out.println(.el vector es0.);
v1.ingresar(#$! ");
v1.ingresar($! 1);
v1.ingresar(1! #);
v1.ingresar(<! $);
v1.ingresar(=! );
v1.ingresar(1<! 5);
v1.ingresar(1#! <);
v1.ingresar(%5! =);
v1.ingresar(<! >);
v1.ingresar(%1<! &);
v1.mostrar();
S'stem.out.println(..);
v1.ma*imo(minimo();
v1.ma'or(menor();
22S'stem.out.print(. cambiar .-v1.cambiar(posecion(<! =));
v1.cambiar(posecion($! #5);
v1.mostrar();

)

)
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((((((
public class vector {
22 estructura pear
22 atributos
public int atamano;
public int avector[];

22 contructures
public vector(){
t6is.atamano=1;
t6is.avector = new int[1];

)
public vector( int ptamano){
t6is.atamano=ptamano;
t6is.avector= new int[ptamano];
)
public void mostrar(){
+or(int i="; i,atamano; i-- )
S'stem.out.print(. .- avector[i]);
)
public void ingresar(int i! int pos){
avector[pos]=i;
)
public +loat valor(ma*imo(){
int ma* =avector["];
+or(int i="; i,atamano%1; i--)
{
i+(ma*,avector[i-1])
{
ma*=avector[i-1];
)
22 S'stem.out.println(. .-ma*imo(valor);
)
return ma*;
)
public +loat min(){
int minimo=avector["];
+or(int i="; i,atamano%1; i--)
{
i+( minimo/avector[i-1])
{
minimo=avector[i-1];
)
)
return minimo;
)
public +loat media(){
+loat med="! suma=";
+or(int i="; i,atamano;i--) {
suma -= avector[i];
22 med= suma2atamano;
)
S'stem.out.println(. la media es .-suma2atamano);
return med;
)

public +loat varian1a(){
+loat pro=";int sum="! varian1a = avector[1]!k=";
+or(int i="; i,atamano; i--) {
sum-= 3at6.s4rt(avector[i]);
pro=sum2atamano;
22sum -= 3at6.s4rt( avector[i]%pro);
varian1a-=( 3at6.s4rt(sum)%3at6.s4rt(pro))2atamano;


)
return varian1a;

)
public void varian1a(paso1()
{
int media = "!resta;
+or(int 7=";7,avector.lengt6;7--)
{
resta=avector[7]%media;
avector[7]=(int) 3at6.pow(resta!#);
)
)
public void suma(varian1a(){
int suma = ";
+or(int k=";k,avector.lengt6;k--)
{
suma -=avector[k];
)
)
public +loat varian1a(total()
{
int varian1a!suma = ";
varian1a=(int)suma2avector.lengt6;
S'stem.out.print(.?arian1a0 .-varian1a) ;
return varian1a;
)
public +loat mediana(){
+loat ban="!au*;
+or(int i=atamano; i/" 99 ban=="; i%%){
ban=1;
+or(int 7="; 7,i; 7--){
i+(avector[7],avector[7]){
au*=avector[7];
avector[7]= avector[7-#];
avector[7-#]= (int) au*;
)
)
)
22S'stem.out.println(. los elementos del vector.);
+or(int i="; i,atamano %1; i--){
22 S'stem.out.println(..);
S'stem.out.println( avector[i]-. .);
)
i+( atamano@#:="){
S'stem.out.println(. el valor de la mediana es0 .-avector[atamano2#]);
)else{
S'stem.out.println(. el valor de la mediana 1 es0 .- avector[atamano2#]);
S'stem.out.println(. el valor de la mediana # es0 .- avector[(atamano2#)%1]);
)
return ";


)
2Apublic +loat moda(){
int moda="!au*! posecion! pos3a'or!ma'or; int pvector[] = null;
+or(int i="; i,atamano; i--){
22 pvector[i]=";
)
+or(int i="; i,atamano; i--){
au*= avector[i];
posecion=i;

)
ma'or=";
pos3a'or=";
+or(int i="; i,atamano; i--){
i+(pvector[i]/ma'or){
pos3a'or=i;
ma'or=pvector[i];
)
)
S'stem.out.println(. la moda es 0 .- avector[pos3a'or]);

return moda;

)A2
public int moda(){
int +recBemp! +recuencia3oda = "! moda = %1;
+or (int i="; i , avector.lengt6%1; i--){
+recBemp = 1;
+or(int 7 = i-1 ; 7,avector.lengt6; 7--){
i+(avector[i] == avector[7])
+recBemp --;
)
i+(+recBemp / +recuencia3oda){
+recuencia3oda = +recBemp;
moda = avector[i];
)
)
S'stem.out.println(.la moda es0 . - moda );
return moda;
)
public +loat percil(){
+loat percil= " !k = ";
+or(int i="; i,atamano%1; i--){
k-= (avector[i]21"");
percil -= k A(atamano-1);
)
S'stem.out.println(. el percil es .- percil);
return percil;

))
public class ma*imo(valor {
public static void main(String[] args) {
vector v1 = new vector(<);
S'stem.out.println(.el vector es0.);
v1.ingresar($! ");
v1.ingresar($! 1);
v1.ingresar(1! #);
v1.ingresar(<! $);
v1.ingresar(=! );
v1.ingresar(1<! 5);
v1.mostrar();
S'stem.out.println(..);
S'stem.out.println(.el valor ma*imo es0. - v1.valor(ma*imo());
S'stem.out.println(..);
v1.valor(ma*imo();
S'stem.out.println(.el valor minimo es0. - v1.min());
22S'stem.out.println(. la media es . - v1.media());
v1.media();
S'stem.out.println(.la varian1a es 0 . - v1.varian1a());
v1.varian1a();
v1.varian1a(paso1();
v1.varian1a(total();
v1.mediana();
22 S'stem.out.println(. la moda sera0 .-v1.moda(avector[<]));
v1.moda();
22S'stem.out.println(. el percil sera .);
v1.percil();
)
)
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((((((((((((((
package valormediaa;
import 7ava.util.A;
public class ?alormediaa {

public static void main(String[] args) {



Scanner sc = new Scanner(S'stem.in);
int i;
int pos = "! neg = "; 22contadores de los nCmeros positivos ' negativos
int[] numeros = new int[1"]; 22arra' 4ue contendrD los nCmeros leEdos por teclado
double sumaFos = "! sumaGeg = "; 22acumuladores para las sumas de positivos ' negativos

22lectura de datos ' llenar el arra'
S'stem.out.println(.Hectura de los elementos del arra'0 .);
+or (i = "; i , 1"; i--) {
S'stem.out.print(.numeros[. - i - .]= .);
numeros[i]=sc.ne*tInt();
)
22recorrer el arra' para sumar por separado los nCmeros positivos
22 ' los negativos
+or (i = "; i , 1"; i--) {
i+ (numeros[i] / "){ 22sumar positivos
sumaFos -= numeros[i];
pos--;
) else i+ (numeros[i] , "){ 22sumar negativos
sumaGeg -= numeros[i];
neg--;
)
)
225alcular ' mostrar las medias
i+ (pos := ") {
S'stem.out.println(.3edia de los valores positivos0 . - sumaFos 2 pos);
) else {
S'stem.out.println(.Go 6a introducido numeros positivos.);
)
i+ (neg := ") {
S'stem.out.println(.3edia de los valores negativos0 . - sumaGeg 2 neg);
) else {
S'stem.out.println(.Go 6a introducido numeros negativos.);
)
)

)
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((
package bus4uedalineal;
public class vector{
public int tamano;
public int vectorcito[];
public vector()
{
vectorcito=new int [1];
tamano=1;
)
public vector(int t)
{
vectorcito=new int[t];
tamano=t;
)
public void insertar(int posicion!int valor)
{
vectorcito[posicion]=valor;
)
public void imprimir()
{
+or(int *=";*,tamano;*--)
{
S'stem.out.println(..-vectorcito[*]);
)

)
public String buscar(int valorbuscado)
{
boolean bandera;
bandera=+alse;

int pos;
pos=%1;
+or(int *=";*,tamano;*--)
{
i+(valorbuscado==vectorcito[*])
{
bandera=true;
pos=*;
22 *=tamano; 22 para buscar en 1ra
)

)
i+(bandera=true)
{
return .se encontro . - valorbuscado - . en . -pos;
)
else
{
return .no se encontro . - valorbuscado;
)
)
)

package bus4uedalineal;
public class principal {

public static void main(String[] args) {
vector v1=new vector(5);
v1.insertar("!=);
v1.insertar(1!$);
v1.insertar(#!#);
v1.insertar($!<);
v1.insertar(!%5);


S'stem.out.println(. . - v1.buscar(1));
v1.imprimir();
)
)
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
(((((((((((((((((((((((((
package viernes#$;
import 7ava.util.Scanner;
public class principal {

public static void main(String[] args) {

Scanner teclado=new Scanner(S'stem.in);

S'stem.out.println(.ingresa el tamaJo.);
int *=teclado.ne*tInt();
vector v1=new vector(*);
int v=";
+or(int '=";',*;'--)
{
S'stem.out.println(.ingresa el valor.);
v=teclado.ne*tInt();
v1.ingresar(v!');

)
v1.imprimirvector();
S'stem.out.println(.el ma*imo es0 . - v1.ma*() );
)

)
package viernes#$;
public class vector {

public int tamano;
public int vectorcito[];
22 constructores
public vector()
{
t6is.tamano=1;
t6is.vectorcito=new int[1];



)
public vector(int t){


t6is.tamano=t;
t6is.vectorcito=new int[t];
)

public void imprimirvector()
{
+or(int *=";*,tamano;*--)
{

S'stem.out.print(. .- vectorcito[*]);

)
)
public void ingresar( int i!int pos)
{
vectorcito[pos]=i;

)
public int ma*()
{
int ma*imo=vectorcito["];
+or(int m=";m,tamano%1;m--)
{

i+ (vectorcito[m-1], ma*imo)
{
ma*imo=vectorcito[m-1];

)


)

return ma*imo;
)

)


((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((((((((((((%%%%%%
public class c3atri1 {
22 atributos
private int aKila!a5olumna;
private int a3atri1[][];
22!!!constructores
protected c3atri1(int pKila!int p5olumna){
aKila=pKila;
a5olumna=p5olumna;
a3atri1=new int[aKila][a5olumna];
)
22....modi+icadores
public void elemento(int p8lemento!int pKila!int p5olumna){
i+(pKila/=" 99 p5olumna/=" 99 pKila,aKila 99 p5olumna,a5olumna)
a3atri1[pKila][p5olumna]=p8lemento;
)
22!!!selectores
public int +ila(){
return aKila;
)
public int columna(){
return a5olumna;
)
public int elemento(int pKila!int p5olumna){
int elemento=%1;
i+(pKila/=" 99 p5olumna/=" 99 pKila,aKila 99 p5olumna,a5olumna)
elemento=a3atri1[pKila][p5olumna];
return elemento;
)
public void cargarmatri1(int pLango){
+or(int i=";i,aKila;i--)
+or(int 7=";7,a5olumna;7--)
a3atri1[i][7]=(int) (3at6.random()ApLango);
)
public void iniciali1ar3atri1(){
+or(int i=";i,aKila;i--)
+or(int 7=";7,a5olumna;7--)
a3atri1[i][7]=";
)
public void mostrar(String mensa7e){
S'stem.out.println(mensa7e);
+or(int i=";i,aKila;i--){
+or(int 7=";7,a5olumna;7--)
S'stem.out.print(a3atri1[i][7]-. .);
S'stem.out.println(..);
)
)
public void transpuesta ( ){
2Aint au* ;
+or ( int i = " ; i , aKila ; i-- )
{
+or ( int 7 = " ; 7 , a5olumna ; 7-- )
{
i+ ( i ,= 7 )
{
au* = a3atri1[i][7] ;
a3atri1[i][7] = a3atri1[7][i] ;
a3atri1[7][i] = au* ;
)
)
)A2

int au*;
+or (int i="; i,aKila; i--)
{
+or (int 7 = i-1;7,a5olumna;7--)
{
au* =a3atri1[i][7];
a3atri1[i][7]=a3atri1[7][i];
a3atri1[7][i]=au*;
)
)
)
public void diagonal(){
S'stem.out.print(.Ha diagonal principal es0 [.);
+or (int i="; i,aKila; i--) {
+or (int 7="; 7,a5olumna; 7--){
i+ (i == 7)
S'stem.out.print(a3atri1[i][7] -. .);
else i+ (i , 7) {
int suma;rriba=";
22suma;rriba -= a3atri1[i][7];
)
2Aelse {
int suma;ba7o=";
suma;ba7o -= a3atri1[i][7];
) A2
)
)
S'stem.out.println(.].);
)
public void diagonal(secondaria(){
S'stem.out.print(.Ha diagonal secundaria es0 [ .);
+or (int i=aKila%1; i/="; i%%)
+or (int 7="; 7,a5olumna; 7--)
i+ (a5olumna%1%7 == i)
S'stem.out.print(a3atri1[7][i] -. .);
S'stem.out.println(. ] .);
)
)

public class app(3atri1 {
public static void main(String[] args) {
22 declarar clase ' construir
c3atri1 m1 = new c3atri1(! );
m1.cargarmatri1(&);
22...inssertando datos
2A m1.elemento(1! "! ");
m1.elemento(#! "! 1);
m1.elemento($! 1! ");
m1.elemento(5! 1! 1);
m1.elemento(&! #! ");
m1.elemento(=! #! 1);
m1.elemento(1! $! ");
m1.elemento(=! $! 1);A2
m1.mostrar(. matri1 n*m.);
m1.transpuesta();
S'stem.out.println(. la trasnpuesta sera0 .);
m1.mostrar(. .);
m1.diagonal();
S'stem.out.println(. .);
m1.diagonal(secondaria();
S'stem.out.println(. .);

)
)
public class matri1 {
public static int generador(aleatorio(int min!int ma*)
{
return min-(int)(3at6.random()A(ma*%min));
)
public static int[][] crear(matri1 (int +ila!int columna!int min!int ma*)
{

int[][] m = new int[+ila][columna];
+or(int i=";i,+ila;i--)
+or(int 7=";7,columna;7--)
m[i][7]=generador(aleatorio(min! ma*);
return m;
)
public static int +ilas (int[][] m) {
return m.lengt6;
)
public static int columnas (int[][] m)
{
return m["].lengt6;
)
public static boolean mismas(dimensiones (int[][] m1!
int[][] m#)
{
return +ilas(m1)==+ilas(m#) 99 columnas(m1)==columnas(m#);
)
public static boolean es(cuadrada (int[][] m) {
return +ilas(m)==columnas(m);
)
public static boolean es(simetrica (int[][] m)
{
i+ ( :es(cuadrada(m) ) return +alse;
+or (int i="; i,+ilas(m); i--)
+or (int 7="; 7,i; 7--)
i+ ( m[i][7]:=m[7][i] ) return +alse;
return true;
)
public static int[][] sumar(matrices (int[][] m1!
int[][] m#) {
int[][] m$ = new int[+ilas(m1)][columnas(m1)];
i+ ( mismas(dimensiones(m1!m#) )
{
+or (int i="; i,+ilas(m1); i--)
+or (int 7="; 7,columnas(m1); 7--)
m$[i][7] = m1[i][7] - m#[i][7];
)
else
{
S'stem.out.print(.distintas dimensiones0 . );
S'stem.out.println(.matrices no sumables. );
)
return m$;
)
public static int[][] producto(matrices (int[][] m1!
int[][] m#) {
int[][] m$ = new int[+ilas(m1)][columnas(m#)];
i+ ( columnas(m1)==+ilas(m#) ) {
+or (int i="; i,+ilas(m1); i--)
+or (int 7="; 7,columnas(m#); 7--)
+or (int k="; k,columnas(m1); k--)
m$[i][7] -= m1[i][k] A m#[k][7];
) else {
S'stem.out.println( .matrices no multiplicables. );
)
return m$;
)
public static void mostrar(matri1 (int[][] m) {
+or (int i="; i,+ilas(m); i--) {
+or (int 7="; 7,columnas(m); 7--)
S'stem.out.print(m[i][7]-. .);
S'stem.out.println(..);
)
S'stem.out.println(..);
)

)
public class principal {
public static void main (String[] args) {
int[][] m1 = matri1.crear(matri1(! ! $! 1");
int[][] m# = matri1.crear(matri1(#!!5!1");
int[][] m$ = matri1.crear(matri1(!5!"!1");
S'stem.out.println(.matri1 uno.);
matri1.mostrar(matri1(m1);
S'stem.out.println(.matri1 dos.);
matri1.mostrar(matri1(m#);
S'stem.out.println(.matri1 tres.);
matri1.mostrar(matri1(m$);
int[][] m = matri1.sumar(matrices(m1!m#);
matri1.mostrar(matri1(m);
int[][] m5 = matri1.sumar(matrices(m#!m$);
matri1.mostrar(matri1(m5);
S'stem.out.println(.suma (matri1 .);
int[][] m< = matri1.crear(matri1($!!1!1");
int[][] m= = matri1.crear(matri1(!$!1!1");
int[][] m> = matri1.producto(matrices(m<!m=);
matri1.mostrar(matri1(m<);
matri1.mostrar(matri1(m=);
matri1.mostrar(matri1(m>);
S'stem.out.println(.producto de matrice1.);
int[][] m& = matri1.crear(matri1(5!5!1!1");
matri1.mostrar(matri1(m&);
i+ ( matri1.es(cuadrada(m&) )
S'stem.out.println(.matri1 cuadrada.);
int[][] m1" = { {1!#!$!5)! {#!5!=!>)!
{$!=!!&)! {5!>!&!1) );
matri1.mostrar(matri1(m1");
i+ ( matri1.es(simetrica(m1") )
S'stem.out.println(.matri1 simetrica.);

)
)
class Matriz
{
// Atributos de la clase
private int tamanno ;
private int[][] datos ;
// Constructor
public Matriz ( )
{
tamanno = 3 ;
datos = new int [tamanno][tamanno] ;
// Matriz
public Matriz (int tam)
{
tamanno = tam ;
datos = new int [tam][tam] ;
// Matriz
// Metodos
public int !et"amanno ( )
{
return tamanno;
// !et"amanno
public void asi!nar#atos ( int[] d )
{
int cont = $ ;
i% ( d&len!t' ( tamanno)tamanno )
{
*+stem&out&println ( ,-o 'a+ datos su%icientes, ) ;

%or ( int i = $ ; i ( tamanno ; i.. )

{
%or ( int / = $ ; / ( tamanno ; /.. )
{
datos[i][/] = d[cont] ;
cont.. ;

// asi!nar#atos
public int !et#atos ( int i 0 int / )
{
i% ( i ( $ 11 i 2= tamanno 11 / ( $ 11 / 2= tamanno )
{
*+stem&out&println ( ,-o 'a+ datos su%icientes, ) ;
return 34 ;

else
{
return datos[i][/] ;

// !et#atos
public void suma ( Matriz m )
{
i% ( m&!et"amanno() 5= tamanno )
{
*+stem&out&println ( ,"amanos no compatibles, ) ;

else
{
%or ( int i = $ ; i ( tamanno ; i.. )
{
%or ( int / = $ ; / ( tamanno ; /.. )
{
datos[i][/] .= m&!et#atos( i 0 / ) ;

public void producto ( Matriz m )

{
int au6 ;
int[][] datosAu6 = new int[tamanno][tamanno] ;
i% ( m&!et"amanno() 5= tamanno )
{
*+stem&out&println ( ,"amanos no compatibles, ) ;

else
{
%or ( int i = $ ; i ( tamanno ; i.. )
{
%or ( int / = $ ; / ( tamanno ; /.. )
{
datosAu6[i][/] = datos[i][/] ;

%or ( int i = $ ; i ( tamanno ; i.. )

{
%or ( int / = $ ; / ( tamanno ; /.. )
{
au6 = $ ;
%or ( int 7 = $ ; 7 ( tamanno ; 7.. )
{
au6 .= datosAu6[i][7] ) m&!et#atos(70/) ;

datos[i][/] = au6 ;

// producto
public void traspuesta ( )
{
int au6 ;
%or ( int i = $ ; i ( tamanno ; i.. )
{
%or ( int / = $ ; / ( tamanno ; /.. )
{
i% ( i ( / )
{
au6 = datos[i][/] ;
datos[i][/] = datos[/][i] ;
datos[/][i] = au6 ;

public void mostrar ( )

{
%or ( int i = $ ; i ( tamanno ; i.. )
{
%or ( int / = $ ; / ( tamanno ; /.. )
{
*+stem&out&print( datos[i][/] . ,8t, ) ;

*+stem&out&println () ;

*+stem&out&println();
// mostrar
// class
1.2
class 9palMatrices
{
public static void main ( *trin! ar!s[] )
{
Matriz m4 = new Matriz ( 3 ) ;
Matriz m: = new Matriz ( 3 ) ;
int[] v4 = { 3 0 : 0 4 0 4 0 : 0 3 0 : 0 3 0 4 ;
int[] v: = { 4 0 4 0 : 0 : 0 4 0 4 0 4 0 : 0 4 ;
int[] v3 = { 4 0 $ 0 $ 0 $ 0 4 0 $ 0 $ 0 $ 0 4 ;
m4&asi!nar#atos ( v4 ) ;
m:&asi!nar#atos ( v: ) ;
m4&mostrar () ;
m:&mostrar () ;
m4&producto(m:);
m4&mostrar () ;
m4&suma ( m: ) ;
m4&mostrar () ;
m4&traspuesta ( ) ;
m4&mostrar () ;