Meta quine checker

10

Este desafío, si lo acepta, es escribir tres funciones o programas A, B y C:

  • A es una quine que genera todos los A, B y C (que también es el contenido completo del código en su envío).
  • B toma un parámetro F y comprueba si se trata de una quine (salida de FBC) o si está haciendo algo diferente.
  • C toma un parámetro G y verifica si G posiblemente funciona como B (verificando si F produce FGC). Es imposible decidir si una función es un verificador de quine, así que hagamos algo más simple:
    • Debe devolver la verdad si G es válido para B.
    • Debe devolver falsey si G devuelve falsey para todas las cuotas válidas, o G devuelve verdadero para todas las no válidas válidas.
    • Puede devolver cualquier cosa, bloquearse o no finalizar, etc., si es cualquiera de los otros casos.

Tenga en cuenta que B es posible. A y F no tienen ninguna entrada, por lo que puede ejecutarlos y verificar el resultado.

Reglas

  • Debería haber alguna forma de saber qué partes son A, B y C a partir de la salida de A. Por ejemplo: cada una tiene una línea o se reconocen como tres funciones en el intérprete.
  • Cada función debe ejecutarse solo con la definición de sí misma, no con el código completo.
  • Puede usar una función / programa o su código fuente, o un par de ambos como entrada de B (o G) y C.
  • Puede redefinir la verdad / falsey a un subconjunto de esos valores. También puede requerir constantemente que F devuelva el tipo que elija, como una sola cadena.
  • Puede requerir A, B, F y G, si se llaman con parámetros válidos, no tiene algunos tipos de otras entradas o efectos secundarios que elija, como acceder a variables globales o leer stdin, etc.
  • También puede asumir que F y G, si se llaman con parámetros válidos, siempre terminan.
  • F debería funcionar en la misma condición que A. Por lo tanto, no puede depender de B o C ni de la existencia de otra variable, a menos que esa variable se defina en su propia parte en su salida.
  • Ninguna función o programa puede leer su propio código fuente.
  • Este es el código de golf, el código más corto (que es la salida de A) en bytes gana.
jimmy23013
fuente
B sigue siendo imposible en general porque F puede no terminar, así como en la práctica en muchos idiomas porque requiere combinaciones de habilidades como la redirección temporal de stdout y función a cadena o exec. Lo mejor que puede esperar es probablemente una solución a medio trabajar en un LISP.
Peter Taylor
¿Cómo verificaría G con todas las quines y no quines? Actualmente estoy trabajando en una solución de Mathematica.
LegionMammal978
@PeterTaylor "También puede suponer F y G, si se llaman con parámetros válidos, siempre terminan". Y "salida" puede significar retorno, no necesariamente imprimir en stdout.
jimmy23013
@ LegionMammal978 Es imposible verificar todas las quines y no quines. Pero la tarea de C es algo más simple, donde solo necesita verificar una quine y una no quine.
jimmy23013
1
@PyRulez Creo que esto está en el espíritu de este desafío, así que lo voy a permitir. Pero la función no puede acceder a su propio código fuente.
jimmy23013

Respuestas:

1

CJam, 254 bytes

Un ejemplo de respuesta, no golf.

{{['{\"_~}{{[1$'{@\"_~}"{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}_``1>W<"\"]s\~=}_~}"@]s}_~}{{[1$'{@"_~}{{[\"_~}\"2$+'{@\"_~}\"]s`\"{{['{\\\\\"\+\"]s}_~}\"+~1$~{L}@~!&}_~}"]s\~=}_~}{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}

Las 3 funciones son:

{{['{\"_~}{{[1$'{@\"_~}"{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}_``1>W<"\"]s\~=}_~}"@]s}_~}
{{[1$'{@"_~}{{[\"_~}\"2$+'{@\"_~}\"]s`\"{{['{\\\\\"\+\"]s}_~}\"+~1$~{L}@~!&}_~}"]s\~=}_~}
{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}

A y F no toman parámetros y devuelven una cadena. B, G y C toman un bloque CJam como parámetro y devuelven 1 para verdad, o 0 para falsey.

jimmy23013
fuente