Introducción: lógica combinatoria
La lógica combinatoria (CL) se basa en cosas llamadas combinadores , que son básicamente funciones. Hay dos combinadores básicos "incorporados" Sy K, que se explicarán más adelante.
Asociatividad izquierda
CL es asociativo a la izquierda , lo que significa que los corchetes (que contienen cosas) que están en el extremo izquierdo del otro par de corchetes que lo contienen se pueden quitar, con su contenido liberado. Por ejemplo, algo como esto:
((a b) c)
Se puede reducir a
(a b c)
Donde (a b)está en el extremo izquierdo del soporte más grande ((a b) c), por lo que se puede quitar.
Un ejemplo mucho más grande de asociación izquierda (los corchetes son explicaciones):
((a b) c ((d e) f (((g h) i) j)))
= (a b c ((d e) f (((g h) i) j))) [((a b) c...) = (a b c...)]
= (a b c (d e f (((g h) i) j))) [((d e) f...) = (d e f...)]
= (a b c (d e f ((g h i) j))) [((g h) i) = (g h i)]
= (a b c (d e f (g h i j))) [((g h i) j) = (g h i j)]
Los corchetes también se pueden reducir cuando más de un par envuelve los mismos objetos. Ejemplos:
((((a)))) -> a
a ((((b)))) -> a b
a (((b c))) -> a (b c) [(b c) is still a group, and therefore need brackets.
Note that this doesn't reduce to `a b c`, because
`(b c)` is not on the left.]
Builtins
CL tiene dos combinadores "incorporados" Sy K, que pueden cambiar objetos (combinadores individuales, o un grupo de combinadores / grupos envueltos entre paréntesis) de la siguiente manera:
K x y = x
S x y z = x z (y z)
Donde x, yy zpueden ser sustitutos para cualquier cosa.
Un ejemplo de Sy Kson los siguientes:
(S K K) x [x is a stand-in for anything]
= S K K x [left-associativity]
= K x (K x) [S combinator]
= x [K combinator]
Otro ejemplo:
S a b c d
= a c (b c) d [combinators only work on the n objects to the right of it,
where n is the number of "arguments" n is defined to have -
S takes 3 arguments, so it only works on 3 terms]
Los anteriores son ejemplos de declaraciones CL normales, donde la declaración no puede evaluarse más y logra un resultado final en una cantidad de tiempo finita. Hay declaraciones no normales (que son declaraciones CL que no terminan y se seguirán evaluando para siempre), pero no están dentro del alcance del desafío y no necesitarán ser cubiertas.
Si desea obtener más información sobre CL, lea esta página de Wikipedia .
Tarea:
Su tarea es hacer combinadores adicionales, dado el número de argumentos, y lo que evalúa como entrada, que se da así:
{amount_of_args} = {evaluated}
Donde {amount_of_args}es un número entero positivo igual al número de args, y {evaluated}consiste en:
- argumentos hasta la cantidad de
1argumentos,2siendo el primer argumento, el segundo, etc.- Se le garantiza que no aparecerán números de argumento por encima de la cantidad de argumentos (por lo que solo es un
4cuándo ) .{amount_of_args}3{evaluated}
- Se le garantiza que no aparecerán números de argumento por encima de la cantidad de argumentos (por lo que solo es un
- soportes
()
Entonces ejemplos de entradas son:
3 = 2 3 1
4 = 1 (2 (3 4))
La primera entrada es pedir un combinador (digamos R) con tres argumentos ( R 1 2 3), que luego se evalúa en:
R 1 2 3 -> 2 3 1
La segunda entrada pide esto (con un nombre de combinador A):
A 1 2 3 4 -> 1 (2 (3 4))
Dada la entrada en este formato, debe devolver una cadena de S, Ky (), cuando se sustituye con un nombre de combinador y se ejecuta con argumentos, devuelve la misma instrucción evaluada que el {evaluated}bloque cuando el bloque de comando se sustituye por ese nombre de combinador.
La declaración del combinador de salida puede tener su espacio en blanco eliminado y los corchetes externos eliminados, por lo que (S K K (S S))se puede convertir algo así SKK(SS).
Si desea probar las salidas de su programa, @aditsu ha hecho un analizador de lógica combinatoria (que incluye S, K, Ie incluso otros como By C) aquí .
Puntuación:
Dado que este es un metagolf , el objetivo de este desafío es lograr la menor cantidad de bytes en la salida posible, dados estos 50 casos de prueba . Ponga sus resultados para los 50 casos de prueba en la respuesta, o haga un pastebin (o algo similar) y publique un enlace a ese pastebin.
En caso de empate, gana la primera solución.
Reglas:
- Su respuesta debe devolver la salida CORRECTA; por lo tanto, dada una entrada, debe devolver la salida correcta según la definición de la tarea.
- Su respuesta debe aparecer dentro de una hora en una computadora portátil moderna para cada caso de prueba.
- No se permite ninguna codificación de soluciones. Sin embargo, puede codificar hasta 10 combinadores.
- Su programa debe devolver la misma solución cada vez para la misma entrada.
- Su programa debe devolver un resultado válido para cualquier entrada dada, no solo para casos de prueba.
1, puede restar 1de todo y luego envolver la solución para esa respuesta K(). Ejemplo: Solución para 2 -> 1is K, por lo tanto, solución para 3 -> 2is KK, solución para 4 -> 3is K(KK)etc.