Cette fois, votre objectif est de trouver le maximum de 3 entiers (de - (2 ^ 31) à 2 ^ 31 - 1 en complément binaire 2) sans utiliser de branchement ou de boucles.

Vous n'autorisé à utiliser

• L' inégalité / l' égalité ( ==, >, >=, <, <=, !=) Ceux - ci comptent comme 2 jetons.

• Arithmétique ( +, -, *, /)

• Opérateurs logiques ( !pas, &&et, || ou)

• Opérateurs de bits ( ~non, &et, |ou, ^xor, <<, >>, >>>gauche arithmétiques et logiques et décalages à droite)

• Constantes. 0 jetons

• Affectation variable. 0 jetons

Entrez 3 variables comme a, bet c. Sortez le nombre maximum.

Les règles standard de golf à code atomique s'appliquent. Si vous avez des questions, veuillez les laisser dans les commentaires. Un jeton est l'un des ci-dessus avec les règles spéciales.

Javascript 10 jetons

Modifier en utilisant <et * au lieu de bidouiller les bits - comme indiqué dans les commentaires, les opérations sur les bits peuvent échouer pour une entrée proche de la limite de plage (plus de 30 bits)

function Max(x,y,z)
{
  var d=y-x;
  x=y-d*(d<0);
  d=x-z;
  return x-d*(d<0);
}

Jetons C 8

Indépendant du langage en fait, n'importe quel langage de type C fera l'affaire. Pour être pointilleux, en C standard, il n'est pas portable car le décalage à droite peut ne pas étendre le signe (mais dans les implémentations courantes, il le fait).

En C (et C ++, C # et Java je pense), nous pouvons facilement gérer les problèmes de débordement en utilisant des valeurs temporaires plus grandes:

int Max(int x, int y, int z)
{
    long long X = x;
    long long Y = y;
    long long Z = z;
    long long D = Y-X;
    X=Y-((D>>63)&D);
    D=X-Z;
    return (int) (X-((D>>63)&D));
}

Javascript

6 jetons

function maxOf3(a, b, c) {
    (b>a) && (a=b);
    (c>a) && (a=c);
    return a;
}

C: 10 jetons

int max(int a, int b, int c)
{
    a += (b > a) * (b - a);
    a += (c > a) * (c - a);
    return a;
}

Inspiré par la réponse de @ openorclose, mais converti en C et rendu sans branche en utilisant la multiplication plutôt que les opérateurs booléens en court-circuit.

Javascript

14 jetons

function max (a, b, c)
{
    var ab = (a >= b) * a + (a < b) * b;
    return (ab >= c) * ab + (ab < c) * c;
}

Plusieurs langues (Python) (10 jetons)

def max3(x,y,z):
    m = x ^ ((x ^ y) & -(x < y))
    return m ^ ((m ^ z) & -(m < z))

print max3(-1,-2,-3) # -1
print max3(-1,2,10) # 10

https://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax

Oh, quelqu'un l'a déjà posté :)

Jetons C ++ 11:15

Utiliser uniquement des opérateurs arithmétiques et au niveau du bit (car les opérateurs d'égalité et de logique booléenne le rendent trop facile) ...

#include <iostream>

auto max(int32_t a, int32_t b, int32_t c)->int32_t {
  return c - ((c - (a - ((a - b) & (a - b) >> 31))) & (c - (a - ((a - b) & (a - b) >> 31))) >> 31);
}

auto main()->int {
  // test harness
  std::cout << max(9, 38, 7) << std::endl;
  return EXIT_SUCCESS;
}

J (pas en compétition)

Je me demandais juste à quoi ressemblerait une solution dans J. Cela utilise un ,et un #bien, donc ce ne sera pas en compétition.

((a<b),(b<c),(c<a))#b,c,a

Ce serait en concurrence, mais c'est beaucoup trop long, avec 9 jetons:

(b*a<:b)+(c*b<c)+(a*c<a)

nous avons les hypothèses suivantes:

• max (a; b) = (a + b + | ab |) / 2

• max (a; b; c) = max (max (a; b); c)

• abs (a) = (a + (a >> 31)) ^ (a >> 31)

on peut utiliser le pseudo-code:

fonction max (a, b, c)

{

out1 = ((a + b) + (((ab) + ((ab) >> 31)) ^ ((ab) >> 31))) div 2

out2 = ((out1 + c) + (((out1-c) + ((out1-c) >> 31)) ^ ((out1-c) >> 31))) div 2

retour2

}

C # (2e essai)

Je l'ai compris ... Pas de fonctions intégrées ...

Mais est-il autorisé à utiliser d'autres types de données intégrés ou tout simplement un entier? Si autorisé, je proposerais:

int foo2(int a, int b, int c)
{
   var x = new SortedList<int,int>();

   x[a] = 1;
   x[b] = 1;
   x[c] = 1;

   return x.Keys[2];
}

jetons javascript 8

bien que similaire à la réponse de @ openorclose, j'utilise en fait les opérateurs logiques pour l'affectation elle-même.

function max( a, b, c ) {
    x=( a > b && a) || b;
    return ( x > c && x ) || c;
}

violon

R (10 jetons)

function max(a, b, c) {
  max <- a
  max <- max + (b - max) * (b > max)
  max <- max + (c - max) * (c > max)
  return(max)
}

Brainfuck (pas en compétition)

>,[-<+>>>+<<]>,[-<+>>>+<<]>[>[-<->>]<<]<[-]>[-]>[-]<<<[->>>>+<<<<]>>>>[-<+>>>+<<]>,[-<+>>>+<<]>[>[-<->>]<<]<<

TIS-100, 8 opérations

MOV ACC UP #A
SUB UP     #B
SUB 999
ADD 999
ADD UP     #B
SUB UP     #C
SUB 999
ADD 999
ADD UP     #C
MOV ACC DOWN

Le fournisseur (UP) ne fait que des MOV, donc non indiqué dans le code Peut-être ne fonctionne pas lorsqu'il est trop près du bord 999

VBA (6 jetons)

 Function max3(a As Integer, b As Integer, c As Integer)
 i = IIf(a >= b And a >= c, a, IIf(b >= c, b, c))
 max3 = i
 End Function  

Je ne sais pas si ce n'est pas une ramification.

JavaScript: 4 jetons (** basé sur une interprétation large de "affectation"!)

Évidemment, mon score de 4 est extrêmement généreux / indulgent!

Pour arriver à ce score, j'ai supposé que «l'affectation» (valant 0 jeton dans la question) comprend des éléments tels que l'affectation additive, l'affectation soustractive, l'affectation multiplicative et l'affectation XOR-ing ( ^=)

function f(a, b, c) {
  d = a;
  d -= b;
  d = d >= 0;

  a *= d;  //a = a if (a>=b), else 0
  d ^= true; //invert d
  b *= d;  //b = b if (b<a), else 0

  a += b;  //a is now max(a,b)

  d = a;
  d -= c;
  d = d >= 0;

  a *= d;  //a = a if (a>=c), else 0
  d ^= true; //invert d
  c *= d;  //c = c if (c<a), else 0
  a += c;  //a is now max(max(a,b),c)

  return a;
}

Si ces affectations comptent réellement, le score est de 14 :)