Su tarea es escribir un programa no vacío / función de la cuenta de bytes L , la cual, cuando se repite M veces, comprueba si un positivo dado número entero N es igual a L x M .

Debería, en teoría, admitir un número arbitrario de repeticiones (un valor entero positivo arbitrario de M ), pero está bien si, debido a las limitaciones del lenguaje, no puede funcionar por encima de un cierto umbral. Está estrictamente prohibido leer el código fuente de su programa o acceder a información al respecto .

Para proporcionar resultados, debe elegir un valor consistente para uno de los estados (verdadero o falso) y usar cualquier otro resultado posible (no necesariamente consistente) para el otro estado ( Discusión ).

Sus respuestas se puntuarán según la longitud L de su programa inicial (en bytes), con menos bytes mejor.

Ejemplo

Digamos que su programa (inicial) es ABCDE. Luego:

• ABCDE(1 repetición) debe verificar si la entrada es igual a 5 .
• ABCDEABCDE(2 repeticiones) debe verificar si la entrada es igual a 10 .
• ABCDEABCDEABCDE(3 repeticiones) debe verificar si la entrada es igual a 15 . Etc ...

La puntuación de este código de muestra sería 5 , ya que la fuente inicial tiene 5 bytes de longitud.

Gelatina , 1 byte

’

La salida es 0 para una coincidencia, no cero para una no coincidencia.

Pruébalo en línea!

Cómo funciona

Esto aprovecha el formato de salida excesivamente liberal. La repetición de ’ M veces simplemente disminuye la entrada M veces, por lo que el resultado será cero si y solo si la entrada es LM , donde L = 1 .

Haskell, 8 bytes

(-8+).id

Pruébalo en línea!

Como muchas otras respuestas, devuelve 0 para verdadero y no 0 para falso al restar repetidamente la longitud del código del número de entrada.

Retina , 21 20 bytes

\d+
*
^$
_
^_{20}

_

Pruébalo en línea! Simplemente repita la parte en la ventana Código para ver cómo maneja los múltiplos.

Da 0los enteros múltiples y positivos correctos para todo lo demás.

Explicación

Veamos primero el programa único:

\d+
*

Esto convierte un número decimal a unario (utilizando _como dígito unario).

^$
_

Si la cadena está vacía (lo que no puede suceder en este momento, porque se garantiza que la entrada sea positiva), la reemplazamos con una sola _.

^_{20}

Ahora nos deshacemos de los primeros 20 guiones bajos. Si la entrada fue 20, esto da como resultado una cadena vacía.

_

Y finalmente contamos el número de guiones bajos en el resultado, que es cero si la entrada fuera 20 .

Ahora, ¿qué sucede cuando repetimos el código fuente? Como no insertamos un salto de línea al unirnos a los programas, la primera línea irá directamente al final de la última línea, obtenemos esto cuando duplicamos el programa:

\d+
*
^$
_
^_{20}

_\d+
*
^$
_
^_{20}

_

Ahora, en lugar de contar los guiones bajos, terminamos con la siguiente etapa:

_\d+
*

Esta etapa no hace nada, porque no hay más dígitos en la cadena de trabajo en este punto, por lo que la expresión regular no puede coincidir.

^$
_

Ahora esta etapa se vuelve relevante. Si la entrada fue un múltiplo más pequeño de 20, la cadena se ha vaciado por la copia anterior del código fuente. En ese caso, lo convertimos en un solo guión bajo, que sabemos que nuestro programa nunca podrá volver a convertir en una cadena vacía. De esta manera nos aseguramos de que solo se acepte el M th múltiplo (y no todos los múltiplos hasta el M ª).

^_{20}

Eliminamos los primeros 20 guiones bajos una vez más. Entonces, M repeticiones del código fuente eliminarán 20M guiones bajos de la cadena, si es posible.

_

Y cuando llegamos al final del programa, todavía contamos los guiones bajos para que las entradas válidas den cero.

Fragmento de código de máquina x86 de 32 bits, 1 byte

48                      dec    eax

