Você pode me superar? (Seção de ladrões)

43

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.5Python 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
Adnan
fonte

Respostas:

8

Queijo Cheddar, 7 6 bytes, Downgoat

(<<)&1

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

feersum
fonte
Alternativamente (**)&2,. Eu tentei 2&(**)e falhei. :(
Dennis
@Dennis (**)&2funciona muito bem para mim: / mas isso também funciona.
Downgoat 7/08/16
14

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

jimmy23013
fonte
1
Certo, fiz algo estranho com determinantes ... Tão bem escondido que não consegui encontrar eu mesmo!
Dennis
@ Dennis Eu sei disso porque um dia tentei estender o determinante também, e é isso que você obtém se quiser que ele funcione como produto cruzado. Mas ele me levou muito tempo porque eu pensei que poderia ser estranho também, e não esperar que alguém venha com a mesma coisa ...
jimmy23013
Estes podem realmente ser considerados "bytes?" O código aponta para e está no intervalo UTF-16. Isso tornaria esta solução 6 bytes assumindo codificação heterogênea e 8 bytes assumindo codificação homogênea. Pedindo honestamente aqui.
Jules
11

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:

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

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):

insira a descrição da imagem aqui

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 .

Martin Ender
fonte
Vaca sagrada! Eu esperava ser derrotado por você, mas não tanto assim! 0o
Azul
@Blue Você planeja adicionar uma explicação à sua? Eu estaria interessado em como isso funciona. :) Acrescentarei uma explicação a essa, mais cedo ou mais tarde, mas não tenho certeza se vou encontrar tempo hoje.
Martin Ender
Sim, o meu usa um método mais tradicional de cálculo. Eu esqueci completamente e, que poderia ter salvo alguns bytes
azul
7

Haskell, 5 4 bytes, xnor

(^)1

Caril simples.

Freira Furada
fonte
7

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.

Sp3000
fonte
6

Sesos, 14 11 bytes, Freira com vazamento

Calcula n 2 . 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
Lynn
fonte
Bom, você é ainda mais baixo que a minha versão original do golfe.
Freira vazada
Este calcula 1 + 3 + … + (2n–1)em vez de n × n:)
Lynn
Eu também usei sua abordagem
Leaky Nun
6

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.

feersum
fonte
5

Brachylog , 27 21 bytes, Fatalizar

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

Experimente online!

Freira Furada
fonte
Bem feito! Usando divisão inteira definitivamente não é a solução que eu tinha em mente (que é ainda mais curto), nem sequer pensar nisso TBH: p
Fatalize
5

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.

randomra
fonte
Neat truque com i:sendo zeros para valores negativos. Minha versão foi +/@(]!2*-)i.,].
milhas
5

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
milhas
fonte
5

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

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

Experimente online!

Lynn
fonte
Muito agradável. Ainda mais curto que o original, que era ((}#1nG|#2nMNdE0nR2aGaZ::nM;aF;aM:nS;aF,nM*)).
Maçaneta
5

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),.

feersum
fonte
Bem feito, é isso que eu tinha em mente. Eu gosto das três palavras.
xnor
4

Python 2, 43 40, xsot

g=lambda n:n<2or-~sum(map(g,range(n)))/3
feersum
fonte
Interessante, isso é diferente do que eu tinha originalmente.
xsot
4

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.
Dennis
fonte
Usando esse método, você pode obter 8 com hV~oX*o+. Minha resposta de 5 bytes foiSDmX^
Blue
Ah, ~oé legal. Eu não tenho idéia do que SDmX^faz embora.
Dennis
Basicamente, usa conversação de base mista no intervalo de 1 índice contra o quadrado. Não é algo sobre OEIS
Blue
Oh, mafeta apenas o Xe não o ^? Isso explica muito.
Dennis
Sim, me similares usam apenas o próximo nó. Algum comentário sobre meus documentos, etc.?
Azul
4

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

alefalpha
fonte
Estou feliz que você tenha quebrado às 4, uma vez que houve uma modificação trivial na minha pública que eu havia perdido. Agradável!
Emigna
4

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!).

feersum
fonte
Para comparação, eu tinha: `` Ḥc_ × c @ + ¥ \ nr0ç @ €: '+ \ S
Sp3000
@ Sp3000 Oh, bem, por que você não publicou?
feersum
Mais tempo para pensar nos 6 antes de Dennis repor em M: P
Sp3000 19/08/16
4

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 .

Dennis
fonte
4

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
Dennis
fonte
Ah, atire. Eu esperava que ninguém pegasse um golfe de matemática que eu perdi. +1
DLosc 20/08/16
4

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.

nimi
fonte
............... Como
TuxCrafting
3

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
Lynn
fonte
Esta é precisamente a minha solução: D
Leaky Nun
3

Python, 39 17 bytes, Melancia destrutível

lambda n:n*-~n>>1
Freira Furada
fonte
realmente muito bom, eu estou realmente feliz por ter sido outgolfed para ver esta solução
Destrutível Lemon
Por que complicar uma fórmula simples com a mudança certa?
Xsot #
@ xsot Porque eu não sabia qual versão ele usava.
Leaky Nun
3

Hexagonia , 7 6 bytes, Adnan

?!/$(@

Desdobrado:

 ? ! 
/ $ (
 @ .

Experimente online!

Mesma idéia, layout ligeiramente diferente.

Martin Ender
fonte
Ahhh, muito legal! Essa foi exatamente a mesma solução :).
Adnan
3

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.

feersum
fonte
3

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
Freira Furada
fonte
Esta é exatamente a resposta que eu tinha em mente, muito bem!
Fatalize
3

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
milhas
fonte
3

M, 9 8 bytes, Dennis

Ḥrc’ḊḄḤ‘
feersum
fonte
Boa ideia com o duplo + incremento
milhas
3

QBasic, 30 29 bytes, DLosc

INPUT n:?(n MOD 2)*(n+.5)+n/2
feersum
fonte
Agradável! (Apesar de não ser bem o que eu tinha.)
DLosc