public Cubo CubeSummation(int dimensions)
{
CuboNegocio cubon = new CuboNegocio(dimensions);
Cubo cubo = new Cubo();
return(cubo);
}
static void Main(string[] args)
{
//Cabecera2();
Cabecera2 cabecera = new Cabecera2();
cabecera.pintarCabecera2();
SetCursorPosition(0, 10);
WriteLine("Introduzca Un numero");
int num1 = int.Parse(ReadLine());
WriteLine("Introduzca otro numero");
int num2 = int.Parse(ReadLine());
Operaciones operaciones = new Operaciones(num1, num2);
operaciones.suma();
operaciones.resta();
operaciones.multiplicacion();
operaciones.division();
operaciones.modulo();
WriteLine("------Aqui el ejercicio del cubo-------");
WriteLine("Introduzca el lado del cubo en cm");
num1 = int.Parse(ReadLine());
Cubo cubo = new Cubo(num1);
cubo.imprSuperficie();
cubo.imprVolumen();
}
private void Start()
{
int cantidadCubosIniciales = 2;
objetivoCamara.transform.position = new Vector3(tamanoMapa / 2, 3f, tamanoMapa / 2);
norte.transform.position = new Vector3(tamanoMapa / 2 + tamanoCubo / 2, 0, tamanoMapa);
norte.GetComponent <Renderer>().material.color = Color.red;
mapa = new Cubo[tamanoMapa, tamanoMapa];
for (int i = 0; i < tamanoMapa; i++)
{
for (int j = 0; j < tamanoMapa; j++)
{
crearBase(i, j);
// int nivel = Random.Range (0, 5);
int nivel = 1;
if (nivel > 0 && cantidadCubosIniciales > 0)
{
Cubo c = new Cubo(i * tamanoCubo, 0, j * tamanoCubo, i, j);
c.nivel = nivel;
mapa[i, j] = c;
cantidadCubosIniciales--;
}
}
}
}
public static void Main(string[] args)
{
Console.WriteLine("elige un numero:");
Calculadora numero1 = new PersonaQueSuma5(int.Parse(Console.ReadLine()));
Console.WriteLine("elige un numero para fibonacci:");
Calculadora numero2 = new RobotFibonacci(int.Parse(Console.ReadLine()));
Console.WriteLine("elige un numero para el factorial:");
Calculadora numero3 = new PerroFactorial(int.Parse(Console.ReadLine()));
Console.WriteLine("elige otro numero:");
Calculadora numero4 = new Cubo(int.Parse(Console.ReadLine()));
Console.WriteLine("elige un numero mas:");
Calculadora numero5 = new Cuadrado(int.Parse(Console.ReadLine()));
List <ICalcular> numeros = new List <ICalcular>();
numeros.Add(numero1);
numeros.Add(numero2);
numeros.Add(numero3);
numeros.Add(numero4);
numeros.Add(numero5);
Console.WriteLine("-Tu numero + 5 es: " + numeros);
Console.WriteLine("-Tu sucesion de fibonacci es: " + numeros);
Console.WriteLine("-Tu numero en factorial es: " + numeros);
Console.WriteLine("-Tu numero al cubo es : " + numeros);
Console.WriteLine("-Tu numero al cuadrado es: " + numeros);
Console.WriteLine("Hello World!");
}
public void Cubeelementos()
{
Cubo cubo = new Cubo();
cubo.dimensions = 0;
cubo.tipoConsulta = "UPDATE";
cubo.ParteElemento = "2 2 2 4";
cubo.tipoConsulta = "QUERY";
cubo.ParteElemento = "1 1 1 3 3 3";
cubo.tipoConsulta = "UPDATE";
cubo.ParteElemento = "1 1 1 23";
cubo.tipoConsulta = "QUERY";
cubo.ParteElemento = "2 2 2 4 4 4";
cubo.tipoConsulta = "QUERY";
cubo.ParteElemento = "1 1 1 3 3 3";
cubo.tipoConsulta = "UPDATE";
cubo.ParteElemento = "2 2 2 1";
cubo.tipoConsulta = "QUERY";
cubo.ParteElemento = "1 1 1 1 1 1";
cubo.tipoConsulta = "QUERY";
cubo.ParteElemento = "1 1 1 2 2 2";
cubo.tipoConsulta = "QUERY";
cubo.ParteElemento = "2 2 2 2 2 2";
}
private List <Cubo> MapearCupo(string[] informacion, ref RespuestaGeneral respuestaGeneral)
{
List <Cubo> listCubo = new List <Cubo>();
Cubo cubo = new Cubo();
for (int i = 1; i < informacion.Length; i++)
{
string[] datos = informacion[i].Split(' ');
if (datos.Length == 2)
{
if (!ValidarTamanoMatrizOperaciones(datos, ref respuestaGeneral))
{
return(new List <Cubo>());
}
cubo = new Cubo
{
TamanoMatriz = Convert.ToInt32(informacion[i].Split(' ')[0]),
CantidadOperaciones = Convert.ToInt32(informacion[i].Split(' ')[1]),
OperacionesCubo = new List <OperacionCubo>()
};
listCubo.Add(cubo);
continue;
}
cubo.OperacionesCubo.Add(new OperacionCubo
{
TipoOperacion = datos[0],
InformacionOperacion = ObtenerInformacionOperacion(datos)
});
}
return(listCubo);
}
List <Cubo> CalcularPath(Cubo a)
{
List <Cubo> res = new List <Cubo>();
res.Add(a);
a.prefab.material.color = Color.yellow;
Cubo actual = a;
while (actual.cameFrom != -1)
{
print("Añadimos uno en el path");
print("CameFrom: " + actual.cameFrom);
res.Add(mundo[actual.cameFrom]);
mundo[actual.cameFrom].prefab.material.color = Color.red;
actual = mundo[actual.cameFrom];
//var aux = mundo[actual.cameFrom];
//aux.prefab.material.color = Color.green;
//mundo[actual.cameFrom] = aux;
}
if (actual.cameFrom == -1)
{
actual.prefab.material.color = Color.green;
}
return(DarVuelta(res));
}
public ActionResult query([FromBody] Payload payload)
{
int sumatoria = 0;
Coordenada c1 = new Coordenada
{
x = payload.x1,
y = payload.y1,
z = payload.z1
};
Coordenada c2 = new Coordenada
{
x = payload.x2,
y = payload.y2,
z = payload.z2
};
Cubo cubo = new Cubo(payload.registro);
sumatoria = cubo.query(c1, c2);
object respuesta = new
{
sumatoria = sumatoria,
mensaje = cubo.registro.mensaje
};
return(Ok(respuesta));
}
private RespuestaGeneral ResolverOperacionesMatriz(long[,,] matriz, Cubo cubo, RespuestaGeneral respuestaGeneral)
{
if (!respuestaGeneral.Estado)
{
return(respuestaGeneral);
}
return(ResolverOperaciones(cubo, matriz, ref respuestaGeneral));
}
/// <summary>
/// Método que ejecuta un comando para el algoritmo.
/// </summary>
/// <returns>Respuesta del comando (si aplica).</returns>
public string Ejecutar(string comando)
{
string respuestaComando = string.Empty;
if (this.NumeroCasos == 0)
{
if (Regex.IsMatch(comando, regexComando01))
{
this.NumeroCasos = int.Parse(comando);
this.CasoActual = 1;
}
}
else if (Regex.IsMatch(comando, regexComando02) && this.CuboActual == null)
{
string[] comando02 = comando.Split(' ');
this.CuboActual = new Cubo(int.Parse(comando02[0]));
this.NumeroOperaciones = int.Parse(comando02[1]);
this.OperacionActual = 0;
}
else
{
if (this.OperacionActual <= this.NumeroOperaciones)
{
Update comandoUpdate = new Update(comando);
if (comandoUpdate.ComandoValido)
{
comandoUpdate.Ejecutar(this.CuboActual);
this.OperacionActual++;
}
else
{
Query comandoQuery = new Query(comando);
if (comandoQuery.ComandoValido)
{
respuestaComando = comandoQuery.Ejecutar(this.CuboActual).ToString();
this.OperacionActual++;
}
}
if (this.OperacionActual == this.NumeroOperaciones)
{
this.CuboActual = null;
this.NumeroOperaciones = 0;
this.CasoActual++;
if (this.CasoActual > this.NumeroCasos)
{
this.NumeroCasos = 0;
}
}
}
}
return(respuestaComando);
}
void Awake()
{
cubo = GameObject.Find("Cubo").GetComponent <Cubo> ();
cubo.dimensoes = armazena.dimensoes;
cubo.CriaCaixas();
cubo.nMinas = armazena.nMinas;
GerarMatriz(armazena.nMinas);
jogando = true;
}
int CalcularH(Cubo a, Cubo b)
{
//Hay que dividir entre las dimensiones del cubo
int xD = (int)(Mathf.Abs(a.centro.x - b.centro.x) / dimensionesCubo);
int zD = (int)(Mathf.Abs(a.centro.z - b.centro.z) / dimensionesCubo);
int resto = (int)Mathf.Abs(xD - zD);
return(14 * Math.Min(xD, zD) + 10 * resto);
}
/// <summary>
/// Método que ejecuta el comando "UPDATE".
/// </summary>
/// <param name="cuboActual">Instancia del cubo actual a ejecutar comando "UPDATE".</param>
/// <returns>Resultado de la operación</returns>
public int?Ejecutar(Cubo cuboActual)
{
if (this.ComandoValido)
{
cuboActual.Elementos.ForEach(e => e.Contenido = e.Coordenada.Equals(this.coordenada) ? this.contenido : e.Contenido);
}
return(null);
}
public ActionResult update([FromBody] Payload payload)
{
Cubo cubo = new Cubo();
cubo.registro = payload.registro;
cubo.update(payload.x, payload.y, payload.y, payload.W);
return(Ok(cubo.registro));
}
void OnTriggerEnter(Collider other)
{
// Destroy(other.gameObject); //para borrar el componente, en caliente.
//hasta aqui esta null, lo instancio para acceder a sus metodos.
cubo = GameObject.Find("Cube (1)").GetComponent <Cubo> ();
//en la clase cubo esta la logica para realizar el movimiento del cubo.
//se llama al metodo que hace el movimiento
cubo.rotarY();
}
void Start()
{
Screen.sleepTimeout = SleepTimeout.NeverSleep;
playerTracker = this.GetComponent <PlayerTracker>();
resetButton.onClick.AddListener(ResetGyro);
Input.gyro.enabled = true;
Application.targetFrameRate = 60;
initialYAngle = transform.eulerAngles.y;
displayCoords.text = "aqui iran las coords";
lastTime = Time.time;
setaCubo = world.GetComponent <Cubo>();
}
public static void Main(string[] args)
{
Esfera e1 = new Esfera(10);
Console.WriteLine($"Volume da esfera: {e1.GetVolume():0.00}");
Figura3D e2 = new Esfera(10);
Console.WriteLine($"Volume da esfera: {e2.GetVolume():0.00}");
Cubo cb = new Cubo(10);
Console.WriteLine($"Volume do cubo: {cb.GetVolume():0.00}");
}
//Devuelve el indice de a en el mundo
int Indice(Cubo a)
{
for (int i = 0; i < mundo.Count; i++)
{
if (a.centro == mundo[i].centro)
{
return(i);
}
}
print("No hemos enconttrado el indice del cubo de mierda de lo0s cojones :)");
//Error, no esta en la lista
return(-1);
}
/// <summary>
/// Método que ejecuta el comando "QUERY".
/// </summary>
/// <param name="cuboActual">Instancia del cubo actual a ejecutar comando "QUERY".</param>
/// <returns>Resultado de la operación</returns>
public int?Ejecutar(Cubo cuboActual)
{
int?respuesta = null;
if (this.ComandoValido)
{
respuesta = cuboActual.Elementos.Where(e =>
e.Coordenada.X >= bloqueInicio.X && e.Coordenada.X <= bloqueFin.X &&
e.Coordenada.Y >= bloqueInicio.Y && e.Coordenada.Y <= bloqueFin.Y &&
e.Coordenada.Z >= bloqueInicio.Z && e.Coordenada.Z <= bloqueFin.Z).Sum(e => e.Contenido);
}
return(respuesta);
}
void Awake()
{
bombasAdjacentes = 0;
if (manager == null)
{
manager = GameObject.Find("Manager").GetComponent <Manager> ();
Debug.Log("FINDO manager");
}
if (cubo == null)
{
cubo = GameObject.Find("Cubo").GetComponent <Cubo> ();
Debug.Log("FINDO cubo");
}
}
public void ValidarCoordenadas(long[] informacionOperacion, Cubo cubo, ref RespuestaGeneral respuestaGeneral, string tipoOperacion)
{
if (!respuestaGeneral.Estado)
{
return;
}
int length = tipoOperacion.Equals(TipoOperacion.UPDATE.ToString()) ? informacionOperacion.Length - 1 : informacionOperacion.Length;
for (int i = 0; i < length; i++)
{
if (informacionOperacion[i] > cubo.TamanoMatriz || informacionOperacion[i] <= 0)
{
respuestaGeneral = FuncionesGenericas.ObtenerRespuesta(false, respuestaGeneral.Mensaje + "\n" + CubeSummationResources.Error_Coordenadas);
return;
}
}
}
void Start()
{
origenAux = origen; destinoAux = destino;
int raizN = (int)Math.Sqrt((double)numeroCubos);
mundo = new List <Cubo>();
//Radios de cubos 2D
float radioCubo = dimensionesCubo * dimensionesCubo / numeroCubos;
Vector3 pos = new Vector3(radioCubo, 1, radioCubo);//pos primer cubo
Vector3 posX, posZ;
posX = pos;
//Avanzamos en el eje X
for (int i = 0; i < raizN; i++)
{
posZ = posX;
posX += new Vector3(dimensionesCubo, 0, 0);
//Avanzamos en el eje Z
for (int j = 0; j < raizN; j++)
{
Quaternion rot = Quaternion.Euler(0, 0, 0);
var cub = Instantiate(prefab, posZ, rot);
cub.transform.parent = cubeHolder;
cub.material.color = Color.magenta;
var cubito = new Cubo(posZ, dimensionesCubo, cub);
mundo.Add(cubito);
//Debug.Log("Cubo creado en: " + cubito.centro);
posZ += new Vector3(0, 0, dimensionesCubo);
}
}
if (bres)
{
path = BresenhamError((int)origen.x, (int)origen.z, (int)destino.x, (int)destino.z);
}
else
{
LimpiarValores();
path = AStar((int)origen.x, (int)origen.z, (int)destino.x, (int)destino.z);
print("path.count: " + path.Count);
}
}
Cubo NodoMenorF(List <Cubo> lista)
{
if (lista.Count <= 0)
{
print("Lista vacia en NodoMenorF");
return(new Cubo(new Vector3(-1, -1, -1), -1, prefab));
}
Cubo menor = lista[0];
foreach (var n in lista)
{
if (n.f < menor.f)
{
menor = n;
}
}
return(menor);
}
public void CambioCaminable(Vector3 pos)
{
int indice = Indice(Encontrar(pos));
Cubo aux = mundo[indice];
if (mundo[indice].caminable)
{
aux.caminable = false;
aux.prefab.material.color = Color.grey;
//No se puede modificar directamente mundo[indice] y aux es solo una copia, asi que hay que volver a reasignarselo
mundo[indice] = aux;
}
else
{
aux.caminable = true;
aux.prefab.material.color = Color.magenta;
mundo[indice] = aux;
}
}
public CuboNegocio(int dimensions)
{
try
{
if (dimensions == 0)
{
throw new ArgumentNullException();
}
Cubo cubo = new Cubo()
{
dimensions = dimensions,
tree = RectangularArrays.ReturnRectangularLongArray(dimensions + 1, dimensions + 1, dimensions + 1),
nums = RectangularArrays.ReturnRectangularLongArray(dimensions, dimensions, dimensions)
};
}
catch (InvalidCastException e)
{
throw (e);
}
}
List <Cubo> NodosVecinos(Cubo a)
{
int tamaño = dimensionesCubo * (int)Math.Sqrt((double)numeroCubos);
List <Cubo> vec = new List <Cubo>();
if (a.centro.x - dimensionesCubo >= 0)
{
vec.Add(Encontrar(new Vector3(a.centro.x - dimensionesCubo, 1, a.centro.z)));//Izquierda
if (a.centro.z - dimensionesCubo >= 0)
{
vec.Add(Encontrar(new Vector3(a.centro.x - dimensionesCubo, 1, a.centro.z - dimensionesCubo)));//Izquierda abajo
}
if (a.centro.z + dimensionesCubo < tamaño)
{
vec.Add(Encontrar(new Vector3(a.centro.x - dimensionesCubo, 1, a.centro.z + dimensionesCubo)));//Izquierda arriba
}
}
if (a.centro.x + dimensionesCubo < tamaño)
{
vec.Add(Encontrar(new Vector3(a.centro.x + dimensionesCubo, 1, a.centro.z)));//Derecha
if (a.centro.z - dimensionesCubo >= 0)
{
vec.Add(Encontrar(new Vector3(a.centro.x + dimensionesCubo, 1, a.centro.z - dimensionesCubo)));//Derecha abajo
}
if (a.centro.z + dimensionesCubo < tamaño)
{
vec.Add(Encontrar(new Vector3(a.centro.x + dimensionesCubo, 1, a.centro.z + dimensionesCubo)));//Derecha arriba
}
}
if (a.centro.z - dimensionesCubo >= 0)
{
vec.Add(Encontrar(new Vector3(a.centro.x, 1, a.centro.z - dimensionesCubo)));//Abajo
}
if (a.centro.z + dimensionesCubo < tamaño)
{
vec.Add(Encontrar(new Vector3(a.centro.x, 1, a.centro.z + dimensionesCubo)));//Abajo
}
return(vec);
}
public virtual long sum(int x, int y, int z)
{
try
{
Cubo cubo = new Cubo();
long sum = 0l;
for (int i = x; i > 0; i -= i & (-i))
{
for (int j = y; j > 0; j -= j & (-j))
{
for (int k = z; k > 0; k -= k & (-k))
{
sum += cubo.tree[i][j][k];
}
}
}
return(sum);
}
catch (InvalidCastException e)
{
throw (e);
}
}
private RespuestaGeneral ResolverOperaciones(Cubo cubo, long[,,] matriz, ref RespuestaGeneral respuestaGeneral)
{
foreach (OperacionCubo operacionCubo in cubo.OperacionesCubo)
{
string tipoOperacion = operacionCubo.TipoOperacion.ToUpper();
if (!respuestaGeneral.Estado)
{
return(respuestaGeneral);
}
validacionDatos.ValidarCoordenadas(operacionCubo.InformacionOperacion, cubo, ref respuestaGeneral, tipoOperacion);
if (tipoOperacion.Equals(TipoOperacion.UPDATE.ToString()))
{
operacion.ProcesarOperacionUpdate(operacionCubo, matriz, ref respuestaGeneral);
}
if (tipoOperacion.Equals(TipoOperacion.QUERY.ToString()))
{
operacion.ProcesarOperacionQuery(operacionCubo, matriz, ref respuestaGeneral);
}
}
return(respuestaGeneral);
}
public virtual void update(int x, int y, int z, int value)
{
try
{
Cubo cubo = new Cubo();
long delta = value - cubo.nums[x][y][z];
cubo.nums[x][y][z] = value;
for (int i = x + 1; i <= cubo.dimensions; i += i & (-i))
{
for (int j = y + 1; j <= cubo.dimensions; j += j & (-j))
{
for (int k = z + 1; k <= cubo.dimensions; k += k & (-k))
{
cubo.tree[i][j][k] += delta;
}
}
}
}
catch (InvalidCastException e)
{
throw (e);
}
}
private void insertarCubo(bool maligno)
{
int i = Random.Range(0, tamanoMapa);
int j = Random.Range(0, tamanoMapa);
if (mapa[i, j] == null)
{
if (!maligno)
{
Cubo c = new Cubo(i * tamanoCubo, 0, j * tamanoCubo, i, j);
c.maligno = true;
c.nivel = 1;
mapa[i, j] = c;
}
else
{
// int nivel = Random.Range (1, 5);
Cubo c = new Cubo(i * tamanoCubo, 0, j * tamanoCubo, i, j);
c.nivel = 1;
mapa[i, j] = c;
}
}
}