Entrada en EAX, salida en EAX: 0 para verdadero, no cero para falso. (También deja el indicador ZF establecido en verdadero, sin establecer en falso, para que pueda je was_equal). Como "bono", no tiene que preocuparse por la envoltura; El x86 de 32 bits solo puede direccionar 4GiB de memoria, por lo que no puede hacer que M sea lo suficientemente grande como para envolverlo todo y encontrar 1 == 2**32 + 1o algo así.

Para realizar una función invocable, agregue una 0xC3 retinstrucción después de repetir 0x48M veces. (No se cuenta en el recuento total, porque muchos idiomas necesitan repetir solo el cuerpo de la función, o una expresión, para poder competir).

Se puede comercializar desde GNU C con el prototipo __attribute__((regparm(1))) int checkeqM(int eax); de regparmatributo de función x86 de GNU C , como -mregparm, usa EAX para pasar el primer argumento entero.

Por ejemplo, este programa completo toma 2 args, y JITs M copias de la instrucción + a reten un búfer, y luego lo llama como una función. (Requiere montón ejecutable; compilar con gcc -O3 -m32 -z execstack)

/******* Test harness: JIT into a buffer and call it ******/
// compile with gcc -O3 -no-pie -fno-pie -m32 -z execstack
// or use mprotect or VirtualProtect instead of -z execstack
// or mmap(PROT_EXEC|PROT_READ|PROT_WRITE) instead of malloc

// declare a function pointer to a regparm=1 function
// The special calling convention applies to this function-pointer only
// So main() can still get its args properly, and call libc functions.
// unlike if you compile with -mregparm=1
typedef int __attribute__((regparm(1))) (*eax_arg_funcptr_t)(unsigned arg);

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    if (argc<3) return -1;
    unsigned N=strtoul(argv[1], NULL, 0), M = strtoul(argv[2], NULL, 0);

    char *execbuf = malloc(M+1);   // no error checking
    memset(execbuf, 0x48, M);     // times M  dec eax
    execbuf[M] = 0xC3;            // ret
    // Tell GCC we're about to run this data as code.  x86 has coherent I-cache,
    // but this also stops optimization from removing these as dead stores.
    __builtin___clear_cache (execbuf, execbuf+M+1);
     //   asm("" ::: "memory");  // compiler memory barrier works too.

    eax_arg_funcptr_t execfunc = (eax_arg_funcptr_t) execbuf;
    int res = execfunc(N);
    printf("%u == %u  =>  %d\n", N,M, res );
    return !!res;   // exit status only takes the low 8 bits of return value
}

los ejecutables que no son PIE se cargan más abajo en la memoria virtual; puede hacer un malloc contiguo más grande.

$ gcc -g -O3 -m32 -no-pie -fno-pie -fno-plt -z execstack coderepeat-i386.c
$ time ./a.out 2747483748 2747483748   # 2^31 + 600000100 is close to as big as we can allocate successfully
2747483748 == 2747483748  =>  0

real    0m1.590s     # on a 3.9GHz Skylake with DDR4-2666
user    0m0.831s
sys     0m0.755s

$ echo $?
0

 # perf stat output:
       670,816      page-faults               #    0.418 M/sec                  
 6,235,285,157      cycles                    #    3.885 GHz                    
 5,370,142,756      instructions              #    0.86  insn per cycle         

Tenga en cuenta que GNU C no admite tamaños de objeto mayores que ptrdiff_t(con signo de 32 bits), pero mallocymemset hacer aún el trabajo, por lo que este programa tiene éxito.

Fragmento de código de máquina ARM Thumb, 2 bytes

 3802            subs    r0, #2

El primer argumento de entrada r0y valor de retorno r0es la convención de llamada ARM estándar. Esto también establece banderas (el ssufijo). Hecho de la diversión; la no versión de establecer -flag desub es una instrucción de 32 bits de ancho.

La instrucción de devolución que debe agregar es bx lr .

Fragmento de código de máquina AArch64, 4 bytes

d1001000        sub     x0, x0, #0x4

Funciona para enteros de 64 bits. Entrada / salida enx0 , según la convención de llamada estándar. int64_t foo(uint64_t);

AArch64 no tiene un modo Thumb (todavía), por lo que 1 instrucción es lo mejor que podemos hacer.

