Você é um hacker profissional e seu chefe acabou de ordenar que você ajude um candidato a vencer uma próxima eleição. Sua tarefa é alterar os dados das urnas para aumentar os resultados do candidato.

As máquinas de votação armazenam os resultados da votação como dois números inteiros: o número de votos para seu candidato ( v1) e o número de votos para seu oponente ( v2).

Após semanas de pesquisa, você encontrou uma falha de segurança no sistema e pode aumentar o valor de v1por um número inteiro xe diminuir o valor de v2pelo mesmo x. Mas há uma restrição, você precisa manter o código de hash de segurança constante:

• código hash de segurança: (v1 + v2*2) modulo 7

Além disso, o valor de xdeve ser mínimo para que suas alterações possam passar despercebidas.

Seu programa deve aceitar como entrada v1e v2; deve gerar o valor ideal para xisso v1>v2.

Existem alguns casos em que você não pode hackear os resultados; você não precisa lidar com eles (isso pode levar a problemas com seu chefe, mas isso é outra história).

Casos de teste

100,123 --> 14
47,23 --> 0
40,80 --> 21
62,62 --> 7
1134,2145 --> 511

Python 2, 30 bytes

lambda u,t:max(0,(t-u)/14*7+7)

usão nossos votos, tsão seus votos.

Python 2, 30 bytes

lambda a,b:max((b-a)/14*7+7,0)

Mathematica, 22 bytes

0//.x_/;2x<=#2-#:>x+7&

Função pura com argumentos #e #2. Atinge a profundidade máxima de recursão se a discrepância for maior que 7*2^16 = 458752.

Explicação

0                       Starting with 0,
 //.                    repeatedly apply the following rule until there is no change:
    x_                    if you see an expression x
      /;                    such that
        2x<=#2-#            2x <= #2-# (equivalently, #+x <= #2-x)
                :>        then replace it with
                  x+7       x+7 (hash is preserved only by multiples of 7)
                     &  End the function definition

Geléia , 9 bytes

IH:7‘×7»0

Experimente online!

Como funciona

IH:7‘×7»0  Main link. Argument: [v1, v2]

I          Increments; compute [v2 - v1].
 H         Halve the result.
  :7       Perform integer division by 7.
    ‘      Increment the quotient.
     ×7    Multiply the result by 7.
       »0  Take the maximum of the product and 0.

Na verdade , 13 bytes

