Sección de ladrones

La sección de policías se puede encontrar aquí .

Reto

Su tarea es superar las presentaciones de los policías en el mismo idioma y la misma versión (por ejemplo, Python 3.5 ≠ Python 3.4 , por lo que no está permitido). Un envío se supera cuando la longitud en bytes es más corta que el envío original. Solo necesita jugar al menos 1 byte para descifrar un envío. Por ejemplo, si la tarea era realizar 2 × n , y el envío fue el siguiente:

print(2*input())

Podrías superar al policía haciendo lo siguiente:

print 2*input()

O incluso esto (ya que los lambda están permitidos):

lambda x:2*x

Publique esto con el siguiente encabezado:

##{language name}, <s>{prev byte count}</s> {byte count}, {cop's submission + link}

Por ejemplo:

Python 2, 16 12 bytes, Adnan (+ enlace a la presentación)

lambda x:2*x

Calcula A005843 , (desplazamiento = 0).

En ese caso, ha descifrado el envío.

Tanteo

La persona con la mayor cantidad de envíos es la ganadora.

Reglas

• El envío de crack debe estar en el mismo idioma que el envío de policía.
• La misma entrada debería resultar en la misma salida (entonces a (2) = 4 debería permanecer 4).
• Para lenguajes como Python, puede importar bibliotecas estándar incluidas dentro del lenguaje. (Entonces, no numpy / sympy etc.)
• La entrada y la salida están en decimal (base 10).

Nota

Este desafío está terminado. El ganador de la sección Robbers es feersum . Los puntajes finales para el CnR se muestran a continuación:

• Feersum : 16 grietas
• Dennis : 12 grietas
• Monja permeable : 6 grietas
• Lynn : 4 grietas
• millas : 3 grietas
• Martin Ender : 2 grietas
• Emigna : 2 grietas
• jimmy23013 : 1 crack
• Sp3000 : 1 grieta
• randomra : 1 crack
• alephalpha : 1 crack
• nimi : 1 crack
• Sandía Destructible : 1 crack
• Dom Hastings : 1 crack

Cheddar, 7 6 bytes, Downgoat

(<<)&1

Esto parece funcionar, pero siempre es posible que no entienda el idioma correctamente.

jalea ,5 54 bytes , George V. Williams

RÆḊḞ

Pruébalo aquí

Una característica oculta!

Si recordaba correctamente, ÆḊ(A) = sqrt (det (AA ^T )) es n! multiplicado por la medida de Lebesgue n dimensional de un símplex formado por n puntos de entrada y el origen en m espacio dimensional. Cuando n = 1 se degenera a la distancia euclidiana. No es tan extraño después de todo ...

Hexagonía , 91 33 bytes, azul

