text:
How many points does my license plate give?
(This is my first code-golf question)
When I was a child, my dad and I invented a game where the license plate we see on cars can give certain points based on some rather simple rules:
X amount of the same letter or number give X-1 points, examples:
22 = 1 point
aa = 1 point
5555 = 3 points

The numbers must be next to eachother, so 3353 only gives 1 point, as the 5 breaks the sequence of 3's.
A sequence of X numbers in ascending or descending order, at a minimum of 3, give X points, examples:
123 = 3 points
9753 = 4 points
147 = 3 points

The point system only works for 1-digit-numbers, so 1919 doesn't give points, and 14710 only give 3, (147).
Sequences can be combined to make more points, examples:
1135 = 4 points (1 point for 11 and 3 points for 135)
34543 = 6 points (3 points for 345 and 3 points for 543)

You are however not allowed to chop a larger sequence into 2 smaller sequences for extra points: 1234 = 123, 234 (6 points) is not allowed.
Your task is, given a sequence, to determine the number of points the license plate gives.
In Denmark, the license plates are structured like this: CC II III, where C is character and I is integer, and thus my example inputs will reflect this structure. If you wish, you may make the sequence fit your own structure, or, if you feel really adventurous, let the program analyze the structure of the license plate and thus have it work on any type of license plate around the world. Explicitly state the structure you decide to use in your answer though.
You may take the input in any way you please, either a string or an array seem to make most sense to me.
Test input | output:
AA 11 111 | 5
AB 15 436 | 3
OJ 82 645 | 0
UI 65 456 | 6
HH 45 670 | 5
YH 00 244 | 5
AJ 00 754 | 1