7;;τ((-\*+0kM

Experimente online!

Usa a mesma max((b-a)/14*7+7,0)fórmula que xnor e orlp usam.

Explicação:

7;;τ((-\*+0kM
7;;            3 copies of 7
   τ           double one of them
    ((-        bring the inputs back to the top, take their difference
       \*+     integer divide by 14, multiply by 7, add 7
          0kM  maximum of that and 0

Groovy, 41 37 bytes

{x,y->[Math.floor((y-x)/14)*7+7,0].max()}

Este é um fechamento sem nome. Obrigado xnore orlppela fórmula e James holdernesspor apontar um bug.

A solução anterior usada intdiv()para divisão inteira, mas se comporta de maneira diferente da //usada em python.

Experimente aqui!

Haskell, 30 24 bytes

a#b=max 0$div(b-a)14*7+7

Um operador de infix recebendo o número de votos do seu candidato preferido primeiro. Usa a mesma lógica que as outras respostas de arredondamento /14*7+7.

J, 15 bytes

0>.7+7*14<.@%~-

Meio interessante, eu estava trabalhando em um problema e achei que tinha uma solução, mas, no fim, estava errado. Ah bem. Experimente online! Aqui está o resultado:

   f =: 0>.7+7*14<.@%~-
   tests =: 123 100 ; 23 47 ; 80 40 ; 62 62 ; 2145 1134
   (,. f/ each) tests
┌─────────┬───┐
│123 100  │14 │
├─────────┼───┤
│23 47    │0  │
├─────────┼───┤
│80 40    │21 │
├─────────┼───┤
│62 62    │7  │
├─────────┼───┤
│2145 1134│511│
└─────────┴───┘

CJam, 13 12 15 bytes

• Guardou um byte graças a Martin Ender.
• Adicionado 3 bytes graças a Martin Ender.
• Alterado ]para [graças a ETHproductions.

q~\-Ed/m[)7*0e>

Roubou descaradamente os métodos orlp e xnor.

Entrada são os dois números separados por um espaço: 100 123

Explicação:

q~\-Ed/m])7*0e>
q~\-            e# Input two numbers, swap and subtract them.
    E           e# Push 0xE (15)
     d/m]       e# Float divide and take the floor.
         )7*    e# Increment and multiply by 7.
            0e> e# Max of this and 0.

Excel VBA, ₂₄ 20 bytes

Função Immediates janela que recebe a entrada a partir de células A1e B1e saídas para a janela do VBE imediatos.

?Int([A1-B1]/14)*7+7

Versão da sub-rotina, 43 bytes

recebe a entrada b, ccomo variante \ inteiro e imprime na janela do VBE imediatamente

Sub a(b,c):Debug.?Int((c-b)/14)*7+7:End Sub

Julia 0,5 , 26 bytes

v\w=max(fld(w-v,14)*7+7,0)

Experimente online!

PHP, 41 39 bytes

    <?=7*max(0,1+($argv[2]-$argv[1])/14|0);

recebe entrada dos argumentos da linha de comando; corra com -r.

7 5 bytes extras apenas para manipular $ a> $ b: - /

Japonês , 14 bytes

V-U /2+7 f7 w0

Execute-o aqui!

Obrigado ETHproductions por reduzir 3 bytes!

05AB1E , 9 bytes

-14÷>7*0M

Experimente online!

Explicação

-          # push difference of inputs
 14÷       # integer divide by 14
    >      # increment
     7*    # times 7
       0   # push 0
        M  # take max

Ou uma função correspondente com a mesma contagem de bytes operando em um par de números

Î¥14÷>7*M

Experimente online!

Dyalog APL , 14 bytes

Toma v1como argumento certo e v2como argumento esquerdo.

0⌈7×1+(⌊14÷⍨-)

0 ⌈ o máximo de zero e

7 × sete vezes

1 + (... ) mais um ...

 ⌊ o chão de

 14 ÷⍨ um décimo quarto de

 - a diferença (entre os argumentos)

TryAPL online!

Befunge, 19 bytes

777+:&&\-+\/*:0`*.@

Experimente online!

Isso depende de uma fórmula ligeiramente diferente da usada pelo orlp e xnor, já que o interpretador de referência Befunge possui regras de arredondamento diferentes para o Python. Befunge também não tem o luxo de uma maxoperação.

O cálculo básico é assim:

x = (v2 - v1 + 14)/14*7
x = x * (x > 0)

Examinando o código em mais detalhes:

7                     Push 7                                      [7]
 77+:                 Push 14 twice.                              [7,14,14]
     &&               Read v1 and v2 from stdin.                  [7,14,14,v1,v2]
       \-             Swap the values and subtract.               [7,14,14,v2-v1]
         +            Add the 14 that was pushed earlier.         [7,14,14+v2-v1]
          \/          Swap the second 14 to the top and divide.   [7,(14+v2-v1)/14]
            *         Multiply by the 7 that was pushed earlier.  [7*(14+v2-v1)/14 => x]
             :        Make a copy of the result                   [x,x]
              0`      Test if it's greater than 0.                [x,x>0]
                *     Multiply this with the original result.     [x*(x>0)]
                 .@   Output and exit.

Go , 36 bytes

func(a,b int)int{return(b-a)/14*7+7}

Experimente online!

JavaScript (ES6), 31 bytes

(a,b,c=(b-a)/14|0)=>c>0?c*7+7:0

f=(a,b,c=(b-a)/14|0)=>c>0?c*7+7:0
document.write(f(1134,2145))

Java 8, 31 bytes

(a,b)->b<a?0:(a=(b-a)/2)+7-a%7;

Esta é uma expressão lambda atribuível a IntBinaryOperator.

a é o voto do seu candidato, b é o seu oponente.

java arredonda para baixo para divisão com números inteiros positivos, então +7-a%7é usado para aumentar o valor para o próximo múltiplo de 7.

Ruby, 26 27 bytes

->a,b{[(b-a)/14*7+7,0].max}

Basicamente, o mesmo que as soluções Python do xnor e do orlp, com um toque (não é necessário adicionar 7, por causa do módulo negativo, economiza 1 byte em ruby, não sabe sobre python)

Sem reviravoltas, a reviravolta foi apenas um caso grave de dissonância cognitiva. Esqueça. Realmente. :-)

Scala, 31 bytes

(a,b)=>Math.max((b-a)/14*7+7,0)

A versão ternária é 2 bytes mais longa

Noodel , 16 bytes

⁻÷14ɲL×7⁺7ḋɲl⁺÷2

A equação extraída das respostas xor e orlp , mas como Noodel não tem uma capacidade máxima, foi necessário contornar isso.

Tente:)

Como funciona

⁻÷14ɲL×7⁺7       # The equation...
⁻                # v2 - v1
 ÷14             # Pops off the difference, then pushes on the (v2 - v1)/14
    ɲL           # Applies lowercase which for numbers is the floor function.
      ×7         # Multiplies that by seven.
        ⁺7       # Then increments it by seven.

          ḋɲl⁺÷2 # To relate with the other answers, this takes the max between the value and zero.
          ḋ      # Duplicates what is on the top of the stack (which is the value just calculated).
           ɲl    # Pops off the number and pushes on the magnitude (abs value).
             ⁺   # Add the abs to itself producing zero if the number came out negative (which means we are already winning).
              ÷2 # Divides the result by two, which will either be zero or the correct offset.

Pitão , 16 bytes

MtS+0[+7*7/-HG14

Experimente aqui!