Funciones especiales del Robot Karel

Dentro de la herramienta didctica y lenguaje de programacin el Robot Karel, no podan faltar tres
funciones muy tiles, y que le dan versatilidad a la forma de solucionar problemas de un mayor grado de
complejidad de los que ya hemos resuelto, o bien resolverlos con ms eficiencia. Por otro lado, debemos
saber que en todos los lenguajes de programacin algortmicos, las funciones pueden regresar un
resultado. Dentro del lenguaje del Robot Karel, hay algunas funciones que si regresan un resultado, estas
funciones son las siguientes:
succ(a), pred(a) e iszero(a); veamos a continuacin cada una de estas tres funciones.

succ(a):
La funcion succ(a), es una de las tres funciones especiales de esta herramienta didctica y Lenguaje de
Programacion El Robot Karel, con esta funcion succ(a) podemos generar el siguiente valor (succesor) del
valor actual del parmetro-variable "a", es decir que al llamar a la funcin succ(a), escribimos entre sus
parntesis el nombre de un parmetro-variable (puede ser tambin un valor numrico constante), y la
funcin succ(a) regresara como resultado el valor (a+1). Esta funcin succ(a), la podemos llamar al
colocar su nombre entre los parntesis al llamar a otra funcin, tambin podemos usar esta funcin en la
instruccin "iterate(succ(a))". Veamos a continuacin algo de esta misma explicacin pero con otras
palabras.
Esta funcin succ(a) la usaremos al momento de llamar, invocar o hacer referencia a otra funcin, modulo
o nueva tarea. La funcin succ(a) tambin la podemos usar, como parmetro, en el estatuto de control de
repeticin "iterate" . Esta funcin succ(a), genera el siguiente valor del parmetro (a), de tal manera que
regresara como resultado el valor (a+1).
El uso de las dos funciones succ(a) y pred(a) puede ser de manera anidada, como por ejemplo
succ(succ(succ(succ(a)))), el grado o nivel de anidamiento no tiene limite (el nico limite es la capacidad
de la pila del Robot Karel).

pred(a):
Esta funcin la usaremos al momento de llamar, invocar o hacer referencia a otra funcin, modulo o
nueva tarea, tambin la podemos usar, como parmetro, en el estatuto de control de repeticin
"iterate(pred(a))", adems de poder usarla tambin como parmetro, al llamar o invocar a la funcin
lgica iszero(pred(a)). Esta funcin pred(a), genera el valor anterior del parmetro (a), de tal manera que
regresara como resultado el valor (a-1).
El uso de las dos funciones succ(a) y pred(a) puede ser de manera anidada, como por ejemplo
pred(pred(pred(pred(a)))), el grado o nivel de anidamiento no tiene limite (el nico limite es la capacidad
de la pila del Robot Karel).
Ejemplo:

Karel tiene un nmero desconocido de trompos en su mochila y debe dejarlos en la posicin en la que se
encuentra, sin embargo no debe dejar todos los trompos, sino que debe quedarse con uno de los trompos
en su mochila. El numero de trompos que tiene Karel en su mochila de trompos o zumbadores, se recibe
como parmetro en la funcin dejaTrompos( a ).
class program {
void dejaTrompos(a) {
iterate (pred(a)) { // se resta uno al nmero de trompos antes de entrar en el iterate
putbeeper();
}
}
program() {
dejaTrompos(5); // llama la funcin dejaTrompos( ) y se le enva el valor 5 como parmetro
turnoff();
}
}
En el ejemplo de arriba, se le manda a la funcin dejaTrompos( 5 ) un 5, asumiendo que son 5 los
trompos que tiene Karel en su mochila.
Ejecuta el programa, y veras que Karel deja 4 trompos, ya que el pred(a) le resta un 1 a la variable "a".
Prueba el cdigo enviando, cada vez, distintos valores a la funcin dejaTrompos( n ).

