Se débarrasser de laide si les déclarations

J'ai ce vilain code:

if ( v > 10 ) size = 6;
if ( v > 22 ) size = 5;
if ( v > 51 ) size = 4;
if ( v > 68 ) size = 3;
if ( v > 117 ) size = 2;
if ( v > 145 ) size = 1;
return size;

Comment puis-je me débarrasser de plusieurs instructions if?

Avez-vous vraiment dire, 5 et 6 pour être dans cet ordre?
Non, je n'ai pas, mon erreur.
FWIW, je ne pense pas que c'est particulièrement laid. Il est facile de voir ce qui se passe, il est facile d'ajouter en plus de cas, c'est clair. La seule chose que j'avais envisager de le faire est d'ajouter une liste où les valeurs sont stockées, mais à part ça, je n'ai pas de problème avec ça.
Toutes ces réponses et aucun on a choisi un switch, qui est clairement plus adapté pour cela.
Comment alors? Ce n'est pas une '==' comparaison.
Ce code n'est pas laid! Un "amateur" solution ne fera que rendre votre code plus illisible et difficile à maintenir dans le futur.
Je ne vois pas pourquoi un interrupteur de 145 cas est moins moche. Regardez de plus près, un > est utilisé comme équation, pas ==.
Donc, ce n'est que le code ne s'v <= 10?
sans doute un cas de défaut?
Vous ne mentionnez pas où vous avez besoin de ce type de code. Tous ces numéros de magie, je me demande où est-ce utilisé.
Cette question est liée au quotidien WTF (donc beaucoup de points de vue): forums.thedailywtf.com/forums/p/20192/234306.aspx On a plus a suggéré un switch à l'intérieur d'un while, qui n'a pas de réponse avant dans cette rubrique. Je ne sais pas si je l'aime plus que l'opérateur ternaire un. Il est également moins efficace.
le commutateur à l'intérieur du while est énorme, les frais généraux (ouais je sais, je devrais en parler). Le comparant est le chemin à parcourir, qui jamais vous le faites. Mais imaginez le gaspillage de cycles pour une boucle si le nombre où les plus éloignées.
Pour ceux qui sont tentés de prendre la boucle-et-conception de commutateur au sérieux ... c'est une blague! C'est l'une des DailyWTF classique de gags, comme enum BOOL { TRUE, FALSE, FILE_NOT_FOUND };. (Ouais, je sais, expliquant la plaisanterie est boiteux. Mais je ne veux pas de maintenir le code de certains mauvais sap qui l'a pris au sérieux.)
IMO ce qui est laid sur le code est l'utilisation de numéros de magie / codé en dur constantes. Pour mes yeux, les multiples IFs ne sont pas un problème, ils sont simple, efficace et lisible, les valeurs des constantes qui sont illisibles...
Cette question a suscité un assez grand nombre de créatrice des réponses qui sont toutes de mauvaises idées dans la vie réelle de la programmation...
Donc, beaucoup de upvotes sur une réponse simple à une question simple, lorsque la dur de questions et de réponses, ne pas obtenir de upvoted que beaucoup. Est StackOverflow dysfonctionnel?
Je vous remercie de votre commentaire, mais c'est le souhait et comme les autres ce qu'ils veulent faire.
La LISIBILITÉ sur if..then..else construction en Java(!?) Cette question est l'exemple parfait d'un morceau de code à titre d'exemple et toujours gérer pour faire un non-constructif/controverse/offtopic. Si vous n'aimez pas if..then..else - faites votre propre DSL de développement, si vous ne savez pas sur l'existence de l'interrupteur ... je suppose - apprendre Java mots-clés. Je ne peut que l'aider par downvoting
Donner une seconde pensée, cette question a sa propre façon de stimuler la créativité.. un très étrange et inhabituelle de l'effet (un codage concours sur mindless problème). Comment des tags à cette question "laid"?

InformationsquelleAutor kofucii | 2010-09-24

coding-style java

75
```
if ( v > 145 ) size = 1;
else if ( v > 117 ) size = 2;
else if ( v > 68 ) size = 3;
else if ( v > 51 ) size = 4;
else if ( v > 22 ) size = 5;
else if ( v > 10 ) size = 6;

return size;     
```
Ce qui est mieux pour votre cas.

En option, vous devez choisir l'Interrupteur Cas où la mesure du possible,

Update:
Si vous avez analysé la valeur de 'v' en général réside dans le bas de la fourchette(<10) dans la plupart des cas que vous pouvez ajouter ce.
```
if(v < 10)           size = SOME_DEFAULT_VALUE;
else if ( v > 145 )  size = 1;
else if ( v > 117 )  size = 2;
else if ( v > 68 )   size = 3;
else if ( v > 51 )   size = 4;
else if ( v > 22 )   size = 5;
else if ( v > 10 )   size = 6;   
```
further :
Vous pouvez également modifier la condition de la séquence, en fonction de votre analyse. Si vous savez que la plupart des valeurs sont inférieures à 10, puis, en second lieu, la plupart des valeurs se situent entre 68-117, vous pouvez modifier la condition de la séquence en conséquence.

