procedure PonerAzulejo(){  procedure MoverComoSea() {

Poner(Verde)
PonerN(5,Negro)  if (puedeMover(Oeste)) {
PonerN(9,Rojo)  Mover(Oeste)
}  } else {
procedure PonerN(cantidad,color){  Mover(Norte)
repeat(cantidad){  }
Poner(color)  }
}
}

procedure MoverN(cantidad,direccion){
repeat(cantidad){ procedure PrenderOApagarLuz() {
Mover(direccion) if (hayBolitas(Verde)) {
} Sacar(Verde)
} Poner(Negro)
}
procedure Guarda(longitud, direccionida, direccionvuelta) { else {
repeat(longitud){ Sacar(Negro)
Mover(direccionida) Poner(Verde)
PonerAzulejo() }
} }
MoverN(longitud, direccionvuelta)
} procedure MoverSegunBolitas() {
procedure GuardaEnL(){ if (nroBolitas(Azul) + nroBolitas(Negro) + nroBolitas(Rojo) +
PonerAzulejo() nroBolitas(Verde) > 10) {
Guarda(2, Este, Oeste) Mover(Este)
Guarda(2, Norte, Sur) } else {
} Mover(Norte)
}
procedure Flecha(direccion){ }
Mover (direccion) function nroBolitasTotal() {
Poner (Rojo) return (nroBolitas(Azul) + nroBolitas(Negro) + nroBolitas(Rojo) +
Mover (opuesto(direccion)) nroBolitas(Verde))
Mover (previo(direccion)) }
Poner (Rojo)
Mover (siguiente(direccion))
Mover (siguiente(direccion))
Poner (Rojo)
 son un caso particular de las expresiones, y por lo tanto
siguen las mismas reglas que ellas: se escriben con
Mover (previo(direccion))
la primera letra minúscula y siempre retornan algún valor
} (en este caso, un número);
procedure CopiarVerdesEnRojas(){
 en la última línea de su definición siempre va un return,
PonerN(nroBolitas(Verde), Rojo)
seguido de una expresión entre paréntesis: el valor que la
} función va a retornar.
procedure SacarTodas(color){
SacarN(nroBolitas(color), color)
}
procedure SacarAzulConMiedo() {
procedure MoverSegunBolitas() {
if (hayBolitas(Azul)) {
if (nroBolitasTotal()> 10) {
Sacar(Azul) Mover(Este)
} } else {
} Mover(Norte)
program{ }
if (puedeMover(Este)){ }
Mover (Este)
function todasExcepto(color){
}
return (nroBolitasTotal()-nroBolitas(color))
} }
procedure AsegurarUnaBolitaVerde(){
if (not hayBolitas(Verde)){ function rojoEsDominante(){
Poner(Verde) return (nroBolitas(Rojo)>todasExcepto(Rojo))
} }
}
function esUnCasilleroCargadoConRojoDominante() {
return (nroBolitasTotal() > 5 && rojoEsDominante())
 El if se escribe seguido de la condición entre paréntesis (()) }
y luego entre llaves las acciones que se deben realizar si la
condición se cumple. Si queremos negar una condición,
function esLibreCostados() {
el not también debe ir dentro del paréntesis.
return (puedeMover(Este) && puedeMover(Oeste))
 El if se escribe con minúsculas, fijate que en tu solución }
está escrito If, y por eso no aparece en azul.
 Te recuerdo que para definir un procedimiento usamos la function hayAlgunaBolita() {
palabra procedure seguida del nombre del mismo y luego
entre llaves ({}) las acciones que realiza. Fijate que en tu
código te estás olvidando de las llaves.
 return (hayBolitas(Negro) || hayBolitas(Azul) || hayBolitas(Verde) ||
hayBolitas(Rojo))
}

 Negación: "da vuelta" una expresión booleana -

ejemplo: not hayBolitas(Rojo).
 Conjunción: determina si se cumplen ambas condiciones -
ejemplo: puedeMover(Norte) && puedeMover(Sur).
 Disyunción: determina si se cumple alguna de las
condiciones - ejemplo: esInteligente() || tieneBuenaOnda().

function estoyEnUnBorde() {
return (not puedeMover(Norte) || not puedeMover(Sur) || not
puedeMover(Este) || not puedeMover(Oeste))
}
Como en la aritmética, en la lógica también existe el concepto
de precedencia y ciertas operaciones se resuelven antes que otras:
primero la negación (not), después la conjunción (&&) y por último la
disyunción (||).

function hayBolitasAl(direccion, color) {

Mover (direccion)
return (hayBolitas(color))
}

function hayBolitasLejosAl(direccion, color, distancia) {

MoverN (distancia, direccion)
return (hayBolitas(color))
}

function estoyRodeadoDe(color) {
return (hayBolitasAl(Norte, color) && hayBolitasAl(Sur, color) &&
hayBolitasAl(Este, color) && hayBolitasAl(Oeste, color))
}

function hayLimite() {
return (estoyEnUnBorde() || estoyRodeadoDe (Rojo))
}