Seção de ladrões

A seção de policiais pode ser encontrada aqui .

Desafio

Sua tarefa é superar os envios dos policiais na mesma linguagem e na mesma versão (por exemplo, Python 3.5 ≠ Python 3.4 , para que isso não seja permitido). Um envio é ultrapassado quando o comprimento em bytes é menor que o envio original. Você só precisa jogar no mínimo 1 byte para obter uma submissão. Por exemplo, se a tarefa era executar 2 × n , e a submissão era a seguinte:

print(2*input())

Você pode superar o policial fazendo o seguinte:

print 2*input()

Ou até mesmo isso (uma vez que os lambda são permitidos):

lambda x:2*x

Poste isso com o seguinte cabeçalho:

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

Por exemplo:

Python 2, 16 12 bytes, Adnan (+ link para envio)

lambda x:2*x

Calcula A005843 , (deslocamento = 0).

Nesse caso, você quebrou o envio.

Pontuação

A pessoa com quem mais rachou as submissões é o vencedor.

Regras

• O envio do crack deve estar no mesmo idioma do envio do policial.
• A mesma entrada deve resultar na mesma saída (então a (2) = 4 deve permanecer 4).
• Para idiomas como o Python, você pode importar bibliotecas padrão incluídas no idioma. (Então, não numpy / sympy etc.)
• Entrada e saída estão em decimal (base 10).

Nota

Este desafio está terminado. O vencedor da seção de ladrões é o feersum . As pontuações finais para o CnR são mostradas abaixo:

• feersum : 16 rachaduras
• Dennis : 12 rachaduras
• Freira com vazamento : 6 rachaduras
• Lynn : 4 rachaduras
• milhas : 3 rachaduras
• Martin Ender : 2 rachaduras
• Emigna : 2 rachaduras
• jimmy23013 : 1 rachadura
• Sp3000 : 1 rachadura
• randomra : 1 crack
• alefalpha : 1 rachadura
• nimi : 1 crack
• Melancia destrutível : 1 rachadura
• Dom Hastings : 1 crack

Queijo Cheddar, 7 6 bytes, Downgoat

(<<)&1

Isso parece funcionar, mas é sempre possível que eu não entenda o idioma corretamente.

Gelatina ,54 bytes , George V. Williams

RÆḊḞ

Experimente aqui.

Um recurso oculto!

Se bem me lembrei, ÆḊ(A) = sqrt (det (AA ^T )) é n! vezes a medida de Lebesgue n dimensional de um simplex formado por n ponto de entrada e a origem em m espaço dimensional. Quando n = 1, degenera para a distância euclidiana. Não é tão estranho, afinal ...

Hexagonia , 91 33 bytes, Azul

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

Desdobrado:

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

Experimente online!

Ainda parece um pouco jogável, mas pensei em publicá-lo antes que o FryAmTheEggman me derrotasse. ;)

Explicação

Aqui estão alguns caminhos de execução com código de cores:

No entanto, estes são desnecessariamente complicados devido ao golfe. Aqui está exatamente o mesmo código com um layout mais saudável:

Isso é melhor. E, finalmente, aqui está um diagrama de memória, onde a seta vermelha indica a posição e a orientação inicial do ponteiro de memória (MP):

A essência é que estou iterativamente computação números de Fibonacci sobre as três bordas marcadas f (i) , f (i + 1) e f (i + 2) mantendo a leitura da iteração nas bordas A , B e C . Enquanto isso, as funções dessas arestas são trocadas ciclicamente após cada iteração. Vamos ver como isso acontece ...

O código inicia no caminho cinza, que faz algumas configurações iniciais. Observe que f (i) já tem seu valor inicial correto de 0.

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

Agora o caminho verde é o loop principal. _e >são apenas espelhos.

(     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.

Dessa maneira, o MP se move em torno do triplo interior das arestas, computando números sucessivos de Fibonacci até nchegar a zero. Finalmente, o caminho vermelho é executado:

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

Diagramas gerados com HexagonyColorer e EsotericIDE de Timwi .

Haskell, 5 4 bytes, xnor

(^)1

Caril simples.

Stack Cats, 14 13 bytes, feersum

^]T{_+:}_

com os -nmsinalizadores para +4 bytes. Experimente online!

Ok, esse loop foi louco. Tentei várias abordagens, como forçar bruto sobre um alfabeto reduzido e forçar bruto 3x+2ou 5x+4tentar estendê-lo, mas nunca esperei que a solução realmente contivesse um loop.

A melhor maneira de ver como isso funciona é adicionar um Dsinalizador para depuração (execute com -nmD) e ativar a depuração no link TIO acima. Um {}loop lembra o topo da pilha no início do loop e sai quando o topo da pilha é esse valor novamente. O interior do loop faz algumas subtrações e ciclos divertidos dos três principais elementos da pilha, e é assim que o loop é executado em tantas iterações.

Sesos, 14 11 bytes, Freira com vazamento

Calcula n ² . Experimente aqui.

Despejo hexagonal:

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

Da montagem:

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

Lamentavelmente, 776 759 bytes, Melancia destrutível

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