iszero(a):
Esta funcin la usamos dentro de un estatuto de control condicional "if(iszero(a))", y tambin dentro del
encabezado en el estatuto de control de repeticin "while(iszero(a))". La funcin iszero(a), regresa como
resultado el valor lgico "true" si el valor del parmetro (a) tiene el valor de cero, en caso contrario
regresa el valor lgico de "false". Al llamar o invocar a esta funcin, podemos utilizar como parmetro la
llamada anidada a la funcin pred(a), como por ejemplo iszero(pred(pred(pred(pred(a))))), con el grado
de anidamiento que necesitemos.
Ejemplo:
Se quiere que Karel ejecute una serie de instrucciones para ciertos casos.
En el cdigo de Karel que esta a continuacin, se le pasa un numero a una funcin llamada
instrucciones(a), y dependiendo del valor que se pase (el cual puede ser 0, 1, 2 o tres), entonces la tarea de
Karel (en la funcin<<instrucciones( a )>>) es:
- si el valor de a es un cero, avanzar una cuadra
- si el valor de a es un uno, girar a la izquierda y avanzar una cuadra.
- si el valor de a es un dos, girar 180 grados y avanzar una cuadra.

- si el valor de a es un tres, girar a la derecha y avanzar una cuadra.

class program {
void instrucciones(a) {
if( iszero(a) ) ) {
// aqu se pregunta si la variable-parametro "a" es igual a cero
move();
}
else{
if( iszero( pred(a) ) { // con el pred(a) se le resta un uno al valor de la variable "a", por lo
que si su valor era uno,
// la funcin pred(a) lo convierte en cero (dado que regresa el valor a-1)

turnleft();
}

move();

else{
if( iszero( pred ( pred(a) ) ) ) {
caso, ya que son dos,
pred(pred(a)), el es convertido a cero

// se pueden hacer llamadas anidadas de pred( ), en este

// si "a" valia dos, con las dos llamadas anidadas de

turnleft();
turnleft();
}

move();

else {
if( iszero( pred ( pred ( pred (a) ) ) ) ) { //Si entra a este "else" es porque el valor del
parametro-variable puede ser 3 entonces, para comprobar que efectivamente el valor del parametro es 3
//usamos tres pred(a) anidados (pred(pred(pred(a)))), con esto a la variable "a" se le restan 3,
//y la funcion iszero(a), regresara un valor "true" cuando a == 0
turnleft(); //estas 4 instrucciones son procesadas por Karel, si el valor de "a" es 3
turnleft();
turnleft();
move();
}

}
}
}

program() {
instrucciones(3);
turnoff();
}

Prueba este programa cambiando el valor que se le manda a la funcin instrucciones( a ).

Veamos a continuacin otro ejemplo en donde podremos utilizar una de estas funciones. La
descripcin de este ejemplo es la siguiente:
Karel inicia con direccin al norte; en esa misma direccin, a una distancia no conocida (entre una y cinco
cuadras), hay una barda. La tarea de Karel es determinar a cuantas cuadras (de su esquina de inicio)
encontr la barda. Karel debe dejar, junto a la barda, un numero de trompos o zumbadores que indique
ese nmero de cuadras.
Karel inicia con cinco trompos o zumbadores en su mochila de trompos.
En las siguientes lneas esta el cdigo que le da solucin al ejemplo planteado. Prueba este programasolucin en tu computadora para que observes el uso de la funcin succ(a).
class program {
void deja(b) {
iterate (b) {
putbeeper();
}
}
void resuelveLaTarea(x) {
move();
if (frontIsBlocked()) {
deja(succ(x));
}
else {
move();
if (frontIsBlocked()) {
deja(succ(succ(x)));
}
else {
move();
if (frontIsBlocked()) {
deja(succ(succ(succ(x))));
}

else {
move();
if (frontIsBlocked()) {
deja(succ(succ(succ(succ(x)))));
}
else {
move();
if (frontIsBlocked()) {
deja(succ(succ(succ(succ(succ(x))))));
}
}
}
}
}
}
program() {
resuelveLaTarea(0);
turnoff();
}
}
//Prueba este programa-solucin en tu computadora para que observes el uso de la funcin succ(a).
//No olvides disear el mundo inicial de Karel como aqui se plantea, recuerda colocar en la mochila de
//trompos del Karel los cinco trompos
Ejemplo:
En este ejemplo, la posicion inicial de Karel es en el extremo de la izquierda de un rectangulo de una
longitud desconocida, pero de una cuadra de altura. El rectangulo crece de Oeste al Este. En el interior del
rectangulo, y en cada esquina, hay montones de uno y de dos trompos, tambien hay trompo en la posicion
inicial de Karel. La tarea de Karel, es que al ir avanzando a cada nueva esquina (dentro del rectangulo)
debe llamar a una funcion para que deje en esa esquina los trompos necesarios para que siempre queden
tres (3) trompos o zumbadores en la esquina actual del Robot Karel, y que haga lo mismo en cada una de
las esquinas dentro del rectangulo. El reto en este ejemplo es que debera usarse la funcion succ(a).
Tambien usaremos la funcion pred(a) para determinar cual es el valor del parametro que recibio la
funcion (en este ejemplo la funcion se llama "void completaATres(a)").
class program {
void completaATres(a) {//Esta funcion va a recibir como dato o valor un numero que indica la
cantidad
//de trompos que hay en este momento en la esquina donde esta parado Karel
if (iszero(pred(a))) {
iterate(succ(succ(a))){
putbeeper( ); //como habia un trompo, va a dejar otros dos para completar a tres trompos

}
}
if (iszero(pred(pred(a)))) {
putbeeper( ); //como habia dos trompos, va a dejar otro para completar a tres trompos
}
}// fin de la funcion completaATres(a)
program( ) {
while (frontIsClear( )){
pickbeeper( ) //levanto el primero, porque se me asegura que siempre hay al menos un trompo
if(nextToABeeper( )){ //si esto se cumple, significa que habia 2 trompos
putbeeper( );
putbeeper( );// dejo los dos trompos que levante
completaATres(2); // aqui llamo a la funcion "completaATres(2)" para que complete a tres
trompos en la esquina actual
}
else{
// Si entra en este "else" es porque solo habia un trompo en la esquina actual
putbeeper( );
completaATres(1); // aqui llamo a la funcion "completaATres(1)" para que complete a tres
trompos en la esquina actual
}
move( ); // avanza a la siguiente esquina dentro del rectangulo
}
turnoff( );
} // Aqui termina la funcion principal "program( )"
} // Aqui termina la clase "class program"
Mundo inicial de ejemplo

Mundo final de ejemplo

Ejemplo funcin pred(a) e iszero(a)

Karel inicia en una esquina donde hay un trompo o dos trompos, si es un trompo Karel deber avanzar
una cuadra y dejar 5 trompos, y si son 2 trompos deber avanzar una cuadra y dejar 10 trompos. Karel
inicia con 10 trompos en su mochila de trompos o zumbadores.
A continuacin estn, primero, los dos mundos posibles iniciales, y luego los dos mundos finales.
Tambin, se encuentra, al final de esta pagina, el cdigo del programa que debers probar en el software
del Robot Karel.
Mundo inicial 1

Mundo inicial 2

Mundo Final1

Mundo Final 2

//************** CODIGO DEL PROGRAMA, PARA QUE LO PRUEBES ***************

class program{
void deja5_o_10(a){
if(iszero(pred(a))){
depositaTrompo(5);
}
if(iszero(pred(pred(a)))){
depositaTrompo(10);
}
}
void depositaTrompo(b){
iterate(b){
putbeeper();
}
}
program(){
pickbeeper();
if(nextToABeeper()){
move();
deja5_o_10(2);
}
else{
move();
deja5_o_10(1);
}

turnoff();
}
}
Copia y pega este cdigo en el modulo del software (programa simulador del Robot Karel),
recuerda probar este cdigo con los dos posibles mundos, y no olvides colocar trompos en la
mochila de trompos o zumbadores de Karel.