Entrada

A entrada é um número inteiro positivo único n

Saída

A saída está ncom o bit mais significativo definido como 0.

Casos de teste

1 -> 0
2 -> 0
10 -> 2
16 -> 0
100 -> 36
267 -> 11
350 -> 94
500 -> 244

Por exemplo: 350em binário é 101011110. Definir o bit mais significativo (ou seja, o 1bit mais à esquerda ) para 0transformá-lo no 001011110equivalente ao número inteiro decimal 94, a saída. Este é o OEIS A053645 .

C (gcc) , 49 44 40 39 bytes

i;f(n){for(i=1;n/i;i*=2);return n^i/2;}

Experimente online!

Python 2 , 27 bytes

lambda n:n^2**len(bin(n))/8

Experimente online!

26 bytes

Infelizmente, isso não funciona para 1:

lambda n:int(bin(n)[3:],2)

Experimente online!

05AB1E , 5 bytes

.²óo-

Experimente online!

Removendo o bit mais significativo de um número inteiro N é equivalente a encontrar a distância a partir de N para a maior potência inteira de 2 inferior ao N .

Assim, usei a fórmula N - 2 ^{andar (log ₂ N)} :

• .²- Logaritmo com base 2 .
• ó - Pavimento para um número inteiro.
• o- 2 elevado à potência do resultado acima.
• - - Diferença.

Gelatina , 3 bytes

BḊḄ

Experimente online!

Explicação

BḊḄ  Main Link
B    Convert to binary
 Ḋ   Dequeue; remove the first element
  Ḅ  Convert from binary

C (gcc) - 59 bytes

main(i){scanf("%d",&i);return i&~(1<<31-__builtin_clz(i));}

Esta resposta do gcc usa apenas operações inteiras bit a bit e aritméticas. Não há logaritmos aqui! Pode ter problemas com uma entrada 0 e é totalmente não portátil.

É a minha primeira resposta neste site, então eu adoraria comentários e melhorias. Eu certamente me diverti aprendendo expressões bit a bit.

MATL , 8 6 bytes

B0T(XB

Experimente online!

Economizou dois bytes graças a Cinaski. A mudança para a indexação de atribuição em vez da indexação de referência foi 2 bytes mais curta :)

Explicação:

          % Grab input implicitly: 267
B         % Convert to binary: [1 0 0 0 0 1 0 1 1]
 0T(      % Set the first value to 0: [0 0 0 0 0 1 0 1 1]
    XB    % Convert to decimal: 11

Java (OpenJDK 8) , 23 bytes

n->n^n.highestOneBit(n)

Experimente online!

Desculpe, embutido: - /

Casca , 3 bytes

ḋtḋ

Experimente online!

Explicação:

    -- implicit input, e.g. 350
  ḋ -- convert number to list of binary digits (TNum -> [TNum]): [1,0,1,0,1,1,1,1,0]
 t  -- remove first element: [0,1,0,1,1,1,1,0]
ḋ   -- convert list of binary digits to number ([TNum] -> TNum): 94

Ohm v2 , 3 bytes

b(ó

Experimente online!

Python 2 , 27 bytes

lambda n:n-2**len(bin(n))/8

Experimente online!

Explicação

lambda n:n-2**len(bin(n))/8  # Lambda Function: takes `n` as an argument
lambda n:                    # Declaration of Lambda Function
              len(bin(n))    # Number of bits + 2
           2**               # 2 ** this ^
                         /8  # Divide by 8 because of the extra characters in the binary representation
         n-                  # Subtract this from the original

Python 3 , 30 bytes

-8 bytes graças a caird coinheringaahing. ^{Eu digitei isso de memória. : o}

lambda n:int('0'+bin(n)[3:],2)

Experimente online!

Mathematica, 37 bytes

Rest[#~IntegerDigits~2]~FromDigits~2&

Experimente online!

JavaScript, 22 20 bytes

Economizou 2 bytes graças a ovs

a=>a^1<<Math.log2(a)

Experimente online!

Outra abordagem, 32 bytes

a=>'0b'+a.toString`2`.slice`1`^0

Experimente online!

J, 6 bytes

}.&.#:

Bem simples.

Explicação

}.&.#:
    #:  convert to list of binary digits
  &.    apply right function, then left, then the inverse of right
}.      behead

APL (Dyalog) , 10 bytes

Função de prefixo tácito.

2⊥1↓2∘⊥⍣¯1

Experimente online!

2∘⊥... descodificar a partir da base-2 ...
 ... ⍣¯1 tempo um negativo (ou seja, codificam na base 2)

1↓ largar o primeiro bit

2⊥ decodificar da base-2

Ruby, 26 bytes

-7 bytes graças a Ventero. -2 bytes graças ao historicrat.

