Calculadora estatal simple de impuestos sobre las ventas

10

Los impuestos sobre las ventas en los Estados Unidos son complicados, por decir lo menos. En general, hay un impuesto estatal a las ventas (hay un puñado de estados que no recaudan un impuesto estatal a las ventas), pero también podría haber un impuesto a las ventas del condado, un impuesto a las ventas del distrito escolar, un impuesto a las ventas municipal (de la ciudad) o un impuesto de ventas del área metropolitana. Incluso podría haber diferentes impuestos sobre las ventas en diferentes partes de una ciudad. Para los propósitos de este desafío, sin embargo, nos enfocaremos solo en el impuesto estatal sobre las ventas.

Dada una cantidad en dólares estadounidenses mayor que cero (con una precisión de dos decimales) y un estado (ya sea el nombre completo o la abreviatura de dos letras, su elección, el caso no importa), y utilizando la siguiente tabla de porcentajes de impuestos sobre las ventas, generar el impuesto estatal sobre las ventas correspondiente que debe recaudarse para esa venta en particular, preciso y truncado a dos decimales. Especifique cómo maneja su código el redondeo.

Editar: La abreviatura de Washington aparece incorrectamente como WS en lugar de WA. Las respuestas pueden usar cualquiera de las abreviaturas, ya que esa fue mi tontería.

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%

Ejemplo para California con un impuesto estatal sobre las ventas del 6%:

CA
1025.00

61.50

Ejemplo para Minnesota en 6.875% -

MN
123.45

8.49
AdmBorkBork
fuente
14
inb4 Mathematica incorporado.
James
Minnesota MN 6.875%- porque .005% es, bueno, en realidad mucho.
Urna de pulpo mágico
1
Ahhh ... cierto ... esto no es impuesto sobre la renta.
Magic Octopus Urn
2
@ Shaggy No, el caso no importa.
AdmBorkBork
2
Pedantry: la abreviatura estatal para Washington es WA, no WS.
Michael Seifert

Respuestas:

15

Mathematica, 112 103 77 76 66 bytes

Mathematica tiene un incorporado para todo

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

Toma un nombre de estado (cualquier formato; abreviatura o nombre completo) y el monto en dólares.

Pruébalo en Wolfram Sandbox

Uso

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

 

f["CA", 1025.00]

61,50

f["miNnNesToA", 123.45]

8.49

Explicación

Interpreter["USState"][#]

Interprete la entrada como un nombre de estado de EE. UU. Y genere un Entity.

... @"StateSalesTaxRate"

Obtenga la tasa de impuesto a las ventas.

... #2

Multiplique eso por la segunda entrada.

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

Formatee el resultado en un número con 9 dígitos a la izquierda del decimal y 2 dígitos a la derecha.

JungHwan Min
fuente
66
Mathematica Por supuesto ...
Ven
8
¡Esto se está volviendo tonto ahora!
Shaggy
¿Por qué necesita usar una API siempre que la cadena para obtener la propiedad 142?
Neil
11
Hay un punto pedante semi serio aquí. Dado que Mathematica obtiene sus datos de palabras reales de un almacén de datos que se actualiza constantemente, ¿qué sucede cuando cambia la tasa impositiva de un estado en particular? ¿Esta respuesta no se vuelve inválida con respecto a la especificación dada en la pregunta?
ymbirtt
44
@ymbirtt debería estar bien según esta meta discusión .
JungHwan Min
5

R , 219 212 bytes

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)

Toma el estado como una abreviatura (mayúsculas).

state.abb son los datos R incorporados con las abreviaturas de estado en orden alfabético, por lo que codifica los impuestos sobre las ventas, encuentra el índice del estado, calcula el impuesto sobre las ventas y los formatos a 2 decimales (salida como una cadena).

Pruébalo en línea!

Giuseppe
fuente
5

05AB1E , 134 bytes

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

Pruébalo en línea!


RIP Mathematica gana.


Todo lo que hace es comprimir las siguientes cadenas:

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

Y:

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

Luego usa el índice del estado de entrada para determinar el índice de la tasa, por defecto a 6, porque hay muchos estados con 6%.


Para que otros consuman:

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

Tenga en cuenta que esto solo funciona porque ordené los estados de manera que ninguna intersección de 2 estados cree un estado diferente EG ( OHINcontiene, [OH,IN,HI]mientras que INOHsolo contiene [IN,OH])


La mayoría de las ideas para esto provienen de mi entrada anterior basada en el estado .

Urna de pulpo mágico
fuente
Enlace TIO tiene -dbandera
H.PWiz
@ H.PWiz Eso es para visualizar la pila. Si lo elimina, verá la salida regular del programa.
Sr. Xcoder
@ H.PWiz es solo para fines de visualización, lo toma comando por comando y le permite ver por qué funciona el programa.
Urna de pulpo mágico
Ah, pensé que se había dejado por error.
H.PWiz
3