V , 16 (o 1) bytes

Respuesta aburrida:

<C-x>

un byte

Respuesta menos aburrida:

uÓ^$/0
16Ø^a$

Pruébalo en línea!

Hexdump:

00000000: 75d3 5e24 2f30 0a31 3601 d85e 1261 240a  u.^$/0.16..^.a$.

De hecho, escribí esto unos 5 minutos después de que salió el desafío. Me tomó 30 minutos arreglar este horrible montón de código de espagueti que llamo un idioma .

Perl 5 -p , 6 bytes

$_-=6;

Pruébalo en línea!

usos 0para igual

Brachylog , 2 bytes

-₂

Pruébalo en línea!

Python 3 , 27 bytes

int=lambda x,i=int:i(x)-27;

Pruébalo en línea!

Código repetido dos veces:

int=lambda x,i=int:i(x)-27;int=lambda x,i=int:i(x)-27;

Pruébalo en línea!

Brain-Flak , 24 bytes

({}[(((()()()){}){}){}])

Pruébalo en línea!

Devuelve 0para igual y algo más para no igual.

Cómo funciona:

({} #pop the top of the stack
  [(((()()()){}){}){}] #subtract 24
) #push the result.

Los ntiempos de ejecución de este código se restarán n * 24de la entrada, dando 0 solo cuando la entrada = n*24.

Stax , 1 byte

v

Pruébalo en línea!

TI-Basic (serie 83), 4 bytes

:Ans-4

Toma entrada Ans: por ejemplo, puede escribir 17:prgmCODEGOLFpara ejecutar esto con una entrada de 17. Imprime (y devuelve Ans) el valor 0si la entrada es igual a L × M , y un valor distinto de cero de lo contrario.

Tenga en cuenta que :es parte del código, por lo que si ingresa esto en el editor de programas, debería ver

PROGRAM:CODEGOLF
::Ans-4

si lo ingresas una vez y

PROGRAM:CODEGOLF
::Ans-4:Ans-4:An
s-4

si lo ingresas tres veces.

Haskell , 12 bytes

(-)$0
 +12--

Pruébalo en línea!

Salidas 0para la verdad y algún número entero distinto de cero para la falsedad.

Solución alternativa, 12 bytes.

id
 .(-)12--

Pruébalo en línea!

Befunge-98 , 15 bytes

]#<@.-&+
>fv
v+

Pruébalo en línea!

¡Pruébalo doblado!

Utiliza 0 para igual y cualquier otra cosa para desigual.

Explicación:

Este código repetido muchas veces se verá así:

]#<@.-&+
>fv
v+]#<@.-&+
>fv
v+]#<@.-&+
>fv
 .
 .
 .
v+]#<@.-&+
>fv
v+

1. ]vuelta a la derecha. Envía la IP hacia abajo.

2. >moverse hacia el este Envía el derecho de propiedad intelectual.

3. f empujar un 16.

4. vmoverse hacia el sur Envía la IP hacia abajo. Si es la última vez, vaya al paso 8.

5. ]vuelta a la derecha. Envía la IP a la izquierda.

6. +añadir. Agrega el 16 a la parte superior de la pila.

7. vmoverse hacia el sur Envía la IP hacia abajo. Ir al paso 2.

8. <moverse hacia el oeste Envía la IP a la izquierda.

9. #omitir. salta sobre ]y envuélvete hasta el final.

10. +añadir. Agrega el 16 a la parte superior de la pila.

11. &entrada. Empuje un número del usuario.

12. -sustraer. obtener la diferencia de suma en la que estábamos trabajando y la entrada.

13. .impresión. Imprime el resultado.

14. @ final.

Pure Bash , 15

Entrada dada como un parámetro de línea de comando. Salida como un código de salida de shell -1 para VERDADERO y0 para FALSO.

(((a + = 15) - $ 1))

• Pruébalo en línea x1
• Pruébalo en línea x2
• Pruébalo en línea x3

Carbón , 13 bytes

ＰＩ⁼Ｉθ×¹³Ｌ⊞Ｏυω

