Eres un hacker profesional y tu jefe te acaba de ordenar que ayudes a un candidato a ganar las próximas elecciones. Su tarea es alterar los datos de las máquinas de votación para aumentar los resultados del candidato.

Las máquinas de votación almacenan los resultados de la votación como dos enteros: el número de votos para su candidato ( v1) y el número de votos para su oponente ( v2).

Después de semanas de investigación, ha encontrado un agujero de seguridad en el sistema y puede aumentar el valor de v1un número entero xy disminuir el valor de v2la misma x. Pero hay una restricción, debe mantener constante el código hash de seguridad:

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

Además, el valor de xdebe ser mínimo para que sus cambios pasen desapercibidos.

Su programa debe aceptar como entrada v1y v2; debería generar el valor óptimo para xeso v1>v2.

Hay algunos casos para los que no puede hackear los resultados; no tiene que manejarlos (esto podría generar problemas con su jefe, pero esa es otra historia).

Casos de prueba

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)

uson nuestros votos, tson sus votos.

Python 2, 30 bytes

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

Mathematica, 22 bytes

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

Función pura con argumentos #y #2. Golpea la profundidad máxima de recursión si la discrepancia es mayor que 7*2^16 = 458752.

Explicación

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

Jalea , 9 bytes

IH:7‘×7»0

Pruébalo en línea!

Cómo 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.

En realidad , 13 bytes

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

Pruébalo en línea!

Utiliza la misma max((b-a)/14*7+7,0)fórmula que usan xnor y orlp.

Explicación:

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 es un cierre sin nombre. Gracias a xnory orlppor la fórmula y James holdernesspor señalar un error.

La solución anterior utilizada intdiv()para la división de enteros pero se comporta de manera diferente a la //utilizada en python.

Pruébalo aquí!

Haskell, 30 24 bytes

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

Un operador infijo que toma primero el número de votos de su candidato preferido. Utiliza la misma lógica que las otras respuestas de redondeo /14*7+7.

J, 15 bytes

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

Un poco interesante, estaba trabajando en un problema y pensé que tenía una solución, pero resultó que estaba equivocado. Oh bien. Pruébalo en línea! Aquí está el 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

• Salvó un byte gracias a Martin Ender.
• Agregado 3 bytes gracias a Martin Ender.
• Cambiado ]a [gracias a ETHproductions.

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

Robaron descaradamente los métodos de Orlp y Xnor.

La entrada son los dos números separados por un espacio: 100 123

Explicación:

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

Immediates función de ventana que toma la entrada de las células A1y B1y salidas a la ventana de la VBE immediates.

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

Versión de subrutina, 43 bytes

toma la entrada b, ccomo variante \ entero e imprime en la ventana VBE inmediatamente

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)

Pruébalo en línea!

PHP, 41 39 bytes

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

toma datos de los argumentos de la línea de comandos; correr con -r.

7 5 bytes adicionales solo para manejar $ a> $ b: - /

Japt , 14 bytes

V-U /2+7 f7 w0

¡Ejecútalo aquí!

¡Gracias ETHproductions por reducir 3 bytes!

05AB1E , 9 bytes

-14÷>7*0M

Pruébalo en línea!

Explicación

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

O una función correspondiente con el mismo número de bytes que opera en un par de números

Î¥14÷>7*M

Pruébalo en línea!

Dyalog APL , 14 bytes

Toma v1como argumento correcto y v2como argumento izquierdo.

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

0 ⌈ el máximo de cero y

7 × siete veces

1 + (... ) uno más ...

 ⌊ el piso de

 14 ÷⍨ un decimocuarto de

 - la diferencia (entre los argumentos)

TryAPL en línea!

Befunge, 19 bytes

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

Pruébalo en línea!

Esto se basa en una fórmula ligeramente diferente a la utilizada por orlp y xnor, ya que el intérprete de referencia de Befunge tiene diferentes reglas de redondeo para Python. Befunge tampoco tiene el lujo de una maxoperación.

El cálculo básico se ve así:

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

Examinando el código con más detalle:

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}

Pruébalo en línea!

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 es una expresión lambda asignable a IntBinaryOperator.

a es el voto de tu candidato, b es el de tu oponente.

Java redondea hacia abajo para la división con enteros positivos, por lo que +7-a%7se utiliza para aumentar el valor al siguiente múltiplo de 7.

Ruby, 26 27 bytes

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

Básicamente lo mismo que la solución Python de xnor y orlp, con un giro (no es necesario agregar 7, debido al módulo negativo, ahorra 1 byte en ruby, no sé sobre python)

Sin giro, el giro fue solo un mal caso de disonancia cognitiva. Olvídalo. De Verdad. :-)

Scala, 31 bytes

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

La versión ternaria es 2 bytes más larga

Noodel , 16 bytes

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

La ecuación extraída de las respuestas xor y orlp , pero dado que Noodel no tiene una capacidad máxima, tuvo que solucionar eso.

Intentalo:)

Cómo 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.

Pyth , 16 bytes

MtS+0[+7*7/-HG14

Pruébalo aquí!