Eu tentei ler o código fonte desse idioma, mas era muito confuso. Por um lado, ip[1]é um número de linha enquanto ip[0]é o número da coluna, enquanto as cpcoordenadas são usadas ao contrário. No entanto, às vezes o valor de cpé atribuído ip. Desisti de tentar entender o que o programa está fazendo e encontrei uma maneira de codificar a sequência idêntica de instruções usando menos barras.

Brachylog , 27 21 bytes, Fatalizar

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

Experimente online!

J, 17 12 bytes, milhas

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

Praticamente o mesmo que o original, apenas mais jogado. :)

i:ter +1alcance comparado a i.é útil (e estranho). Se você usar i.aqui n=0será incorreto, mas felizmente i:resolve isso.

Experimente online aqui.

M, 10 6 bytes, Dennis

R×\³¡Ṫ

Dada n , ele calcula o n ^º -level fatorial de n . Este foi um exercício divertido!

O código é capaz de executar como Jelly para que você possa experimentá-lo online .

Explicação

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

Boneco de neve, 50 44 bytes, Maçaneta de porta

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

Experimente online!

Haskell, 15 14 bytes, xnor

until odd succ

Passei algumas horas infrutíferas aprendendo a decifrar a sintaxe "sem sentido" ... untilEncontrei isso em seu lugar.

Ou para 13 bytes menos melíferos until odd(+1),.

Python 2, 43 40, xsot

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

Pyke, 11 9 bytes, peixes enlameados

hVoeX*oe+

Experimente aqui!

Como 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

A partir da fórmula da soma dos quadrados dos números inteiros positivos 1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ... + n ^ 2 = n (n + 1) (2 * n + 1) / 6, se multiplicarmos ambos os lados por 2, obtemos Sum_ {k = 0..n} 2 * k ^ 2 = n (n + 1) (2 * n + 1) / 3, que é uma fórmula alternativa para esta sequência. - Mike Warburton (mikewarb (AT) gmail.com), 8 de setembro de 2007

Geléia, 22 21 bytes, Dennis

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

Passei várias horas lendo o código-fonte do Jelly para o último, então é melhor usar essa "habilidade". Espero que o @Dennis compartilhe conosco suas descobertas matemáticas, permitindo uma fórmula mais curta (supondo que exista algo e não apenas truques estranhos de geléia!).

J, 20 19 bytes, milhas

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

Isso calcula o produto como uma soma dos números de Fibonacci ao quadrado, calculados como uma soma dos coeficientes binomiais.

Felizmente, o próprio @miles postou o código para gerar números de Fibonacci neste comentário .

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
}

Não tenho ideia de como isso funciona, mas pude detectar uma pequena melhoria.

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

Haskell, 10 bytes, xnor

gcd=<<(2^)

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

Como funciona: A partir da página OEIS vemos que a(n) = gcd(2^n, n)ou escritas na sintaxe Haskell: a n = gcd (2^n) n. As funções com o padrão f x = g (h x) xpode ser transformado de livre-ponto pela função =<<: f = g =<< h, portanto, gcd=<<(2^)o que se traduz para trás gcd (2^x) x.

Sesos, 14 9 bytes, Freira com

Calcula o mod 16 . Experimente aqui.

Hex:

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

Montagem:

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, Melancia destrutível

lambda n:n*-~n>>1

05AB1E, 9 4 bytes, Emigna

>n4÷

Experimente online!

Calcula esta função:

Hexagonia , 7 6 bytes, Adnan

?!/$(@

Desdobrado:

 ? ! 
/ $ (
 @ .

Experimente online!

Mesma idéia, layout ligeiramente diferente.

MATL, 11 10 bytes, Luis Mendo

YftdAwg_p*

Em vez de fazer -1 ^ length (array), ele converte os elementos em valores booleanos (que são sempre 1), os nega e pega o produto dos elementos.

Jelly, 11 10, Dennis

Ḥ’_Rc’*@RP

Versão vetorizada da mesma abordagem.

Experimente online!

05AB1E, 10 8 bytes, Adnan

µNÂÂQ>i¼

Experimente online .

Brachylog, 11 10 bytes, Fatalizar

yb:AcLrLc.

Experimente online!

Explicação

Brachylog é uma linguagem derivada do Prolog, cuja maior habilidade é provar as coisas.

Aqui, provamos estas afirmações:

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

Geléia, 9 8 bytes, Dennis

œċr0$L€Ḅ

Desculpa! Não consegui encontrar a solução pretendida.

Isso depende do fato de que C(n+k-1, k)é o número de maneiras de escolher kvalores ncom a substituição.

Nota: Isso é ineficiente, pois gera os conjuntos possíveis para contá-los, portanto, evite usar grandes valores de n online.

Experimente online ou verifique até n .

Mais tarde, encontrei outra versão de 8 bytes que é eficiente o suficiente para calcular n = 1000. Isso calcula os valores usando o coeficiente binomial e evita a geração das listas.

Ḷ+c’Ṛ;1Ḅ

Experimente online ou verifique atén .

Explicação

œċ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