Pruébalo en línea! Según mi respuesta a Doblo la fuente, ¡tú doblas la salida! Explicación:

         ⊞Ｏυω   Push empty string to predefined empty list
        Ｌ       Take the length
     ×¹³        Multiply by 13
  ⁼Ｉθ           Compare to the input
 Ｉ              Cast to string
Ｐ               Print without moving the cursor

Se las arregla para dar salida 1a la verdad y 0a la falsedad. Repeticiones posteriores comparan contra la entrada 13, 26, 39, 52etc, pero cada vez la respuesta se sobreimprime tan sólo se ve la respuesta final.

JavaScript ES6, 32 bytes

((f=k=>n=>n>0?n==k:f(k+32))(32))

si verdadero es 0 y falso como otros, 31 bytes

(f=k=>n=>n>0?n-k:_=>f(k+_))(31)

console.log([
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (31),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (32),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (33),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (64),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (32),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (63),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (64),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (96)
]);

MIPS, 4 bytes

Usos $a0como argumento y valor de retorno.

0x2084fffc    addi $a0, $a0, -4

MIPS, 8 bytes (utilizando la convención de llamadas MIPS)

0x2084fff8    addi $a0, $a0, -8
0x00041021    move $v0, $a0

x86, 5 bytes

Esta es mi primera respuesta x86, por lo que sus comentarios son bienvenidos. Utiliza la convención _fastcall con ecx como primer argumento.

83 e9 05                sub    $0x5,%ecx
89 c8                   mov    %ecx,%eax

Peter Cordes tiene una solución de 1 byte en los comentarios.

Comentario Brainfuck : La parte difícil es conseguir que devuelva un solo valor. De lo contrario, algo como esto sería fácil.

- >,[-<->] < .

Octava: 23 bytes

+23;[ans,i]((N==ans)+1)

Si N = L * M, la expresión devuelve 0+i (es decir, un número puramente imaginario), de lo contrario, la expresión da como resultado un número complejo con un componente real.

Para obtener un resultado ligeramente más agradable a costa de un byte adicional:

+24;[ans,-1]((N==ans)+1)

Si N = L * M, la expresión devuelve -1 ; de lo contrario, un número positivo.

Manifestación:

N=48;
+24;[ans,-1]((N==ans)+1)                                                 #>> 24 
+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1)                         #>> -1
+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1) #>> 23

_{PD, puedes obtener el mismo resultado con +24;if N==ans;-1;end;ans pero el bytecount es el mismo}

Lua, 56 46 bytes

a=(a or io.read())-46io.write(a<=0 and a or"")

Emite un 0 (sin una nueva línea final) si es igual y nada o una serie de números negativos (con cero anterior en algunos casos) si no es igual.

Solo: ¡ Pruébelo en línea!

Repetido muchas veces: ¡ Pruébelo en línea!

Explicación

a=(a or io.read())-46

En la primera iteración (cuando aaún no se ha definido y, por lo tanto nil, está ), se establece aen un número tomado de la entrada, de lo contrario a sí mismo. En ambos casos, 46 se resta de a.

io.write(a<=0 and a or"")

Esto solo se imprime asi es menor que (para ocuparse de los casos en que la entrada fue mayor que la longitud total) o igual a cero, y la cadena vacía de lo contrario.

-10 bytes para recordar que Lua realiza conversiones entre números y cadenas automáticamente. Whoops

JavaScript (ES6), 47 bytes

Esto está utilizando la misma técnica que Benoit Esnard en esta respuesta (de doble de la fuente, ¡duplica la salida! ).

Imprime 0 si n = 47 * M , o un valor distinto de cero de lo contrario.

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///

Demostración para M = 1

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///

Demo para M = 2

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///

Brain-Flak , 24 bytes

({}[(((()()()){}){}){}])

Pruébalo en línea!

Solo resta 24 de la entrada. Salidas 0para verdadero y cualquier otra cosa para falso.

Brain-Flak , 68 bytes

{<>}<>(({}[((((()()()()){}){}()){}){}])<>{})((){[()](<{}<>>)}{}<>{})

Pruébalo en línea!

Este es más sofisticado, da como resultado 1verdadero y 0falso.