Java - CONVERTIR ESTE CODIGO DE C++ A JAVA

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

void avanza(int, int, int *, int *);

int main(void)
{
int i,j,a,b,c,d;
char casillaInicial[3];
char casillaFinal[3];
int tablero[8][8];

system ("color 5f");

printf(" Tablero vac¡o: ");
printf(" A B C D E F G H ");
for (i=1; i<9; i++)
{
printf("%d . . . . . . . . ", i);
}

/* Punto 1.*/
i=1;
while(i)
{
printf(" Introduce la casilla inicial. ");
printf("Una letra mayuscula de la A a la H seguida de un ");
printf("numero del 1 al 8, sin espacios :");
scanf("%s", casillaInicial);
if (casillaInicial[0] < 65 || casillaInicial[0] > 73 ||
casillaInicial[1] < 49 || casillaInicial[1] > 56)
printf("Error introduciendo la casilla inicial. ");
else
i=0;
}

/* Punto 2.*/
printf(" Posici¢n de la reina en el tablero: ");
printf(" A B C D E F G H ");
for (i=1; i<9; i++)
{
printf("%d", i);
for (j=1; j<9; j++)
{
if (casillaInicial[0]-64 == j && casillaInicial[1]-48 == i)
printf(" R ");
else
printf(" . ");
}
printf(" ");
}

/* Punto 3.*/
printf(" Posibles movimientos de la reina: ");
printf(" A B C D E F G H ");
for (i=1; i<9; i++)
{
printf("%d", i);
for (j=1; j<9; j++)
{
if (casillaInicial[0]-64 == j && casillaInicial[1]-48 == i)
{
printf(" R ");
tablero[i-1][j-1]=1;
}
else if (casillaInicial[0]-64 ==j || casillaInicial[1]-48 == i)
{
printf(" * ");
tablero[i-1][j-1]=1;
}
else if (casillaInicial[0]-64 - j==casillaInicial[1]-48 - i)
{
printf(" * ");
tablero[i-1][j-1]=1;
}
else
{
printf(" + ");
tablero[i-1][j-1]=0;
}
}
printf(" ");
}

/* Punto 4.*/
i=1;
while(i)
{
printf(" Introduce la casilla de destino. ");
printf("(Una letra may£scula de la A a la H seguida de un ");
printf("n£mero del 1 al 8, sin espacios) :");
scanf("%s", casillaFinal);
if (casillaFinal[0] < 65 || casillaFinal[0] > 73 ||
casillaFinal[1] < 49 || casillaFinal[1] > 56)
printf("Error introduciendo la casilla final. ");
else if(tablero[casillaFinal[1]-49][casillaFinal[0]-65]==0)
printf("La reina no puede ir a esa casilla. ");
else
{
tablero[casillaFinal[1]-49][casillaFinal[0]-65]=2;
i=0;
}
}

/* Punto 5.*/
printf(" Movimiento final: ");
printf(" ABCDEFGH ");
for (i=0; i<8; i++)
{
printf("%d", i+1);
for (j=0; j<8; j++)
{
if (casillaInicial[0]-65 == j && casillaInicial[1]-49 == i)
printf("i");
else if (tablero[i][j]==2)
printf("f");
else
printf(".");
}
printf(" ");
}

/* Punto voluntario.*/
printf(" Movimiento final detallado: ");
a=casillaFinal[1]-49;
b=casillaFinal[0]-65;
c=casillaInicial[1]-49;
d=casillaInicial[0]-65;
while(a!=c || b!=d)
{
avanza(a,b,&c,&d);
if(c!=casillaFinal[1]-49 || d!=casillaFinal[0]-65)
tablero[c][d]=3;
}
printf(" ABCDEFGH ");
for (i=0; i<8; i++)
{
printf("%d", i+1);
for (j=0; j<8; j++)
{
if (casillaInicial[0]-65 == j && casillaInicial[1]-49 == i)
printf("i");
else if (tablero[i][j]==2)
printf("f");
else if (tablero[i][j]==3)
printf("x");
else
printf(".");
}
printf(" ");
}

}

void avanza(int a, int b, int *c, int*d)
{
if (a>*c) *c=*c+1;
if (a<*c) *c=*c-1;
if (b>*d) *d=*d+1;
if (b<*d) *d=*d-1;
}

umm ...
ya ni siquiera dicen porfavor, gracias, ayuda.

jajajaja si es cierto jajajajaj

main()
{
int algo [600000];x;j;aux;
clock_t inicio;final;
float tlleno,torden,tmostrar;
randomizer();
inicio=clock();
for(x=0;x<=599999;x++)
algo[x]=1+rand()%2340;
final=clock();
tlleno=final-inicio;
inicio=clock();
for(x=0;x<= 599998;x++)
{
for(j=x+1;j<=599999;x++)
{
if(algo[x]>algo[j])
{
aux=algo[x];
algo[x]=algo[j];
algo[j]=aux;
}
}
}
final=clock();
torden=final-inicio;
inicio=clock();
clrscr();
for(x=0;x<=599999;x++)
printf("%d\t"; algo[x]);
final=clock();
tmostrar=final-inicio;
clrscr();
gotoxy(20,13);
printf("tiempo de carga=f segundos";tlleno CLK_TCK);
gotoxy(20,13);
printf("tiempo de orden=f segundos";torden CLK_TCK);
gotoxy(20,14);
printf("tiempo de listado=f segundos";tmostrar CLK_TCK);
getchar();
return(0);
}