Due to the nature of choosing your own structure, or even covering all structures, I dont necessarily see how a winner can be explicitly determined. I suppose the winner will be the shortest bytes on the structure one has decided. (And don't take an input like C I C I C, just to make it easy for yourself)
EDIT:
Due to comments asking, I have a few extra pieces of information to share: A sequence of ascending or descending numbers refers to an arithmetic sequence, so X +/- a * 0, X +/- a * 1, ... X +/- a * n etc. So 3-5-7 for example is 3 + 2 * 0, 3 + 2 * 1, 3 + 2 * 2. The sequence does not, however, need to start from 0 nor end in 0.
MORE EDIT:
You may give the input in any way you please, you dont need to input spaces, dashes or any other thing that makes a license plate more readable. If you can save bytes by only accepting capital letters or something like that, you may do that aswell. The only requirement is that your program can take a string/array/anything containing both characters and numbers, and output the correct amount of points according to the rules stated.

Loosely related. Welcome to PPCG and nice first question!

Suggested test case: XX 87 654. I came up with something that was correct for all your test cases but somehow incorrect for this one.. Working on fixing it.

I strongly suggest you fix a certain structure (I suggest CCIIIII, no spaces), or else this problem lacks an objective win criterion, which we require around here. As-is, “(And don't take an input like C I C I C, just to make it easy for yourself)” is very subjective. What is and isn’t an admissible structure?

@Lynn An admissible structure is one that can actually yield points, CICIC will never have a sequence that yields any points, therefore it is not admissible. And on top of that, why is 'shortest answer in bytes on the chosen programming language and chosen structure' not a clear, objective win criteria? This win criteria has a straight, easy to follow rule, yet gives the developer freedom to choose what kind of structure they want it to work with. Granted it may have a lot of different winners, but, really, so what?

Test case: IA99999 (contains a decreasing sequence of code points, but not numbers).

RE: allowing us to choose any input "that can actually yield points": CC would be acceptable and has a very simple 2-byte Jelly answer and perhaps even just 1 byte in another language. It just feels like abusing the specification to me though. Hence I also suggest fixing the input format as CCIIIII.

...just to add that if we also need to have characters and numbers in the input like in the "MORE EDIT" we may still do something like this for CCII. (Also not that adding addenda like "EDIT" and "MORE EDIT" is a poor alternative to changing the specification in the body of the post itself. )

@JonathanAllan If someone wants to make a CC or CCII answer using 2 or 1 byte, they are welcome to do so, as that is a legitimate structure that they may choose, I honestly dont see the point in limiting what the developer can choose to develop. This is a challenge, it has rules and it has answer-variants, if you solve the problem within these rules, it's an accepted answer. It is not my task as a question-giver to make the question as complicated as possible, it's the challenged developer who may choose how difficult he wants the task to be. By letting the goal be a bit more open than ...

@JonathanAllan ... just CCIIIII, the challenged developer may choose the path to success, if you find a solution such as the ones you have linked satisfactory for how challenged you were by the question, thats completely fine, but as the answers below show, people like to take the more challenging path to this question than just the easiest solution. I honestly dont see the point in restricting a question, as opposed to give the challenged developer free-roam over where they want to take it

05AB1E, 25 22 20 18 bytes
Accepts a string of lower-case alphabetic chars and numbers with no spaces.
Ç¥0Kγ€gXK>OIγ€g<OO

Try it online!
or as a Test Suite

I can't read 05AB1E without an explanation ;) But can you save bytes by getting the input without spaces?

@Mr.Xcoder I doubt it as well. But I personally can't read 05AB1E, so I thought perhaps Emigna had added any code to get rid of/ignore the spaces. Probably it does this implicitly without any extra bytes, but I just asked in case it didn't.

I just took your code for a swing, and holy crap, it actually works for any length or sequence! The only 'issue' is that it also gives 3 points for ABC, which in and of itself isn't wrong, I just did not account for it, as in Denmark we only have 2 letters next to eachother.

@KevinCruijssen: No spaces in the input would save several bytes yes. I missed the part where we could decide that ourselves. Thanks for the heads up. (An explanation is coming as well).

@Emigna I hadn't stated it in the question explicitly, I thought I hinted enough at it when I wrote You may take the input in any way you please, either a string or an array seem to make most sense to me..

@TroelsM.B.Jensen: Yeah, I have a bad habit of skimming over information at times. Re-reading it after Kevin's comment I noticed it :P

@Emigna I know what you mean, and I could possibly have been more specific in my explanations; when you write (or tell) something, you generally have a tendency to skip specific details because you find it 'obvious' to the listener, which it often times isn't.

Seems to fail on IA99999.

@Zgarb: Ah yes, thanks for the heads up. Was able to fix with just the input format.

Husk, 20 16 15 bytes
-1 byte thanks to @Zgarb
Takes input without spaces and in lower case.
ṁ??¬o→LεL←gẊ¤-c

Try it online!
Explanation
           Ẋ      Map over all adjacent pairs
            ¤-c   get the difference of their codepoints
          g       Split into groups of equal elements
ṁ                 Map then sum
 ?       ←          If the head of the list is truthy (not 0)
  ?    ε              If the length of the list is 1
   ¬                    return 0
                       Else
    o→L                 return the length + 1
                     Else
        L             return the length

I think K0 can be ¬ here.

Hmm, this seems to fail on IA99999.

@Zgarb, changed input format to lower case.

Python 3, 193 85 bytes
-3 bytes thanks to Lynn
Takes input as a byte-string with lowercase letters as: b'aa11111'.
def f(s):
 d=l=L=p=0
 for c in s:C=0!=d==c-l;p+=(c==l)+C*L;L=3>>C;d=c-l;l=c
 return p

Try it online!

131 bytes

C=0!=d==c-l is even shorter.

R, 153, 145, 143 bytes
function(x){p=0;s=sum;if(x[1]==x[2])p=1;a=diff(strtoi(x[3:7]));p=p+s(a==0);l=sort(table(a[a!=0]),T);(p=p+s(l[(l[((s(l)>0)&(l[1]>1))]+1)>2]+1))}

Anonymous function that takes a character vector and returns an integer.
Expected input z(c("A", "A", "1", "1", "1", "1", "1"))
Try it online!
Ungolfed version
function(x){
  pnt <- 0; s <- sum
  if(x[1] == x[2]) pnt <- 1
  a <- diff(strtoi(x[3:7]))
  pnt <- pnt + s(a == 0)
  l <- sort(table(a[a!=0]), T)
  (pnt <- pnt + s(l[(l[((s(l) > 0) & (l[1] > 1))] + 1) > 2] + 1))
}

Java 8, 195 bytes
a->{int r=a[0]==a[1]?1:0,i=3,j,p=a[2],x,y,z;for(;i<7;p=a[i++])for(r+=(x=a[i])==p?1:0,j=-4;++j<4;r+=j==0?0:i<6&&p+j==x&x+j==(y=a[i+1])?++i<6&&y+j==(z=a[i+1])?++i<6&&z+j==a[i+1]?5:4:3:0);return r;}

Can definitely be golfed some more by using another technique to check for sequences.
Explanation:
Try it here.
a->{                      // Method with character-array parameter and integer return-type
  int r=                  //  Result-integer
        a[0]==a[1]?       //   If the two letters are equal:
         1                //    Start this result-integer at 1
        :                 //   Else:
         0,               //    Start the result-integer at 0 instead
      i=3,j,              //  Index-integers
      p=a[2],x,y,z;       //  Temp integers
   for(;i<7;              //  Loop (1) from index 3 to 7 (exclusive)
       p=a[i++])          //    And after every iteration: Set `p` and raise `i` by 1
     for(r+=(x=a[i])==p?  //   If the current digit (now `x`) equals the previous `p`:
             1            //    Raise the result-integer by 1
            :             //   Else:
             0,           //    Keep the result-integer the same
         j=-4;++j<4;      //   Inner loop (2) from -3 to 3 (inclusive)
       r+=j==0?           //    If `j` is 0:
           0              //     Skip it, so keep the result-integer the same
          :i<6            //    Else-if `i` is not 6,
           &&p+j==x       //    and the previous digit `p` + `j` equals the current digit,
           &x+j==(y=a[i+1])?
                          //    and the current digit `x` + `j` equals the next digit `y`:
            ++            //     Raise index `i` by 1 first,
              i<6         //     and check if `i` is not 6 again,
              &&y+j==(z=a[i+1])?
                          //     and if the new current digit `y` + `j` equals the next digit `z`:
               ++         //      Raise index `i` by 1 first again,
                 i<6      //      and check if `i` is not 6 again,
                 &&z+j==a[i+1]?
                          //      and if the new current digit `z` + `j` equals the next digit:
                  5       //       Raise the result-integer by 5
                 :        //      Else:
                  4       //       Raise it by 4 instead
              :           //     Else:
               3          //      Raise it by 3 instead
           :              //    Else:
            0             //     Keep it the same
     );                   //   End of inner loop (2)
                          //  End of loop (1) (implicit / single-line body)
  return r;               //  Return the result-integer
}                         // End of method

Perl 5 -pF, 116 89 bytes
$a.=($_=(ord$F[++$t])-ord)?chr$_+77:++$;for@F[0..@F-2];$_=$a=~s/(\S)\1+/$;+=length$&/ge+$

Try it online!

Pyth, 48 42 bytes
Direct port from my python answer. Takes input as a byte-string with lowercase letters as: b'aa11111'.
This is my first time coding in Pyth, so any tips are welcome :D
KJ=b0VQ=d&KqK-NJ=+b+qNJ*dZ=Z-3yd=K-NJ=JN;b

Try it here

Pyth,  51  50 bytes (staggering)
+/|R0.+QZslM.MlZ+kfTsmm?&!-K.+sMkhK.AKkY.:>Q2d}3 5

Verify all test cases or Try it here.

I now realize I can make it shorter, but will update if I am able to golf it consistently.

C (gcc), 91 bytes
f(p,r,d,D,s,l)char*p;{for(r=D=0;d=p[1]-*p,*++p;D=d){s=d&&d==D;r+=!d+s*l;l=3-2*s;}return r;}

Try it online!
Idea stolen from Felipe Nardi Batista's Python answer.

JavaScript, 216 192 186 202 201 bytes
function f(s){var a=s.split(" "),c=a[1],a=a[0],r,h=b=i=p=0;for(i=0;i<4;i++){if(i<2&(r=a[i+1]-a[i]==a[i+2]-a[i+1])){p++;b=2}if(i>0){if(a[i]==a[i-1]){p++;h++}if(i<3&c[i]==c[i-1])p++}}return h==4?p+b:p-b}

Unminified
function f(s){
    var a=s.split(" "),c=a[1],a=a[0],r,h=b=i=p=0;
    for(i=0;i<4;i++){
        if(i<2&(r=a[i+1]-a[i]==a[i+2]-a[i+1])){
            p++;
            b=2
        }
        if(i>0){
            if(a[i]==a[i-1]){
                p++;
                h++;
            }
            if(i<3&c[i]==c[i-1])
                p++;
        }
    }

    return h==4?p+b:p-b
}

Edit history:

Narrowed down the code to only work with 0000 XXX format. (-24 bytes)
Edits as suggested by @Titus. (-6 bytes)
fixed a bug where four identical numbers gave a score of 7 instead of 3. (+16 bytes)
Removed last semi-colon. (-1 byte)
Fixed a typo in the code. (no byte change)

How do i count the bytes?

Byte counter

im really hating the fact that the code block isn't recognizing the language...

Do want syntax highlighting?

btw, 0000 gives 7 points, is that correct? (it's getting read as an arithmetic sequence and a repeated number sequence at the same time)

0000 should score 3 points.

Welcome to PPCG! Try <!-- language: lang-javascript -->. You could golf this further down with b=i=p=0, q instead of ap, b=2 and return p+b. You can probably also use & instead of &&. p+=(condition) instead of if(condition)p++ might also work. Where do You use j?


text:
Simple State Sales Tax Calculator
Sales taxes in the United States are complicated, to say the least. Generally, there's a state sales tax (there are a handful of states that do not collect a state sales tax), but there could also be a county sales tax, a school district sales tax, a municipal (city) sales tax, or a metropolitan area sales tax. There could even be different sales taxes in different parts of a city. For the purposes of this challenge, however, we're going to focus on just the state sales tax.
Given a U.S. dollar amount greater than zero (accurate to two decimal places) and a state (either the full name or the two-letter abbreviation, your choice, case doesn't matter), and using the below chart of sales tax percentages, output the corresponding state sales tax required to be collected for that particular sale, accurate and truncated to two decimal places. Please specify how your code handles rounding.
Edit: The abbreviation for Washington was listed incorrectly as WS instead of WA. Answers may use either abbreviation, since that was my goof.
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%

Example for California at 6% state sales tax --
CA
1025.00

61.50

Example for Minnesota at 6.875% --
MN
123.45

8.49

inb4 Mathematica builtin.

Minnesota       MN  6.875% - because .005% is, well, actually a lot.

@MagicOctopusUrn Also because Minnesota has to be different. The actual law is spelled out as a fraction "six and seven-eighths of a percent" (or somesuch) rather than a decimal, so that's why it's a weird number.

Also why do OR, AK and MT have 0% sales tax, is that true??

@MagicOctopusUrn Yes, that's true. There are a handful of states that don't collect state sales tax on any purchase. There may still be county/city/etc. sales tax.

Ahhh... right... this isn't income tax.

Do I have to truncate the values or is rounding okay?

@JungHwanMin Since we're dealing with currency, it doesn't make sense to have more than two decimal places.

@AdmBorkBork I mean, does 0.495 have to become 0.49 or can I round it up to 0.50?

@JungHwanMin Up to you, just specify how you handle it.

Does case matter for the input?

@Shaggy No, case doesn't matter.

Pedantry:  the state abbreviation for Washington is WA, not WS.

@MichaelSeifert Typo on my part. Thanks for pointing it out.

Truncation would mean 0.495 -> 0.49. Rounding could be 0.50 or 0.49 depending on the rule. Removing truncation and just saying how you round to 2 decimal places is up to you would probably be clearer.

Mathematica, 112 103 77 76 66 bytes
Mathematica has a builtin for everything
NumberForm[Interpreter["USState"][#]@"StateSalesTaxRate"#2,{9,2}]&

Takes a state name (any format; abbreviation or full name) and the dollar amount.
Try it on Wolfram Sandbox
Usage
f = NumberForm[Interpreter["USState"][#]@"StateSalesTaxRate"#2,{9,2}]&

f["CA", 1025.00]

61.50

f["miNnNesToA", 123.45]

8.49

Explanation
Interpreter["USState"][#]

Interpret the input as a US State name and generate an Entity.
... @"StateSalesTaxRate"

Get the sales tax rate.
... #2

Multiply that by the second input.
NumberForm[..., {9,2}]

Format the result into a number with 9 digits to the left of the decimal and 2 digits to the right.

Mathematica. Of course...

This is just getting silly now!

Why do you need to use an API as long as the string to get the 142nd property?

There's a semi-serious pedantic point here. Given that Mathematica sources its real-word data from a constantly updating datastore, what happens when the tax rate of a particular state changes? Doesn't this answer then become invalid with respect to the spec given in the question?

@ymbirtt should be fine per this meta discussion.

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„ .‡#è*т/}

Try it online!

RIP Mathematica wins.

All this does is compresses the following strings:
AKDEMTNHOR CO ALGANYHIWY MO VA SDOK NV UT NC LANDWI NM MENE AZ OH ILMATX CT ARKSWS MN NJ INMSRITN

And:
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

Then uses the index of the input state to determine the index of the rate, defaulting to 6, because there are so many states with 6%.

For others to consume:
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

Note this only works because I ordered the states such that no intersection of 2 states creates a different state E.G. (OHIN contains [OH,IN,HI] whereas INOH only contains [IN,OH])

Most of the ideas for this came from my previous state-based entry.

TIO link has -d flag

@H.PWiz That's for visualizing the stack. If you remove it, you will see the regular output of the program.

@H.PWiz it's for visualization purposes only, takes it command-by-command and lets you see why the program works.

Ah, I thought it was left in by mistake.

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)

Takes the state as an abbreviation (all caps).
state.abb is the builtin R data with the state abbreviations in alphabetical order, so it hardcodes the sales taxes, finds the index of the state, calculates the sales tax, and formats to 2 decimal places (output as a string).
Try it online!

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 thanks to @MagicOctopusUrn by removing the semicolons.
Explanation:
Try it here.
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

If you use the ordering from my answer you can remove all semicolons in your strings.

HI;NY and  MT;NH are currently the only things in your code stopping you from removing all semi-colons. Reverse the order of both and it'd work for like 20 bytes saved.

@MagicOctopusUrn Thanks, edited! Btw, you might want to add the states for 7 to your answer as well (although TN does interfere with the current order of 0).

@MagicOctopusUrn INMSRITN 7.00 & AKDENHORMT 0.00 is possible without conflicting with anything else.

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

Try it online!

You can save 9 bytes by directly addressing Arrays as java.util.Arrays and getting rid of the import statement. I'd include a TIO link but it's too long. :P

You can save a few more bytes by removing final; changing double to float; changing Double.parseDouble to new Float; and changing (s,a)-> to s->a-> by using currying. Here is the TIO-link to see how.

Oh, and you can also remove all commas and trailing zeroes and change substring(3) to substring(2): TIO 415 bytes. That's shorter than my Java answer.. ;)

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

Must be passed parameters like so:
1025
CA

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

Thanks to @Mr.Xcoder.

233 bytes

195 characters, 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. It uses packed strings (those that start with .")

I thought only .Z was available. Thank you again ;-).

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}

So, huh. This is pretty contrived, I guess. This uses Perl 6's meta-operators, like X=> here, which is X (cross product) combined with =>.
That means <ME NE> X=> 5.5 (where <ME NE> means ('ME', 'NE')) gets => 5.5 applied on each element of the array, yielding ME => 5.5, NE => 5.5. The parentheses are merely here for precedence...

As a golfer (erm...), I obviously didn't write that one by hand (except the actual function). So I wrote a meta-golfer to generate the most efficient combination!
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
}

It generates both the X=> cases and the more simple case (with each one being enumerated), and I picked the shortest one (the former).

JavaScript (ES6), 227 224 bytes
Takes input in currying syntax (s)(v) where s is the state and v is the amount. Uses floor rounding.
s=>v=>(v*(p=s=>parseInt(s,36))('3344bk50k4mo28k4we4tm5eg3uw48s5az39i3js5b43yi3ny4fq3h03mk3bg'.substr(p('k039017k00038f00030022h00g000j00k600k080k707h30706800ba0030305ic0303303930460000e00d2'[p(s)*84%943%85])*3,3))/1e3|0)/100

Demo

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

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)

Try it online!
Very simple: the data is stored data as two chars + list of digits: every percentage is less than 10, thus it can be stored as integer part (1 digit) + decimal part (0-... digit(s)).

C#, 318 309 bytes

Data

Input String s The 2 letter abbreviation of the state uppercase.
Input Double v The value
Output String The tax value to be collected rounded to 2 decimal places

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

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

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

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

Releases

v1.0 - 318 bytes - Initial solution.
v1.1 - - 9 bytes - Changed the .ToString("F2") used in the first return to interpolated strings.

Notes

None

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

Try it online!
Beautified
// 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)
}

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}

Try it online!
A respectable score, but nowhere near Mathematica.
I did add 2 bytes by having a newline print after each check, but I think it's prettier that way :)
(Hopefully it's obvious that input should be the state abbreviation and a value on one line. )

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
When do I get my sandwich?

Given one of the following inputs: Sweet Onion Chicken Teriyaki
Oven Roasted Chicken
Turkey Breast
Italian BMT
Tuna
Black Forest Ham
Meatball Marinara output a number from 1-7 (or 0-6) representing the day of the week that you get that deal, starting with Monday as the lowest number. Input can be all lowercase or uppercase if preferred (i.e "italian bmt"). No internet allowed.

Don't really see how this Kolmogorov complexity. The text is the input...numbers are the output.

Fixed inputs and outputs are considered [tag:kolmogorov-complexity] by some people.

Also does Sunday say "Meatball Marinara" or "Meatball Marina Ra"?

I'm pretty sure it's supposed to be Marinara but the keming in the image is pretty awful...

@i cri everytim do you mean kerning?

@Restioson Yes, that was an intentional typo. :P

If it's useful to anyone: the number of a's plus the number of e's in each input is [5,4,3,2,1,3,6] respectively.

When you use sudo.

@jpmc26 That doesn't work, and in fact, might be dangerous.

How am I seeing this question?  I have ad-blocker turned on.

Python 2, 38 30 28 bytes
lambda S:`6793**164`[len(S)]

Try it online!
Unfortunately still one byte longer than the best Python 2 answer thus far; though not using the enklact-approach.
Now one byte shorter than i cri everytim's answer!
How does it work?
After a lot of brute force, I found an expression that results in a number which has just the right digits.
I noticed that looking at only one specific digit of the given string's lengths required 3 bytes (%10). So I wrote another Python program (Pastebin link) to further search for numbers who directly map the input strings' lengths to the day of the week.
The magic number looks like this: 6793**164 = 28714733692312345620167113260575862840674216760386883406587492336415023761043044176257567032312859371641211117824224067391750766520256112063756278010050204239810862527958109285342869876264808102743173594017101607983288521836082497514383184553444755034407847810524083812459571382103831904835921560285915349760536969265992879312869538914200854305957428078269094250817029486005437991820466986793657301214564264748923199288698278615871481529585816783654841131577178922192383679718074693535597651237893794976519274268917335387876260270630339777501802739852278932279775510324916969726203688466311848240746465178859847331248655567344801 (a number with an impressive 629 decimal digits)
And as you can see, the number provides the necessary mapping from [28, 20, 13, 11, 4, 16, 17] to [0, 1, 2, 3, 4, 5, 6] (Python strings are 0-indexed):
2871  4  733692  3  1  2  34  5 6  20  1  6711326  0  5758628406742167603868834...
    [4]^      [11]^ [13]^  [16]^  ^[17]  ^[20]       ^[28]
My program also found other expressions which yield numbers with the required property, though they take more bytes to represent (29 instead of 28): 19439**540, 34052**726, 39311**604, 44873**182, 67930**164 and 78579**469. (Those are all the expressions found by the linked program; its execution took several hours.)
Alternative function that requires 28 bytes: lambda S:`7954<<850`[len(S)]
Alternative function that requires 29 bytes: lambda S:`9699<<2291`[len(S)]
Alternative function that requires 30 bytes: lambda S:`853<<4390`[len(S)+9]
Alternative function that requires 31 bytes: lambda S:`1052<<3330`[len(S)+8]
How does it work? How did I generate that number? (30 byte answer)
The 30 byte answer was lambda S:`3879**41`[len(S)%10].
Looking at the input string's lengths [28, 20, 13, 11, 4, 16, 17], I noticed that all last digits in base ten differ, resulting in the list [8, 0, 3, 1, 4, 6, 7]. So I only needed a mapping from that list to the list of all seven days of the week, [0, 1, 2, 3, 4, 5, 6].
My first approach simply used a string to perform the mapping: lambda S:"13*24*560"[len(S)%10], though the string required eleven bytes ("13*24*560").
So I wrote a Python program (Pastebin link) to test for arithmetic expressions which result in an integer with matching digits, hoping to further golf the program. What I came up with thus far is `3879**41` (only ten bytes, the only and thereby smallest expression my program finds).
Of course, there are many different possible expressions one could try; I just got lucky that there was one in the form a**b with a reasonably small result that fit my need.
Just for anyone curious, 3879**41 = 1372495608710279938309112732193682350992788476725725221643007306215781514348937145528919415861895033279220952836384201346579163035594383625990271079 = 1.372... * 10**147.
Another valid function I found whilst searching for alternative expressions that unfortunately requires 32 bytes: lambda S:`7**416`[len(S)%10+290]

How did you generate that number? :o

@icrieverytim Brute force.

-9114**28 is a smaller integer* that also works (*in absolute terms not just because it is negative -- 111 digits rather than 629). Does not save on bytes though.

Every once in a while I check the PCG questions in HNQ, and am usually disappointed to find golfing languages are the top three spots. Today i was not disappointed. Thank you!

Now comes a magic number solution to all questions

@Nobody Well, if you have the computational power, sure!

@icrieverytim 7954<<850 is already listed as an alternative function.

@icrieverytim ಠ_ಠ that's just the same number but halved with a shift factor of one more ಠ_ಠ :P

Python 2, 29 bytes
lambda s:'enklact'.find(s[3])

Try it online!
Explanation
The magic string, enklact, was found by looking for the first column with unique letters.
The first column goes SOTITBM which is not useful 'cause it contains duplicates. The second and third ones also don't work because they are wvutule and eeranaa respectively. The fourth column, however works as it has all unique letters.
lambda s:'enklact'.find(s[3])

lambda s:                      # declare a function that takes a single paramater s
                  .find(    )  # find the index of the first instance of...
                        s[3]   # the fourth (0-indexing) character of s...
         'enklact'             # in the magic string

Python, 26 bytes
lambda S:1923136>>len(S)&7

Try it online!
With a debt of thanks (for my second straight code-golf try) to Jonathan Frech's answer -- I wouldn't have thought to use the string length instead of a distinguishing letter!
This code derives from my experience with De Bruijn Sequences and programming for chess.
In chess, you often work with several 64-bit integers, where each bit indicates something is true or false about the corresponding square on the chessboard, such as "there is a white piece here" or "this square contains a pawn".
It is therefore useful to be able to quickly convert 2**n to n quickly and cheaply.  In C and C++, the quickest way to do this is to multiply by a 64-bit De Bruijn sequence -- equivalent to shifting by n bits -- then right-shift 58 (to put the first six bits last -- make sure you're using an unsigned int or you'll get 1s half the time) and look up this 0..63 number in a table that gives you the corresponding n which is in the same range, but rarely the same number.
This is kind of related.  Instead of changing from 2**n to n, however, we want to change from n to some other 3-bit number.  So, we hide our 3-bit numbers in a magic 31-bit number (a 28-bit shift requires bits 28-30, with numbering starting at 0.)
I generated the number needed by just seeing what values had to fall where (trying both 0..6 and 1..7 as the output sets).  Fortunately, the overlapping values (14, 16, and 17) happen to work out!  And since the first tri-bit is 000 and the next is 001, we don't need the leftmost 7 bits, resulting in fewer digits -> fewer bytes of source.
The required number is 000xxxx001110101011xxxx100xxxx, where the x's can be 1 or 0 and it doesn't affect the result for these particular subs -- I set them to 0 just to minimize the number, but changing any of the last 8 xs shouldn't affect the source code's length.  Setting all the xs to 0, and leaving off the start, gives 1923136 in decimal (or 1D5840 in hex, but then you need the 0x prefix -- shame!)  The &7 at the end just masks the last 3 bits, you could also use %8, but then you'd need parentheses due to python's operator precedence rules.
tl;dr: 1923136 encodes each of the three-bit combinations from 0 to 6 in exactly the right spots that these sandwich names happen to fall in place, and then it's a matter of taking the last three bits after a right shift.

Quite similar to my bit mask approach, but even better.

Jelly, 10 bytes
What's with all this "enklact" business?
⁽ṃXị“Ð$¥»i

A monadic link taking a list of characters and returning the Monday=1 day of the week.
Try it online! or see the test-suite
How?
⁽ṃXị“Ð$¥»i - Link: list of characters, sandwichName  e.g. "Tuna"
⁽ṃX        - base 250 literal                             -7761
   ị       - index into sandwichName (1-indexed & modular) 'n'
    “Ð$¥»  - dictionary word                               "retinal"
         i - index of                                           5

How did you find the -7761/retinal combo?

Wrote a loop that ran through creating "words" and seeing if they existed in the dictionary. "retinal" was the only one between -32249 and 32250 (the range of ⁽...)

...slight mistake - the range of ⁽.. is actually [-31349,32250]-[-99,999] (there are also other numbers one may represent with three or less bytes like 7!! or ȷ76)

C (gcc), 72 71 56 46 41 39 bytes
f(char*s){s=index(s="enklact",s[3])-s;}

Try it online!

i;char x[]="enklact"; is shorter than i,x[]={101,110,107,108,97,99,116};.

Was about to post that to: char*x="enklact" is even shorter: Try it online!

Also, you can remove i=0.

Even shorter version using index: Try it online!

@scottinet Nice! I've never used index() before.  Thanks

It's old, deprecated and POSIX only, but it's also 1  byte shorter than strchr :-)

MATL, 16 15 bytes
O5OHlO7KI6vjYm)

Try it online! Or verify all test cases.
Explanation
O5OHlO7KI6 % Push numbers 0, 5, 0, 2, 1, 0, 7, 4, 3, 6
v          % Concatenate all numbers into a column vector
j          % Push input as a string
Ym         % Mean (of ASCII codes)
)          % Index into the column vector (modular, 1-based, with implicit rounding)
           % Implicit display

