Existe uma maneira melhor de escrever v = (v == 0? 1: 0); [fechadas]

Quero alternar uma variável entre 0 e 1. Se for 0, quero configurá-lo para 1, caso contrário, se for 1, quero configurá-lo para 0.

Esta é uma operação tão fundamental que escrevo tantas vezes que gostaria de investigar a maneira mais curta e clara possível de fazê-lo. Aqui está o meu melhor até agora:

v = (v == 0 ? 1 : 0);

Você pode melhorar isso?

Edit: a pergunta é perguntar como escrever a declaração acima com o menor número de caracteres, mantendo a clareza - como isso não é uma pergunta real? Não era para ser um exercício de código-golfe, embora algumas respostas interessantes tenham surgido de pessoas que o abordam como golfe - é bom ver o golfe sendo usado de maneira construtiva e instigante.

Você pode simplesmente usar:

v = 1 - v;

Obviamente, isso pressupõe que a variável seja inicializada corretamente, ou seja, que ela tenha apenas o valor 0 ou 1.

Outro método que é mais curto, mas usa um operador menos comum:

v ^= 1;

Editar:

Para ser claro; Eu nunca abordei essa questão como código de golfe, apenas para encontrar uma maneira curta de executar a tarefa sem usar truques obscuros, como efeitos colaterais dos operadores.

Uma vez que 0é um falsevalor e 1é um truevalor.

v = (v ? 0 : 1);

Se você está feliz em usar truee, em falsevez de números

v = !v;

ou se eles devem ser números:

v = +!v; /* Boolean invert v then cast back to a Number */

v = (v + 1) % 2e se você precisa para percorrer mais valores apenas mudar 2para (n + 1). Digamos que você precise pedalar 0,1,2, apenas faça v = (v + 1) % 3.

Você pode escrever uma função para ela e usá-la como:

v = inv(v)

Se você não se importa com outra possibilidade além de 1:

v = v ? 0 : 1;

No caso acima, v acabará sendo 1 se v for 0, falso, indefinido ou nulo. Tome cuidado ao usar esse tipo de abordagem - v será 0 mesmo que v seja "olá mundo".

Linhas como v = 1 - v, ou v ^= 1ou v= +!v, todas farão o trabalho, mas constituem o que eu chamaria de hacks. Essas não são belas linhas de código, mas truques baratos para obter o efeito pretendido. 1 - vnão se comunica "alterna o valor entre 0 e 1". Isso torna seu código menos expressivo e apresenta um local (ainda que pequeno) onde outro desenvolvedor precisará analisar seu código.

Ter, em vez disso, uma função como v = toggle(v)comunica a intenção à primeira vista.

( Honestidade e integridade matemática - dado o número de votos nesta "resposta" - levaram-me a editar essa resposta. Esperei o máximo possível, porque ela pretendia ser uma piada curta e não como algo "profundo", para qualquer explicação parecia contrária ao objetivo. No entanto, os comentários estão deixando claro que devo ficar claro para evitar mal-entendidos. )

Minha resposta original:

O texto desta parte da especificação:

Se for 0, quero defini-lo como 1, caso contrário, defina-o como 0.

implica que a solução mais precisa é:

v = dirac_delta(0,v)

Em primeiro lugar, a confissão: eu queria chegar em minhas funções delta confuso. O delta do Kronecker teria sido um pouco mais apropriado, mas não tanto quanto eu queria algo independente do domínio (o delta do Kronecker é usado principalmente apenas para números inteiros). Mas eu realmente não deveria ter usado funções delta, eu deveria ter dito:

v = characteristic_function({0},v)

Deixe-me esclarecer. Recorde-se que uma função é um triplo, (X, Y, F) , em que X e Y são grupos (o chamado domínio e codomain respectivamente) e f é um regra que atribui um elemento de Y para cada elemento de X . Muitas vezes escrever o triplo (X, Y, f) como f: X → Y . Dado um subconjunto de X , digamos A , existe uma função característica que é uma função χ _A : X → {0,1}(também pode ser pensado como uma função para um codomain maior, como ℕ ou ℝ). Esta função é definida pela regra:

χ _A (x) = 1 , se x ∈ A e χ _A (x) = 0 se x ∉ Uma .

Se você gosta de tabelas verdade, é a tabela verdade para a pergunta "O elemento x de X é um elemento do subconjunto A ?".

Portanto, a partir dessa definição, fica claro que a função característica é o que é necessário aqui, com X um grande conjunto contendo 0 e A = {0} . Isso é o que eu deveria ter escrito.