->n{/./=~'%b'%n;$'.to_i 2}

C (gcc), 38 bytes

Built-in gcc usado.

f(c){return c^1<<31-__builtin_clz(c);}

Montagem do BRAÇO, 46 43 bytes

(Você pode omitir o registro de destino ao adicionar quando for igual à fonte)

clz x1,x0
add x1,1
lsl x0,x1
lsr x0,x1
ret

Pitão, 5 bytes

a^2sl

Suíte de teste.

Explicação:

    l   Log base 2 of input.
   s    Cast ^ to integer (this is the position of the most significant bit.)
 ^2     Raise 2 to ^ (get the value of said bit)
a       Subtract ^ from input

Alice , 8 bytes

./-l
o@i

Experimente online!

Explicação

.   Duplicate an implicit zero at the bottom of the stack. Does nothing.
/   Switch to Ordinal mode, move SE.
i   Read all input as a string.
l   Convert to lower case (does nothing, because the input doesn't contain letters).
i   Try reading all input again, pushes an empty string.
/   Switch to Cardinal mode, move W.
.   Duplicate. Since we're in Cardinal mode, this tries to duplicate an integer.
    To get an integer, the empty string is discarded implicitly and the input is 
    converted to the integer value it represents. Therefore, at the end of this,
    we get two copies of the integer value that was input.
l   Clear lower bits. This sets all bits except the MSB to zero.
-   Subtract. By subtracting the MSB from the input, we set it to zero. We could
    also use XOR here.
/   Switch to Ordinal, move NW (and immediately reflect to SW).
o   Implicitly convert the result to a string and print it.
/   Switch to Ordinal, move S.
@   Terminate the program.

Japonês , 6 bytes

^2p¢ÊÉ

Experimente online!

Explicação

^2p¢ÊÉ
   ¢     Get binary form of input
    Ê    Get length of that
     É   Subtract 1
 2p      Raise 2 to the power of that
^        XOR with the input

Se a entrada 1puder falhar: 4 bytes

¢Ån2

Experimente online!

Explicação : obtenha binário de entrada ( ¢), corte primeiro char ( Å), analise como binário novamente em um número ( n2).

Oitava , 20 bytes

@(x)x-2^fix(log2(x))

Experimente online!

APL (Dyalog Unicode) , 9 bytes

⊢-2*∘⌊2⍟⊢

Experimente online!

-1 byte graças a Adam

CJam , 7 bytes

{2b()b}

Experimente online!

Explicação:

{     }  Block:         267
 2b      Binary:        [1 0 0 0 0 1 0 1 1]
   (     Pop:           [0 0 0 0 1 0 1 1] 1
    )    Increment:     [0 0 0 0 1 0 1 1] 2
     b   Base convert:  11

Reutilize o MSB (que é sempre 1) para evitar ter que excluí-lo; o equivalente sem esse truque seria {2b1>2b}ou {2b(;2b}.

Retina , 15 13 bytes

^(^1|\1\1)*1

Experimente online!

Entrada e saída em unário (o conjunto de testes inclui a conversão de e para decimal por conveniência).

Explicação

Isso é bastante fácil de fazer em unário. Tudo o que queremos fazer é excluir a maior potência de 2 da entrada. Podemos combinar uma potência de 2 com algumas referências avançadas. Na verdade, é mais fácil corresponder aos valores do formulário 2 ⁿ -1 , portanto, faremos isso e corresponderemos a 1 separadamente:

^(^1|\1\1)*1

O grupo 1corresponde a um single 1no início para iniciar as coisas ou corresponde ao dobro do que fez na última iteração. Então corresponde 1, então 2, então 4e assim por diante. Uma vez que estes são somados, estamos sempre com uma potência abaixo de 2, que corrigimos 1no final.

Devido ao avanço de linha à direita, a correspondência é simplesmente removida da entrada.

R , 28 bytes

function(x)x-2^(log2(x)%/%1)

Experimente online!

Mais fácil calcular o bit mais significativo por 2 ^ floor(log2(x))meio de conversões básicas, que são bastante detalhadas em R

PARI / GP, 18 bytes

n->n-2^logint(n,2)

Solução alternativa:

n->n-2^exponent(n)

Haskell , 32 29 bytes

(!1)
x!y|2*y>x=x-y|z<-2*y=x!z

Experimente online!

-3 bytes graças a @Laikoni

Solução mais antiga, 32 bytes

f x=last[x-2^i|i<-[0..x],2^i<=x]

Experimente online!

Excel, 20 bytes

=A1-2^INT(LOG(A1,2))

Excel, 36 31 bytes

-5 bytes graças a @ IanM_Matrix1

=BIN2DEC(MID(DEC2BIN(A1),2,99))

Nada interessante.