No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Funciones

9/36
Recursos

Aportes 54

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Seg煤n entiendo ser铆a algo as铆 馃く
def isGreater(a: Int) = (b: Int) => a < b

println(isGreater(10)(20))

Hola!

def isGreather(x: Int, y: Int):Boolean = {
   x > y
}
val isGreatherObj = isGreather _

def comparar(fx: (Int, Int) => Boolean, a: Int, b: Int): Boolean = fx(a,b)

comparar(isGreatherObj, 3, 1)

Mi solucion es generar una funcion que retorne una funcion anonima y en la funcion anonima se 鈥渇ija鈥 el parametro pasado a la funcion padre. El concepto puede ser dificil de explica, pero si miras el codigo seguro lo entiendes.

// Funcion que genera funciones
def isGreaterGenerator(ref: Int): Int => Boolean = {
    (x:Int) => ref < x
} 

// Usando el generador de funciones
val isGreaterThanTen = isGreaterGenerator(10)

// Usando la funcion generada
isGreaterThanTen(11) // true
isGreaterThanTen(1) // false
isGreaterThanTen(10) // false

Hola, quiero felicitarte tienes una buena facilidad para explicar las cosas, me parece que eres un muy buen profesor.
Pero me gustar铆a que ahondes un poco en eso del apply, por lo que me parece y se de Java, creo el compilador de Scala interpreta esta funci贸n an贸nima:
(x: Int) => x * x
Como un objeto que interpreta la interfaz funcional https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html
es por eso que puedes ejecutar la funci贸n con apply, sin embargo si la funci贸n no recibe ning煤n par谩metro y produce una salida, eso del apply no funciona y tal vez en vez de apply se utilizar铆a get (https://docs.oracle.com/javase/8/docs/api/java/util/function/Supplier.html) o si hablamos de que se recibe algo y no se produce nada usar铆amos accept (https://docs.oracle.com/javase/8/docs/api/java/util/function/Consumer.html)

Es una duda que tengo, gracias.

Yo no le tengo miedo a las mates 馃槃

Tengo dos soluciones pero entonces no se cual seria la que mejor da la repsuesta al reto:

SOLUCION 1:

scala> def calcMayorQue(x:Int,y:Int) = {
     | if (x>y){
     | "El numero " + x + " es mayor al numero " + y}
     | else{
     | "El numero " + x + " es menor al numero " + y}}
calcMayorQue: (x: Int, y: Int)String

scala> calcMayorQue(5,8)
res1: String = El numero 5 es menor al numero 8

SOLUCION 2:

scala> def calcMayorQue(x:Int,y:Int) = {
     | val resComp = x > y
     | def MayorQue(bool: Boolean) = {
     | if (bool){
     | "El numero " + x + " es mayor al numero " + y}
     | else{
     | "El numero " + x + " es menor al numero " + y}}
     | MayorQue(resComp)}
calcMayorQue: (x: Int, y: Int)String

scala> calcMayorQue(5,1)
res2: String = El numero 5 es mayor al numero 1

Quedo atento a sus comentarios

<h4>Funciones</h4>

Para definir funciones en scala tenemos dos opciones

  1. def f(x: Any) = // C贸digo ...
  2. a = (x: Any) => // C贸digo ...

La segunda siendo una funci贸n lambda la cual se comporta como un objeto y podemos usar el metodo apply. Podemos pasar de una funci煤n com煤n a un obeto usando la siguiente expresi贸n

val c = f _

Lo cual deja c como una funci贸n lambda basada en f. Para definir funciones que reciben funciones como parametros usamos la siguiente expresi贸n

def g(h: Any => Any) = // C贸digo ...

def k(h: Any => Any)(x: Any) = // C贸digo ...

La segunda notaci贸n nos permiten pasar dos parametros a la funci贸n k, en primer lugar otra funci贸n y en segundo lugar una variable.

<h5>Funciones como metodos</h5>
object Util {
  def metodo (x: Int) = x+x
  val a = metodo _
}

En mi caso si me funciono f.apply() sobre

def f(x: Int) = x * x

馃槷

scala> val otraFunction = (parametro: Int) => ((x: Int) => x > parametro)
otraFunction: Int => (Int => Boolean) = $$Lambda$992/0x00000008010dc040@53c1f4ae

scala> otraFunction(10)(5)
res18: Boolean = false

scala> otraFunction(10)(13)
res19: Boolean = true

Hola, yo encounter otra manera para pasar los paramteros de las funciones

// Definicion de la function suma para hacer el llamado se ejecuta como fx_suma(3,4)

def fx_suma (x:Int, y:Int):Int ={
	x+y
}

// Convertir la function en un objeto

val obj_fx_suma = fx_suma _


def fx_multi(x:Int, y:Int):Int ={
	x*y
}


// Definicion de una funcion de orden superior

def fx_orden_superior ( fx:(Int,Int)=> Int,x:Int, y:Int):Int = {
	fx(x,y)
}

// Llamado con la funcion como objeto
 fx_orden_superior(obj_fx_suma,3,5)
 fx_orden_superior(fx_suma,3,5)
 fx_orden_superior(fx_multi,3,5)

me dio mucha risa cuando dijiste: existe una **vaina **que se llama el apply jaja

Solucion: `val evaluaSiEsMayor = (paramIngresado: Int, paramExistente: Int) => if(paramExistente > paramIngresado) "El numero existenete es mayor al ingresado" else "El numero existente es menor o igual al numero ingresado"` `def evaluadorNumero21(h:(Int, Int) => String)(x:Int) = h(x,21)` lo ejecutaria asi `evaluadorNumero21(evaluaSiEsMayor)(21)` la solucion seria algo asi `val res17: String = El numero existente es menor o igual al numero ingresado`
Listo aqui mi aporte: def calcula\_Si\_Numero\_Es\_Mayor(a : Int, b : Int): String = { val resultado = if (a > b) "El primer numero es mayor" else "El segundo numero es mayor" resultado } println(calcula\_Si\_Numero\_Es\_Mayor(550, 6))
A mi me quedo asi: `def is_greater_than(n1: Int): Int=>Boolean = (n2:Int) => n2> n1` `val f=is_greater_than(3)` `f(4)`
Reto: def functionFactory = (x: Int) => if(5 > x) "Es mayor" else "es menor"
def isGreater (j:Int => if(J>5) "Es Mayor que 5" else "No Es Mayor que 5" ) = J(25)

Scala 3

@main def hello(): Unit =
  def isGreater(a: Int): Int => String = (b: Int) =>
    if (a > b) s"El primer parametro a=$a es mayor que el segundo parametro b=$b"
      else s"El primer parametro a=$a es menor que el segundo parametro b=$b"
  
  println(isGreater(15)(8))

Podr铆a ser que en Scala 3.2.1 ya apliquen las funciones como objetos?

object Main {
  def main(args: Array[String]): Unit = {
    val res = isGreater(10)
    println(res)
  }

  def isGreater(num1:Int):Int => Boolean = {
    (num2:Int) => num1 < num2
  }
} 

Comparto por aca mi solucion al reto:

object Util{
	def metodo(x:Int,e:Int) = 
if (x>e) {
		println("Primero mayor a segundo")
	} else if (x<e) {
		println("Segundo mayor a primero")
	} 
	else {
		println("Son iguales")
	}                                                   
}

Funciones

Hablamos de funciones en su definici贸n matem谩tica.

  • Dominio: Datos de entrada
  • Rango: Datos de salida

f: D 鈫 R

Funciones de orden superior

Una funci贸n es tratada como un valor m谩s. Esto implica que una funci贸n puede recibir y retornar otras funciones.

  • Funciones an贸nimas (lambdas)
  • Funciones como objetos
  • Funciones como m茅todos
def f(x: Int) = x * x
// f: (x: Int)Int

f(2)
//res0: Int = 4
f(2)
//res1: Int = 16

// Funci贸n an贸nima
(x; Int) => x*x
// res2: Int => Int = $$Lambda$$770/123467@333f5f6
val a = (x; Int) => x*x
//a: Int => Int = $$Lambda$$770/123467@333f5f6
a(2)
//res3: Int = 4
a(4)
//res4: Int = 16

// a es un objeto y f es una funci贸n
f.apply(2) // error
a.apply(2) ////res4: Int = 4

// convertir f en objeto
val c = f _
// c: Int => Int = $$Lambda$$770/123467@333f5f6
c.apply(2)
//res7: Int = 4

def g(h: Int => Int) = h(3)
//g: h: Int => Int)Int

g(f)
//res10: Int =9

def k(h: Int => Int)(x: Int) = h(x)
// k: (h: Int => Int)(x: Int)Int

k(f)(3)
//res11: Int = 9
k(f)(4)
//res12: Int = 16

// Funciones como m茅todos

object Util {
	def metodo(x: Int) = x+x
	val a = metodo _
}

Util.metodo(3)
//res5: Int = 6

Util.a(3)
//res6: Int = 6

scala> def es_Mayor(x: Int, z: Int) = (if x > z then "El numero X es mayor que Z" else "El numero X es menor que Z")
def es_Mayor(x: Int, z: Int): String

scala> es_Mayor(10,5)
val res1: String = El numero X es mayor que Z

scala> es_Mayor(5,15)
val res2: String = El numero X es menor que Z

Creo que podr铆a ser algo as铆:

def g(x: Int) = (a: Int) => a>x

Esta creo que es la soluci贸n del problema y mas abajo esta una peque帽a utilidad que se le puede hacer a dicha funci贸n.


def isGreater(num : Int) = (num2 : Int) => num2 > num

val isGreaterThan3 = isGreater(3)
isGreaterThan3(5)

Creo un objeto que recibe la funci贸n devuelta por la primera funci贸n, la cual se le pasa como par谩metro el n煤mero 3, lo que nos permite que el objeto no devuelva un booleano si el n煤mero que se le pasa por par谩metros es mayor o no.

Soluci贸n al reto

def calculateHigherInt(base:Int) = (judged:Int) => judged > base
def calculateHigherIntOfFive = calculateHigherInt(5)

calculateHigherIntOfFive(10)

def f (x : Int)(a : Int) = {
if(x>a) "x es mayor al par谩metro a"
else 鈥渘o es mayor鈥
}

 object Calcular {
  def mayor_menor(x: Int, y : Int) = if(x > y)
    println( x + " es mayor que " + y)
  else
    println( x + " no es mayor que " + y)

   val validar = mayor_menor _
  }
Calcular.mayor_menor(1, 4)

Mi soluci贸n:

def isGreater(a:Int, b:Int)= if(a>b)
 "A is greater" else if(a.equals(b)) "Are similar" else "B is greater"

def comparar(f:(Int,Int)=>String)(a:Int,b:Int)
 = f(a,b)
comparar(isGreater)(4,2)

object Test{
def calcular(valor:Int, val2:Int)= if(valor>val2) valor else val2
val parametro= calcular _
}
// Test.calcular(2,4)
Test.parametro(2,4)

soluci贸n del reto

object Util {
  def calcular(a: Int, b: Int): String = {
    if (a > b) "Es mayor" else "Es menor"
  }
}

println (Util.calcular(6,5))

def GreaterThan(x: Int) = (y: Int) => (y > x)
GreaterThan(5)(2)

Seria algo asi:

def mayor(x:int) = (x2: int) => x<x2
println(mayor(4)(5))

脡sta es mi soluci贸n

def isGreater(x: Int) : (Int => Boolean) ={ 
	(y: Int) => {x>y}
}

Buenas noches, este es mi aporte

def may(x: Int,y: Int): Boolean = x<y
may: (x: Int, y: Int)Boolean

may(10,10)
res0: Boolean = false

may(10,101)
res1: Boolean = true

may(1000,101)
res2: Boolean = false

Gracias.

Mi soluci贸n fue esta:
Object Mayor {
def validar(x:Int) = if ( x > 10) 鈥淓l numero 鈥+x+鈥 es mayor a 10鈥 else "El numero 鈥+x+鈥 es menor a 10"
Val m = validar _
}

Mayor.a(11)
Val res0: String = El numero 11 es mayor a 10

object comparador {
  def comparar( a: Int ) = {
    ( b: Int ) => println( a < b )
  }
}

comparador.comparar(10)(20)

Easy!

def m(x: Int) = (y: Int) => x > y

O eso creo!!! Jajaj

Mi soluci贸n quedo as铆, seg煤n entend铆

// Con una funci贸n simple
def a(x: Int)(y: Int) = x > y
println(a(1)(2))
// Una funci贸n que resuelve el problema acorde al enunciado
def a(y: Int) = 6 > y
println(a(2))
// Agregando la parte de una funci贸n que genera una funci贸n
def a(x: Int) = { def y(x: Int) = 6 < x; y(x); }
println(a(2))

no me quedo muy claro lode funciona an贸nimamente, no me dio el msj de Lambda.

scala> val a = (x: Int ) => x*x
a: Int => Int = <function1>

scala> def Mayor(p: Int) = if(p > 10) "Es Mayor" else "Es Menor o Igual"
Mayor: (p: Int)String

scala> def MayorQue(funcionBase: Int => String)(p: Int) = funcionBase(p)
MayorQue: (funcionBase: Int => String)(p: Int)String

scala> MayorQue(Mayor)(2)
res0: String = Es Menor o Igual

scala> MayorQue(Mayor)(10)
res1: String = Es Menor o Igual

scala> MayorQue(Mayor)(11)
res2: String = Es Mayor

Para el ejercicio he realizado varios intentos el mas simplificado es el siguiente

def validator(param:Int) = if (param >= scala.util.Random.nextInt(10)) "Es mayor o igual" else "Es menor o igual" 

Sin embargo quisiera saber porque no funciona el siguiente C贸digo:

def fx_identify_parameter(param: Int) = {

    def validator ():String ={
		val num_aleatorio = scala.util.Random.nextInt(10)

		if (num_aleatorio > param) {
		  "El parametro es mayor al numero aleatorio"
		} else if (num_aleatorio < param) {
		  "El parametro es menor al numero aleatorio"
		} else {
		  "El parametro es igual al numero aleatorio"
		}
	}

}```
val calc = (x:Int) => ((y:Int) => x > y)

def f(x: (Int, Int) => Int)(y: Int, z: Int) = x(y,z)
def x(a: Int, b: Int) = if(a>b) a else b

def functionFactory(num: Int): Int => Boolean = { (param: Int) => num > param }

val test = functionFactory(10)

test(20)

test(5)

Si entend铆 bien deber铆a ser as铆

def function(a:Int): (Int) => Boolean = (b:Int) => a > b

Qu茅 tal, comparto mi ejercicio:
![]()

object ChallengeOne extends App {
  def generatorChallenge = (x: Int) => if (x > 10) "Is greater than" else "Is less than"
  val result = generatorChallenge
  println(result(15))
  println(result(7))
}

Acorde a lo que yo entend铆 esta es mi propuesta
def isGreater(num: Int) = (param : Int) => num > param
isGreater(4)(2)
val res0: Boolean = True
isGreater(4)(5)
val res1: Boolean = False

Lo logreee!!
-Seg煤n comprend铆 el enunciado y mis conocimientos actuales en scala

Abierto a sugerencias y correcciones

Creo que ser铆a algo as铆:

scala> val compara = (a:Int,b:Int) => a>b
compara: (Int, Int) => Boolean = <function2>

scala> def esMayor(f: (Int,Int) => Boolean)(x:Int)(y:Int) = f(x,y)
esMayor: (f: (Int, Int) => Boolean)(x: Int)(y: Int)Boolean

scala> esMayor(compara)(5)(4)
res7: Boolean = true

scala> esMayor(compara)(5)(7)
res8: Boolean = false

scala> esMayor(compara)(5)(5)
res9: Boolean = false

def g(h: Int => Int)(x: Int) = h(x) > x

La respuesta que yo propongo es
def genera3(b: Int): Int => Boolean = (c: Int)=> if(b<c)true else false
println("El resultado es: " + genera3(4)(6))