1""?{\>{+/</+'+./_'..@'~&/!}'+=($

Desplegado:

    1 " " ?
   { \ > { +
  / < / + ' +
 . / _ ' . . @
  ' ~ & / ! }
   ' + = ( $
    . . . .

Pruébalo en línea!

Todavía parece algo golfable pero pensé que lo publicaría antes de que FryAmTheEggman me ganara. ;)

Explicación

Aquí hay algunas rutas de ejecución codificadas por colores:

Sin embargo, estos son innecesariamente complicados debido al golf. Aquí está exactamente el mismo código con un diseño más sano:

Eso es mejor. Y finalmente, aquí hay un diagrama de memoria, donde la flecha roja indica la posición inicial y la orientación del puntero de memoria (MP):

Lo esencial es que estoy iterativamente el cálculo de los números de Fibonacci en los tres bordes marcados f (i) , f (i + 1) y f (i + 2) mientras que el seguimiento del iterador en los bordes A , B y C . Al hacerlo, los roles de estos bordes se intercambian cíclicamente después de cada iteración. Veamos cómo sucede esto ...

El código comienza en la ruta gris que realiza una configuración inicial. Tenga en cuenta que f (i) ya tiene su valor inicial correcto de 0.

1   Set edge f(i+1) to 1.
""  Move the MP to edge A.
?   Read input n into edge A.
)   Increment n.

Ahora el camino verde es el bucle principal. _y >son solo espejos.

(     Decrement n.
<     If the result is zero or less, continue on the red path, otherwise
      perform another iteration of the main loop.
{     Move the MP to edge f(i+2).
+     Add edges f(i) and f(i+1) into this edge, computing the next Fibonacci number.
'     Move the MP to the edge opposite A.
~     Multiply by -1 to ensure that it's non-positive (the edge may have a positive
      value after a few iterations).
&     Copy the current value of n from A.
'     Move back and to the right again.
+     Copy n by adding it to zero. Since we know that the other adjacent edge
      is always zero, we no longer need to use ~&.
'+'+  Repeat the process twice, moving n all the way from A to B.
=     Reverse the orientation of the MP so that it points at f(i) which now
      becomes f(i+2) for the next iteration.

De esta manera, el MP se mueve alrededor del triplete interno de bordes, calculando números sucesivos de Fibonacci hasta nllegar a cero. Luego, finalmente, se ejecuta el camino rojo:

{}    Move the MP to f(i).
!     Print it.
@     Terminate the program.

Diagramas generados con HexagonyColorer de Timwi y EsotericIDE .

Haskell, 5 4 bytes, xnor

(^)1

Curry simple

Stack Cats, 14 13 bytes, feersum

^]T{_+:}_

con las -nmbanderas para +4 bytes. Pruébalo en línea!

De acuerdo, ese bucle estaba loco. Intenté varios enfoques, como el forzado bruto sobre un alfabeto reducido y el forzado bruto 3x+2o 5x+4tratar de extenderlo, pero nunca esperé que la solución realmente contuviera un bucle.

La mejor manera de ver cómo funciona esto es agregar un Dindicador para la depuración (así que ejecute con -nmD) y active la depuración para el enlace TIO anterior. Un {}ciclo recuerda la parte superior de la pila al comienzo del ciclo y sale cuando la parte superior de la pila es ese valor nuevamente. El interior del bucle hace un poco de diversión restando y ciclando los tres elementos principales de la pila, que es cómo el bucle se ejecuta durante tantas iteraciones.

Sesos, 14 11 bytes, Leaky Nun

Calcula n ² . Pruébalo aquí

Volcado hexadecimal:

0000000: 16c0f7 959d9b 26e83e ce3d                         ......&.>.=

De la asamblea:

set numin
set numout
get
jmp
  jmp, sub 1, fwd 1, add 1, fwd 1, add 2, rwd 2, jnz
  fwd 2, sub 1
  rwd 1, sub 1
  jmp, sub 1, rwd 1, add 1, fwd 1, jnz
  rwd 1
jnz
fwd 2
put

Lamentablemente, 776 759 bytes, Sandía Destructible

| |||||||| | |
|| |||||| |
||| |||| |
|||| || |
||||| || |
|||| |||| |
||| |||||| |
|| |||||||| |
| |||||||||| |
|| |||||||| |
||| ||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
||||||||| |
||||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |
|| |
| |
| |
| |
|| |
||| |
|||| |
||||| |
|||||| |
||||||| |
|||||| |
||||||| |
|||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
| |
|| |
| |
|| |
||| |
||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |

Traté de leer el código fuente de este idioma pero fue demasiado confuso. Por un lado, ip[1]es un número de línea, mientras que ip[0]es el número de columna, mientras que las cpcoordenadas se usan al revés. Sin embargo, a veces cpse le asigna el valor de ip. Dejé de tratar de entender lo que estaba haciendo el programa y encontré una manera de codificar la secuencia idéntica de instrucciones usando menos barras.

Brachylog , 27 21 bytes, Fatalize

yrb:1a:+a:[1]c*.
:2/.

Pruébalo en línea!

J, 17 12 bytes, millas

+/@(]!2*-)i:

Más o menos lo mismo que el original solo más golfizado. :)

i:tener +1rango en comparación con i.es útil (y extraño). Si usa i.aquí n=0será incorrecto pero por suerte lo i:resuelve.

Pruébelo en línea aquí.

M, 10 6 bytes, Dennis

R×\³¡Ṫ

Dado n , se calcula el n ^º -level factorial de n . Este fue un ejercicio divertido!

El código es capaz de ejecutarse como Jelly para que pueda probarlo en línea .

Explicación

R×\³¡Ṫ  Input: n
R       Create the range [1, 2, ..., n]
   ³¡   Repeat n times starting with that range
 ×\       Find the cumulative products
     Ṫ  Get the last value in the list
        Return implicitly

Muñeco de nieve, 50 44 bytes, pomo de la puerta

((}#2nMNdE0nR1`wRaC2aGaZ::nM;aF;aM:`nS;aF*))

Pruébalo en línea!

Haskell, 15 14 bytes, xnor

until odd succ

Pasé un par de horas infructuosas aprendiendo a descifrar la sintaxis "sin sentido" ... untilEn cambio, encontré esto.

O para un menor melífluas 13 bytes, until odd(+1).

Python 2, 43 40, xsot

g=lambda n:n<2or-~sum(map(g,range(n)))/3

Pyke, 11 9 bytes, pez lodo

hVoeX*oe+

Pruébalo aquí!

Cómo funciona

          Implicit input: n (accumulator), n (iterations)
h         Increment the number of iterations.
 V        Do the following n + 1 times.
  o         Iterator. Pushes its value (initially 0) and increments it.
   e        Perform integer division by 2.
            This pushes 0 the first time, then 1, then 2, etc.
    X       Square the result.
     *      Multiply the accumulator and the result.
      oe    As before.
        +   Add the result to the accumulator.
            This sets the accumulator to a(0) = 0 in the first iteration and
            applies the recursive formula in all subsequent ones.

05AB1E , 7 4, Emigna

LnOx

De la fórmula para la suma de cuadrados de enteros positivos 1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ... + n ^ 2 = n (n + 1) (2 * n + 1) / 6, si multiplicamos ambos lados por 2 obtenemos Sum_ {k = 0..n} 2 * k ^ 2 = n (n + 1) (2 * n + 1) / 3, que es una fórmula alternativa para esta secuencia. - Mike Warburton (mikewarb (AT) gmail.com), 08 de septiembre de 2007

Jalea, 22 21 bytes, Dennis

_²×c×Ḥc¥@÷⁸÷’{S
‘µR+ç

Pasé varias horas leyendo el código fuente de Jelly para el último, por lo que podría utilizar esta "habilidad". Espero que @Dennis comparta con nosotros sus descubrimientos matemáticos que permitan una fórmula más corta (¡suponiendo que haya algo y no solo trucos extraños de Jelly!).

J, 20 19 bytes, millas

[:+/2^~+/@(!|.)\@i.

Esto calcula el producto como una suma de números de Fibonacci al cuadrado, que se calculan como una suma de coeficientes binomiales.

Afortunadamente, @miles mismo publicó el código para generar números de Fibonacci en este comentario .

Acc !! , 526 525 bytes, DLosc

N
Count x while _%60-46 {
(_+_%60*5-288)*10+N
}
_/60
Count i while _/27^i {
_+27^i*(_/27^i*26-18)
}
_*3+93
Count i while _/27^i/27%3 {
_-i%2*2+1
Count j while _/3^(3*j+2-i%2)%3 {
_+3^(1+i%2)
Count k while _/3^(3*k+1+i%2)%3-1 {
_+3^(3*k+1+i%2)*26
}
}
}
Count i while _/27^i/3 {
_-_/27^i/3%27*27^i*3+_/3^(3*i+1+_%3)%3*3
}
_/3
Count i while _/100^i {
_*10-(_%100^i)*9
}
Count i while _/100^i/10 {
_+_/100^i/10%10
Count j while i+1-j {
_+(_%10-_/100^(j+1)%10)*(100^(j+1)-1)
}
}
_/100
Count j while _/100^j {
Write _/100^j%10+48
}

No tengo idea de cómo funciona esto, pero pude detectar una pequeña mejora.

24c24
< _+_/100^i*100^i*9
---
> _*10-(_%100^i)*9

Haskell, 10 bytes, xnor

gcd=<<(2^)

Ejemplo de uso: map ( gcd=<<(2^) ) [1..17]-> [1,2,1,4,1,2,1,8,1,2,1,4,1,2,1,16,1].

Cómo funciona: Desde la página de OEIS vemos que a(n) = gcd(2^n, n)o se escribe en la sintaxis de Haskell: a n = gcd (2^n) n. Las funciones con el patrón f x = g (h x) xse pueden convertir en punto libre a través de la función =<<:, f = g =<< hpor lo gcd=<<(2^)que se traduce de nuevo a gcd (2^x) x.

Sesos, 14 9 bytes, Monja Leaky

Calcula n mod 16 . Pruébalo aquí

Maleficio:

0000000: 17f84a 750e4a 7d9d0f                              ..Ju.J}..

Montaje:

set numin
set numout
set mask
get
jmp, sub 1, fwd 1, add 16, rwd 1, jnz
fwd 1
jmp, sub 16, fwd 1, add 1, rwd 1, jnz
fwd 1
put

Python, 39 17 bytes, Sandía Destructible

lambda n:n*-~n>>1

05AB1E, 9 4 bytes, Emigna

>n4÷

Pruébalo en línea!

Calcula esta función en su lugar:

Hexagonía , 7 6 bytes, Adnan

?!/$(@

Desplegado:

 ? ! 
/ $ (
 @ .

Pruébalo en línea!

La misma idea, diseño ligeramente diferente.

MATL, 11 10 bytes, Luis Mendo

YftdAwg_p*

En lugar de hacer -1 ^ longitud (matriz), convierte los elementos en valores booleanos (que siempre son 1), los niega y toma el producto de los elementos.

Jelly, 11 10, Dennis

Ḥ’_Rc’*@RP

Versión vectorizada del mismo enfoque.

Pruébalo en línea!

05AB1E, 10 8 bytes, Adnan

µNÂÂQ>i¼

Pruébalo en línea .

Brachylog, 11 10 bytes, Fatalize

yb:AcLrLc.

Pruébalo en línea!

Explicación

Brachylog es un lenguaje derivado de Prolog, cuya mayor habilidad es probar cosas.

Aquí, probamos estas declaraciones:

yb:AcLrLc.
yb:AcL       Inclusive range from 1 to input, concatenated with A, gives L
     LrL     L reversed is still L
       Lc.   L concatenated is output

Jalea, 9 8 bytes, Dennis

œċr0$L€Ḅ

¡Lo siento! No pude encontrar tu solución prevista.

Esto se basa en el hecho de que C(n+k-1, k)es la cantidad de formas de elegir kvalores ncon reemplazo.

Nota: Esto es ineficiente ya que genera los conjuntos posibles para contarlos, así que trate de evitar el uso de grandes valores de n en línea.

Pruébelo en línea o verifique hasta n .

Más tarde encontré otra versión de 8 bytes que es lo suficientemente eficiente como para calcular n = 1000. Esto calcula los valores utilizando el coeficiente binomial y evita generar las listas.

Ḷ+c’Ṛ;1Ḅ

Pruébelo en línea o verifique hasta n .

Explicación

œċr0$L€Ḅ  Input: n
  r0$     Create a range [n, n-1, ..., 0]
œċ        Create all combinations with replacement for
          (n, n), (n, n-1), ..., (n, 0)
     L€   Find the length of each
       Ḅ  Convert it from binary to decimal and return

Ḷ+c’Ṛ;1Ḅ  Input: n
Ḷ         Creates the range [0, 1, ..., n-1]
 +        Add n to each in that range
   ’      Get n-1
  c       Compute the binomial coefficients between each
    Ṛ     Reverse the values
     ;1   Append 1 to it
       Ḅ  Convert it from binary to decimal and return

M, 9 8 bytes, Dennis

Ḥrc’ḊḄḤ‘

QBasic, 30 29 bytes, DLosc

INPUT n:?(n MOD 2)*(n+.5)+n/2