Perl 5, 24 bytes
23 bytes code + 1 for -p.
/[Svrl\s](?!a)/;$_="@+"

-4 bytes thanks to @nwellnhof!
Try it online!

Jelly, 11 bytes
4ị“-ƭɼoṚ0»i

Try it online!
Explanation:
4ị“-ƭɼoṚ0»i
4ị          4th element of z
  “-ƭɼoṚ0»i First index in "enklactate"

Yeah, compressed strings makes it 13 bytes, sadly

@Mr.Xcoder unless I use enklactate instead of enklact for my string, in which case it brings it down to 11 ;)

Oh, for fudge's sakes, why is enklactate in Jelly's dictionary?

@icrieverytim It's not, enk is a string and lactate is a word. EDIT: just confirmed, enklactate isn't in the dictionary.

@icrieverytim I think it's just lactate.

Aw maaan, I wanted to find a way to mock Jelly's dictionary... Maybe next time. :P

Every time I see a frustratingly short PCG answer written in Jelly, it makes me jelly.

I thought I would post a couple of other alternatives
Javascript 38 bytes
a=s=>(271474896&7<<s.Length)>>s.Length

Explanation: Bit-mask rocks?
Javascript 27 bytes
s=>"240350671"[s.length%10]

the 2nd alternative is 29 bytes long forgot a=