# include<stdio.h>
# include<dos.h>
# include<iostream.h>


int main(int argc, char *argv[ ])

{
FILE *fd;
if ( (fd = fopen("prueba.txt","w") )==NULL)
printf("No se puede crear el Archvivo ");
else
{
fprintf(fd, "Hola Mundo");
fclose(fd);
}
return(0);
}

#include <iostream>
#include <limits.h>
#include <float.h>
using namespace std;

#define MAXNODOS 500 // tamaño máximo de la red
#define INDEFINIDO -1

int N;
float dist[MAXNODOS][MAXNODOS];
float minimo[MAXNODOS];
int anterior[MAXNODOS];
bool visitado[MAXNODOS];

bool minimoNodoNoVisitado (int * nodo)
{
int candidato = -1;
for (int n = 0; n < N; n++) {
if (!visitado[n] && (minimo[n] < minimo[candidato] || candidato == -1)) {
candidato = n;
}
}
*nodo = candidato;
return candidato != -1;
}

void dijkstra (int origen, int destino) {

minimo[origen] = 0.0;
int nodo;

while (minimoNodoNoVisitado(&nodo)) {
if (minimo[nodo] == FLT_MAX)
return; // otros vértices son inaccesibles
visitado[nodo] = true;
for (int n = 0; n < N; n++) {
if (!visitado[n] && distancia[nodo][n] < 1.0) {
float posibleMin = minimo[nodo] + distancia[nodo][n];
if (posibleMin < minimo[n]) {
minimo[n] = posibleMin;
anterior[n] = nodo;
}
}
}
}
}

void camino_minimo (int inicio, int final)
{
if (inicio != final) {
camino_minimo (inicio, anterior[final]);
cout << ", ";
}
cout << final;
}

int main(int argc, char **argv)
{
int M, inicio, final;

// inicializar matriz de distancias y camino minimo
cin >> N;
for (int k = 0; k < N; k++) {
anterior[k] = INDEFINIDO;
visitado[k] = false;
minimo[k] = MAXINT;
for (int l = 0; l < N; l++) {
camino[k][l] = FLT_MAX;
}
}

// leer distancias en arcos reales
cin >> M;
for (int k = 0; k < M; k++) {
int i, j;
cin >> i >> j;
cin >> prob[i][j];
}

cin >> inicio >> final;

dijkstra(inicio, final);

camino_minimo(inicio, final);

return 0;
}

//-----Dependencias
#include <stdio.h>
#include <conio.h>

//-----Declaración de funciones
void limpiar(char[],int), pasar(char[],char[]),
conv_pre(char[],char[]), conv_pos(char[],char[]),
rec_exp(char[]), inver(char[],char[]);
int verif(char[]), tama(char[]), sim(char),
prio(char,char);

//-----Variables globales
char Simb[4][2]={{'(',')'},{'-','+'},{'/','*'},{'$','\0'}},
expr[50], pila[50], expr_c[50], epre[50], epos[50],
elem, simb;
int i, j, n, tope, val, cont1, cont2, v;

//-----Inicio del programa
main(){
clrscr();
limpiar(expr,50);
limpiar(pila,50);
limpiar(expr_c,50);
limpiar(epre,50);
limpiar(epos,50);
do{
printf("Introduzca la expresión infija: ");
for(i=0;(expr[i]=getchar())!='\n';++i);
if(expr[i]=='\n'){
expr[i]='\0';
}
if(verif(expr)!=3){
printf("\nLa expresión %s no es valida, ",expr);
switch(verif(expr)){
case 0: printf("esta mal la función.");
case 1: printf("le faltan paréntesis derechos.");
case 2: printf("le faltan paréntesis izquierdos.");
}
getche();
clrscr();
}
}while(verif(expr)!=3);
inver(expr_c,expr);
conv_pre(expr_c,epre);
printf("\nLa conversión a Prefija es: %s",epre);
pasar(expr_c,expr);
conv_pos(expr_c,epos);
printf("\nLa conversión a Posfija es: %s",epos);
getche();
}

//-----Limpia la variable
void limpiar(char a[], int n){
for(i=0;i<n;i++){
a[i]='\0';
}
}

//-----Pasa de una variable a otra
void pasar(char a[], char b[]){
int n1, n2;
n1=tama(a);
n2=tama(b);
if(n1>n2){
for(i=0;i<n1;i++){
a[i]=b[i];
}
}
if(n1<n2){
for(i=0;i<n2;i++){
a[i]=b[i];
}
}
}