E assim, para funções delta. Para isso, precisamos saber sobre integração. Ou você já sabe ou não. Caso contrário, nada do que eu possa dizer aqui irá falar sobre os meandros da teoria, mas posso dar um resumo de uma frase. Uma medida em um conjunto X é essencialmente "aquilo que é necessário para fazer as médias funcionarem". Isto é, se tivermos um conjunto X e uma medida μ nesse conjunto, haverá uma classe de funções X → ℝ , denominada funções mensuráveis para as quais a expressão ∫ _X f dμ faz sentido e, em algum sentido vago, a "média" de f sobre X .

Dada uma medida em um conjunto, pode-se definir uma "medida" para subconjuntos desse conjunto. Isso é feito atribuindo a um subconjunto a integral de sua função característica (assumindo que essa seja uma função mensurável). Isso pode ser infinito ou indefinido (os dois são sutilmente diferentes).

Existem muitas medidas por aí, mas há duas que são importantes aqui. Uma é a medida padrão na linha real, ℝ. Para esta medida, então ∫ _ℝ f dμ é praticamente o que se ensina na escola (é cálculo ainda ensinada nas escolas?): Soma-se pequenos retângulos e tomar larguras menores e menores. Nesta medida, a medida de um intervalo é sua largura. A medida de um ponto é 0.

Outra medida importante, que funciona em qualquer conjunto, é chamada de medida pontual . É definido para que a integral de uma função seja a soma de seus valores:

∫ _X f dμ = ∑ _{x fX} f (x)

Essa medida atribui a cada conjunto singleton a medida 1. Isso significa que um subconjunto possui uma medida finita se e somente se ela própria é finita. E muito poucas funções têm integral finito. Se uma função tem uma integral finita, ela deve ser diferente de zero apenas em um número contável de pontos. Portanto, a grande maioria das funções que você provavelmente conhece não possui integral finita sob essa medida.

E agora para funções delta. Vamos dar uma definição muito ampla. Temos um espaço mensurável (X, μ) (de modo que é um conjunto com uma medida sobre ele) e um elemento a ∈ X . "Definimos" a função delta (dependendo de a ) para ser a "função" δ _a : X → ℝ com a propriedade que δ _a (x) = 0 se x ≠ a e ∫ _X δ _a dμ = 1 .

O fato mais importante sobre isso para se manter em contato é o seguinte: A função delta não precisa ser uma função . É não corretamente definido: Eu não disse que ô _um (a) é.

O que você faz neste momento depende de quem você é. O mundo aqui se divide em duas categorias. Se você é matemático, diz o seguinte:

Ok, então a função delta pode não estar definida. Vamos dar uma olhada em suas propriedades hipotéticas e ver se podemos encontrar um lar adequado para onde é definido. Podemos fazer isso e terminamos com distribuições . Essas não são (necessariamente) funções, mas são coisas que se comportam um pouco como funções, e geralmente podemos trabalhar com elas como se fossem funções; mas há certas coisas que eles não têm (como "valores"), por isso precisamos ter cuidado.

Se você não é um matemático, diz o seguinte:

Ok, então a função delta pode não estar definida corretamente. Quem diz isso? Um monte de matemáticos? Ignore-os! O que eles sabem?

Tendo agora ofendido meu público, continuarei.

O dirac delta geralmente é considerado a função delta de um ponto (geralmente 0) na linha real com sua medida padrão. Portanto, aqueles que estão reclamando nos comentários sobre eu não conhecer meus deltas estão fazendo isso porque estão usando essa definição. Para eles, peço desculpas: embora eu possa me esquivar disso usando a defesa do matemático (como popularizada por Humpty Dumpty : simplesmente redefina tudo para que esteja correto), é uma má forma usar um termo padrão para significar algo diferente.

Mas não é uma função delta que faz o que eu quero fazer e é isso que eu preciso aqui. Se eu tomar uma medida de ponto em um conjunto X , então não é uma função genuína δ _um : X → ℝ que satisfaça os critérios de uma função delta. Isto é porque nós estamos olhando para uma função X → ℝ que é zero, exceto em um e tal que a soma de todos os seus valores é 1. função Tal é simples: a peça faltando apenas de informação é o seu valor em um , e para que a soma seja 1, apenas atribuímos o valor 1. Isso não é outro senão a função característica em {a} . Então:

∫ _X δ _a dμ = ∑ _{x ∈ X} δ _a (x) = δ _a (a) = 1.

Portanto, neste caso, para um conjunto de singleton, a função característica e a função delta concordam.

Em conclusão, existem três famílias de "funções" aqui:

1. As funções características de conjuntos singleton,
2. As funções delta,
3. O delta do Kronecker funciona.

O segundo deles é o mais geral, já que qualquer um dos outros é um exemplo disso ao usar a medida pontual. Mas o primeiro e o terceiro têm a vantagem de serem sempre funções genuínas. O terceiro, na verdade, é um caso especial do primeiro, para uma família específica de domínios (números inteiros ou algum subconjunto deles).

Então, finalmente, quando escrevi a resposta originalmente, não estava pensando direito (não diria que estava confuso , pois espero ter demonstrado que sei o que estou falando quando Na verdade, penso primeiro, não pensei muito). O significado usual do delta dirac não é o que se quer aqui, mas um dos pontos da minha resposta foi que o domínio de entrada não foi definido, de modo que o delta Kronecker também não estaria certo. Assim, a melhor resposta matemática (que eu estava buscando) teria sido a função característica .

Espero que tudo esteja claro; e também espero que nunca precise escrever uma peça matemática novamente usando entidades HTML em vez de macros TeX!

Você poderia fazer

v = Math.abs(--v);

O decremento define o valor como 0 ou -1 e depois Math.absconverte -1 em +1.

em geral, sempre que você precisar alternar entre dois valores, basta subtrair o valor atual da soma dos dois valores de alternância:

    0,1 -> v = 1 - v
    1,2 -> v = 3 - v
    4,5 -> v = 9 - v 

Se deve ser o número inteiro 1 ou 0, a maneira como você faz isso é boa, embora parênteses não sejam necessários. Se estes a forem usados ​​como booleanos, você poderá:

v = !v;

v = v == 0 ? 1 : 0;

Basta !

Lista de soluções

Gostaria de propor três soluções. Todos eles converter qualquer valor para 0(se 1, trueetc.) ou 1(se 0, false, nulletc.):

• v = 1*!v
• v = +!v
• v = ~~!v

e um adicional, já mencionado, mas inteligente e rápido (embora funcione apenas para 0s e 1s):

• v = 1-v

Solução 1

Você pode usar a seguinte solução:

v = 1*!v

Isso primeiro converterá o número inteiro para o valor booleano oposto ( 0para Truee qualquer outro valor para False) e, em seguida, o tratará como número inteiro ao multiplicar por 1. Como resultado 0, será convertido para 1e qualquer outro valor para 0.

Como prova, veja este jsfiddle e forneça os valores que você deseja testar: jsfiddle.net/rH3g5/

Os resultados são os seguintes:

• -123irá converter para inteiro 0,
• -10irá converter para inteiro 0,
• -1irá converter para inteiro 0,
• 0irá converter para inteiro 1,
• 1irá converter para inteiro 0,
• 2irá converter para inteiro 0,
• 60irá converter para inteiro 0,

Solução 2

Como mblase75 observou, o jAndy tinha outra solução que funciona como a minha:

v = +!v

Também primeiro torna booleano a partir do valor original, mas usa em +vez de 1*convertê-lo em número inteiro. O resultado é exatamente o mesmo, mas a notação é mais curta.

Solução 3

A outra abordagem é usar o ~~operador:

v = ~~!v

É bastante incomum e sempre converte em número inteiro a partir de booleano.

Para resumir outra resposta, um comentário e minha própria opinião, sugiro combinar duas coisas:

1. Use uma função para alternar
2. Dentro desta função, use uma implementação mais legível

Aqui está a função que você pode colocar em uma biblioteca ou talvez envolvê-lo em um plug-in para outro framework Javascript.

function inv(i) {
  if (i == 0) {
    return 1
  } else {
    return 0;
  }
}

E o uso é simplesmente:

v = inv(v);

As vantagens são:

1. Duplicação sem código
2. Se você ou alguém ler isso novamente no futuro, entenderá seu código em um período mínimo de tempo.

Não sei por que você quer construir seus próprios booleanos? Gosto das sintaxes descoladas, mas por que não escrever código compreensível?

Este não é o mais curto / mais rápido, mas o mais claro (e legível para todos) está usando o conhecido se / else estado:

if (v === 0)
{
  v = 1;
}
else
{
  v = 0;
}