Why is the a= part needed? Look at Shaggy's answer.

@BrunoCosta On this site, we don't require you to name your functions. Anonymous ones work, so you don't need the a=.

@Riker Yeah I read that some time ago in meta but I like the fact that you are able to paste it into console and test it without modifications.

@BrunoCosta tha'ts cool, it's really up to you.  You can also just not count it in the header byte count, and include it in the snippet for ease of testing.

Can that first alternative be reduced by assigning s.Length to a variable?  I don't know JS that well, but I'd think this should work.

@MichaelBoger Unfofrtantly I don't think it can because the minimum amount of code to make that work I believe it's something along the lines of
a=s=>{b=s.Length;return(271474896&7<<b)>>b}

a=s=>(271474896&7<<(l=s.length))>>l

Japt, 12 bytes
0-indexed, takes input in lowercase.
`kÇXsm`bUg#

Test it

Explanation
Implicit input of lowercase string U
`kÇXsm`

The compressed string kotinsm.
bUg#

Get the first index (b) of the character at index (g) 26 (#) in U. (Yay, index wrapping!)
Implicit output of integer result.

Alternative
Same as the above (and everyone else!), just using the characters at index 3 instead, allowing for title case input.
`klact`bUg3

Test it

Where'd the en go? :P

@icrieverytim: that's a compressed string; en is compressed to an unprintable.

I think I see a bUg in your code.

05AB1E, 11 bytes
Saved 1 byte thanks to Erik the Outgolfer and 1 byte thanks to Magic Octopus Urn.
.•ΛΓ2º•I3èk

Try it online!

"enklact" -> ’enkl†¼’

’enkl†¼’ -> .•ΛΓ2º•

@MagicOctopusUrn Oh thanks

@Mr.Xcoder this is how I got that.

@MagicOctopusUrn Will keep in the archive, thanks :p

JavaScript (ES6), 25 bytes
0-indexed.
s=>"enklact".search(s[3])

Test it

o.innerText=(f=
s=>"enklact".search(s[3])
)(i.value);oninput=_=>o.innerText=f(i.value)
<select id=i><option selected value="Sweet Onion Chicken Teriyaki">Sweet Onion Chicken Teriyaki</option><option value="Oven Roasted Chicken">Oven Roasted Chicken</option><option value="Turkey Breast">Turkey Breast</option><option value="Italian BMT">Italian BMT</option><option value="Tuna">Tuna</option><option value="Black Forest Ham">Black Forest Ham</option><option value="Meatball Marinara">Meatball Marinara</option></select><pre id=o>

This is 25 bytes!

Thanks, @geokavel. Don't know where I got those extra 3 bytes from; even counting f= would only make it 27.

simple and effective solution. +1 :)

@Shaggy Maybe your third extra byte was a trailing newline.