Modifications:
```
if(v < 10)           return SOME_DEFAULT_VALUE;
else if ( v > 145 )  return 1;
else if ( v > 117 )  return 2;
else if ( v > 68 )   return 3;
else if ( v > 51 )   return 4;
else if ( v > 22 )   return 5;
else if ( v > 10 )   return 6;   
```
- "Optionnel, vous devez choisir l'Interrupteur Cas où la mesure du possible" pourquoi ?
- Il serait plus readable. Je ne dis pas qu'il est mieux vu de la performance, Il dépend de nombreux facteurs.
- Mieux encore: il suffit de retourner la valeur immédiatement, sans l'aide d'intermédiaires size variable.
- Dans ce cas, l'instruction switch aurait 145 cas ou plus, et qu'il serait assez illisible. (Surtout si le lecteur a besoin de considérer le cas où le programmeur a tapé un de ces numéros. Je suppose que c'est une sorte de tacite par "éventuellement", bien que je ne l'aurais pas formulé de cette façon.
- Je ne pense pas que le commutateur est nettement plus lisible, vous avez à regarder dehors pour instruction de saut et de tomber. Très utile, mais pas aussi simple que "si".
- Il sera si vous le formater correctement je pense
- Saarsoo Il est plus pratique d'avoir une seule instruction de retour
- J'ai entendu dire que la meilleure pratique tout le temps, mais quand elle rend le code maladroit, il semble ridicule à moi. Avez-vous des preuves à l'appui de cette affirmation qu'il est en fait mieux? Remarque ce n'est pas la même chose que "c'est le consensus que c'est la meilleure pratique", mais quelque chose qui prouve que c'EST la meilleure pratique.
- J'aime le Javascript de la mise en œuvre de switch mieux: vous pouvez faire switch(true) {case size > 146: ... case size > 117: ...
- Cette "meilleure pratique" est tout à fait subjective et plus probablement obsolète (car c'est un retour aux jours de langages comme C le cas, vous devez explicitement gérer les ressources). Il y a beaucoup de moments lorsque vous obtenez beaucoup plus lisible et maintenable code par plusieurs instructions return. Smart compilateurs de prendre soin de tout le reste. Voir consultingblogs.emc.com/anthonysteele/archive/2008/07/14/...
- Quelle est la valeur qui est renvoyée lorsque v == 9 ?
- c'est hors de propos. java du commutateur ne fonctionne pas de cette façon, que vous le vouliez ou non...
- Évidemment size est de retour 😀
- ce n'est pas un problème avec le compilateur de ne pas comprendre, plusieurs retour des déclarations de rendre le code moins compréhensible.
- moins compréhensible que d'utiliser des tonnes de inutile d'étapes intermédiaires pour l'amour de code de "pureté"?
- C'est les programmeurs que le code est lisible ou pas lisible, pas rigide Stalanist orthodoxies qui doivent être respectées.
- Auriez-vous peut-être dire Stalinienne? Je ne me souviens pas d'assassiner des millions de personnes innocentes, tout récemment, mais ma mémoire n'est pas aussi bon qu'il était une fois... @ninjalj si il prend de nombreuses étapes, qui est une indication de la mauvaise conception du code.
- Oui, c'était une faute de frappe, et pourtant c'était une métaphore pour s'en tenir à quelques-en-pierre de l'idéologie plutôt que d'être pragmatique et de l'aide, peu importe l'approche la mieux adaptée à la situation.
- votre méthode recommandée fait un pas de trop, d'enregistrer le résultat de retour à une variable temporaire. C'est encore plus laid lorsqu'il est utilisé dans les boucles.
- Je ne dis pas que c'est bon ou mauvais, mais de son mieux pour garder un standard, personnellement, je le suivre, Il va rendre le code plus lisible je ressens.
- Je pense que le fait de revenir tout de suite quand c'est ce que vous avez l'intention de rendre le code plus lisible." Si nous définissons la lisibilité que la rapidité avec laquelle la structure et les intentions du code sont fait évident pour le lecteur, puis stratégique renvoie sens pour moi. Le attente ce code va retourner à la fin d'une procédure est le problème, et un artificiel qui rend la programmation plus laborieuse. Il appelle un standard n'est pas raisonnable. On pourrait alterner Majuscules et de l'appeler un standard, mais ce ne serait pas le rendre raisonnable.
- S'il y a plusieurs naturel de points de sortie dans une fonction (qui devrait déjà être pas beaucoup de pages ou c'est la violation d'autres principes utiles), le travail nécessaire pour réaliser "souhaité la sortie de l'état" à la fin de la fonction, tout devient plus complexe. Elle rend aussi plus difficile à assurer la fonction est d'effectuer correctement car toutes les branches de l'écoulement à travers l'ensemble de la chose et certaines conditions peuvent être complexes. Dans le code, dans cette question, renvoie à fait logique, car rien n'est fait par la suite! Nul ne pourrait obtenir confus au sujet de ce qui se passe ici.
- Ici, il sera lisible mais je parle de flux complexe, là, je crois qu'il faudrait une instruction de retour. Il sera également vous aider à tout debugning.
- Votre affirmation "Il est plus pratique d'avoir une seule instruction de retour" a été mondiale. Si vous n'avez plus à penser que c'est une règle globale tous devraient suivre, eh bien, plus de puissance pour vous. 🙂
- J'Ai regardé @ stackoverflow.com/questions/36707/... ,plus aucun de programmeurs préfèrent, je dirais dans un complexe de flux, je vais rester avec elle/
- La meilleure pratique n'est pas la même que la plupart de la pratique courante. Je suppose que nous avons juste à être en désaccord. 🙂
- en faveur de org.life.java déclaration, je dirais que même si il a suggéré des "meilleures pratiques" est subjective (note de biais: j'adhère à elle aussi), il fait des tests et le débogage est plus facile en vous permettant de contrôler qu'un seul point de sortie (vous allez dire des cours de langue/IDE combinaison, ils contrôlent la fonction des points de sortie, mais ce n'est pas toujours le même. C'est donc un de ces "plus petit dénominateur commun" de la pratique.)
- Je l'ai trouvé plus lisible en tout cas:-)
- peut-être, mais c'est le caractère subjectif de la partie 🙂 Ma principale raison est "moins de code, moins de bug", et je préfère unique des points de sortie pour la traçabilité lors de l'ajout de déclaration logging (besoin d'un seul au lieu de N, excepté en cas d'utilisation de l'AOP) ou de débogage. En Plus en fin de compte, la plupart des compilateurs produirait le même code machine, de sorte que l'optimisation n'est pas vraiment une raison valable ici.
- d'accord .
- [SEULEMENT POUR CEUX AVEC UN SENS DE l'HUMOUR] Pour les puristes là-bas, seul les points de sortie sont incompatibles avec la gestion des exceptions. Essayer d'attraper chaque exception conduirait à attraper-bloc de code de ballonnements et de séparer le retour loin du corps de la méthode. Par souci de lisibilité (aka seul point de sortie), le code se termine illisible(rempli avec de catch). L'unique point de sortie' approche est subjective. Juste dire aux gens "je préfère ça" et revenir au codage. Pas raisonnable programmeur à contrecoeur une préférence lorsqu'elle est formulée de cette façon.
- La LISIBILITÉ sur if..then..else construction en Java(!?) Cette question est l'exemple parfait d'un morceau de code à titre d'exemple et toujours gérer pour faire un non-constructif/controverse/offtopic. Je suppose que si vous n'aimez pas if..then..else - faites votre propre DSL de développement, si vous ne savez pas sur l'existence de l'interrupteur - apprendre Java mots-clés ou de retravailler le problème. Je ne peut que l'aider par downvoting
InformationsquelleAutor Jigar Joshi
160

Comment une telle approche:
```
int getSize(int v) {
    int[] thresholds = {145, 117, 68, 51, 22, 10};

    for (int i = 0; i < thresholds.length; i++) {
        if (v > thresholds[i]) return i+1;
    }
    return 1;
}
```
Fonctionnellement: (Démontré en Scala)
```
def getSize(v: Int): Int = {
  val thresholds = Vector(145, 117, 68, 51, 22, 10)
  thresholds.zipWithIndex.find(v > _._1).map(_._2).getOrElse(0) + 1
}
```
- Bonne chose à propos de cette approche est qu'il peut être facilement étendu à plus d'étapes ou plus large éventail sans trop d'effort.
- +1 c'est le plus élégant de la non-orientée objet en solution ici 🙂
- Manque une dernière instruction de retour, ce ne compile pas (en java)
- +1 assez bon. @seanizer - une fois que vous obtenez pour le matériel, c'est tout non-OO de toute façon 😉
- Bon appel... certainement pas quelque chose que j'ai vu avant.
- +1, Très intelligent. Mais moins lisible au premier coup d'oeil à mon humble avis.
- J'aime bien, aussi. Juste pour être sûr que je mettrais un commentaire au cas où quelqu'un ajoute/modifie steps sans se rendre compte de l'ordre est important. Alternativement, un tri inverse sur steps avant la boucle pourrait fonctionner, trop.
- Je serais retournée 6 et pas 1 à la fin si il n'y a pas de match (alors qu'il y a un bug dans la mise en œuvre originale if v <= 10)
- C'est moins lisible. Avec le if/elseif solution le code est immédiatement compréhensible. Ce code, bien que faciles à comprendre, exige toujours une petite pensée pour grok. Exactement le même nombre de lignes de code, mais nécessite un tout petit peu plus d'effort pour le lire == moins de solution optimale de l'OMI.
- Je n'aime pas l'idée, ce que si vous devez changer et pour 22 retour 17 et 51 retour 50? le code ne change pas et c'est un entretien cauchemar.
- Je dois dire que j'ai eu à réfléchir plus de temps à comprendre le code d'origine que j'ai eu avec cette boucle.
- faire la boucle d'une recherche binaire et que vous êtes encore mieux
- Si c'était un nombre arbitraire qui pourrait être un sujet de préoccupation, mais l'idée de seuils (pensez à des niveaux d'expérience au sein d'un jeu, ou des limites d'alertes sur la valve de pression) dicte les niveaux sera séquentielle et non-cumul.
- exemple requiremtn - si vous payer plus de 200 $le code de l'ajout de deux niveaux. si vous avez atteint le niveau 100, vous obtenez 2 niveaux supplémentaires. juste 2 supplémentaire de l'ifs, droit?
- Oui et non. Vous avez besoin de personnes supplémentaires si énoncés dans le code d'origine ainsi. Le point de la poste est de remplacer le if avec un tableau de valeurs à la recherche (qui s'étend en fait à une recherche binaire au lieu d'une recherche linéaire, mais c'est un exercice pour le lecteur). Rouler dans une boucle ne résout pas tous les problèmes, mais il élimine la nécessité pour les passe-partout si consolidés. (Ironie du sort, il sera probablement déroulé par le compilateur, mais c'est une autre histoire.)
InformationsquelleAutor mfloryan
88

À l'aide de la NavigableMap API :
```
NavigableMap<Integer, Integer> s = new TreeMap<Integer, Integer>();
s.put(10, 6);
s.put(22, 5);
s.put(51, 4);
s.put(68, 3);
s.put(117, 2);
s.put(145, 1);

return s.lowerEntry(v).getValue();
```
- Si vous laissez les clés que l'OP n'a, vous pouvez utiliser lowerEntry au lieu de floorEntry. De cette façon, les données sont cohérentes w/ OP.
- Merci, j'ai édité la réponse à l'aide de lowerEntry
- très belle solution de (+1), en fait je dirais que c'est le seul non-laid solution ici
- Eh bien, pas du tout laid jusqu'à ce que vous regardez à la surcharge.
- Je pense que HashMap serait la meilleure solution si vous êtes à la fixer à l'aide de la carte seulement.
- Un HashMap ne fonctionne pas ici. NavigableMap permet de trouver le plus proche de clé (inférieure ou supérieure) pour une valeur donnée, ce qui est important dans notre cas.
- J'avoue que je ne voudrais pas utiliser ma solution dans ce cas simple, mais plutôt un tas de if. Toutefois, si une certaine souplesse est nécessaire (par exemple, si ces chiffres ne sont pas codées en dur, mais venir à partir d'un fichier de configuration), puis cette solution est logique. De Plus, cette solution peut être utile si la touche "f" de mon clavier est cassé 🙂
- il y a bien toujours un compromis entre le code de la convivialité et de la performance. C'est très utilisable code orienté objet, ce qui, naturellement il n'y a surcharge. Si vous ne voulez pas de frais généraux, le bâton avec if/else horreur.
- C'est effectivement une très laid solution. Le plus simple est toujours la meilleure. Pourquoi voudriez-vous d'abus TreeMap pour simuler l'ifs? Une solution générale est de mettre les valeurs dans un tableau et faire binaires de recherche.
- Les règles de l'Abstraction: Règle 1: Ne pas le faire. Règle 2 (pour les experts uniquement): ne le faites pas encore.
- Il n'y a rien de particulièrement orientée objet sur l'utilisation d'un hachage de la carte ou équivalent. J'ai été en utilisant ces types de structures de données avant, j'ai même pris la moindre bouffée de la programmation orientée objet en arrière dans les années '80.
- C'est plus orienté-objet l'utilisation d'un objet personnalisé (voir ma solution), mais moins orienté objet à utiliser si/d'autre blocs. Et je doute que vous avez utilisé quelque chose de semblable à la java interface de carte il y a 20-30 ans. Oui, vous avez probablement utilisé les tables de hachage, mais vous ne disposez pas d'une interface propre qui les résumés des travaux en-dessous (qui ne sont pas l'équivalent, il existe de grandes différences entre les valeurs de hachage et basée sur l'arbre de recherche).
- si vous pensez que oui, alors la programmation orientée objet est clairement pas le bon concept pour vous (et donc de java n'est pas la bonne langue)
- Intéressant morceau de code, je n'avais jamais vu NavigableMap avant. Bonne chose à savoir, merci.
- J'aime la POO, mais je pense que vous allez un peu aussi de loin avec celui-là. Je veux dire, la configuration d'un structure de données et navigation c'est juste pour faire un peu de plage de chèques?
- s'il vous plaît apprendre un peu d'histoire, et, de préférence, une théorie trop. Résumé des types de données ne nécessitent pas de programmation orientée objet, et le concept de la présentation d'une interface propre qui les résumés des travaux dessous a été autour depuis au moins 50 ans.
- Je pense que c'est ce qui pue à propos de java: il vous donne le choix de faire les choses de la programmation orientée objet ou non. Si java ont été un véritable langage de programmation orientée objet (et n'essayez pas d'être un C dialecte et un langage de programmation orientée objet en même temps) tout serait un objet, il n'y aurait pas de primitives et de là, il n'y aurait pas de dois-je utiliser de la POO ici question.
- savoir beaucoup au sujet de l'histoire, Ne savent pas beaucoup la biologie, Ne savent pas beaucoup au sujet d'un livre scientifique, Ne savent pas beaucoup sur le français, j'ai pris ... Résumé des Types de Données ne nécessitent pas de POO, et je n'ai jamais dit non plus. Il serait beaucoup plus facile de faire ce genre de code dans un langage fonctionnel comme Haskell ou Erlang et même dans un preudo-fonctionnel comme Scala ou Groovy. Mais le sujet est Java et Java, la programmation orientée objet est la façon la plus élégante pour aller.
- les frais généraux? peut-être pour les 6 valeurs... mais dans la grande image, le navigables de la carte à l'échelle belle et la enchaînés si les autres ne le seront pas. Si vous voulez quelque chose de plus efficace codé en dur, le si-d'autre aura besoin d'avoir une structure d'arbre pour effectuer un équivalent binaire de recherche.
- Si vous êtes dans une position où vous êtes, même les chaînes de six if/else (ou leur équivalent), vous avez besoin de retravailler votre conception rapidement dans 99.44% des cas.
- Je ne reçois pas votre point de vue. Il y a beaucoup de choses là-bas qui ne suivent pas simple et les règles ordinaires et doivent être mappés ou regardé avec des tables/switch/si-d'autre ou quoi que ce soit.
InformationsquelleAutor barjak
81

Le problème le plus évident avec l'OPs solution est de ramification, je vous suggère une régression polynomiale. Il en résultera une belle dépourvu de branches expression sur le formulaire
```
size = round(k_0 + k_1 * v + k_2 * v^2 + ...)
```
Vous bien sûr de ne pas obtenir un résultat exact, mais si vous pouvez tolérer de la déviance, c'est une très performant alternative. Depuis la " un congé non modifié le comportement de la fonction originale de valeurs où v<10 est impossible de modèle avec un polynôme, j'ai pris la liberté d'en supposant un maintien d'ordre zéro interpolation pour cette région.

Pour un 45-polynomiale de degré avec les coefficients suivants,
```
-9.1504e-91 1.1986e-87 -5.8366e-85 1.1130e-82 -2.8724e-81 3.3401e-78 -3.3185e-75  9.4624e-73 -1.1591e-70 4.1474e-69 3.7433e-67 2.2460e-65 -6.2386e-62 2.9843e-59 -7.7533e-57 7.7714e-55 1.1791e-52 -2.2370e-50 -4.7642e-48 3.3892e-46 3.8656e-43 -6.0030e-41 9.4243e-41 -1.9050e-36 8.3042e-34 -6.2687e-32 -1.6659e-29 3.0013e-27 1.5633e-25 -8.7156e-23  6.3913e-21 1.0435e-18 -3.0354e-16 3.8195e-14 -3.1282e-12 1.8382e-10 -8.0482e-09 2.6660e-07 -6.6944e-06 1.2605e-04 -1.7321e-03 1.6538e-02 -1.0173e-01 8.3042e-34 -6.2687e-32 -1.6659e-29 3.0013e-27 1.5633e-25 -8.7156e-23 6.3913e-21 1.0435e-18 -3.0354e-16 3.8195e-14 -3.1282e-12 1.8382e-10 -8.0482e-09 2.6660e-07 -6.6944e-06 1.2605e-04 -1.7321e-03 1.6538e-02 -1.0173e-01 3.6100e-01 -6.2117e-01 6.3657e+00
```
vous obtenez une belle courbe ajustée:

Et comme vous pouvez le voir, vous obtenez un 1-norme d'erreur de seulement de 1,73 à travers l'ensemble de la gamme de 0 à 200*!

*Les résultats de v∉[0,200] peut varier.
- J'aime cela parce que j'ai toujours aimé venir avec des expressions "pack" les données d'une recherche dans des expressions mathématiques. Prendre quelques constantes, jeter un peu de multiplication, addition, le module abs(), floor(), et ainsi de suite, et vous pouvez faire des choses amusantes pour calculer des choses comme le nombre de jours dans chaque mois. Mais je ne l'ai jamais considéré comme un polynôme pour ce genre de chose!
- Wow! Pourriez-Vous donner plus de détails sur les outils que Vous avez utilisés pour produire la sortie?
- Comment avez-vous trouver les coefficients? C'est une avancée en mathématiques?
- C'est juste un polynôme de régression, voir en.wikipedia.org/wiki/Polynomial_regression. J'ai utilisé Octave à écrire la fonction de sortie calculées et un meilleur ajustement à l'aide de la fonction polyfit.
- Si vous tour la plus proche int après calcul, vous devriez obtenir près des résultats parfaits.
- +1 très bonne, mais ce sera un peu dur de comprendre ce qu'il fait et plus difficile à maintenir.
- C'est ainsi que la Programmation Fonctionnelle œuvres?
- Drôle, mais horribe.
InformationsquelleAutor Alexander Torstling
51
```
return v > 145 ? 1 
     : v > 117 ? 2 
     : v > 68 ? 3 
     : v > 51 ? 4 
     : v > 22 ? 5 
     : v > 10 ? 6 
     : "put inital size value here";
```
- Ahhhh! Mes yeux! Mes yeux!
- Êtes-vous pour de vrai? C'est nettement plus illisible, et de ne pas trivial à changer si les règles de 'taille' changement.
- pourriez-vous veuillez lire la question initiale? "Comment puis-je me débarrasser de plusieurs instructions if?" Il n'existe pas de "si" énoncés dans ma réponse comme vous pouvez le voir.
- bien sûr, vous avez supprimé la if's mais l'op déclaré que son code était ugly, et destiné à le rendre plus lisible...avez-vous fait croire que c'est plus joli...?
- La question d'origine était probablement destiné à être "Comment puis-je me débarrasser de plusieurs instructions if sans avoir recours à de très laid code" 🙂
- Il n'est techniquement répondre à la question sur la façon de se débarrasser de "si" les déclarations, mais il augmente le "laid" facteur par quelques ordres de grandeur.
- Simplement considérée comme une ligne de caractères sans signification, il est en fait assez régulière et prévisible. Certains considèrent que pour être jolie!
- J'ai ajouté quelques retours à la ligne. La lisibilité entre les démarreurs est toujours discutable.
- Je pense que le code en question, c'est moche et n'a pas de sens donc, la meilleure solution est de le rendre aussi petit et compact que possible afin de ne pas importuner les yeux (je l'espère, quelques options développeur de le supprimer dans le futur le plus proche). En plus de tout, cette fonction (probablement, c'est une fonction) doit être insérée. Et c'est mieux de le faire d'une manière concise, plutôt que par humpty-dumpty beaucoup de-lignes-de nombreux supports de code.
- Jésus-Christ, qu'avez-vous fait avec mon code?! Il était destiné à être sur une seule ligne! (voir pourquoi dans mon commentaire précédent)
- Vous êtes me confondre avec quelqu'un d'autre. Mon nom est Bauke Scholtz, pas Jésus-Christ. Comme dit dans un commentaire, j'ai ajouté quelques retours à la ligne. Il est moins moche et améliore la lisibilité.
- Sûrement, si jamais il y avait un code qui justifie de prendre le nom du Seigneur en vain, c'est elle!
- se sentir libre si pour restaurer le modifier de sorte que vous pouvez manger downvotes 🙂 venait d'être utile.
- haha oui! Je l'aime, et il ne devrait pas être difficile à lire pour quelqu'un qui connait la syntaxe 😀
- J'aime ce formulaire et de le trouver lisible, même si je reconnais que la plupart des gens ont un problème avec elle. Je ne vois pas pourquoi quelqu'un qui comprenne les enchaînés if/else-if/else construire a un problème avec la enchaînés ternaire ?: de l'opérateur. Ils sont parfaitement parallèles l'un à l'autre.
- Si rien d'autre, ce formulaire vous oblige à écrire ce que le "défaut" est. +1
- Je trouve cela beaucoup plus facile à lire que les acceptée si/d'autre-si la réponse, grâce à Balus' reformatage. Je suis d'accord avec Bert, oui, les gens semblent avoir un problème avec cela; je ne comprends pas pourquoi les gens à trouver le ternaire ?: de manière cryptique. D'accord avec badp trop, ni l'OP du code ou de la accepté de répondre à face avec une valeur par défaut "autrement" cas.
- P — je pense ternaire lui-même finit par sembler énigmatique simplement parce que c'est plus de l'anglais que nous avons l'habitude. Mais même moi, être familier avec et probablement trop ternaire de la syntaxe, de se confondre par essayer de comprendre comment le processus de enchaînés ternaire. J'ai peut mémoriser que c'est son comportement, même si, pour référence future.
- Dans le reformaté, c'est plus agréable et plus lisible qu'une chaîne de si/elses. Comme pour embrouiller les gens qui ne comprennent pas l'opérateur ternaire -- eh bien, ceux qui ne comprennent pas ?: mais il faut drôlement bien apprendre, et tous ceux qui vous ne pouvez pas apprendre a clairement des problèmes plus profonds en tant que programmeur.
- qui de vous mettre en charge de décider wbat un programmeur doit apprendre? L'opérateur ternaire est un joli gadget pour une ligne switch, mais il rend le code moins lisible et à mon humble avis, cette solution est horrible abus de celle-ci
- Bon, évidemment, un programmeur doit apprendre l'ensemble de la langue (au moins les bases), il ne peut y avoir débat sur ce sujet. De plus, il s'agit d'un idiome à traiter avec les enchaînés-fi que le simple fait de sélectionner une valeur et loin d'être un abus c'est un parfait cas d'utilisation. Je préfère votre (apparemment très controversée, mais pourquoi m'échappe) de la solution, mais à peine.
- Je me souviens d'une règle de style quelque part que recommandé de ne pas nidification ternaires. Ne peut pas se rappeler où il était, cependant.
InformationsquelleAutor dhblah

Le code d'origine semble bien pour moi, mais si vous n'avez pas l'esprit de plusieurs retours que vous pourriez vous préférez l'approche tabulaire:

if ( v > 145 ) return 1;
if ( v > 117 ) return 2;
if ( v >  68 ) return 3;
if ( v >  51 ) return 4;
if ( v >  22 ) return 5;
if ( v >  10 ) return 6;
return ...;     //The <= 10 case isn't handled in the original code snippet.

Voir les multiples de retour ou pas de discussion dans org.life.java's réponse.

InformationsquelleAutor Jim Ferrans

17

Il y a une tonne de réponses et suggestions ici, mais honnêtement, je ne vois pas l'un d'eux "plus joli" ou "élégante" que la méthode d'origine.

Si vous avez eu des dizaines ou des CENTAINES d'itérations pour vérifier que je pouvais facilement voir s'en aller de certains de boucle, mais honnêtement, pour la poignée de comparaisons que vous avez eu, le bâton avec les si de et de progresser. Il n'est pas laid.
- D'accord. Mais ces questions est de laisser les gens montrent des solutions de rechange. Par exemple, je n'avais jamais entendu parler de NavigableMap.
- Bien que vous avez probablement entendu parler d'un TreeMap, mais vous ne savez pas qui les interfaces qu'il implémente 🙂
- D'accord... Prendre un bon coup d'oeil dur à votre première révision et juste dire à vous-même, [gants]. [gants]: thedailywtf.com/Articles/The_Complicator_0x27_s_Gloves.aspx Edit: Pourquoi est-ce à étouffer la Démarque de l'analyseur?!
InformationsquelleAutor cbmeeks
14
```
return (v-173) / -27;
```
- btw, il n'est pas correct, qu'une approximation
- +1 parce que c'est une approche intéressante. (173-v) / 27 pour supprimer le -. Il ne fonctionne pas pour les grands nombres, et à proximité de l'un des seuils. Mais intéressant...
- Quelle est la formule derrière tout cela?
- lol +1 je veux vous présenter certains ce type de code dans un environnement de production, comme une blague ^_^
InformationsquelleAutor mhaller
12

Voici ma chance...

Mise À Jour: Correction. Solution précédente a donné les réponses incorrectes pour les valeurs exactes (10,22,51...). Ce défaut de paiement d'un de 6 pour le si val < 10
```
   static int Foo(int val)
    {
                          //6, 5, 4, 3, 2 ,1
        int[] v = new int[]{10,22,51,68,117,145};
        int pos = Arrays.binarySearch(v, val-1);
        if ( pos < 0) pos = ~pos;
        if ( pos > 0) pos --;
        return 6-pos;
    }
```
- J'étais sur le point de poster une solution comme la vôtre, à l'aide de binarySearch. +1 pour l'utilisation de la ~ opérateur sur binarySearch résultat, je n'ai jamais pensé à ce sujet. Remarque : vous pouvez vous débarrasser de la size tableau, il n'est pas 5,6 mais de 6,5.
- Il est intelligent, mais à mon humble avis moins clair que l'original.
- je suis d'accord. Ce n'est pas, était d'offrir une alternative.
- +1 pour une solution qui fonctionne rapidement pour grands ensembles de données, et n'a pas plus de ressources que l'original pour les petits jeux de données.
InformationsquelleAutor st0le
11

Je n'ai plus de version pour vous. Je ne pense pas vraiment que c'est le meilleur, car cela ajoute à la complexité inutile, au nom de la "performance" quand je suis 100% sûr que cette fonction ne sera jamais un rendement de porc (à moins que quelqu'un est le calcul de la taille dans une boucle serrée, un million de fois ...).

Mais je présente ce tout simplement parce que j'ai pensé que l'exécution d'un hard-codé binaire de recherche à d'intéressants. Il n'a pas l'air très binaire-y, car il n'y a pas assez d'éléments pour aller plus en profondeur, mais il a le mérite de il renvoie un résultat en moins de 3 tests au lieu de 6 comme dans le post original. Le retour des déclarations sont également dans l'ordre par la taille, ce qui contribuerait à la compréhension et/ou de modification.
```
if (v > 68) {
   if (v > 145) {
      return 1
   } else if (v > 117) {
      return 2;
   } else {
      return 3;
   }
} else {
   if (v > 51) {
      return 4;
   } else if (v > 22) {
      return 5;
   } else {
      return 6;
   }
}
```
- Efficace et original (+1), mais un entretien cauchemar
- Clairement un entretien cauchemar. Mais c'était amusant de penser! 🙂
- Si vous utilisez un mécanisme de génération de code pour construire automatiquement cela pourrait en fait être assez bon.
- Je vous souhaite la bienvenue downvotes, mais SOUHAITE que vous commentaire pourquoi, s'il vous plaît?
- upvoted parce que j'ai aussi dit que dans un autre commentaire, mais j'étais trop paresseux pour publier la réponse xD
InformationsquelleAutor ErikE
7
```
7 - (x>10 + x>22 + x>51 + x>68 + x>117 + x>145)
```
où 7 est la valeur par défaut (x <= 10).

Edit: au départ, je ne savais pas que cette question est au sujet de Java. Cette expression n'est pas valide en Java, mais qu'il est valide en C/C++. Je vais laisser la réponse, car certains utilisateurs ont trouvé très utile.
- La question est balisé de Java, pas de C/C#/C++.
- Ce n'est PAS valide en C#. Vous ne pouvez pas ajouter des Booléens.
- Merci, il fixe. J'ai mal interprété le commentaire concernant le C/C#/C++.
InformationsquelleAutor George
5

Mon commentant capacité n'est pas encore, espérons que personne ne va dire "à juste titre" basé sur de ma réponse...

Jolie-ing le laid code pourrait/devrait être défini comme essayer de réaliser:
1. La lisibilité (OK, une lapalissade -- redondant à la question peut-être)
2. Performance -- au mieux la recherche optimale, au pire c'est pas un gros drain
3. Pragmatisme -- il n'est pas loin de la façon dont la plupart des gens à faire des choses, étant donné un problème ordinaire qui n'est pas dans le besoin d'un élégant ou de solution unique, le changer plus tard doit être naturelle effort, pas besoin de beaucoup de recueillement.
De l'OMI, la réponse donnée par org.life.java était la plus jolie et très facile à lire. J'ai bien aimé aussi l'ordre dans lequel les conditions ont été écrits, pour des raisons de lecture et de performance.

Regardant par-dessus tous les commentaires sur ce sujet, au moment de mon écriture, il semble que seule org.life.java soulevé la question de la performance (et peut-être mfloryan, trop, indiquant quelque chose "de plus"). Certainement, dans la plupart des situations, et compte tenu de cet exemple, il ne devrait pas porter un ralentissement notable toutefois vous l'écrivez.

Cependant, en regroupant vos conditions et de manière optimale la commande les conditions peuvent améliorer les performances [utile, en particulier si cette boucle].

Tout cela étant dit, la nidification et des conditions de commande (qui sont plus complexes que l'exemple) apportées par la détermination de réaliser aussi vite que possible l'exécution sera souvent moins lisible le code, et le code qui est plus difficile à changer. Je me réfère de nouveau à #3, pragmatisme... en équilibrant les besoins.

InformationsquelleAutor Chris Adragna
5

Ici est un objet-orienté solution, une classe appelée Mapper<S,T> que les cartes de valeurs à partir de n'importe quel type qui implémente comparable à n'importe quel type de cible.

Syntaxe:
```
Mapper<String, Integer> mapper = Mapper.from("a","b","c").to(1,2,3);

//Map a single value
System.out.println(mapper.map("beef")); //2

//Map a Collection of values
System.out.println(mapper.mapAll(
    Arrays.asList("apples","beef","lobster"))); //[1, 2, 3]
```
Code:
```
public class Mapper<S extends Comparable<S>, T> {
private final S[] source;
private final T[] target;
//Builder to enable from... to... syntax and
//to make Mapper immutable
public static class Builder<S2 extends Comparable<S2>> {
private final S2[] data;
private Builder(final S2[] data){
this.data = data;
}
public <T2> Mapper<S2, T2> to(final T2... target){
return new Mapper<S2, T2>(this.data, target);
}
}
private Mapper(final S[] source, final T[] target){
final S[] copy = Arrays.copyOf(source, source.length);
Arrays.sort(copy);
this.source = copy;
this.target = Arrays.copyOf(target, target.length);
}
//Factory method to get builder
public static <U extends Comparable<U>, V> Builder<U> from(final U... items){
return new Builder<U>(items);
}
//Map a collection of items
public Collection<T> mapAll(final Collection<? extends S> input){
final Collection<T> output = new ArrayList<T>(input.size());
for(final S s : input){
output.add(this.map(s));
}
return output;
}
//map a single item
public T map(final S input){
final int sourceOffset = Arrays.binarySearch(this.source, input);
return this.target[
Math.min(
this.target.length-1,
sourceOffset < 0 ? Math.abs(sourceOffset)-2:sourceOffset
)
];
}
}
```
Edit: finalement remplacé la méthode map() avec un plus efficace (et plus court) version. Je sais: une version qui recherche les partitions serait encore plus rapide pour les grands tableaux, mais je suis désolé: je suis trop paresseux.

Si vous pensez que c'est trop lourd, pensez à ceci:
1. Il contient un constructeur qui vous permet de créer le Mapper à l'aide de varargs de la syntaxe. Je dirais que c'est un must-have pour la facilité d'utilisation
2. Il contient à la fois un élément unique et une collection de méthode de cartographie de l'
3. Il est immuable et donc thread-safe
Sûr, tous ces éléments peuvent être facilement enlevés, mais le code sera moins complet, moins utilisable ou moins stable.
- Trop compliqué.... pourquoi quelqu'un devrait impliquer des objets dans quelque chose d'aussi simple que de prendre des décisions sur les types primitifs?
- Ceci est conçu comme une solution généraliste. Dans ce cas simple, il peut être dessus, mais en plus avancé des cas d'utilisation (en regardant avec le dernier exemple que j'ai fourni) les avantages de l'utilisation de l'interface comparable sont énormes.
- Bien sûr, il serait encore mieux si vous pouviez passer à une coutume de comparaison, peut-être que je vais le retravailler pour qu'.
- Comment est-ce une amélioration par rapport à la NavigableMap-réponse? À tout le moins, si je voulais de cette interface, j'aurais enveloppé NavigableMap avant d'écrire quelque chose comme cela. Je serais curieux de voir un test de votre solution contre NavigableMap trop.
- Sainte Grace Hopper, quelle monstruosité est-ce? Ils avaient juste envie de le serrer un peu de Fi.
- perdre une référence par rapport à une bibliothèque standard utilisé par des millions d'utilisateurs n'est pas une honte, est-il? Voyons votre wrapper autour de NavigableMap... @user257493 à mon humble avis 6 n'est pas un peu. Si il y a plus de 2 si les clauses, le refactoring est un must. et si vous n'aimez pas l'objet-orienté solutions, peut-être que vous devriez coller avec un strictement procédurale des langages comme le c. btw, qui êtes-vous pour prendre grace hopper nom en vain?
- Prématuré de l'abstraction est la racine de tous les maux. Non... la perte d'un indice de référence de la bibliothèque standard n'est pas une honte. Rouler votre propre solution de de toute façon, sans avoir quelque chose au cours de la bibliothèque standard est une drôle de choix, et en particulier quand il signifie le remplacement de 6 if états avec 54 lignes de Java (sans compter le code à fait utilisation cette chose). D'ailleurs, quand était orientée objet en soi un avantage?
- si vous ne pensez pas être orientée objet est en soi un avantage, peut-être que vous devriez coller avec un non-langage oo. Java n'est pas c sans pointeurs, c'est un langage orienté objet (même si c'est pas propre). l'orientation de l'objet ne gagne rien au niveau de la machine, mais il rend le code lisible et réutilisable et réduit les bugs, car il est facilement vérifiable. Aussi: Si 10 des situations similaires se produisent dans une même base de code, alors ma solution peut être réutilisé comme un oneliner, tandis que si/d'autre solutions à base devrait être refaite entièrement.
- BTW, je suis en total désaccord avec votre point de vue à propos de l'abstraction. L'Abstraction est ce qui rend le code gérable.
- Croyez-vous sérieusement crois que c'est plus facile à gérer que l'original? Je suis pour la programmation orientée objet, lorsque cela a du sens, mais la chaîne de si les déclarations était déjà facile à lire et à modifier.
- Oui, tout comme je préfère une liste de tableaux sur un tableau. C'est une classe, vous pouvez définir une fois et l'utiliser pour de nombreuses fins différentes. Il est immuable, thread-safe et raisonnablement rapide, tout en étant extensible et réutilisable.
- L'Intuition de la lecture de votre code sans lire le Mappeur de la classe me font penser à de 10 cartes à 6, etc., qui n'est pas. Si je suis tombé sur ceci dans une base de code, je dois le lire et à comprendre votre classe (ou de sa documentation, aviez-vous pris la peine d'écrire tout) savoir ce que cela fait vraiment. Cela prend plus de temps que de comprendre une chaîne de if. Bien sûr, votre solution est plus générale, et même intelligent, mais qui a dit était nécessaire dans ce contexte?
- Même si vous étiez à inclure une coutume de comparaison, ce ne serait pas encore clair si votre mapper sera la "ronde" vers le haut ou vers le bas pour les seuils. Vous devez aller et regarder à l'intérieur de la classe. Étant donné que l' > opérateur a été soigneusement testé, je suis à paris vos collègues de travail serait plutôt l'utiliser. Aussi, il n'y a aucune indication que votre abstraction est même droit. Vous avez codé en dur le cas par défaut, et le > relation, alors que dans le même temps, en supposant que l'OP "pourrait" besoin de mettre des chaînes à une date ultérieure. Donné le nom de la variable "taille", qui semble juste comme une étrange hypothèse à faire.
- Même si je suis d'accord avec vous que d'autres réponses ici valent également le downvote.
- une solution comme celle-ci repose sur la documentation, c'est clair. 2 lignes de javadoc et chaque collègue de travail serait de voir immédiatement ce dont il s'agit, sans même quitter l'IDE. @chris je ne dis pas que les autres méritent un downvote, bien au contraire. Je suis en train de dire quand quelqu'un prend le temps d'élaborer une solution de travail qu'ils méritent un peu de respect parce qu'ils sont les gens qui maintenir ce site en vie. Mon propre politique est ceci: upvote ce que j'aime, downvote de la merde uniquement. Et si vous aimez ma solution ou pas, ce n'est certainement pas de la merde. Il est peut-être exagéré, mais il fonctionne
- N'est ce pas? Même après l'importation java.util.* votre code ne compile sur cette ligne dans le constructeur pour Mapper: final U[] copy = Arrays.copyOf(source, source.length);
- Désolé, j'ai refait le code dans le navigateur plus tôt et apparemment oublié de changer le nom d'une variable de type. Il devrait qork maintenant, tout comme la première version de travail (mais je n'ai aucun moyen de le tester en ce moment car il n'y a pas de jdk sur mon iphone)
- Travail, pas qork. Bien qu'il puisse également qork. Je vais le tester que lorsque je rentre à la maison. Btw, y compris les déclarations d'importation dans les listes est considéré comme le bruit inutile dans des cas évidents comme celui-ci.
- Cette compile, mais a des résultats inattendus: Mapper<Integer, Integer> map = Mapper.from(145, 117, 68, 51, 22, 10).to(1, 2, 3, 4, 5, 6); System.out.println(map.mapAll(Arrays.asList(11, 23, 52, 69, 118, 146))); retourne [1, 2, 3, 4, 5, 6] où je m'attends à tout à fait le contraire. Ce serait beaucoup plus facile de repérer et de corriger dans une chaîne de if.
- Inattendu? Depuis Comparable est utilisé en interne, tout autre comportement serait un non sens et potentiellement indécidable. E. g. Si vous avez demandé le programme à la carte 10,30,50,20,40 a, b, c, d et e de ce que vont faire avec la valeur d'entrée de 25? Vous devez trier les entrées premier à utiliser avec succès comparable. Et bien sûr, on pourrait l'étendre facilement à inverser l'ordre de tri quelque chose comme Mapper.descending().from(..).to(..), mais je préfère trier mes données d'entrée, comme c'est la plus intuitive de la façon de faire les choses.
- Ce qui est évident, c'est que cette solution s'appuie sur la documentation, mais qui est commune à toutes les solutions ici. (Je suppose que la demande de la cartographie sera utilisé dans plus d'un endroit et d'où sera stockée dans certains méthode statique dans le si/d'autre cas, tout comme il sera stocké dans une variable d'instance ou un singleton dans le cas de ma solution).
- De quoi parles-tu? Remarquez que je n'ai fait flip les deux tableaux... donc il devrait fournir le même résultat que votre exemple. Je vous remarquerez que trier le tableau d'entrée, mais pas le tableau de sortie... il semble que vous avez l'intention de permettre les conditions à préciser l'ordre, mais votre classe ne prend pas en charge cette. De ce fait, je ne peux pas écrire les conditions dans l'ordre naturel, ils seraient écrites dans une chaîne de if. Si c'est une fonction et pas un bug, cette classe vraiment besoins de documentation, j'ai un avis n'a pas été écrite.
- Une meilleure approche serait d'utiliser une triés carte d'une certaine variété dans la première place. Cela vous permettrait de trier les valeurs pour faire correspondre les clés, et les utilisateurs de votre classe peut fournir de l'entrée dans un ordre arbitraire. À tout le moins, cela devrait faciliter l'écriture de la situation dans leur ordre naturel (if (v > 145) /* ... */; else if (v > 117) /* ... */), depuis l'instruction if est au moins souple.
- Bien sûr, pas de doc a été écrit, c'est pas de logiciel, projet de la mine, mais une solution rapide, j'ai piraté en 20 minutes comme une tech demo. Tri le tableau d'entrée est nécessaire, comme je l'ai dit (et en accord avec la NavigableMap version), mais de tri le tableau de sortie serait de limiter les possibilités de cette version. "Ordre naturel" en Java signifie l'ordre créés par l'interface Comparable (lire download.oracle.com/javase/6/docs/api/java/lang/Comparable.html) et donc exactement ce que j'ai mis en place. Et c'est plus intuitif, trop. Je ne sais pas pour vous, mais je compte 1, 2, 3 3, 2, 1.
- Je ne dis pas que c'est la solution que tout le monde devrait l'utiliser, mais c'est une approche valable et certainement plus original que le if / else ennui nous avons tous appris à 30 ou 40 ans. Tout ce que je veux dire c'est: il n'y a plus d'une façon de faire, et qui vient d'une programmation orientée objet et assez fonctionnel de fond c'est le genre de solution que je préfère.
- Votre réponse a gagné type de prix: forums.thedailywtf.com/forums/p/20192/234306.aspx
- kewl. la fortune et la gloire, enfin. 🙂
- Étrangement, la réputation a disparu up depuis le WTF de l'article. Probablement pas ce que l'auteur avait en tête. Merci beaucoup, "Enterprise Architect".
- Nous ne pouvons pas facilement dire si cette réponse est trop ou pas parce que l'OP ne mentionne pas où il a besoin de ce type de code. Tous ces numéros de magie (dans le cas des OP question), je me demande où est-ce utilisé.
- Exactement. I suppose c'était une cartographie de l'importance qui serait utilisé dans plusieurs lieux et ont donc conçu une simple solution réutilisable qui peut être la dépendance injecté tous sur la place. Si c'est une chose, alors oui, bien sûr que c'est exagéré.
- si vous voulait battre le TreeMap, vous devriez avoir trié les tableaux et utiliser les binaires de recherche...
- Je ne veux pas battre le TreeMap. Le TreeMap est une bibliothèque standard de l'élément qui est en développement depuis des années. Mon code a été écrit en 20 minutes. Je dois être Jon Skeet pour gagner cette bataille. Cela dit, oui, bien sûr binaire de recherche serait une bonne idée.
- il y a eu assez de commentaires de gens qui, en fait, aimé ma solution, à la fois sur cette page et sur le WTF thread que je pense que je peux vivre à la fois avec cette possibilité avec votre propre sarcastique downvote.
- bien sûr...et c'est tout fait dans la bonne humeur. pour moi c'est juste un excellent exemple de l'entreprise de programmation où l'on prend quelque chose qui pourrait être fait beaucoup plus rapide, beaucoup plus lisible, et beaucoup plus simple sans POO et la métamorphoser en un résumé de la POO monstre. parfois, cela peut être nécessaire, mais d'après mon expérience, ces moments sont rares et loin entre.
- esprit? Comme ça peut-être? flickr.com/photos/gillyberlin/4931194595 que ce soit. Pour le x + n-ième fois: j'essayais juste de rendre l'image complète en ajoutant un objet orienté solution. À cette époque, plusieurs solutions étaient déjà présents, dont certains que j'avais loué et upvoted, donc je n'ai jamais dit que le mien est celui qui doit être utilisée. La question était de se débarrasser de laide si les déclarations et c'est exactement ce que j'ai fait, au détriment de l'efficacité. C'était une expérience, rien de plus. BTW: je dirais que ma syntaxe d'appel est beaucoup plus lisible qu'un multi si/d'autre solution.
- Si vous avez un marteau, tout ressemble à un clou. Je suis désolé pour celui qui aurait à lire grâce à ce code à reproduire la fonctionnalité d'un si-l'état de la chaîne.
- quand je regarde votre page utilisateur, je vois PHP, PHP et même plus de PHP. Peut-être que vous devriez coller avec des sujets qui conviennent le mieux à votre "Skilset". Désolé, je commence à avoir vraiment ped par des gens qui, comme toi, dump leur mauvais karma sur moi. Vous n'aimez pas mon code? Des beaux. Vous downvote il? Des beaux. Mais dire que vous vous sentez désolé pour les gens qui ont à lire à quelqu'un du code est inutile et fing offensive.
- Si PHP est vraiment mon meilleur niveau de compétences, pourquoi voudrais-je poser beaucoup de questions à ce sujet? Mes principales compétences (et de carrière) est de Java. Pour l'enregistrement, PHP dispose de toutes les fonctionnalités orientées objet que vous avez besoin. Il est tout à fait ignorants de faire une déclaration générale sur l'ensemble d'une langue tout simplement parce qu'il n'a pas de appliquer la POO. Mon intention n'était pas d'être agressif, mais plutôt pour être pratique. Je n'ai jamais dit que le code est mauvais, j'ai simplement dit que c'est un fardeau inutile pour les éventuels co-travailleur qui aurait à le lire. À mon avis, les gestionnaires ne seriez pas heureux avec quelqu'un d'aller à la mer sur l'abstraction.
- a) Pour l'enregistrement: j'ai utilisé PHP pour les 10 ans environ, je suis toujours en convalescence. Pourquoi serait-on utiliser de façon intentionnelle PHP si ils savent Java? Pourquoi sur la terre pas Ruby ou Python qui sont maintenant presque aussi disponible partout? b) j'ai dit que si tout ce qu'ils doivent l'utiliser, de ne pas le lire (c'était quand la dernière fois que vous lisez le PHP ou Java compiler du code pour analyser si les déclarations?) c) la Dernière phrase: d'accord, et à juste titre. Il y a quelques situations où la solution de la mine pourrait résoudre les problèmes, mais dans la plupart des situations, il serait cludgy (et je n'ai jamais dit le contraire). Je pense toujours que mon code est plus jolie que si...
- .../d'autre chaînes, mais nous savons tous qu'ils travaillent, et j'ai également les utiliser plus souvent alors j'aime. Je ne suis pas de la programmation orientée objet-maniac tout le monde semble penser que je suis, j'étais juste intéressé à faire une démonstration de la technologie.
- désolé si mon downvote ou un commentaire vous a offensé. je ne voudrais pas prendre downvotes si personnel, si j'étais vous. c'est votre style de code. il semble qu'environ 50% de SORTE que les utilisateurs sont en désaccord avec vous. qui pourrait être bien pire. c'est un verre à moitié plein de chose, je suppose. 😉
- et à propos de cette déclaration: il semble qu'environ 50% de SORTE que les utilisateurs sont en désaccord avec vous. La plupart des flaming commentateurs ci-dessus ont peu ou pas d'activité dans la java des balises, donc je suppose que ce sera la même chose pour le downvoters. Je n'ai pas reçu la critique (beaucoup moins flamboyant) à partir de quelqu'un avec au moins une médaille de bronze de java insigne de tout ceux qui ont aimé ma solution sont pour la plupart très active dans la balise Java. Ainsi, alors qu'il est probablement plus de 95%, de SORTE que les utilisateurs de trouver ma solution horrible, l'expérimenté java gars ne semblent pas, et c'est ce qui compte pour moi.
- mec maintenant, vous êtes l'personnels. chill. Je n'étais pas demander aux gens de me moquer de vous - mais puisque c'est la façon dont vous avez pris, j'ai juste supprimé le commentaire et je m'en excuse il est venu à travers cette façon.
- OK, le mien est allé trop. C'est peut-être temps que quelqu'un le clos ce fil.
- Patrick Floyd, je pense que vous avez un bug dans les " Mathématiques.min( ce.cible.longueur-1, sourceOffset < 0 ? Les mathématiques.abs(sourceOffset)-2:sourceOffset ) `
- Je vous crois, mais je ne vais pas toucher à cette vieille bête. Je n'ai jamais été sérieux à ce sujet, en premier lieu, mais je me suis attaqué gros temps et a été fait pour la défendre. Maintenant, je serais heureux de le laisser mourir. Il a passé plusieurs tests simples à l'époque, mais il est loin de la qualité de la production 🙂
- pourquoi, l'idée de base de la recherche binaire est fine w/ moi :). Si le sourceOffset est -1 effectivement vous avez aussi l'indice de Mathématiques.abs(-1)-2==-1. Je suppose que vous voulez ~sourceOffset. s'il vous plaît, modifier, c'est un beau morceau de code
InformationsquelleAutor
4

Est-il mathématique sous-jacente à cette règle? Si donc vous devriez l'utiliser: mais seulement si elle vient du domaine du problème, et pas seulement une formule qui arrive à s'adapter à la cas.

InformationsquelleAutor user207421

int[] arr = new int[] {145, 117, 68, 51, 22, 10};
for(int index = 0; index < arr.length; index++)
{
if(v > arr[index]) return 1 + index; 
}
return defaultValue;

InformationsquelleAutor Ani

Vous pourrait le réécrire dans les BRAS de code. C'est seulement 7 cycles pire des cas et un mince 164 octets. Espérons que cela aide. (note: ce n'est pas testée)

; On entry
;   r0 - undefined
;   r1 - value to test
;   lr - return address
; On exit
;   r0 - new value or preserved
;   r1 - corrupted
;
wtf
SUBS    r1, r1, #10
MOVLE   pc, lr
CMP     r1, #135
MOVGT   r0, #1
ADRLE   r0, lut
LDRLEB  r0, [r0, r1]
MOV     pc, lr
;
; Look-up-table
lut
DCB     0   ; padding
DCB     6   ; r1 = 11 on entry
DCB     6
DCB     6
DCB     6
DCB     6
DCB     6
DCB     6
DCB     6
DCB     6
DCB     6
DCB     6
DCB     6
DCB     5   ; r1 = 23 on entry
DCB     5
...
ALIGN

Vous n'avez pas mis plein la table de choix, le code est incomplet 🙁
Vrai. J'allais terminer le LUT, mais je ne pouvais pas décider si l'utilisation d'une carte ou d'une régression polynomiale de la générer.

InformationsquelleAutor Sarev of Aona

En réalité, si les tailles sont susceptibles de changer, de le faire dans la base de données pourrait être une bonne stratégie de rechange:

CREATE TABLE VSize (
LowerBound int NOT NULL CONSTRAINT PK_VSize PRIMARY KEY CLUSTERED,
Size int NOT NULL
)
INSERT VSize VALUES (10, 6)
INSERT VSize VALUES (22, 5)
INSERT VSize VALUES (51, 4)
INSERT VSize VALUES (68, 3)
INSERT VSize VALUES (117, 2)
INSERT VSize VALUES (145, 1)

Et une procédure stockée ou une fonction:

CREATE PROCEDURE VSizeLookup
@V int,
@Size int OUT
AS
SELECT TOP 1 @Size = Size
FROM VSize
WHERE @V > LowerBound
ORDER BY LowerBound

🙂 a décidé, depuis oracle est le maître, vous devez utiliser une base de données pour cette
Pourquoi les votes contre? Les gars, vous aimez sortir une nouvelle version juste pour accueillir des modifications de données?

InformationsquelleAutor ErikE

1

Juste pour être complet, permettez-moi de suggérer que vous pourriez mettre en place un tableau des TAILLES avec 145 éléments de la réponse pourrait être retournés directement de taille[v]. Pardonnez-moi de ne pas écrire l'ensemble de la chose. Vous devez assurez-vous que v était à portée, bien sûr.

La seule raison pour laquelle je peux penser pour le faire de cette façon serait si vous étiez sur le point de créer le tableau une fois et d'utiliser des milliers de fois dans une application qui a dû être très rapide. Je le mentionne comme un exemple de compromis entre la mémoire et de la vitesse (pas le problème, il était une fois), et aussi entre le temps de configuration et la vitesse.
- C'est la même que ma solution ci-dessous qui a -1 pour quelque raison que ce soit, même si c'est très raisonnable situation dans certaines situations.
InformationsquelleAutor phv3773
1

La réponse évidente est d'utiliser Groovy:
```
def size = { v -> [145,117,68,51,22,10].inject(1) { s, t -> v > t ? s : s + 1 } }
```
Un doublures sont toujours mieux. Retourne 7 pour l'indéfini cas où v <= 10.

InformationsquelleAutor Zutty

pourquoi quelqu'un n'ont pas suggéré d'instruction switch. il est de loin meilleure que si d'autre échelle.

public int getSize(int input)
{
int size = 0;
switch(input)
{
case 10:
size = 6;
break;
case 22:
size = 5;
break;
case 51:
size = 4;
break;
case 68:
size = 3;
break;
case 117:
size = 2;
break;
case 145:
size = 1;
break;
}
return size;
}

InformationsquelleAutor RTA

0

C'est mon exemple de code, à l'aide de SortedSet. Vous définissez les limites une fois.
```
SortedSet<Integer> boundaries = new SortedSet<Integer>;
boundaries.add(10);
boundaries.add(22);
boundaries.add(51);
boundaries.add(68);
boundaries.add(117);
boundaries.add(145);
```
Puis l'utiliser par la suite cette façon, pour plusieurs valeurs de v (et initialisées à la taille)
```
SortedSet<Integer> subset =  boundaries.tailSet(v);
if( subset.size() != boundaries.size() )
size = subset.size() + 1;
```
- Ceci est destiné à montrer une méthode générique permettant de faire un "histogramme" type de recherche, et utilise un O(log N) recherche pour le nombre de limites. Où N est petit, cela peut s'avérer moins efficace que les instructions if imbriquées.
- Tout d'abord: ce ne sera pas compilé. Il doit être SortedSet<Integer>, pas SortedSet<int>. En outre, cette approche a déjà été prises de manière plus efficace à l'aide de NavigableMap.lowerEntry() ici: stackoverflow.com/questions/3786358/...
- Non, NavigableMap est différent parce que vous avez eu à associer une valeur à l'entrée. Maintenant, que pensez-vous qui se passerait si ils ont décidé d'insérer 89 comme un supplément de frontière et nous avons maintenant de retour 1..7. J'aurais besoin d'un complément supplémentaire ()), alors que NavigableMap nécessiterait de modifier les valeurs sur tout le bas de celles existantes.
- Ouais, je sais, ma solution est la plus souple 🙂
- Votre solution est en effet le plus souple, mais si l'intention de l'OP, c'est que de ce que Neil pense que c'est (compter le nombre de limites au-dessus de la valeur de v) et sa solution, serait plus juste.
- Vrai. Il n'y a jamais une solution parfaite pour tous les cas. La question est de savoir si vous voulez faire une solution parfaite pour un petit nombre de cas ou de bonne solution qui correspond à de nombreux cas. Dans une performance-partie critique de votre demande, vous allez prendre la première approche, mais si vous allez avoir à répondre à l'évolution des exigences (et ils ne sont pas toujours changer?) ensuite, une solution souple est plus approprié.
- Je pense que le vrai problème, c'est que vous ne pouvez pas lire l'original de l'énoncé du problème à partir d'une solution générale. Cela conduit à beaucoup de solutions à des problèmes inexistants, en essayant de garder la souplesse de la première solution. Nous ne le savons pas si la séquence 6..1 est arbitraire ou non, alors pourquoi ne pas simplement demander à l'OP? Si vous avez des exigences en constante évolution, les chances sont qu'ils changent quelque chose qui n'est pas reflété dans votre " semi-général, de solution, de sorte que vous feriez mieux de faire une très solution spécifique.
- a) Au moment où j'ai écrit ma solution, il y avait environ 8 réponses, dont l'un a déjà été acceptée. Je ne pense pas que l'OP serait encore participer à la discussion. b) toutes les autres bonnes versions étaient déjà là, mon approche a été de souligner une autre approche inhabituelle pour rendre l'image complète. c) oui, j'ai été faire quelques hypothèses et je pense que j'ai déclaré que je l'ai fait. Rappelez-vous, l'OP n'est pas mon client, c'est un gars qui a posé une question sur DONC. Il a reçu de bonnes réponses et de mauvaises réponses, mais tout d'abord, il a obtenu les réponses libres à partir de personnes qui font régulièrement la charge des charges de l'argent pour leurs services.
- Je ne pense pas qu'implique la nature de la relation, un développeur a avec un client, avez-vous?
- Je n'ai pas l'esprit des gens de la publication des solutions, et je ne pense pas que votre solution est mauvais, je dis juste que la conjecture de Neal (1..6 ne change pas et le problème est "compter les limites ci-dessus") est tout aussi bon que le vôtre (1..6 va changer et le problème est la carte en entier intervalle"). Vous avez tous deux affiché des solutions de travail, et les deux sont bons, mais aucun n'est meilleur que l'autre, puisque nous ne savons tout simplement pas ce que le problème d'origine a été.
- certes, mais vous oubliez le contexte: ma solution a été WTFed, flambé et downvoted, d'autres n'ont pas, alors que j'ai respecté les autres solutions et upvoted plusieurs d'entre eux. Alors, quand je reçois certains yahoos l'appel de mon code une monstruosité, j'ai au moins la réserve de souligner les faiblesses des autres solutions, même si ce n'est pas Neil faute. Je pense que cette solution est à courte vue et je suis allergique à ce genre, car à courte vue, des solutions d'autres développeurs m'ont fait des centaines d'heures de travail dans le passé. C'est pourquoi je ne souscris pas à l'YAGNI philosophie, je l'ai vu il échoue trop souvent.
- Je ne souscris pas à YAGNI dans ce sens, je crois qu'il est justifié de se préparer pour "tout changer" s'il est possible de le faire (comme l'utilisation de modèles de données, stratégie de modèles, etc). Mais je suis contre la préparation pour les non-changement général comme "peut-être que quelqu'un voudra changer la mise en page de ce bouton, je m'en tiendrai donc les dimensions dans un fichier de propriétés'. Bien sûr, c'est un équilibre délicat d'essayer de décider du moment de l'introduction générale de la flexibilité, c'est pourquoi je pense que YAGNI est libellée comme il est maintenant.
InformationsquelleAutor CashCow
0

Il est intéressant de noter qu'il y a plein de belles réponses pour un simple "laid" question. J'aime mfloryan la réponse de meilleur, mais je voudrais pousser plus loin en supprimant les codée en dur de tableau à l'intérieur de la méthode. Quelque chose comme,
```
int getIndex(int v, int[] descArray) {
for(int i = 0; i < descArray.length; i++)
if(v > descArray[i]) return i + 1;
return 0;
}
```
Il devient maintenant de plus flexibles et permettent de traiter tout tableau donné dans l'ordre décroissant, et la méthode trouverez l'index où la valeur " v " appartient.

PS. Je ne peux pas encore de commentaires sur les réponses.

InformationsquelleAutor Adrian M
0

Si vous voulez vraiment le plus rapide big-O de la complexité en temps de la solution pour ce type particulier de répondre à cette question est en constante recherche.
```
final int minBoundary = 10;
final int maxBoundary = 145;
final int maxSize = 6;
Vector<Integer> index = new Vector<Integer>(maxBoundary);
//run through once and set the values in your index
```
par la suite
```
if( v > minBoundary )
{
size = (v > maxBoundary ) ? maxSize : index[v];
}
```
Ce que nous faisons ici, c'est le marquage de tous les résultats possibles de v dans la gamme et l'endroit où elles tombent, et puis nous avons seulement besoin de test pour des conditions aux limites.

Le problème, c'est qu'il utilise plus de mémoire et bien sûr, si maxBoundary est beaucoup plus grande qu'il sera très inefficace de l'espace (ainsi que prendre plus de temps pour initialiser).

Cela peut parfois être la meilleure solution pour la situation.

InformationsquelleAutor CashCow
-1
```
            if (v <= 10)
return size;
else {
size = 1;
if (v > 145)
return size;
else if (v > 117)
return ++size;
else if (v > 68)
return (size+2);
else if (v > 51)
return (size+3);
else if (v > 22)
return (size+4);
else if (v > 10)
return (size+5);
}
```
Exécute le nécessaire si les déclarations seulement.
- Pourquoi -1? Vous s'il vous plaît laissez-moi savoir?
- Je pense que c'est parce que votre solution est pire, il ne veut pas se débarrasser du vilain si les déclarations...
- Mais, il l'exécute moins si consolidés (que l'original Q) ce qui le rend plus rapide.
InformationsquelleAutor Vikram

-1

Encore une autre variation de la (moins prononcée que celle de la réponse par George)

  //int v = 9;
int[] arr = {145, 117, 68, 51, 22, 10};
int size = 7; for(;7 - size < arr.length && v - arr[size - 2] > 0; size--) {};
return size;

InformationsquelleAutor Yauhen Yakimovich

Vous devez vous connecter pour publier un commentaire.