Se você quiser ser realmente claro, use booleanos em vez de números para isso. Eles são rápidos o suficiente para a maioria dos casos. Com os booleanos, você pode usar esta sintaxe, que vencerá em pouco tempo:

v = !v;

Outra forma de sua solução original:

v = Number(v == 0);

Edição: Obrigado TehShrike e Guffa por apontar o erro na minha solução original.

Eu o tornaria mais explícito.

O que vsignifica isso ?

Por exemplo, quando v é algum estado. Crie um objeto Status. No DDD, um objeto de valor.

Implemente a lógica nesse objeto de valor. Então você pode escrever seu código de uma maneira mais funcional e mais legível. O status da troca pode ser feito criando um novo status com base no status atual. Sua instrução if / lógica é então encapsulada em seu objeto, que você pode unittest. Um valueObject é sempre imutável, portanto, não tem identidade. Então, para mudar seu valor, você precisa criar um novo.

Exemplo:

public class Status
{
    private readonly int _actualValue;
    public Status(int value)
    {
        _actualValue = value;
    }
    public Status(Status status)
    {
        _actualValue = status._actualValue == 0 ? 1 : 0; 
    }

    //some equals method to compare two Status objects
}

var status = new Status(0);

Status = new Status(status);

Outra maneira de fazer isso:

v = ~(v|-v) >>> 31;

Está faltando:

v = [1, 0][v];

Também funciona como rodízio:

v = [2, 0, 1][v]; // 0 2 1 0 ...
v = [1, 2, 0][v]; // 0 1 2 0 ...
v = [1, 2, 3, 4, 5, 0][v]; // 0 1 2 3 4 5 ...
v = [5, 0, 1, 2, 3, 4][v]; // 0 5 4 3 2 1 0 ...

Ou

v = {0: 1, 1: 0}[v];

O charme da última solução, também funciona com todos os outros valores.

v = {777: 'seven', 'seven': 777}[v];

Para um caso muito especial, gostaria de obter um valor (em mudança) e undefined, esse padrão pode ser útil:

v = { undefined: someValue }[v]; // undefined someValue undefined someValue undefined ...

Como esse é o JavaScript, podemos usar o unário +para converter em int:

v = +!v;

Isso lógico NOTo valor de v(fornecendo truese v == 0ou falsese v == 1). Em seguida, convertemos o valor booleano retornado em sua representação inteira correspondente.

Apenas para chutes: v = Math.pow(v-1,v)também alterna entre 1 e 0.

Mais um: v=++v%2

(em C seria simples ++v%=2)

ps. Sim, eu sei que é atribuição dupla, mas isso é apenas uma reescrita bruta do método C (que não funciona como está, porque o operador de pré-incremento JS não retorna lvalue.

Se você está garantido que sua entrada é 1 ou 0, então você pode usar:

v = 2+~v;

defina uma matriz {1,0}, defina v como v [v]; portanto, v com o valor 0 se tornará 1 e vica versa.

Outra maneira criativa de fazer isso, vsendo igual a qualquer valor, sempre retornará 0ou1

v = !!v^1;

Se os valores possíveis para v forem apenas 0 e 1, para qualquer número inteiro x, a expressão: v = Math.pow ((Math.pow (x, v) - x), v); irá alternar o valor.

Sei que essa é uma solução feia e o OP não estava procurando por isso ... mas estava pensando em outra solução quando estava no banheiro: P

Não testado, mas se você estiver atrás de um booleano, acho var v = !vque funcionará.

Referência: http://www.jackfranklin.co.uk/blog/2011/05/a-better-way-to-reverse-variables

v=!v;

funcionará para v = 0 e v = 1; e alternar o estado;

Se houver apenas dois valores, como neste caso (0, 1), acredito que seja um desperdício usar int. Em vez disso, escolha boolean e trabalhe em bits. Eu sei que estou assumindo, mas no caso de alternar entre dois estados booleanos parece ser a escolha ideal.

Bem, como sabemos que em javascript, apenas essa comparação booleana também fornecerá o resultado esperado.

ie v = v == 0 é suficiente para isso.

Abaixo está o código para isso:

var v = 0;
alert("if v  is 0 output: " + (v == 0));

setTimeout(function() {
  v = 1;
  alert("if v  is 1 Output: " + (v == 0));
}, 1000);

JSFiddle: https://jsfiddle.net/vikash2402/83zf2zz0/

Esperando que isso ajude você :)

v = Número (! v)

Ele digitará o valor booleano invertido para Number, que é a saída desejada.