GolfScript, 12 bytes
{+}*93&(5?7%

Try it online!
Maps the inputs (via the sum of their code points) to 0 to 6.
Explanation
Found with a GolfScript snippet brute force tool I wrote a while ago...
{+}*  # Sum all code points.
93&   # ... AND 93.
(     # Decrement.
5?    # ... raised to the fifth power.
7%    # ... modulo 7.

Here is how this transforms each of the inputs to the desired result:
                                 {+}*   93&     (            5?   7%
Sweet Onion Chicken Teriyaki     2658    64    63     992436543    0
Oven Roasted Chicken             1887    93    92    6590815232    1
Turkey Breast                    1285     5     4          1024    2
Italian BMT                       965    69    68    1453933568    3
Tuna                              408    24    23       6436343    4
Black Forest Ham                 1446     4     3           243    5
Meatball Marinara                1645    77    76    2535525376    6

Excel, 28 bytes
Using the enklact method:
=FIND(MID(A1,4,1),"enklact")

You can drop 2 bytes by converting this to Google Sheets and dropping the ")

Perl 6, 22 bytes
tr/enklact/^6/.comb[3]

Try it online!

perl 2017.07 accepts tr/enklact/^6/.comb[3] which would be 22 bytes, but tio.run apparently does not have it yet.

(tio.run runs perl6 v2017.6)

As long as an interpreter exists that can run the 22 byte version, it's valid.

CJam, 11 bytes
l1b93&(5#7%

Try it online!
A port of my GolfScript answer. It costs 1 byte to read the input explicitly, but we save two when summing the code points.

Husk, 10 bytes
%7^5←n93ṁc

Try it online!
Another port of my GolfScript answer. I'm sure eventually I'll find a language that can sum the code points for a single byte...
Husk (post-challenge update), 9 bytes
%7^5←n93Σ

Try it online!
Now, Σ does sum code points directly. Since this was added per a request after I answered this challenge, I'm not going to use it as my primary score though.

Perl 5, 43 + 1 (-p) = 44 bytes
for$i(S,O,TUR,I,TUN,B,M){$"++;$_=$"if/^$i/}

Try it online!
Requires the first three characters of input to be upper case.

It has to be all uppercase, all lowercase, or regular.

Call it all uppercase, then.  Anything beyond the first three characters is ignored.

C++, 119 118 77 76 73 bytes
-41 bytes thanks to Peter Cordes
-1 byte thanks to Zacharý
-3 bytes thanks to Michael Boger
At the string index 3, character for every sandwich is different
#include<string>
int s(char*p){return std::string("enklact").find(p[3]);}

std::initializer_list<char*> t{
    "Sweet Onion Chicken Teriyaki",
    "Oven Roasted Chicken",
    "Turkey Breast",
    "Italian BMT",
    "Tuna",
    "Black Forest Ham",
    "Meatball Marinara"
};

for (auto& a : t) {
    std::cout << s(a);
}

Golfing with std::string, that was obvious ofc... what was i thinking...

std::find in a string literal (or maybe a std::string) seems like the obvious way to go.  Basically the same idea as index or strchr that the C answers are using, in a data structure where the 0-5 is implicit from the position.

You can remove the newline inbetween lines 2 and 3.

You don't need a variable to store enklact. std::string("enklact").find(p[3]) works fine. This brings it down 3 characters.

You CAN pass string literals to your function (g++ only raises a warning) so the memcpy stuff isn't needed.

Pyth, 13 bytes
x"enklact"@w3

Verify all the test cases.
Alternative:
x."atÖÅû"@w3

3 can be substituted by any of the following values: [3, 4, 11, 13, 21, 24, 25, 26]

Java 8, 26 bytes
Credit to @icrieverytim
Takes input as a char[]
s->"enklact".indexOf(s[3])

You can do s->"enklact".indexOf(s[3]) if you specify that you take input as a char array.

Is that okay? I've a few answers that can be shortened like that

Pyke, 12 bytes
3@"enklact"@

Try it here!

Proton, 23 bytes
s=>'enklact'.find(s[3])

Try it online!
:P

Haskell, 36 bytes
-9 bytes thanks to H.PWiz.
f s=length$fst$span(/=s!!3)"enklact"

Try it online!
Alternate solution, 45 bytes
This uses the indexOf function in Data.List as elemIndex.
import Data.List
(`elemIndex`"enklact").(!!3)

Try it online!

37 bytes

@H.PWiz Oh, neat abuse of break. Thanks!

36

@H.PWiz Haha, how'd I miss that. XD

Golfscript, 13 bytes
Try it online!
'enklact'\3=?

Takes the 4th character (which, for each, will be unique) and looks it up in the string "enklact".
Alternatively:
'nklact'\3=?)

This takes advantage of the fact that Golfscript's ? function returns -1 if the element searched for is not found (which, for Monday, it will not). If this were allowed, the solution could be reduced by 1 byte.

Dyalog APL, 13 bytes
'enklact'⍳4⌷⍞

Try it online!

C# (.NET Core), 289 bytes
using System;class c{delegate int s(string r);static void Main(){s y=x=>{if(x[0]==83)return 1;if(x[0]==79)return 2;if (x[0]==84&x[2]=='r')return 3;if(x[0]==73)return 4;if(x[0]==84)return 5;if(x[0] ==66)return 6;if(x[0]==77)return 7;return 0;};Console.Write(y.Invoke(Console.ReadLine()));}}

Run online

K (oK), 13 bytes
Solution:
"enklact"?*3_

Try it online!
Examples:
> "enklact"?*3_"Black Forest Ham"
5
> "enklact"?*3_"Turkey Breast"
2

Explanation:
Interpretted right-to-left, pull out the 4th element from the input and return the zero-index location in the "enklact" list:
"enklact"?*3_  / the solution
           3_  / 3 drop, 3_"Turkey Breast" => "key Breast"
          *    / first, *"key Breast" => "k"
         ?     / lookup right in left
"enklact"      / list to lookup element in

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
My device malfunctions... Abuse its undefined string behaviour!
Help! My device malfunctions and whenever I try to repeat a String, I get a messy results. Instead of repeating the same string N times, it fills an NxN square with each of its characters, and stacks the squares up.
For example, given the String "Test" and the number 2, instead of "TestTest", I get:
TT
TT
ee
ee
ss
ss
tt
tt

After I have seen this for a while, I started to like it. Your task today is to reproduce this strange behaviour. Given a non-empty string that consists of printable ASCII only, and a positive integer, output the String my malfunctioning device returns.

All standard rules apply.

The input and output may be handled through any reasonable mean.

This is code-golf, so the shortest code in bytes in each language wins.

Test Cases

Input
Output

----------

"Test", 2

TT
TT
ee
ee
ss
ss
tt
tt

----------

"UuU", 3

UUU
UUU
UUU
uuu
uuu
uuu
UUU
UUU
UUU

----------

"A", 5

AAAAA
AAAAA
AAAAA
AAAAA
AAAAA

----------

You can find a larger test case here. Good luck and have fun golfing!

Borderline duplicate of Enlarge ASCII art

Is a "list of lines" instead of a string separated by newlines valid?

Hmm, I don't see how the "abuse its undefined behavior" from the title actually shows in the task. There is no undefined behavior, the task is to reproduce a quite specifically defined behavior.

it fills an NxN square - Not a correct statement.

Vyxal, 1 byte: * Only works on your machine.

Jelly, 5 bytes
This is exactly what we are asked to do... Abuse undefined behaviour!*
×+⁷×⁴

Try it online!
* By undefined behaviour I am talking about using × for repeating strings. Sometimes it's shorter than usual behaviour, so why not?

Damn, beat me by a minute!

@cairdcoinheringaahing I have a feeling it can be golfed, though :-/

I have used your abuse to golf a different five byter down to four

Jelly, 4 bytes
Inspired by Mr. Xcoder's Jelly abuse
x⁹×Y

A full program taking the string and the number as command line arguments and printing the result (since as a dyadic link it returns a list of strings and newline characters, which may not really be acceptable).
Try it online!
How?
The naive (non-abusive) five byter is:
x⁹x€Y - Main link: list of characters, s; number, n  e.g. "xyz", 2
 ⁹    - chain's right argument, n                         2
x     - times (repeat each element)                       ['x','x','y','y','z','z']
  x€  - times for €ach                                   [['x','x'],['x','x'],['y','y'],['y','y'],['z','z'],['z','z']]
    Y - join with newlines                                ['x','x','\n','x','x','\n','y','y','\n','y','y','\n','z','z','\n','z','z']
      - as a full program: implicit print
      -   note: this could be submitted as a dyadic link (AKA unnamed function)

The abuse used by Mr. Xcoder (Python's operator.mul may act on a str and an int to repeat the str - here single characters - and the atom which uses it, ×, vectorises w.r.t. its left argument) can be used here too to replace x€ with × - yielding the full program:
x⁹×Y - Main link: list of characters, s; number, n  e.g. "xyz", 2
 ⁹   - chain's right argument, n                         2
x    - times (repeat each element)                       ['x','x','y','y','z','z']
  ×  - multiply (vectorises)                             ["xx","xx","yy","yy","zz","zz"]
     -     (note, these "..." are actually strings, something not usually seen in Jelly)
    Y - join with newlines                                ["xx",'\n',"xx",'\n',"yy",'\n',"yy",'\n',"zz",'\n',"zz"]
      - implicit print

heh abuse on challenge about abuse

Haskell, 26 bytes
The function (!) returns a list of lines.
n!s=map(<$[1..n])s<*[1..n]

Try it online!

Bash + GNU Sed, 58
Using a very similar technique to this answer to illustrate how close to being a dup to this that this question is:
printf -vr %$1s
sed "s/./${r// /&}\n/g;s/\S*./${r// /&}/g"

Try it online.

Husk, 5 4 bytes
-1 byte thanks to @Zgarb
SṀRṘ

Try it online!

ṠMRṘ works if you swap the inputs.

05AB1E, 7 5 bytes
-2 bytes thanks to scottinet
ε×²F=

Try it online!
ε     # For each character:
 ×    #   Repeat this character N times
  ²F  #   For 0 .. N:
    = #     Print without popping

-2 bytes by taking advantage of implicit inputs, printing without popping (=) and by replacing vywith ε : Try it online!

I know this answer is almost 6 years old, but you can save a byte by taking the input-string as a list of characters.

PowerShell, 31 bytes
param($a,$b)$a|%{,("$_"*$b)*$b}

Try it online!
Explanation:
param($a,$b)                    # Takes input $a (char-array) and $b (integer)
            $a|%{             } # Loop through every character in $a
                   "$_"*$b      # Construct a string of $b length of that character
                 ,(       )*$b  # Repeat that $b times
                                # Implicit Write-Output inserts a newline between elements

Python 3, 42 bytes
lambda x,y:"".join(y*(r*y+"\n")for r in x)

Try it online!

Japt, 7 bytes
Outputs an array of strings.
VÆmpVÃy

Try it (-R flag for visualisation purposes only)

Explanation
Implicit input of string U and integer V.
VÆ    Ã

Generate an array of integers from 0 to V-1 and pass each through a function.
mpV

Map (m) over U and repeat (r) each character V times.
y

Transpose and implicitly output resulting array.

C++, 125 123 bytes
-2 bytes thanks to aschepler
#include<string>
using s=std::string;s u(s a,int b){s r;for(auto&c:a)for(int i=0;i<b*b;){if(!(i++%b))r+=10;r+=c;}return r;}

Make sure that the overload of the += operator called takes a char data type in this instruction if(!(i++%b))r+=10

using s=std::string; is shorter than typedef std::string s; by two bytes.

MATL, 5 bytes
t&Y"!

Try it online!
Explanation
t     % Implicitly input a number, n. Duplicate
&Y"   % Implicitly input a string. Three-input repelem function. Repeats
      % each entry in the first input (s) the specified numbers of times
      % vertically (n) and horizontally (n). Gives a char matrix
!     % Transpose. Implicit display

Charcoal, 9 8 bytes
-1 thanks to Kevin Cruijssen
ＦＳ«ＧTηι↓

Try it online!
Explanation
ＦＳ        For each character (i) in the next input as a string
   «
    Ｇ   ι  Polygon using i as fill
      T     Right, down, then left
       η    The second input (h) (automatically casted to a number)
          ↓ Move down

I know this answer is nearly 6 years old, but you no longer need the cast and can change Ｉη/Cast(h) to η/h.

smh necroposting lol

Brainfuck, 103 Bytes
,[>,]-[>+<-----]>---[-<<->>]<<[->+<]>[[->+>+<<]>>[-<<+>>]<[<<<[<]>.[>]>>-]++++++++++.[-]<<<[<]>[-]>[>]>

Try it online (Make sure to turn on dynamic memory or it won't run)
Note: The input is slightly different. This code takes in a string where the last character is a digit for number of repeats. So input might look like Test5.
This code requires an unbounded tape, and relies on byte wrapping behavior.
Ungolfed:
,[>,]< Take Input
>-[>+<-----]>--- ASCII 0, to use in next step
[-<<->>]<< Convert ASCII number to raw number by subtracting ASCII 0
[->+<]> Move the number over one to separate it from the phrase
[
  [->+>+<<]>>[-<<+>>]< Copy the number
  [
    <<<[<]> Back to Letter
    . Print Letter
    [>]>>- Back to Counter
  ]
  ++++++++++.[-]< Print the newline
  <<[<]>[-]> Clear Letter
  [>]> Back to Counter
]

J, 15 14 bytes
[:,/]$"1 0~[,[

Sub-optimal for sure. Returns a 2D array of chars. Takes n as the left argument and the string as the right.
On mobile, so the usual amenities are missing.
Explanation
(For old answer)
[:,/(2#[)$"1 0]

$"1 0 reshape each character to
(2#[) an n * n matrix.
,/ join matrices together to yield the output.

5 bytes

@miles brilliant! I'd say that deserves its own answer personally.

@miles post yours :)

SOGLOnline commit 2940dbe, 4 bytes
∙ι*I

This was made for a specific commit, namely the one before I changed ∙ from, when used on an array of strings, repeating each letter x times to repeat each item x times. Here is the online interpreter without that version, which, as can be seen, doesn't work.
To try the commit, download this, open the index.html file, in the program paste ∙ι*I and in the input write something like
Test
2

Explanation:
∙ι*I
∙     get an array with 2nd input amount of items of the 1st input
 ι    pop one implicit input to cycle back to the number
  *   multiply horizontally each separate character
   I  rotate clockwise

If it doesn't work, why the link?

@isaacg good question. First I intended it to write what changed, but forgot

R, 59 bytes
function(S,n)write(rep(strsplit(S,"")[[1]],e=n*n),"",n,,"")

Writes to stdout.
Splits the string into characters, repeats each n^2 times, and then prints with width n and with no separator.
Try it online!

Pyth, 9 bytes
VEp*+*NQb

Try it here!
Pyth, 11 10 bytes
sm*Q+*QdbE

Try it here!
Or, 10 bytes:
jsm*Q]*QdE

Or, 11 bytes:
js*RQm]*dQE
jsm*vzm*dvz
sm*vz+*dvzb

Perl 5, 26 + 1 (-p) = 27 bytes
$"=<>;s|.|($&x$".$/)x$"|ge

Try it online!

This seems to replace each character with a horizontal row of characters, not with a square of characters.

I guess I didn't understand it properly at first.  Fixed it with an extra 5 bytes.

Java 8, 152 128 118 100 bytes
s->n->{for(char c:s)for(int j=0;j++<n;System.out.println("".valueOf(new char[n]).replace('\0',c)));}

Try it online!

100 bytes: s->n->{for(char c:s)for(int j=0;j++<n;System.out.println("".valueOf(new char[n]).replace('\0',c)));}

D, 86 bytes
S u(S,I)(S a,I b){S r;foreach(c;a)for(I i;i<b*b;){if(!(i++%b))r~='\n';r~=c;}return r;}

Try it online!
Takes the string as the left argument, and the integer as the right argument.
This is a port of HatsuPointerKun's C++ answer into D.

APL (Dyalog), 8 bytes
Takes repetition as left argument and text as right argument.
{⍺⌿⍺/⍪⍵}

Try it online!
{…} an unnamed lambda where ⍺ represents the left argument and ⍵ the right argument
 ⍪⍵ make the text into a one-column table
 ⍺/ replicate ⍺ times horizontally
 ⍺⌿ replicate ⍺ times vertically

Japt, 7 bytes
mpV² òV

Returns an array of strings.
Try it online! with the -R flag to join the array with newlines.
Explanation
mpV² òV     Implicit input of U=string, V=number
m           Map each char in the input string to...
 pV²        Itself repeated V² times
     òV     Cut the resulting string into partitions of length V

Thunno 2 N, 3 bytes
Ḅd×

Try it online!
Takes the number then the string
Explanation
Ḅd×  # Implicit input                                  ->  2, "Test"
Ḅ    # Multiply each of the characters by the number   ->  "TTeesstt"
 d   # Split this string into a list of characters     ->  ["T",  "T",  "e",  "e",  "s",  "s",  "t",  "t" ]
  ×  # Repeat each character input number of times     ->  ["TT", "TT", "ee", "ee", "ss", "ss", "tt", "tt"]
     # Implicit output, joined on newlines

C (gcc), 83 79 bytes
i,j;f(p,n)char*p,n;{for(;*p;p++)for(i=n;i--;puts(""))for(j=n;j--;putchar(*p));}

Try it online!

CJam, 11 Bytes
{__*@e*/N*}

Function that takes string followed by int.
Try it Online

Kotlin 1.1 - 99 bytes
fun s(s:String,c:Int)=s.flatMap{p->List(c,{p})}.joinToString("\n"){p->List(c,{p}).joinToString("")}

Returns the whole output as a string.
Can't use TryItOnline as 1.1 is not supported
Test
fun s(s:String,c:Int)=s.flatMap{p->List(c,{p})}.joinToString("\n"){p->List(c,{p}).joinToString("")}

fun main(args: Array<String>) {
    println(s("Hello World", 5))
}

It would be 84 if a list of strings was acceptable as output:
fun s(s:String,c:Int)=s.flatMap{p->List(c,{p})}.map{p->List(c,{p}).joinToString("")}

Mathematica, 49 bytes
(z=#2;Grid[Column/@Table[#,z,z]&/@Characters@#])&

input

["Test",4]

PHP, 97 bytes
for($i=0;$i<strlen($s=$argv[1]);$i++)for($j=0;$j<$r=$argv[2];$j++)echo str_repeat($s[$i],$r)."
";

Pyth, 12 bytes
Small minded, but I haven't gotten there just yet.
VQp*+*Nszbsz

Explanation:
VQ          For every letter in the first input...
  p         Print without newline...
   *+*Nszsz (The index * int(second input) + newline) * int(the second input)

Test Suite

Clojure, 82 75 bytes
#(dotimes[x(count %1)](dotimes[y %2](prn(apply str(repeat %2(get %1 x))))))

Try it online!
Uncompressed:
#(dotimes [x (count %1)]
  (dotimes [y %2]
    (prn
      (apply str
        (repeat %2 (get %1 x))))))

Edit: Shaved a few chars off the end by replacing a for loop with the stdlib repeat function.

C# (.NET Core), 68 + 18 bytes
a=>n=>new int[a.Length*n].Select((x,i)=>Enumerable.Repeat(a[i/n],n))

Also included in byte count:
using System.Linq;

Try it online!
Output is a collection of collections of characters (one collection for each line).
Explanation:
a => n =>                                // Take a string and a number
    new int[a.Length * n]                // Create new collection, 'n' times larger than 'a'
    .Select((x, i) =>                    // Replace every member with
        Enumerable.Repeat(a[i / n], n)   //     a collection of repeated character from 'a', based on index
    )

Clojure v1.8, 63 62 58 bytes
#(map(fn[l](dotimes[i %2](prn(apply str(repeat %2 l)))))%)

Try it online!
Explanation
(map ... s)           For every letter of the string 's'
(dotimes[i %2] ...)   Do 'n' times
(prn(apply str(repeat %2 l))) Repeat the letter 'n' times, combine to string and print

GNU APL, 11 bytes
⍪/⎕{⍺⍺⍴⍵}¨⍞

Left argument: ⍺ number of repetitions. ⍵ the string.
This uses ⍴ to repeat each letter (⍵ in the inner {} block) in ⍺x⍺ matrix.
Then we use ⍪/ to "laminate" them.

Which APL is this? If it works on GNU APL, you can make ⍺ ⍺ ⍺⍺. Also, it might be possible to make it ⍪/⎕{⍺⍺⍴⍵}¨⍞ by receiving input from STDIN (on GNU APL). (Fair warning, I haven't used gnu apl in a while. so this might be wrong.)

Yeah, I just verified, ⍪/⎕{⍺⍺⍴⍵}¨⍞ does work on GNU APL.

⍪/⎕{⍺⍺⍴⍵}¨⍞ also works for 11 bytes, receiving input through STDIN (a line of text, then the number)

Python 2, 46 bytes
x,y=input()
for p in x:print'\n'.join([p*y]*y)

Try it online!

Doesn’t really work for the white square emoji, but that might just be because of decoding errors. Try it online!

Bash, 49 bytes
sed s/./$(printf \&%.s `seq $[$1*$1]`)/g|fold -$1

Try it online!

MathGolf, 8 bytes
*mÅn+m*~

String input as a list of characters.
Try it online.
Explanation:
*        # Repeat each character in the second (implicit) input-list the first
         # (implicit) input-integer amount of times
 mÅn+    # Append a newline to each inner string:
 m       #  Map over each string,
  Å      #  using the following two characters as inner code-block:
   n     #   Push a newline character
    +    #   And append it to the string
     m*  # Repeat each inner string the first (implicit) input-integer amount of times
       ~ # Dump this list of lines with trailing newlines to the stack
         # (after which the entire stack is joined and output implicitly as result)

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
There's no place like home
I recently watched The Wizard Of Oz and thought that when Dorothy taps her shoes together three times, it would be easier if she used a program to do it. So let's help her.
Task
Output slippers being tapped together 3 times.
Output
Slippers being tapped together. A pair of slippers not being tapped looks like this:
  __.....__                   __.....__
 / ,------.\                 /.------, \
(  \        \               /        /  )
\  \      ___\             /___      /  /
 \  \   ,'  __`.         .´__  ',   /  /
  \  `.'  ='  `=\       /=´  '=  '.´  /
   `.  `.        \     /        .´  .´
     `.  `.       \   /       .´  .´
       `.  `-.___.'\ /'.___.-´  .´
         `-._      / \      _.-´
             `----'   '----´

And a pair being tapped together looks like this:
         __.....__     __.....__
        /.------, \   / ,------.\
       /        /  ) (  \        \
      /___      /  / \  \      ___\
    .´__  ',   /  /   \  \   ,'  __`.
   /=´  '=  '.´  /     \  `.'  ='  `=\
  /        .´  .´       `.  `.        \
 /       .´  .´           `.  `.       \
/'.___.-´  .´               `.  `-.___.'\
\      _.-´                   `-._      /
 '----´                           `----'

Basically, output
  __.....__                   __.....__
 / ,------.\                 /.------, \
(  \        \               /        /  )
\  \      ___\             /___      /  /
 \  \   ,'  __`.         .´__  ',   /  /
  \  `.'  ='  `=\       /=´  '=  '.´  /
   `.  `.        \     /        .´  .´
     `.  `.       \   /       .´  .´
       `.  `-.___.'\ /'.___.-´  .´
         `-._      / \      _.-´
             `----'   '----´

         __.....__     __.....__
        /.------, \   / ,------.\
       /        /  ) (  \        \
      /___      /  / \  \      ___\
    .´__  ',   /  /   \  \   ,'  __`.
   /=´  '=  '.´  /     \  `.'  ='  `=\
  /        .´  .´       `.  `.        \
 /       .´  .´           `.  `.       \
/'.___.-´  .´               `.  `-.___.'\
\      _.-´                   `-._      /
 '----´                           `----'

  __.....__                   __.....__
 / ,------.\                 /.------, \
(  \        \               /        /  )
\  \      ___\             /___      /  /
 \  \   ,'  __`.         .´__  ',   /  /
  \  `.'  ='  `=\       /=´  '=  '.´  /
   `.  `.        \     /        .´  .´
     `.  `.       \   /       .´  .´
       `.  `-.___.'\ /'.___.-´  .´
         `-._      / \      _.-´
             `----'   '----´

         __.....__     __.....__
        /.------, \   / ,------.\
       /        /  ) (  \        \
      /___      /  / \  \      ___\
    .´__  ',   /  /   \  \   ,'  __`.
   /=´  '=  '.´  /     \  `.'  ='  `=\
  /        .´  .´       `.  `.        \
 /       .´  .´           `.  `.       \
/'.___.-´  .´               `.  `-.___.'\
\      _.-´                   `-._      /
 '----´                           `----'

  __.....__                   __.....__
 / ,------.\                 /.------, \
(  \        \               /        /  )
\  \      ___\             /___      /  /
 \  \   ,'  __`.         .´__  ',   /  /
  \  `.'  ='  `=\       /=´  '=  '.´  /
   `.  `.        \     /        .´  .´
     `.  `.       \   /       .´  .´
       `.  `-.___.'\ /'.___.-´  .´
         `-._      / \      _.-´
             `----'   '----´

         __.....__     __.....__
        /.------, \   / ,------.\
       /        /  ) (  \        \
      /___      /  / \  \      ___\
    .´__  ',   /  /   \  \   ,'  __`.
   /=´  '=  '.´  /     \  `.'  ='  `=\
  /        .´  .´       `.  `.        \
 /       .´  .´           `.  `.       \
/'.___.-´  .´               `.  `-.___.'\
\      _.-´                   `-._      /
 '----´                           `----'

For reference, the characters used are _-.,/\()='`´
Rules

The output can have an optional leading/trailing whitespace
While not explicitly banned, builtins detract from the competition, so please don't post an answer which is simply a single builtin*
This is a code-golf so shortest code in characters wins. Characters is chosen due to the use of a multibyte character.

* For all you killjoys out there, this rule is intended for comedic effect and shouldn't be taken literally

does leading whitespace include extra spaces before each line (as long as they are the same amount everywhere)?

@dzaima Yes, I'll allow that.

Are you missing the last untap from your output?

@EngineerToast no, sorry, the structure part was left over from the sandbox.

´ makes me sad.

SOGL V0.12, 113 110 108 characters
░╗╬)λ]cw╚╥Æ⁄║RL↓κΟiRDΨ℮≠3*s4sφ¡┐rκ⁾žχ&ν3.ΦƧ⁴ty¬`OΗΒ%Τz׀PΥω╤8⅟∆KΣ⅜4⅔⅝⁰?Z+pķcE□L6⁵/4γ⁽Κ¹‘▓:±↔Ζ`´ŗ⁴@┼⁴┼≥@┼;┼+3∙

Try it Here!
Explanation:
...‘                       push a compressed string of one slipper (one as the top left one) with a leading newline
    ▓                      convert from a multiline string to an array of lines
     :                     dulplicate a copy for reversing horizontally
      ±↔                   reverse horizontally
        Ζ`´ŗ               replace ` with ´
            ⁴              create a copy of the original slipper for the untapped part
             @┼            append a line of spaces after it horizontally
               ⁴┼          append horizontally a copy of the reversed slipper
                 ≥         move this - the untapped version - to the botton of the stack
                  @┼       append a space after the reversed slipper
                    ;┼     append the original slipper after it
                      +    join the two vertically together
                       3∙  multiply vertically three times

Charcoal, 165 127 bytes
Ｆ´´`«‖ＴＰ⪫⪪”}∧≕Ｉ3⁼wＸ¿↔？⁺⊖？◧χêIr﹪≦⎈X⊞c_⁹jＥτＴＣεh⌊Y﹪ＹＹ}φ⬤»[↷¢|nＸ;ＩζCHE⁷ＲrCsd～¢_⊖⦄⎚§⌈▷φＳ¤Iv}›ＲPx!∧⁵Ｆ]üC”`ι»Ｃ⁴²¦⁰Ｃ²¹¦¹²Ｔ⁴²¦²⁴Ｆ²Ｃ⁰¦²⁴

Try it online! Verbose approximation (I don't know how to write ´ in Verbose mode). Explanation:
Ｆ´´`«

Loop twice, once with ´, once with `.
‖Ｔ

Reflect the canvas, transforming the characters, except for the above two, which is why they are special-cased. Note that this causes the right slipper to end up on the left, which is actually correct for the second row.
⪫⪪””`ι»

Print the compressed slipper string, but with `s replaced with the loop character. (Note that the compressed string includes left padding; this means that the reflected string from the first iteration doesn't touch the second string.)
Ｃ⁴²¦⁰

The right slipper is in the wrong place on the canvas, so copy it to the correct place. (This also makes an extra copy of the left slipper.)
Ｃ²¹¦¹²

The second row also needs a copy of the pair of slippers, but this is the same way around as they were originally created. (Actually both pairs get copied, so we now have eight slippers.)
Ｔ⁴²¦²⁴

Delete all unnecessary extra slippers, leaving two rows of two slippers.
Ｆ²Ｃ⁰¦²⁴

Make two additional vertical duplicates of the whole thing.

It doesn't mirror because I don't consider them as opposites, not sure if it would be more useful if they mirrored

Bash + Common Utilities (268 265 258 Bytes)
Saved a few bytes thanks to Justin Mariner
Bash (31 21 Bytes)
gzip -d w;cat w w w

Additional File named w (237 Bytes) (Base64 Encoded so I can paste it here)
H4sICIT6rlkAA3cAbZFbDsQgCEX/WQV/ziQWV+BOTOgiu4JZ2YAWhVYSGxpOfNyDyExazPiuOQMsmIe1F5YoTHK2OCDOIEnWVzzhTYBZo5oYbuOkAXwRnNS9qTJ0e9SMOVJKneScFXWWW3bUn+XcFUWaack6krsxav2DH5QP8LaHNcxG7wkMSYUsOSenc8oIHYAy0ExRYxKCl5ByZtZLrG0ZrzZA9eSvohU54RwQUGa7CTgFEX7OIf2XhTsMveQvSeYBO9j3Rpglf2PrHgCR75Y6zgCrwGfJczBuZjgy1c1QH8Af0NuE5gAwAA

This might be seen as cheating, and I kind of agree :P.

Could you do cat w w w instead of three cats?

PowerShell, 575 bytes 553 551 characters
$a="3__.....__222 __.....__
 / ,1.\2233 /.1, \
(3\23\223 /23/3)
\3\2___\22 /___2/3/
 \3\3 ,'3__0.23 .´__3',3 /3/
3\30.'3='30=\2 /=´3'=3'.´3/
3 0.30.23\33 /23.´3.´
33 0.30.2 \3 /2 .´3.´
2 0.30-.___.'\ /'.___.-´3.´
23 0-._2/ \2_.-´
22 0----'3 '----´

23 __.....__33 __.....__
23/.1, \3 / ,1.\
2 /23/3) (3\23\
2/___2/3/ \3\2___\
33.´__3',3 /3/3 \3\3 ,'3__0.
3 /=´3'=3'.´3/33 \30.'3='30=\
3/23.´3.´2 0.30.23\
 /2 .´3.´233 0.30.2 \
/'.___.-´3.´223 0.30-.___.'\
\2_.-´222 0-._2/
 '----´22223 0----'"
0..3|%{$a=$a-replace$_,('`','------',333,'  ')[$_]}
,$a*3

Try it online!
Simple repeated character replacement. Edit - saved two characters by using $a and looping the replace commands.

Remember, it's scored by characters, not bytes.

@ConorO'Brien Ah, thanks. I missed that.

Python 2, 495 468 bytes
r,R,s,a,b=str.replace,range(12),str.split,"/(`","\\)\xb4";A=B=r(r("  __.....__8 @ / ,------.#8@(  #8#       @#  #      ___#      @ #  #   ,'  __`.    @  #  `.'  ='  `=#   @   `.  `.8#  @     `.  `.       # @       `.  `-.___.'#@8 `-._      /@"+" "*13+"`----' @","#","\\"),"8"," "*8)
for _ in(0,1,2):B=r(r(r(B,a[_],"*"),b[_],a[_]),"*",b[_])
A,B,j=s(A,"@"),[_[::-1]for _ in s(B,"@")],"\n".join
for _ in"*"*3:print j(j(" ".join((A[_],B[_])[::p])for _ in R)for p in(1,-1))

Try it online!
Excited to read Mathematica 12's update notes. (SlippersTapped@3 only requires 16 bytes!)

05AB1E, 140 bytes
"_ ./,-\)'´="•3₅Cæ¶ÿâsΣkÞ₂ÏÕ›|Y=ß°«:ws^N5%ÖΩjĆR["DĀó©›tØ¹oÜ™¾týǝàZ½aÕL.sΔÊÑû8&+››₄|wεŠ8ε¼áNsHÑŽJнi'`³Ö!èÆžIIƵò•11вèJ20ô∞¶¡ε2ä`"´"'`:‚}6FíD»,

Try it online!
Explanation
"_ ./,-\)'´="                                   # push this string
             •...•                              # push a base-255 compressed number
                  11в                           # convert to a list of base-11 numbers
                     èJ                         # index into the string with these and join
                       20ô                      # split in pieces of size 20
                          ∞                     # mirror, giving us a pair of shoes
                                                # both using the char "´"
                           ¶¡                   # split on newlines
                             ε                  # apply to each row
                              2ä`               # split in 2 pieces on stack
                                 "´"'`:         # replace "´" with "`" in the 2nd string
                                       ‚        # pair them up
                                        }       # end apply
                                         6F     # 6 times do
                                           í    # reverse each
                                            D», # print a copy joined on space and newline

Python 2, 328 326 316 bytes
s=[''.join(' '*int(c)if'/'<c<':'else c for c in l)for l in r"2__.....__9 1/1,------.\8 (2\8\7 \2\6___\6 1\2\3,'2__`.4 2\2`.'2='2`=\3 3`.2`.8\2 5`.2`.7\1 7`.2`-.___.'\ 9`-._6/ 94`----'1 0".split()]
r=[''.join(dict(zip("`/\\(","\xb4\\/)")).get(c,c)for c in l[::-1])for l in s]
for a,b in(zip(s,r)+zip(r,s))*3:print a,b

Try it online!

327 bytes

Bubblegum, 219 bytes
00000000: ec93 d1c9 8630 0c00 df33 c5bd e5ff 419b  .....0...3....A.
00000010: 09dc a410 8774 0227 fb34 a0d4 9011 7aa0  .....t.'.4....z.
00000020: 147a 88e4 08b8 b71b 7732 c39d 602c 6bd0  .z......w2..`,k.
00000030: 3a19 6b6b b0d0 e50f 5e21 9b36 1cfe a5bf  :.kk....^!.6....
00000040: 82bb 7f55 73f7 d734 2154 5814 dcf7 c643  ...Us..4!TX....C
00000050: 3b0f 77d0 e531 c3db 9bc2 a6b0 6f1d 02db  ;.w..1......o...
00000060: ce03 7403 6de7 11e6 ed11 cff8 b336 7c3a  ..t.m........6|:
00000070: 5e02 490d d30a ed15 d7e6 ee4d 3ba6 715a  ^.I........M;.qZ
00000080: 9344 2804 4627 082d 8cc1 ba50 40ef c375  .D(.F'.-...P@..u
00000090: 2b90 cba4 4e45 1218 e349 d582 4f35 a922  +...NE...I..O5."
000000a0: f0cd 25d5 f821 9792 6af6 00b9 9314 a327  ..%..!..j......'
000000b0: c899 042b bda2 93a4 f933 905b c990 2189  ...+.....3.[..!.
000000c0: b998 3c3d c8e4 7422 30f7 6bee d7dc afb9  ..<=..t"0.k.....
000000d0: 5f73 bfe6 7efd 36e4 f217 00              _s..~.6....

Try it online!
Format: DEFLATE
Maximum attempted iterations: 10000
Decompressing iterations: 1019

JavaScript, 455 bytes
for(_="  Y#YXY WWWV#VU---T.TT, S ,TT.R__QW/PQ_O/OWPY/N%.Y%MM-.O.'L%-._WPK.´JJYJI#0H-´G/'.O.GYJFJQY',PY/EV DX#W,'YQ%.C/=´Y'=Y'JY/BX%.'Y='Y%=#AD @Q.....Q?@ >Y?>> ?0 /R#>@/SH(Y#@#>WP@/Y)0XUO#>W N0 C>E0YADB0WM.@XP@I0WYM.D#PDI0DL# F0>K U_.G0>W %T-'W'TG0>?WY?0@/S#PRHD/@/Y) (Y#@HVN XUOHW EWC0WBWYA0Y/@IDM.@H /DI>YM.DHF>VLHU_.G>> K0 'TG>>>%T-'0";G=/[>-Y]/.exec(_);)with(_.split(G))_=join(shift());f=a=>_.replace(/./g,a=>`\\\`
`['#%0'.indexOf(a)]||a).repeat(3)

Try it online!