Les taxes de vente aux États-Unis sont pour le moins compliquées. En règle générale, il existe une taxe de vente d'État (il existe une poignée d'États qui ne perçoivent pas de taxe de vente d'État), mais il peut également y avoir une taxe de vente du comté, une taxe de vente de district scolaire, une taxe de vente municipale (ville) ou une taxe de vente de la région métropolitaine. Il pourrait même y avoir différentes taxes de vente dans différentes parties d'une ville. Aux fins de ce défi, cependant, nous allons nous concentrer uniquement sur la taxe de vente d'État.

Étant donné un montant en dollars américains supérieur à zéro (précis à deux décimales près) et un état (le nom complet ou l'abréviation à deux lettres, votre choix, la casse n'a pas d'importance), et en utilisant le tableau ci-dessous des pourcentages de taxe de vente, produire la taxe de vente d'État correspondante qui doit être perçue pour cette vente particulière, précise et tronquée à deux décimales. Veuillez spécifier comment votre code gère l'arrondi.

Edit: l'abréviation de Washington a été incorrectement répertoriée comme WS au lieu de WA. Les réponses peuvent utiliser l'une ou l'autre abréviation, car c'était ma gaffe.

State          Abbr   %
Alabama         AL  4.00%
Alaska          AK  0.00%
Arizona         AZ  5.60%
Arkansas        AR  6.50%
California      CA  6.00%
Colorado        CO  2.90%
Connecticut     CT  6.35%
Delaware        DE  0.00%
Florida         FL  6.00%
Georgia         GA  4.00%
Hawaii          HI  4.00%
Idaho           ID  6.00%
Illinois        IL  6.25%
Indiana         IN  7.00%
Iowa            IA  6.00%
Kansas          KS  6.50%
Kentucky        KY  6.00%
Louisiana       LA  5.00%
Maine           ME  5.50%
Maryland        MD  6.00%
Massachusetts   MA  6.25%
Michigan        MI  6.00%
Minnesota       MN  6.875%
Mississippi     MS  7.00%
Missouri        MO  4.23%
Montana         MT  0.00%
Nebraska        NE  5.50%
Nevada          NV  4.60%
New Hampshire   NH  0.00%
New Jersey      NJ  6.88%
New Mexico      NM  5.13%
New York        NY  4.00%
North Carolina  NC  4.75%
North Dakota    ND  5.00%
Ohio            OH  5.75%
Oklahoma        OK  4.50%
Oregon          OR  0.00%
Pennsylvania    PA  6.00%
Rhode Island    RI  7.00%
South Carolina  SC  6.00%
South Dakota    SD  4.50%
Tennessee       TN  7.00%
Texas           TX  6.25%
Utah            UT  4.70%
Vermont         VT  6.00%
Virginia        VA  4.30%
Washington      WA  6.50%
West Virginia   WV  6.00%
Wisconsin       WI  5.00%
Wyoming         WY  4.00%

Exemple pour la Californie à 6% de taxe de vente d'État -

CA
1025.00

61.50

Exemple pour le Minnesota à 6,875% -

MN
123.45

8.49

Mathematica, 112 103 77 76 66 octets

^{Mathematica a une fonction intégrée pour tout}

NumberForm[Interpreter["USState"][#]@"StateSalesTaxRate"#2,{9,2}]&

Prend un nom d'état (n'importe quel format; abréviation ou nom complet) et le montant en dollars.

Essayez-le sur Wolfram Sandbox

Usage

f = NumberForm[Interpreter["USState"][#]@"StateSalesTaxRate"#2,{9,2}]&

f["CA", 1025.00]

61,50

f["miNnNesToA", 123.45]

8.49

Explication

Interpreter["USState"][#]

Interprétez l'entrée comme un nom d'État américain et générez un Entity.

... @"StateSalesTaxRate"

Obtenez le taux de taxe de vente.

... #2

Multipliez cela par la deuxième entrée.

NumberForm[..., {9,2}]

Formatez le résultat en un nombre avec 9 chiffres à gauche de la décimale et 2 chiffres à droite.

R , 219 212 octets

function(S,m)sprintf("%.2f",c(4,0,5.6,6.5,6,2.9,6.35,0,6,4,4,6,6.25,7,6,6.5,6,5,5.5,6,6.25,6,6.875,7,4.23,0,5.5,4.6,0,6.88,5.13,4,4.75,5,5.75,4.5,0,6,7,6,4.5,7,6.25,4.7,6,4.3,6.5,6,5,4)[match(S,state.abb)]*m/100)

Prend l'état comme abréviation (toutes majuscules).

state.abb correspond aux données R intégrées avec les abréviations d'état par ordre alphabétique, de sorte qu'il code en dur les taxes de vente, trouve l'index de l'État, calcule la taxe de vente et formate à 2 décimales (sortie sous forme de chaîne).

Essayez-le en ligne!

05AB1E , 134 octets

.•2=Šλ₁ÙH ’€9¿FîβïLT_s€¤Ôтαxì8ÜuK8º'DιÒ—pcλ¯øÒÔ\’þü€ŒβÞéΣŽZê•#.å1kUX0‹i6*т/ëX•Ž½ì∞в’±₃C¸wiα·¥žYÉúžĆƵ˜šŸ‰Ê‡†Σgλ&/ûjDĆв₆•hR„AB„ .‡#è*т/}

Essayez-le en ligne!

RIP Mathematica gagne.

Tout cela ne fait que comprimer les chaînes suivantes:

AKDEMTNHOR CO ALGANYHIWY MO VA SDOK NV UT NC LANDWI NM MENE AZ OH ILMATX CT ARKSWS MN NJ INMSRITN

Et:

0 2.9 4 4.23 4.3 4.5 4.6 4.7 4.75 5 5.13 5.5 5.6 5.75 6.25 6.35 6.5 6.875 6.88 7

Utilise ensuite l'index de l'état d'entrée pour déterminer l'indice du taux, par défaut à 6, car il y a tellement d'états à 6%.

Pour les autres à consommer:

AKDEMTNHOR 0
CO         2.9
ALGANYHIWY 4
MO         4.23
VA         4.3
SDOK       4.5
NV         4.6
UT         4.7
NC         4.75
LANDWI     5
NM         5.13
MENE       5.5
AZ         5.6
OH         5.75
CAFLIDIAKYMDMIPASCVTWV 6
ILMATX     6.25
CT         6.35
ARKSWS     6.5
MN         6.875
NJ         6.88

Notez que cela ne fonctionne que parce que j'ai ordonné les états de telle sorte qu'aucune intersection de 2 états ne crée un état différent EG ( OHINcontient [OH,IN,HI]alors que INOHne contient que [IN,OH])

La plupart des idées pour cela sont venues de mon entrée précédente basée sur l'état .

Pyth, 270 258 233 219 octets

*c@[6Z5.75K6.25 5.5 5 4Z7 6.5J6 7J6.875 7 4J6.35Z6 7 5 4.75 4 4.23J5J5.13 4.6JJ4J4 4.3 4.5Z5.6J.5 4.7K4.5KZ6.5 6.88 5.5J2.9)xc."AZ-íâFT34r7²¨cK'ÉT?Ú5Ï)}4Që7ËÅÖpuªXTiÖ¶7×ì­Éͨ."2w100

Doit être passé des paramètres comme ceci:

1025
CA

Explication:

*c@[...)xc."..."2w100
          ."..."       Decompress the string
         c      2      Cut the string in chunks of size 2 (states abbreviations)
        x        w     Get the index of the second parameter in that string
  @[    )              Index into the tax array
 c                100  Generate a percentage
*                      Multiply that with the implicit input at the end
Alas, `.Z` makes this longer. Maybe there's a way to write the array more efficiently, by repeating the keys, but I havn't found one yet.

Merci à @ Mr.Xcoder.

Java (OpenJDK 8) , 594 + 19 592 580 575 412 octets

s->a->{float[]r={0};java.util.Arrays.asList("AL4`AK0`AZ5.6`AR6.5`CA6`CO2.9`CT6.35`DE0`FL6`GA4`HI4`ID6`IL6.25`IN7`IA6`KS6.5`KY6`LA5`ME5.5`MD6`MA6.25`MI6`MN6.875`MS7`MO4.23`MT0`NE5.5`NV4.6`NH0`NJ6.88`NM5.13`NY4`NC4.75`ND5`OH5.75`OK4.5`OR0`PA6`RI7`SC6`SD4.5`TN7`TX6.25`UT4.7`VT6`VA4.3`WS6.5`WV6`WI5`WY4".split("`")).forEach(e->{if(e.contains(s))r[0]=a/100*new Float(e.substring(2));});return s.format("%.2f",r[0]);}

Essayez-le en ligne!

Java 8, 486 467 309 299 290 289 octets

s->a->{float r=6;for(String x:"AKDENHORMT0 CO2.9 ALGANYHIWY4 MO4.23 VA4.3 SDOK4.5 NV4.6 UT4.7 NC4.75 LANDWI5 NM5.13 MENE5.5 AZ5.6 OH5.75 ILMATX6.25 CT6.35 ARKSWS6.5 MN6.875 NJ6.88 MSRINTN7".split(" "))if(x.contains(s))r=new Float(x.replaceAll("[A-Z]",""));return s.format("%.2f",a*r/100);}

-19 octets grâce à @MagicOctopusUrn en supprimant les points-virgules.

Explication:

Essayez-le ici.

s->a->                    // Method with String and float parameters and String return-type
  float r=6;              //  Float starting at 6 (most states had 6.00 as tax)
  for(String x:"...".split(" "))
                          //  Loop over all states + amounts
    if(x.contains(s))     //   If the input-state is found in String `x`:
      r=new Float(x.replaceAll("[A-Z]",""));
                          //    Set float `r` to the amount of this state
                          //  End of loop (implicit / single-line body)
  return s.format("%.2f", //  Return result rounded to 2 decimal points:
     a*r/100);            //   Float input multiplied by `r` divided by 100
}                         // End of method

Perl 6, 341 octets

my%a=((<ME NE>X=>5.5),CO=>2.9,MO=>4.23,MN=>6.875,NJ=>6.88,(<LA ND WI>X=>5),(<AK DE MT NH OR>X=>0),(<IN MS RI TN>X=>7),(<AR KS WS>X=>6.5),AZ=>5.6,(<AL GA HI NY WY>X=>4),VA=>4.3,UT=>4.7,(<IL MA TX>X=>6.25),(<CA FL ID IA KY MD MI PA SC VT WV>X=>6),(<OK SD>X=>4.5),NV=>4.6,NM=>5.13,CT=>6.35,OH=>5.75,NC=>4.75).flat;{round $^a*(%a{$^b}/100),0.01}

Alors, hein. C'est assez artificiel, je suppose. Cela utilise les méta-opérateurs de Perl 6, comme X=>ici, qui est X(produit croisé) combiné avec =>.

Cela signifie <ME NE> X=> 5.5(où <ME NE>moyens ('ME', 'NE')) est => 5.5appliqué sur chaque élément du tableau, ce qui donne ME => 5.5, NE => 5.5. Les parenthèses ne sont là que pour la préséance ...

En tant que golfeur (euh ...), je n'ai évidemment pas écrit celui-là à la main (sauf la fonction réelle). J'ai donc écrit un méta-golfeur pour générer la combinaison la plus efficace!

my %values;
my %simple;
for lines() {
  my $abb = m/<[A .. Z]> ** 2/.Str;
  my $val = m/\d\.\d+/.Str;
  %values{$val}.push: $abb;
  %simple{$abb} = $val;
}

say "(", (join ',', do for %values.kv -> $key, @vals {
  my $int-key = +$key;
  if @vals > 1 {
    "(<{@vals}>X=>$int-key)"
  } else {
    "{@vals}=>$int-key"
  }
}), ").flat";

say();

say join ',', do for %simple.kv -> $key, $val {
  "$key=>" ~ +$val
}

Il génère à la fois les X=>cas et le cas le plus simple (chacun étant énuméré), et j'ai choisi le plus court (le premier).

JavaScript (ES6), 227 224 octets

Prend une entrée dans la syntaxe de curry (s)(v)où s est l'état et v est le montant. Utilise l'arrondi au sol.

s=>v=>(v*(p=s=>parseInt(s,36))('3344bk50k4mo28k4we4tm5eg3uw48s5az39i3js5b43yi3ny4fq3h03mk3bg'.substr(p('k039017k00038f00030022h00g000j00k600k080k707h30706800ba0030305ic0303303930460000e00d2'[p(s)*84%943%85])*3,3))/1e3|0)/100

Démo

let f =

s=>v=>(v*(p=s=>parseInt(s,36))('3344bk50k4mo28k4we4tm5eg3uw48s5az39i3js5b43yi3ny4fq3h03mk3bg'.substr(p('k039017k00038f00030022h00g000j00k600k080k707h30706800ba0030305ic0303303930460000e00d2'[p(s)*84%943%85])*3,3))/1e3|0)/100

console.log(f("CA")(1025))
console.log(f("MN")(123.45))

Kotlin , 444 octets

val S="0|AK|DE|MT|NH|OR#2.9|CO#4|AL|GA|HI|NY|WY#4.23|MO#4.3|VA#4.5|OK|SD#4.6|NV#4.7|UT#4.75|NC#5|LA|ND|WI#5.13|NM#5.5|ME|NE#5.6|AZ#5.75|OH#6|CA|FL|ID|IA|KY|MD|MI|PA|SC|VT|WV#6.25|IL|MA|TX#6.35|CT#6.5|AR|KS|WS#6.875|MN#6.88|NJ#7|IN|MS|RI|TN"
fun c(t:String,d:Double){
val m=mutableMapOf<String,Double>()
S.split("#").map{val s=it.split("|")
for (item in s.subList(1, s.size))m.put(item, s[0].toDouble())}
System.out.printf("%.2f", m[t]!!*d*.01)}

Essayez-le en ligne!

Embellie

// Tax rate followed by states with that rate separated by pipes, with hashes in between
val STATES="0|AK|DE|MT|NH|OR#2.9|CO#4|AL|GA|HI|NY|WY#4.23|MO#4.3|VA#4.5|OK|SD#4.6|NV#4.7|UT#4.75|NC#5|LA|ND|WI#5.13|NM#5.5|ME|NE#5.6|AZ#5.75|OH#6|CA|FL|ID|IA|KY|MD|MI|PA|SC|VT|WV#6.25|IL|MA|TX#6.35|CT#6.5|AR|KS|WS#6.875|MN#6.88|NJ#7|IN|MS|RI|TN"

fun function(targetState: String, amount: Double) {
    // Stores data
    val m = mutableMapOf<String, Double>()
    // For each rate
    STATES.split("#").map {
        // Split the data out
        val rateData = it.split("|")
        // For each state with that rate
        for (stateCode in rateData.subList(1, rateData.size)) {
            // Put it in the dataset
            m.put(stateCode, rateData[0].toDouble())
        }
    }

    // Print out the tax rate
    System.out.printf("%.2f", m[targetState]!! * amount * .01)
}

Python 3 , 303 octets

import re
t=re.split("(\d+)","AL4AK0AZ56AR65CA6CO29CT635DE0FL6GA4HI4ID6IL625IN7IA6KS65KY6LA5ME55MD6MA625MI6MN6875MS7MO423MT0NE55NV46NH0NJ688NM513NY4NC475ND5OH575OK45OR0PA6RI7SC6SD45TN7TX625UT47VT6VA43WS65WV6WI5WY4")
f=lambda s,a:"%.2f"%({t[i-1]:float(t[i])/10**-~len(t[i])for i in range(1,len(t),2)}[s]*a)

Essayez-le en ligne!

Très simple: les données sont stockées sous forme de deux caractères + liste de chiffres: chaque pourcentage est inférieur à 10, donc elles peuvent être stockées en partie entière (1 chiffre) + partie décimale (0 -... chiffre (s)).

C # , 318 309 octets

Les données

• Entrée String s Abréviation à 2 lettres de l'état en majuscule.
• Entrez Double v la valeur
• Sortie String La valeur de taxe à collecter arrondie à 2 décimales

Golfé

(s,v)=>{for(int i=0;i<21;i++)if("NHAKDEMTOR,CO,ALHIGANYWY,MO,VA,SDOK,NV,UT,NC,NDLAWI,NM,MENE,AZ,OH,KYCAFLIDIAMDMIPASCVTWV,ILMATX,CT,ARKSWA,MN,NJ,MSINRITN".Split(',')[i].Contains(s))return $"{v*(new[]{0,2.9,4,4.23,4.3,4.5,4.6,4.7,4.75,5,5.13,5.5,5.6,5.75,6,6.25,6.35,6.5,6.875,6.88,7}[i]/100):F2}";return "";};

Non golfé

( s, v ) => {
    for( int i = 0; i < 21; i++ )
        if( "NHAKDEMTOR,CO,ALHIGANYWY,MO,VA,SDOK,NV,UT,NC,NDLAWI,NM,MENE,AZ,OH,KYCAFLIDIAMDMIPASCVTWV,ILMATX,CT,ARKSWA,MN,NJ,MSINRITN".Split( ',' )[ i ].Contains( s ) )
            return $"{v * ( new[] { 0, 2.9, 4, 4.23, 4.3, 4.5, 4.6, 4.7, 4.75, 5, 5.13, 5.5, 5.6, 5.75, 6, 6.25, 6.35, 6.5, 6.875, 6.88, 7 }[ i ] / 100 ):F2}";
    return "";
};

Non lisible non lisible

// Takes a 2 letter abbreviation state ( 's' ) and a value ( 'v' )
( s, v ) => {

    // Cycles through an array with the states grouped by tax value
    for( int i = 0; i < 21; i++ )

        // Checks if the state group at the current index contains the state 's'
        if( "NHAKDEMTOR,CO,ALHIGANYWY,MO,VA,SDOK,NV,UT,NC,NDLAWI,NM,MENE,AZ,OH,KYCAFLIDIAMDMIPASCVTWV,ILMATX,CT,ARKSWA,MN,NJ,MSINRITN".Split( ',' )[ i ].Contains( s ) )

            // Returns the value 'v' * the corresponding state percentage divided by 100
            return $"{v * ( new[] { 0, 2.9, 4, 4.23, 4.3, 4.5, 4.6, 4.7, 4.75, 5, 5.13, 5.5, 5.6, 5.75, 6, 6.25, 6.35, 6.5, 6.875, 6.88, 7 }[ i ] / 100 ):F2}";

    // If the state isn't found, return an empty string
    return "";
};

Code complet

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestBench {
    public static class Program {
        private static Func<String, Double, String> f = ( s, v ) => {
            for( int i = 0; i < 21; i++ )
                if( "NHAKDEMTOR,CO,ALHIGANYWY,MO,VA,SDOK,NV,UT,NC,NDLAWI,NM,MENE,AZ,OH,KYCAFLIDIAMDMIPASCVTWV,ILMATX,CT,ARKSWA,MN,NJ,MSINRITN".Split( ',' )[ i ].Contains( s ) )
                    return $"{v * ( new[] { 0, 2.9, 4, 4.23, 4.3, 4.5, 4.6, 4.7, 4.75, 5, 5.13, 5.5, 5.6, 5.75, 6, 6.25, 6.35, 6.5, 6.875, 6.88, 7 }[ i ] / 100 ):F2}";
            return "";
        };

        static void Main( string[] args ) {
            List<KeyValuePair<String, Double>>
                testCases = new List<KeyValuePair<String, Double>>() {
                    new KeyValuePair<String, Double>( "CA", 1025.0d ),
                    new KeyValuePair<String, Double>( "MN", 123.45d ),
                };

            foreach( KeyValuePair<String, Double> testCase in testCases ) {
                Console.WriteLine( $" STATE: {testCase.Key}\n VALUE: {testCase.Value}\nOUTPUT: {f( testCase.Key, testCase.Value )}\n" );
            }

            Console.ReadLine();
        }
    }
}

Communiqués

• v1.0 - 318 bytes- Solution initiale.
• v1.1 - - 9 bytes- Changé l' .ToString("F2")utilisé dans le premier retour aux chaînes interpolées.

Remarques

• Aucun

AWK , 277 octets

{split("LANDWI 5 VA 4.3 IACAFLIDKYMDMIPASCVTWV 6 SDOK 4.5 MO 4.23 CO 2.9 NM 5.13 NV 4.6 UT 4.7 NJ 6.88 MENE 5.5 AZ 5.6 ARKSWA 6.5 MN 6.875 MSINRITN 7 ILMATX 6.25 NC 4.75 CT 6.35 ALGANYWYHI 4 OH 5.75 AKDEMTORNH 0",T)
for(i in T)if(T[i]~s=".*"$1".*")printf"%.2f\n",$2*T[i+1]*.01}

Essayez-le en ligne!

Un score respectable, mais loin de Mathematica. J'ai ajouté 2 octets en ayant une impression de nouvelle ligne après chaque vérification, mais je pense que c'est plus joli de cette façon :)

(J'espère qu'il est évident que l'entrée doit être l'abréviation de l'état et une valeur sur une ligne.)