//-----Cuenta cuantos caracteres hay en la variable
int tama(char var[]){
for(n=0;var[n]!='\0';++n);
return(n);
}

//-----Verifica si no le faltan paréntesis a la función
int verif(char ex[]){
val=0;
n=tama(ex);
if(n>0){
tope=0;
cont1=cont2=0;
for(i=0;i<n;i++){
elem=ex[i];
if(elem=='('){
pila[tope]=elem;
tope+=1;
pila[tope]='\0';
}
else{
if(elem==')'){
if(tope>0){
if(pila[tope-1]=='('){
tope-=1;
pila[tope]='\0';
}
}
else{
pila[tope]=elem;
tope+=1;
pila[tope]='\0';
}
}
}
}
if(tope>0){
for(i=0;i<tope;i++){
if(pila[i]=='('){
cont1+=1;
}
if(pila[i]==')'){
cont2+=1;
}
}
if(cont1<cont2){
val=2;
}
if(cont1>cont2){
val=1;
}
}
else{
val=3;
}
}
else{
val=0;
}
return(val);
}

//-----Conversión de la función a prefija
void conv_pre(char ex[], char epre[]){
char expre[50];
limpiar(expre,50);
conv_pos(ex,expre);
inver(epre,expre);
}

//-----Conversión de la función a postfija
void conv_pos(char ex[], char epos[]){
tope=-1;
n=tama(ex);
while(ex[0]!='\0'){
simb=ex[0];
rec_exp(ex);
n-=1;
if(simb=='('){
tope+=1;
pila[tope]=simb;
}
else{
if(simb==')'){
while(pila[tope]!='('){
int x=tama(epos);
epos[x]=pila[tope];
pila[tope]='\0';
tope-=1;
}
pila[tope]='\0';
tope-=1;
}
else{
if(sim(simb)==0){
int x=tama(epos);
epos[x]=simb;
}
else{
if(tama(pila)>0){
while(prio(simb,pila[tope])<=0){
int x=tama(epos);
epos[x]=pila[tope];
pila[tope]='\0';
tope-=1;
if(tope<0){
break;
}
}
}
tope+=1;
pila[tope]=simb;
}
}
}
}
while(tope>=0){
int x=tama(epos);
epos[x]=pila[tope];
pila[tope]='\0';
tope-=1;
}
}

//-----Recorre los caracteres un lugar
void rec_exp(char a[]){
int x=tama(a);
for(i=0;i<(x-1);i++){
a[i]=a[i+1];
}
a[i]='\0';
}

//-----Verifica si es un operador
int sim(char s){
v=0;
for(i=0;i<4;i++){
for(j=0;j<2;j++){
if(s==Simb[i][j]){
v=1;
}
}
}
return(v);
}

//-----Verifica la prioridad para colocar en la pila
int prio(char s1, char s2){
int p1, p2;
p1=p2=0;
for(i=0;i<4;i++){
for(j=0;j<2;j++){
if(s1==Simb[i][j]){
p1=i;
}
if(s2==Simb[i][j]){
p2=i;
}
}
}
if(p1<p2){
i=-1;
}
else{
if(p1==p2){
i=0;
}
else{
i=1;
}
}
return(i);
}

//-----Invierte la función completa
void inver(char a[], char b[]){
int x=tama(b);
n=0;
for(i=(x-1);i>=0;i--){
simb=b[i];
if(simb==')'){
a[n]='(';
}
else{
if(simb=='('){
a[n]=')';
}
else{
a[n]=simb;
}
}
n++;
}
}

class TElevisor
{

bool prendido = false; // apagado
int volumen = 0; // sin volumen

class televisor()
{
prendido = false;
volumen = 0;
}

class televisor(bool _prendido, int _volumen)
{
prendido = _prendido;
volumen = _volumen;
}

void prender()
{
prendido = true;
}

void apagar()
{
prendido = false;
}

void subirVolumen()
{
volumen ++;
}

void bajarVolumen()
{
volumne--;
}
int repeticionesMayor()
{
int mayor = mayor();

int repeticiones = 0;

for (int i=0; i<10; i++)
{
if (arreglo[i] == mayor)
{
repeticiones++;
}
}

}

Yo Lo Tengo En Java...

# Include
# Define s 1000001
char a [s], b [s];
int main () (
n de largo, m, i, añadir, k;
/ / Freopen ("10013.in", "r", stdin);
scanf ("% ld", & n);
for (k = 1, k <= n, k + +) (
scanf ("% ld", & m);
for (i = 1; <i = m; i + +)
scanf ("% ld% ld", & a [i], y b [i]);
add = 0;
for (i = m, i> = 1; i -)
(
add = a [i] + b [i] + añadir;
a [i] = añadir el 10%;
add = add/10;
)
if (add! = 0)
printf ("% ld", añade);
for (i = 1; <i = m; i + +)
printf ("% ld", a [i]);
if (k! = n)
printf ("\ n \ n");
más
printf ("\ n");
)
return 0;
)

void)() main
elfe: no return

cous : gol
default(main)args: switch