Hack les élections

46

Vous êtes un pirate informatique professionnel et votre patron vient de vous ordonner d'aider un candidat à remporter les prochaines élections. Votre tâche consiste à modifier les données des machines à voter pour améliorer les résultats du candidat.

Les machines à voter enregistrent les résultats de vote sous la forme de deux entiers: le nombre de votes pour votre candidat ( v1) et le nombre de votes pour son adversaire ( v2).

Après des semaines de recherche, vous avez trouvé une faille de sécurité dans le système et vous pouvez augmenter la valeur de v1par un entier xet diminuer la valeur de v2par la même chose x. Mais il y a une contrainte, vous devez garder le code de hachage de sécurité constant:

  • code de hachage de sécurité: (v1 + v2*2) modulo 7

En outre, la valeur de xdoit être minimale pour que vos modifications puissent passer inaperçues.

Votre programme devrait accepter comme entrée v1et v2; il devrait générer la valeur optimale pour xso v1>v2.

Dans certains cas, vous ne pouvez pas pirater les résultats. vous n'êtes pas obligé de les gérer (cela pourrait entraîner des problèmes avec votre patron, mais c'est une autre histoire).

Cas de test

100,123 --> 14
47,23 --> 0
40,80 --> 21
62,62 --> 7
1134,2145 --> 511
code-golf  arithmetic 
— Arnaud
source
4
Les commentaires ne sont pas pour une discussion prolongée; cette conversation a été déplacée pour discuter .
— Dennis
11
Aussi, pour les électeurs proches: C'est parfaitement sur le sujet. Si vous ne l'aimez pas, vous pouvez le transférer.
— Rɪᴋᴇʀ
10
Quelle fonction de hachage sécurisée!
— Cruncher
Pouvez-vous supposer que les entrées sont suivies de .0(J'aime 100.0 123.0)?
— Fruit Esolanging

Réponses:

21

Python 2, 30 octets

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

uce sont nos votes, ce tsont leurs votes.

— orlp
source
3
Ne pourrait pas (t-u)/14*7être juste (t-u)/2?
— Conor O'Brien
2
Oh, attends, ça ne fait rien, Py2 fait la division entière
— Conor O'Brien
@ ConorO'Brien Nope. Tenez compte t-u == 16. Alors
— 16/14
@ orlp Je ne sais pas à qui poser, alors je vais vous demander à tous les deux. Pouvez-vous s'il vous plaît m'expliquer comment vous avez pensé à cela? y<x?0:(y-x)/2-(y-x)/2%7+7;, Je pensais que je devrais prendre la différence en la divisant en deux, puis trouver le plus proche multiple de 7. Comment êtes-vous arrivé à cela?
— Wade Tyler
1
la même solution est ci
— nom d'utilisateur.ak
20

Python 2, 30 octets

lambda a,b:max((b-a)/14*7+7,0)
— Xnor
source
3
@ orlp Ouais, je pense que c'est juste la façon d'écrire l'expression. Sauf si une solution récursive est plus courte, ce dont je doute.
— xnor
1
@xnor Je ne sais pas à qui poser, alors je vais vous poser une question à tous les deux. Pouvez-vous s'il vous plaît m'expliquer comment vous avez pensé à cela? y<x?0:(y-x)/2-(y-x)/2%7+7;, Je pensais que je devrais prendre la différence en la divisant en deux, puis trouver le plus proche multiple de 7. Comment êtes-vous arrivé à cela?
— Wade Tyler
2
@WadeTyler Nous cherchons le plus petit multiple de 7 strictement supérieur à la moitié de la différence. Pour trouver cela à partir de (b-a)/2, nous /7*7arrondissons les nombres au multiple de 7 le plus proche, puis +7montons au suivant. Autrement dit, à moins que nous obtenions un nombre négatif, dans ce cas, nous gagnons quand même, nous ne pouvons que faire 0. Prendre le maxavec 0 permet d’atteindre cet objectif. Certaines d'entre elles consistaient également à peaufiner l'expression et à l'exécuter sur les cas de test pour voir ce qui fonctionnait.
— xnor
2
@WadeTyler The /7*7est un type d'expression qui apparaît assez souvent dans le golf pour que je le considère comme un idiome. L'idée est de n/7prendre la parole n/7, c'est-à-dire de trouver le nombre entier de multiples d' 7ajustement à l'intérieur n. Ensuite, multiplier par le 7ramène à ce nombre multiple de 7.
— xnor
1
@JackAmmo Cet exemple donne -2/7*7, et puisque Python arrondit les divisions d'étage vers l'infini négatif, 2/7vaut -1, donc 7*-7+10. Donc, les deux côtés donnent 0, ce qui fonctionne bien.
— xnor
13

Mathematica, 22 octets

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

Fonction pure avec des arguments #et #2. Touche la profondeur de récursivité maximale si la différence est supérieure à 7*2^16 = 458752.

Explication

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
— ngenisis
source
4
Pouvez-vous ajouter une explication à tout cela?
— Pavel
@Pavel Peut-être que votre commentaire a continué à recevoir des votes positifs parce que mon explication n'était pas claire?
— ngenisis
Je pensais que ça allait, mais je connais aussi Mathematica.
— Pavel
@Pavel Eh bien, c'est mieux maintenant :)
— ngenisis
7

Gelée , 9 octets

IH:7‘×7»0

Essayez-le en ligne!

Comment ça fonctionne

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.
— Dennis
source
6

En fait , 13 octets

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

Essayez-le en ligne!

Utilise la même max((b-a)/14*7+7,0)formule que xnor et orlp.

Explication:

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
— Mego
source
5
En fait , c’est une excellente réponse
— TrojanJus par accident le
J'ai l'impression que le nom de cette langue était intentionnel pour que les titres de soumission ressemblent à des mots: "Les gars, en fait , c'est 13 octets! Allez!"
— Patrick Roberts
@ PatrickRoberts En fait, c'est correct.
— Mego
6

Groovy, 41 à 37 octets

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

C'est une fermeture sans nom. Merci à xnoret orlppour la formule et James holdernesspour avoir signalé un bug.

La solution précédente utilisait la intdiv()division entière, mais son comportement était différent de celui //utilisé en python.

Essayez-le ici!

— Gurupad Mamadapur
source
5

Haskell, 30 à 24 octets

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

Un opérateur infixe prenant en premier le nombre de voix de votre candidat préféré. Utilise la même logique que les autres réponses d'arrondi avec /14*7+7.

— Renzeee
source
2
Trouver la première valeur qui remplit une condition est utile pour until:, a#b=until(\c->a+c>b-c)(+7)0ou mieux a%b=until(>(b-a)/2)(+7)0. Bien qu'une formule arithmétique soit encore probablement plus courte.
— xnor
1
Notez qu'en dehors des options plus courtes de xnor, il head[...]est presque toujours possible de raccourcir[...]!!0
— Laikoni
@xnor: jusqu'à ce que votre solution renvoie un Fractional a, je ne sais pas si cela est accepté. Avec divc'est bien plus court, alors merci! Finalement utilisé l'approche mathématique - et en effet, il était encore deux octets plus court que jusqu'à. @ Laikoni: bon golf, je ne savais pas que celui-là, s'en souviendra.
— Renzeee
4

J, 15 octets

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

Assez intéressant, je travaillais sur un problème et je pensais avoir une solution, mais il s'avère que je me suis trompé. Tant pis. Essayez-le en ligne! Voici le résultat:

   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│
└─────────┴───┘
— Conor O'Brien
source
À l'avenir, utilisez TIO.run/nexus
— Pavel le
@Pavel Non, tio.run est v2, Nexus existe uniquement pour la compatibilité v1
— ASCII uniquement
@ ASCII-only tio.run a un avertissement en bas que tous les permaliens générés pourraient casser dans le futur. Je pense que je devrais rendre cela plus important. Sauf à des fins de test, personne ne devrait utiliser v2 à ce moment.
— Dennis
@ Dennis Oh, je ne savais pas! Éditera dès que possible.
— Conor O'Brien
4

CJam, 13 12 15 octets

  • Enregistrement d'un octet grâce à Martin Ender.
  • Ajout de 3 octets grâce à Martin Ender.
  • Changé ]en [grâce à ETHproductions.

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

Volé de manière flagrante les méthodes orlp et xnor.

L'entrée est les deux nombres séparés par un espace: 100 123

Explication:

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.
— Fruit d'esolanging
source
Dest seulement 13. Et vous pouvez enregistrer un octet en incrémentant la valeur avant multiplication au lieu d’ajouter 7 par la suite.
— Martin Ender
@JamesHolderness Le problème est que la division entière de Python fonctionne autour de -inf alors que celle de CJam est nulle.
— Martin Ender
Je me trompe peut-être, mais je pensais que c’était ce qui m]se passait; m[est le sol.
— ETHproductions
@ETHproductions Vous avez raison, édité.
— Fruit Esolanging
4

Excel VBA, 24 20 octets

Immediates fonction de fenêtre qui accepte une entrée à partir de cellules A1et de B1et sorties à la fenêtre du VBE.

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

Version du sous-programme, 43 octets

prend une entrée en b, ctant que variant \ integer et s'imprime dans la fenêtre VBE immédiate

Sub a(b,c):Debug.?Int((c-b)/14)*7+7:End Sub
— Taylor Scott
source
3

PHP, 41 39 octets

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

prend les arguments de la ligne de commande; courir avec -r.

7 5 octets supplémentaires juste pour gérer $ a> $ b: - /

— Titus
source
3

Japt , 14 octets

V-U /2+7 f7 w0

Exécutez-le ici!

Merci à ETHproductions d’avoir supprimé 3 octets!

— Oliver
source
1
Très agréable. faccepte un argument et prend un multiple de ce nombre, je pense donc V-U /2+7 f7 w0pouvoir économiser trois octets.
— ETHproductions
3

05AB1E , 9 octets

-14÷>7*0M

Essayez-le en ligne!

Explication

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

Ou une fonction correspondante avec le même nombre d'octets opérant sur une paire de nombres

Î¥14÷>7*M

Essayez-le en ligne!

— Emigna
source
2

Dyalog APL , 14 octets

Prend v1comme argument droit et v2comme argument gauche.

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

0 ⌈ le maximum de zéro et

7 × Sept fois

1 + (... ) un plus ...

 ⌊ le sol de

 14 ÷⍨ un quatorzième de

 - la différence (entre les arguments)

TryAPL en ligne!

— Adam
source
2

Befunge, 19 octets

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

Essayez-le en ligne!

Cela repose sur une formule légèrement différente de celle utilisée par orlp et xnor, car l'interpréteur de référence Befunge a des règles d'arrondi différentes de celles de Python. Befunge n'a pas non plus le luxe d'une maxopération.

Le calcul de base ressemble à ceci:

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

Examiner le code plus en détail:

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.
— James Holderness
source
2

Java 8, 31 octets

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

Ceci est une expression lambda assignable à IntBinaryOperator.

a est le vote de votre candidat, b est celui de votre adversaire.

java arrondit la division avec les entiers positifs, elle +7-a%7est donc utilisée pour augmenter la valeur jusqu'au prochain multiple de 7.

— Jack Ammo
source
a->b->(b=(b-a)/14*7+7)>0?b:0est plus court de 3 octets, mais j'aime un peu plus votre approche, donc +1 de moi. Presque chaque réponse donnée utilise déjà max((b-a)/14*7+7,0)..
— Kevin Cruijssen
Je préfère utiliser des lambdas qui renvoient directement le résultat. et yeahb tout le monde a fait la formule un peu plus courte mais c'est comme ça que j'ai réfléchi avant de vérifier tout le monde elses
— Jack Ammo
a->b->(b=(b-a)/14*7+7)>0?b:0renvoie également le résultat directement: essayez-le ici. Ou voulez-vous dire que vous préférez les lambdas à une méthode plutôt que les lambdas au curry; (a,b)->préférence plus a->b->, même si c'est plus long?
— Kevin Cruijssen
méthode unique sur currying, mais c'est juste une préférence personnelle
— Jack Ammo
1

Ruby, 26 à 27 octets

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

Fondamentalement identique à la solution Python de xnor et orlp, avec une torsion (inutile d’ajouter 7, en raison de la modulo négative, enregistre 1 octet dans ruby, je ne connais pas python)

Aucune torsion, la torsion était juste un mauvais cas de dissonance cognitive. Oublie. Vraiment. :-)

— GB
source
1

Scala, 31 octets

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

La version ternaire est plus longue de 2 octets

— jaxad0127
source
1

Noodel , 16 octets

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

L'équation tirée des réponses xor et orlp , mais puisque Noodel ne dispose pas d'une capacité maximale, il a fallu contourner ce problème .

Essayez-le :)

Comment ça fonctionne

⁻÷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.
— tkellehe
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.