front + back

De esos ejercicios que sirve hacerlos primero en un lenguaje que domines (como Java), luego en uno que no domines tanto (como Groovy) y luego en uno que estés aprendiendo y que sea distinto a los otros (como Scala)...

En Java para empezar.

De la manera más aburrida en ambos casos (sin funciones adicionales ni recursión ni nada de eso):

Y una manera un poquitito menos aburrida, en Scala (para que no fuera exactamente lo mismo que en Java, que bien lo pudo haber sido), definiendo un par de funciones inline:

La parte central de todo eso NO es partir las cadenas, sino calcular la posición en donde hay que partirlas... tomando eso en cuenta, aquí está mi segunda versión en los 3 lenguajes:

La de Java sigue estando algo aburrida... no hay más que agregar un método que calcule la mitad y luego invocarlo.

La de Groovy queda un poquito menos aburrida, si definimos un closure con el cálculo, dentro del mismo método:

Y la de Scala queda casi igual, solamente definimos una función inline adicional, que usamos dentro de las otras dos...

En Groovy lo que puede estar interesante es pegarle   y   a la clase String, para al final poder hacerlo algo como   y en Scala creo que se puede hacer algo similar pero con un mixin...

Bueno pues ya hice mi primer intento y este es mi resultado:
 

Hare el intento de reducir línea de código =P

Mientras yo hacia mi primer intento ezamudio lo hizo no se cuantas veces con java, groovy y con Scala... no mas por que aun no sale Ryz sinooo tmb hubiera estado incluido en la lista.

Tu frontBack en Scala se ve muy Javera todavía.

Como las funciones ( closures ) son elementos de primer nivel, se pueden declarar también como  

Y cuando el valor de retorno es claro se puede omitir y el compilador lo infiere:

Como   siempre regresa el mismo valor ( no tiene efectos secundarios ) se prefiere omitir los parentesis. También se pueden omitir los "." y hay una forma ( que no me salió ahorita ) en la que también se pueden omitir el parametro y usar "_" .

Lo que dices de agregar esa función a string se llama "implicit conversion" y para ello tienes que convertir el string en otro objeto que tenga el método:

En este ejemplo el objeto se declara en línea también con   etc. aunque aun no sé como se llame eso.

Y luego se puede usar:
 

Eso es más Scalish..

Por eso digo que en Scala lleva aquello de "escribir lo mismo de diferente forma" a otro nivel, porque mientras en la mayoría de los lenguajes se refiere a usar un diferente algoritmo para obtener los mismos resultados, en Scala literalmente es escribir lo mismo de una forma diferente.

Gracias, estaba recordando lo de funciones anónimas pero no encontraba cómo usarlo en esas que declaré =>. Mientras estaba haciendo un frontback2, que recibe la función para calcular la posición como un parámetro:

Yo no hablaba de conversión sino de mixin, es otro desmadre Scalero. Voy a ver qué onda, luego. En Groovy sí encontré (bueno ya me la sabía) la manera de pegarle esos métodos a String:

EDIT: Lo del subguión en Scala no se puede usar para definir ninguna de las 3 funciones, pero sí para pasarle una función distinta a esta última versión que hice:

Intente otras formas pero pues así me quedo : (....
 

EDIT: Borre las que puse antes por que estaban mal.

Pffff no pues nada que ver, me gustaron todas las que van hasta ahorita, pero ya leyendo los comentario la parte más ruda fue partir las palabras, he imaginar una manera que no fuera la más obvia, pues como muy seguido me pasa me confundí de que lado se ponía la letra que sobraba en los nones, pero en fin estuvo divertido.

Y la mía es muy tosca, no se me ocurrió algo más novedoso : S jejeje
Saludos y Chau...

Pues ya, tampoco tiene mucha ciencia lo que encontré así que no voy a crear más expectativa.

Si aún desean poner su propia implementación simplemente no vean mi código ( las ideas se contagian )

El origen está en esta pregunta en Python

Mi idea original fue poner la implementación tal cual viene descrita en el problema:

"Si la longitud es non, el caracter extra se queda en el frente"

Entonces dije: divido entre dos y si es non, le sumo 1

O sea longitud entre dos , más 0 si es par o 1 si es non.

La solución que tiene ezamudio es lo mismo, sumarle a la mitad el módulo, que al ser módulo de 2 siempre será o 0 o 1

Y casí todas las respuestas fueron en el mismo sentido. Como que ya estamos acondicionados a que si leemos aquello de "Si es par.." y se dispara el "Fuck it!! I'll use %"

Hasta aquí todo tranquilo no?

Pues bien, lo que me pareció interesante y la razón de este post en primer lugar es que hubo quién contestó:

Ahhh verdad? Esto es nuevo, porque nunca se usó el operador módulo. Y el resultado es idéntico.

Si es non y se le suma 1 al dividirlo entre dos da de todas formas el indice correcto:

Y obvio funciona perfectamente.

Acá va la versión en Java:

Interesante no?

p.d. Ya que @AlexSnake lo menciona, esta sería la versión equivalente en Ryz (   )

Que sí compila en mi versión privada, la versión del repositorio necesita los parentesis siempre y el tipo de dato.

Usé unos métodos de extensión   y   nomás para que se vea más bonito y para presumir.

Este el el código completo:

Resumen ( tl;dr )

La pregunta era:

La respuesta que encontré fue:

Que no usa el operador módulo  .