Pyth, 270 258 233 219 bytes

*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

Deben pasar parámetros como este:

1025
CA

Explicación:

*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.

Gracias a @ Mr.Xcoder.

Ven
fuente
233 bytes
Sr. Xcoder
Pensé que solo .Zestaba disponible. Gracias de nuevo ;-).
Ven
3

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

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]);}

Pruébalo en línea!

Roberto Graham
fuente
1
Puede guardar 9 bytes dirigiéndose directamente Arrayscomo java.util.Arraysy deshaciéndose de la declaración de importación. Incluiría un enlace TIO pero es demasiado largo. : P
totalmente humano
Puede guardar algunos bytes más al eliminarlos final; cambiando doublea float; cambiando Double.parseDoublea new Float; y cambiando (s,a)->a s->a->mediante el uso de curry. Aquí está el enlace TIO para ver cómo.
Kevin Cruijssen
1
Ah, y también puede eliminar todas las comas y ceros finales y cambiar substring(3)a substring(2): TIO 415 bytes . Eso es más corto que mi respuesta Java ...;)
Kevin Cruijssen
3

Java 8, 486 467 309 299 290 289 bytes

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 bytes gracias a @MagicOctopusUrn al eliminar los puntos y comas.

Explicación:

Pruébalo aquí.

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
Kevin Cruijssen
fuente
1
Si usa el orden de mi respuesta, puede eliminar todos los puntos y comas en sus cadenas.
Urna de pulpo mágico
HI;NYy MT;NHactualmente son las únicas cosas en su código que le impiden eliminar todos los puntos y coma. Invierta el orden de ambos y funcionaría como 20 bytes guardados.
Urna de pulpo mágico
1
@MagicOctopusUrn Gracias, editado! Por cierto, es posible que desee agregar los estados para 7su respuesta también (aunque TNinterfiere con el orden actual de 0).
Kevin Cruijssen
@MagicOctopusUrn INMSRITN 7.00& AKDENHORMT 0.00es posible sin entrar en conflicto con nada más.
Kevin Cruijssen
2

Perl 6, 341 bytes

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}

Entonces, eh. Esto es bastante artificial, supongo. Utiliza los metaoperadores de Perl 6, como X=>aquí, que es X(producto cruzado) combinado con =>.

Eso significa que <ME NE> X=> 5.5(donde <ME NE>significa ('ME', 'NE')) se => 5.5aplica en cada elemento de la matriz, lo que produce ME => 5.5, NE => 5.5. Los paréntesis son simplemente aquí por precedencia ...


Como golfista (erm ...), obviamente no escribí eso a mano (excepto la función real). ¡Entonces escribí un meta-golfista para generar la combinación más eficiente!

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
}

Genera tanto los X=>casos como el caso más simple (con cada uno enumerado), y elegí el más corto (el primero).

Ven
fuente
2

JavaScript (ES6), 227 224 bytes

Toma entrada en la sintaxis de curry (s)(v)donde s es el estado y v es la cantidad. Utiliza redondeo de piso.

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

Manifestación

Arnauld
fuente
1

Kotlin , 444 bytes

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)}

Pruébalo en línea!

Embellecido

// 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)
}
jrtapsell
fuente
1

Python 3 , 303 bytes

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)

Pruébalo en línea!

Muy simple: los datos se almacenan como dos caracteres + lista de dígitos: cada porcentaje es inferior a 10, por lo que se puede almacenar como parte entera (1 dígito) + parte decimal (0 -... dígito (s)).

jferard
fuente
1

C # , 318309 bytes


Datos

  • Entrada String s La abreviatura de 2 letras del estado en mayúscula.
  • Entrada Double v el valor
  • Salida String El valor impositivo a cobrar redondeado a 2 decimales

Golfed

(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 "";};

Sin 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 "";
};

Legible sin golf

// 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 "";
};

Código completo

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();
        }
    }
}

Lanzamientos

  • v1.0 - 318 bytes- Solución inicial.
  • v1.1 - - 9 bytes- Cambió el.ToString("F2") usado en el primer retorno a cadenas interpoladas.

Notas

  • Ninguna
auhmaan
fuente
0

AWK , 277 bytes

{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}

Pruébalo en línea!

Una puntuación respetable, pero nada cerca de Mathematica. Agregué 2 bytes al imprimir una nueva línea después de cada verificación, pero creo que es más bonito de esa manera :)

(Con suerte, es obvio que la entrada debe ser la abreviatura del estado y un valor en una línea).

Robert Benson
fuente