text:
Fizz Buzz.. Crackle Pop! (Generalized Fizz Buzz)
We've all heard of the ol' Fizz Buzz problem, but what happens when you try to apply it with more factors? Fizz Buzz Crackle Pop!
The Challenge
Write a full program that takes an integer input n, then n tuples containing an integer and a string, then another integer (>1) k, as such:
 n int1 str1 int2 str2 (...) intn strn k

You can take this line from either command line or STDIN.
Then, for all integers 1 to k, if it is divisible by any of int1, int2...intn, output all corresponding strs in the input order, followed by a newline. If it isn't, then just output the integer, followed by a newline.
For example, with input
3 2 Fizz 3 Buzz 5 Crackle 10

we get
1
Fizz
Buzz
Fizz
Crackle
FizzBuzz
7
Fizz
Buzz
FizzCrackle

But with input (notice the order change)
3 3 Buzz 2 Fizz 5 Crackle 10

we get
1
Fizz
Buzz
Fizz
Crackle
BuzzFizz
7
Fizz
Buzz
FizzCrackle

Optional trailing newline is acceptable.
Shortest code in bytes wins.
Edits:
Obviously I've missed out a lot, sorry.

Inputs from console and STDIN, anything else gets +5 bytes (:c) anywhere
Full programs please.
Assume non-empty strings for strs
No guarantees for uniqueness of ints

Sample C++ program (limited at 20 because I'm lazy):
#include <iostream>
#include <string>
using namespace std;

int main() {
  string names[20];
  int mods[20], n, max;
  cin >> max >> n;
  for (int i=0; i<n; i++) {
    cin >> mods[i] >> names[i];
  }
  for (int i=1; i<=max; i++) {
    bool found = false;

    for (int j=0; j<n; j++) {
      if (i % mods[j] == 0) {
        found = true;
        cout << names[j];
      }
    }
    if (!found)
     cout << i;
    cout << endl;
  }

  return 0;
}

Related.

Does the input need to be so rigid? Or could we take in a hashtable/dictionary/array/etc. in language's native format?

Also, welcome to PPCG!

Is a leading newline acceptable?

What if two of the numbers are the same? Will they always be unique positive integers?

What guarantees are there about the numbers: will they all be positive, or at least non-zero? What about the strings: are they all non-empty?

Also: can we submit a function rather than a full program? I'm voting to close as unclear what you're asking until these points are clarified, and before there are too many answers which may turn out to be invalid.

@Arnauld That's the default.

A better title might be Generalized Fizz Buzz.

@mbomb007 True. But the way the question is written, it seems like the OP is expecting a program exclusively ("write a program" and "you can take this line from either command line or STDIN")

Should functions become allowed, someone please ping me unless @Arnauld has meanwhile saved 12 bytes on his answer.

@MartinEnder Kinda related, but more general than just 3.

Would it be too late to add bonus marks? ;))

Thanks for the clarifications. Voted to reopen. The default rules however are to accept either a program or a function, and it is usually encouraged to be quite flexible on the input format (and, maybe to a lesser extent, the output format). So please consider this for your future challenges. (Also, I think you should remove the anything else gets +5 bytes rule. It should be either allowed or not.)

@Arnauld I guess I'll allow it.

May the input be in a different order than specified, i.e. strn intn rather than intn strn?

@R.Kap No it can't

05AB1E, 28 bytes
#¦¤U¨2ôøVXLvY`sysÖÏJDg1‹iy},

Try it online!
Or with a different input format:
05AB1E, 16 bytes
Lv²y³ÖÏJDg1‹iy},

Try it online!

JavaScript (ES6), 90 bytes
Generates a leading newline.
f=(a,i=a.pop())=>i?f(a,i-1)+`
`+(a.map((_,j)=>++j>a[0]|i%a[j*2-1]?'':a[j*2]).join``||i):''

Test

f=(a,i=a.pop())=>i?f(a,i-1)+`
`+(a.map((_,j)=>++j>a[0]|i%a[j*2-1]?'':a[j*2]).join``||i):''

console.log(f([3, 2, 'Fizz', 3, 'Buzz', 5, 'Crackle', 10]))
console.log(f([3, 3, 'Buzz', 2, 'Fizz', 5, 'Crackle', 10]))

Python 2, 98 bytes
lambda b:[''.join(''if x%b[1+i*2]else b[2+i*2]for i in range(b[0]))or`x`for x in range(1,b[-1]+1)]

Try it online!

C++, 194 bytes
#include <iostream>
#define p std::cout<<
int main(int c,char**a){c=2*atoi(a[1])+2;int x,f,i,n=atoi(a[c]);for(x=1;x<=n;x++){f=0;for(i=2;i<c;i+=2)if(x%atoi(a[i])<1)f=1,p a[i+1];if(!f)p x;p'\n';}}

Ungolfed:
#include <iostream>

int main(int c, char **a) {
    c = 2 * atoi(a[1]) + 2;
    int x, f, i, n = atoi(a[c]);
    for (x = 1; x <= n; x++) {
        f = 0;
        for (i = 2; i < c; i += 2)
            if (x % atoi(a[i]) < 1) f = 1, std::cout << a[i+1];
        if (!f) std::cout << x;
        std::cout << '\n';
    }
}

If the result of x%atoi(a[i]) can't be negative, then just check x%atoi(a[i])<1.

@TuukkaX Good point, thanks.

Also, I'm quite sure you can do p'\n' :)

PHP, 99 bytes
Based on primo´s FizzBuzz answer: õ is chr(245), a bit inverted newline.
for(;$i++<($a=$argv)[$z=$argc-1];){for($k=$s="";$z>$k+=2;)$s.=[$a[$k+1]][$i%$a[$k]];echo$s?:$i,~õ;}

ignores the first argument; run with -nr.

JavaScript (ES6), 105 97 bytes
g=(m,k,i=1)=>i<-~k?([...m.keys()].filter(j=>i%j<1).map(j=>m.get(j)).join``||i)+"\n"+g(m,k,i+1):""

Takes in a map of pairs m (integer, string) and an integer k. Comes with a trailing newline.
Here's a non-recursive version (105 bytes), but doesn't yield a trailing newline.
m=>k=>[...Array(k).keys()].map(x=>[...m.keys()].filter(j=>-~x%j<1).map(j=>m.get(j)).join``||x+1).join`\n`

Try it online!

Java, 331 bytes
Because Java.
import java.util.*;class A{A(int c,String x){i=c;v=x;}int i;String v;void x(String[]x){ArrayListl=new ArrayList();int n=0;for(;++n<x.length-1;)l.add(new A(Integer.valueOf(x[n++]),x[n]));n=Integer.valueOf(x[n]);for(int i=1;i++<n;){String o="";boolean y=1>0;for(A a:l)if(i%a.i==0){y=1<0;o+=a.v;}if(y)o+=i;System.out.println(o);}}}

This is the full class required for this. However, in order to run it, you must call the method x on an existing instance of A. For the sake of testing, I have provided a command-line runnable class below, which is partially ungolfed.
import java.util.*;
class A{
A(int c,String x){i=c;v=x;}
int i;
String v;
void x(String[]x){
ArrayListl=new ArrayList();
int n=0;
for(;++n<x.length-1;)
l.add(new A(Integer.valueOf(x[n++]),x[n]));
n=Integer.valueOf(x[n]);
for(int i=1;i++<n;){
String o="";
boolean y=1>0;
for(A a:l)if(i%a.i==0){y=1<0;o+=a.v;}
if(y)o+=i;
System.out.println(o);
}
}
public static void main(String[] args) {
new A(0,"").x(args);
}
}

stacked, 85 bytes
args rev...2*nsgroup rev 2 chunk@s~>{!s[1#]map s[0#n|]map keep''join:[n]\¬if out}map

Try it online! Alternatively, 86 bytes:
args behead...@k sgroup 2 chunk@s k~>{!s[1#]map s[0#n|]map keep''join:[n]\¬if out}map

dc, 121 bytes
?dstsw?[rdlt:Y:Rlt1-dst0<q]dsqx?sb1sm[ln;Y;RnlP1+sP]ss[lmn]sF[1sn0sP[lnd;Ylmr%0=s1+dsnlw!<g]dsgxlP0=Flm1+dsm10Plb!<i]dsix

Takes input on 3 separate lines, the first line containing the integer n, the second housing the int str tuples with the strings enclosed in square brackets ([]), and the third line consists of the integer k. For example, 3 2 Fizz 3 Buzz 5 Crackle 10 could be input as:
3
3 [Buzz] 2 [Fizz] 5 [Crackle]
10

Try it online!
Or taking input in a different order:
dc, 118 bytes
?dstsw[dlt:Y:Rlt1-dst0<q]dsqxsb1sm[ln;Y;RnlP1+sP]ss[lmn]sF[1sn0sP[lnd;Ylmr%0=s1+dsnlw!<g]dsgxlP0=Flm1+dsm10Plb!<i]dsix

This takes input in a different order, but on a single line in the format
k [str1] int1 [str2] int2 (...) [strn] intn n

For example, 3 2 Fizz 3 Buzz 5 Crackle 10 would be input as:
10 [Buzz] 3 [Fizz] 2 [Crackle] 5 3

Try it online!


text:
Find the Maximal Prime Powers
A prime power is a positive integer n that can be written in the form n = pk where p is a prime and k is a positive integer. For example, some prime powers are [2, 3, 5, 4, 9, 25, 8, 27, 125].
Next, consider prime powers of 2. These are [2, 4, 8, 16, ...] and can be written in the form 2k. They would all be included when considering prime powers beneath 20. However, 16 is the maximal prime power with a base prime of 2 in that range. A prime power pk is maximal in a range if it is the highest power of p in that range. We are only interested in the maximal prime power in each range so all lower prime powers must be excluded.
Your goal is to write a function or program that takes a positive integer n and outputs the maximal prime powers in the range [2, 3, 4, ..., n].
Thanks to @Peter Taylor for clarifying the definition of maximal prime power and more.
Rules

This is code-golf so make your code as short as possible.
The maximal prime powers may be output in any order but there must be no duplicates.

Test cases
n      result
1      []
2      [2]
3      [2, 3]
4      [3, 4]
5      [3, 4, 5]
6      [3, 4, 5]
7      [3, 4, 5, 7]
20     [5, 7, 9, 11, 13, 16, 17, 19]
50     [11, 13, 17, 19, 23, 25, 27, 29, 31, 32, 37, 41, 43, 47, 49]
100    [11, 13, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49, 53, 59, 61, 64, 67, 71, 73, 79, 81, 83, 89, 97]
10000  <1229 results>
       [101, 103, 107, 109, 113, 127, 131, 137, 139, 149, ..., 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973]

The full list of maximal prime powers for 10000 can be found here.

Jelly, 7 4 bytes
æḟÆR

Try it online!
How it works
æḟÆR  Main link. Argument: n

  ÆR  Prime range; yield all primes in [1, ..., n].
æḟ    Power floor; round n down to the nearest power of each prime in the range.

Oh so obvious once one sees it!

Power floor What the heck

This post officially convinced me to learn Jelly.

Mathematica, 44 43 40 bytes
Saved 4 bytes thanks to miles and Martin Ender
n#^⌊#~Log~n⌋&/@Select[Range@n,PrimeQ]
(x=Prime@Range@PrimePi@#)^⌊x~Log~#⌋&

⌊ and ⌋ are the 3 byte characters U+230A and U+230B representing \[LeftFloor] and \[RightFloor], respectively.
Explanation:

Pure function. # is short for Slot[1] which represents the first argument to the Function. PrimePi@# counts the number of primes less or equal to #, Range@PrimePi@# is the list of the first PrimePi[#] positive integers, and so Prime@Range@PrimePi@# is the list of primes less than or equal to # (this is one byte shorter than Select[Range@#,PrimeQ]). The symbol x is Set equal to this list, then raised to the Power ⌊x~Log~#⌋, which is the list of Floor[Log[n,#]] for each n in x. In Mathematica, raising a list to the Power of another list of the same length results in the list of the powers of their corresponding elements.

I thought Range@#~Select~PrimeQ would be shorter than Prime@Range@PrimePi@# ... but it's a tie

That's a nice figure. Was it generated using a builtin or created manually?

@miles It was generated using TreeForm

Thanks. I don't remember ever seeing it, but evidently it's been around forever.

MATL, 13 bytes
ZqG:!^tG>~*X>

Try it Online!
Explanation
        % Implicitly grab the input as a number (N)
Zq      % Get an array of all primes below N
G:!     % Create an array from [1...N]
^       % Raise each prime to each power in this array which creates a 2D matrix
        % where the powers of each prime are down the columns
tG>~    % Create a logical matrix that is TRUE where the values are less than N
*       % Perform element-wise multiplication to force values > N to zero
X>      % Compute the maximum value of each column
        % Implicitly display the resulting array

Jelly, 12 9 bytes
RÆEz0iṀ$€

Try it online! (method is too slow for the 10000 case).
How?
Builds the list of pk in order of p.
RÆEz0iṀ$€ - Main link: n                      e.g. 7
R         - range(n)                          [1 ,2  ,3    ,4  ,5      ,6    ,7]
 ÆE       - prime factor vector (vectorises)  [[],[1],[0,1],[2],[0,0,1],[1,1],[0,0,0,1]]
   z0     - transpose with filler 0           [[0,1,0,2,0,1,0],[0,0,1,0,0,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,1]]
       $€ - la$t two links as a monad, for €ach       ^             ^                   ^                   ^
     i    -     first index of                        4             3                   5                   7
      Ṁ   -     maximum                       [4,3,5,7]

Jelly, 8 bytes
ÆR*ÆE€»/

Try it online!
How it works
ÆR*ÆE€»/  Main link. Argument: n

ÆR        Prime range; yield all primes in [1, ..., n].
   ÆE€    Prime exponents each; yield the exponents of 2, 3, 5, ... of the prime
          factorization of each k in [1, ..., n].
          For example, 28 = 2² × 3⁰ × 5⁰ × 7¹ yields [2, 0, 0, 1].
  *       Exponentiation; raise the elements of the prime range to the powers
          of each of the exponents arrays.
      »/  Reduce the columns by maximum.

Pyth, 13 bytes
m^ds.lQdfP_TS

Try it here!
        f   S -  filter(v, range(1, input))
         P_T  -   is_prime(T)
m             - map(v, ^)
    .lQd      -    log(input, d)
   s          -   int(^)
 ^d           -  d ** ^

I haven't played with Pyth in a while so any golfing tips are appreciated.

I couldn't get a shorter Mathematica solution than ngenisis's solution, but I thought I'd offer a couple of (hopefully interesting) alternative approaches.
Mathematica, 65 bytes
#/#2&@@@({#,#}&/@Range@#~Select~PrimeQ//.{a_,b_}/;a<=#:>{b a,b})&

First we use {#,#}&/@Range@#~Select~PrimeQ to build a list of all primes in the appropriate range, but with ordered pairs of each prime, like { {2,2}, {3,3}, ...}. Then we operate on that list repeatedly with the replacement rule {a_,b_}/;a<=#:>{b a,b}, which multiplies the first element of the ordered pair by the second until the first element exceeds the input. Then we apply #/#2&@@@ to output, for each ordered pair, the first element divided by the second. (They end up sorted by the underlying prime: an example output is {16, 9, 5, 7, 11, 13, 17, 19}.)
Mathematica, 44 bytes
Values@Rest@<|MangoldtLambda@#->#&~Array~#|>&

The von Mangoldt function Λ(n) is an interesting number theory function: it equals 0 unless n is a prime power pk, in which case it equals log p (not log n). (These are natural logs, but it won't matter.) Thus MangoldtLambda@#->#&~Array~# creates an array of rules { 0->1, Log[2]->2, Log[3]->3, Log[2]->4, Log[5]->5, 0->6, ... } whose length is the input integer.
We then turn this list of rules into an "association" using <|...|>. This has the effect of retaining only the last rule with any given left-hand value. In other words, it will throw away Log[2]->2 and Log[2]->4 and Log[2]->8 and keep only Log[2]->16 (assuming that the input is between 16 and 31 for this example). Therefore the only remaining right-hand sides are the maximal prime powers—except for the one remaining rule 0->n, where n is the largest non-prime-power up to the input integer. But Rest throws that undesired rule away, and Values extracts the right-hand sides from the rules in the association. (They end up sorted as above.)
A slightly longer (46 bytes) version, which counts the number of appearances of each log p and then exponentiates to convert to the maximal prime powers:
E^(1##)&@@@Rest@Tally[MangoldtLambda~Array~#]&

Neat use of associations. They've been out since 2014 but I don't think they've seen much use in golfing. Very useful to know it replaces identical keys with values from left to right.

CJam, 21 20 bytes
Saved 1 byte thanks to Martin Ender
ri_){mp},f{\1$mLi#}p

Try it online!
Explanation
ri                    e# Read an integer from input (let's call it n)
  _                   e# Duplicate it
   ){mp},             e# Push the array of all prime numbers up to and including n
         f{           e# Map the following block to each prime p:
           \          e#   Swap the top two elements of the stack
            1$        e#   Copy the second element down in the stack. Stack is now [p n p]
              mL      e#   Take the base-p logatithm of n
                i     e#   Cast to int (floor)
                 #    e#   Raise p to that power
                  }   e# (end of map block)
                   p  e# Print

05AB1E, 15 12 bytes
ƒNpiN¹N.nïm,

Try it online!
Explanation
ƒ             # for N in [0 ... input]
 Npi          # if N is prime
    N         # push N
     ¹N.n     # push log_N(input)
         ï    # convert to int
          m   # raise N to this power
           ,  # print

Brachylog, 24 21 19 bytes
3+2 bytes saved thanks to Fatalize!
This is my first time using Brachylog, and I know some things could have been done in shorter ways, but I'm happy that it even works :D
{≥.~^ℕ₁ᵐhṗ:.≜×>?∧}ᶠ

Try it online! (Return values are ordered by their base primes)
Explanation:
{................}ᶠ           #Find all possible results of what's inside.
 ≥.                           #Input is >= than the output.
  .~^ℕ₁ᵐ                      #Output can be calculated as A^B, where A and B are
                              #Natural numbers >=1.
        hṗ                    #The first of those numbers (A) is prime
          :.≜×>?              #That same element (A), multiplied by the output
                              #is greater than the input - This means
                              #that B is the maximal exponent for A.
                ∧             #No more restrictions on the output.

Great! You can save two bytes by using the specific variable names ? and . for Input and Output, instead of I and X, as such: {≥N~^.hṗ:N×>?∧0<~t}ᶠ^ᵐ

You can also save another byte by removing 0<~t and stating that each element of the Output . is in ℕ₁ = [1, ..., +inf) as such: {≥N~^.ℕ₁ᵐhṗ:N×>?∧}ᶠ^ᵐ

@Fatalize thank you! I'll update the solution with your suggestions :)
By the way, do you know why a solution like {≥.~^ℕ₁ᵐhṗ:.×>?∧}ᶠ (using N directly as output) doesn't work? I tried first something like this, but then had to resort to using X and applying ^ over it

I actually wondered the same thing; this is possibly due to the implicit labelization step that occurs at the end of the predicate in {...}ᶠ which causes weird behavior. I intend to change that and I will look specifically into why this program does not work the same way as the one above.

It actually works if you do it like this: {≥.~^ℕ₁ᵐhṗ:.≜×>?∧}ᶠ That way you get correct labelization. (A change was made to the specs in the meantime but does not actually change the behavior of this particular program, so it does not make it non-competing). This saves 2 bytes

Brachylog, 15 bytes
⟧{ḋ=}ˢ⊇Xhᵐ≠∧X×ᵐ

Try it online!
This outputs the powers from biggest to smallest.
This is very inefficient.
Explanation
⟧                   The Range [Input, Input - 1, ..., 1, 0]
 {  }ˢ              Select:
  ḋ=                  The elements of that range whose prime decompositions are lists of the
                      same element (e.g. [3,3,3]); output is those prime decompositions
      ⊇X            X is an ordered subset of that list of prime decompositions
       Xhᵐ≠         All first elements of the prime decompositions are different (that is,
                      X contains prime decompositions with different primes each times)
           ∧
            X×ᵐ     Output is the result of mapping multiplication to each element of X

This will find the biggest prime decompositions for each prime first because of the way ⊇ works: from left to right and from biggest to smallest subsets.

Jelly, 9 bytes
Ræl/ÆF*/€

One byte longer than my other answer, but finishes for input 10,000 is a couple of seconds.
Try it online!
How it works
Ræl/ÆF*/€  Main link. Argument: n

R          Range; yield [1, ..., n].
 æl/       Reduce by least common multiple.
    ÆF     Factor the LCM into [prime, exponent] pairs.
      */€  Reduce each pair by exponentiation.

There is also a 7 byte version in Jelly that finishes quickly.

I'll see your 7 and raise you 4. :P

Wow, I did not know that was a builtin too. That takes the cake.

Bash + GNU utilities, 74 bytes
seq $1|factor|sed "s@.*: \(\w*\)\$@\1;l($1);l(\1);print \"/^p\"@"|bc -l|dc

Try it online!
The input number is passed as an argument.  The output is printed to stdout. (As is customary, stderr is ignored.)
Sample output:
./maximalprimepowers 100 2>/dev/null
64
81
25
49
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

./maximalprimepowers 10000 2>/dev/null | wc -l
1229

Here's how it works:
Call the argument N.
seq generates all the numbers from 1 to N, and factor factors them all.
The regex in the call to sed identifies those lines where the number is a prime P, and replaces those lines with lines that are of the form `
P;l(N);l(P);print "/^p"

(where P and N are replaced by their actual numerical values, and everything else is copied literally, even the quotes and semicolons, and the string print).
These lines are fed as input to bc -l; bc prints the values of the three indicated numbers, each followed by a newline, and then prints the characters /^p .  (In bc, l(x) denotes the natural logarithm of x.) JK K
The strings that bc prints are then fed as input to dc; dc prints the value of each P^(log(N)/log(P)) using integer arithmetic (truncating); that's the greatest power of P that is <= N.
One thing that's glossed over above is what happens to lines that are produced by factors that don't correspond to primes.  Those lines don't match the regex in the call to sed, so no replacement is done on those. As a result, those lines start with a number followed by a colon, which generates an error when fed as input to bc.  But bc just prints to stderr then, which we ignore; it doesn't print anything to stdout.  By default, stderr is ignored on PPCG.

Haskell, 73 67 66 bytes
p n=[last[x^i|i<-[1..n],x^i<=n]|x<-[2..n],all((>0).mod x)[2..x-1]]

Try it online! Usage:
Prelude> p 50
[32,27,25,49,11,13,17,19,23,29,31,37,41,43,47]

Edit: 6 bytes off thanks to Zgarb!
Explanation:
p n=[... x|x<-[2..n]                         ] -- list of all x in the range 2 to n
p n=[... x|x<-[2..n],        mod x<$>[2..x-1]] -- where the remainders of x mod the numbers 2 to x-1
p n=[... x|x<-[2..n],all(>0)$mod x<$>[2..x-1]] -- are all greater 0. This yields all primes in the range.

p n=[    [x^i|i<-[1..n]       ]|...] -- for each of those x generate the list of all x^i with i in the range 1 to n
p n=[last[x^i|i<-[1..n],x^i<=n]|...] -- where x^i is smaller or equal to n
p n=[last[x^i|i<-[1..n],x^i<=n]|...] -- and take the last (that is the largest) element

I think the left side can be last[x^i|i<-[1..n],x^i<=n].

@Zgarb Thanks! It's always the list comprehensions, isn't it ...

Regex (ECMAScript 2018 / Pythonregex / .NET), 97 bytes
(?=(?=(xx+?)\1*$)(((?=(x+)(\4+$))\5)*\1$))(?<!(?=(?=(xx+?)(\6*$))(?=\7\1$)(?=(x+)\8+$)\8\9$)(x+))

Try it online! - ECMAScript 2018
Try it online! - Python (with regex)
Try it online! - .NET
Like Pseudofactorial, this uses Neil's prime powers test instead of mine, because when capturing the smallest prime factor is also needed, it results in a shorter total length.
                              # tail = N ≤ M = input number
# Assert tail is a prime power ≥ 2
(?=                           # Atomic lookahead
    (?=(xx+?)\1*$)            # \1 = smallest prime factor of tail,
                              #      asserting that tail ≥ 2
    (                         # \2 = tail = N
        (
            (?=(x+)(\4+$))\5  # tail = {largest proper divisor of tail}
                              #      = tail / {smallest prime factor of tail}
        )*                    # Iterate the above as many times necessary
                              # (minimum zero) to make the following match:
        \1$                   # Assert that tail == \1; if N is a prime power,
                              # the end result of the above loop will always
                              # be this. Otherwise it will be a larger prime,
                              # and this will fail to match.
    )
)
# Assert there is no prime power (of the same base prime \1)
# that is greater than N but less than or equal to M.
(?<!              # Negative Lookbehind - evaluated right-to-left, so read it
                  # from bottom to top, but once entering the lookahead, go
                  # back to left-to-right (top to bottom); assert that the
                  # following cannot match:
    (?=                       # Lookahead
        (?=(xx+?)(\6*$))      # \6 = smallest prime factor of tail; \7 = tail-\6
        (?=                   # Lookahead
            \7                # tail = tail - (tail - \6) = \6
            \1$               # Assert tail == \1
        )
        (?=(x+)\8+$)          # \8 = {largest proper divisor of tail}
                              #    = tail / {smallest prime factor of tail}
        \8\9$                 # Assert tail == \8 + \9, meaning \8 == N
    )
    (x+)          # tail += \9 = any positive value, in which all possibilities
                  # are tried, until a match is found, or all have been tried
                  # and no matches were found) as long as the resulting tail ≤ M
)

JavaScript (ES6), 118 120 119 114 112 105 bytes
(n,r)=>(r=k=>[...Array(k-1)].map((_,i)=>i+2),r(n).filter(q=>r(q).every(d=>q%d|!(d%(q/d)*(q/d)%d)&q*d>n)))

Suggestions welcome. This is kind of long, but it seemed worth posting because it does all the divisibility testing explicitly rather than using built-ins related to primes.
Notes:

A natural number q is a prime power <=> all of q's divisors are powers of the same prime <=> for any d which divides q, one of d and q/d is a divisor of the other.
If q is a power of p, q is maximal <=> q * p > n <=> q * d > n for every nontrivial divisor d of q.

Sage, 43 bytes
lambda i:[x^int(ln(i,x))for x in primes(i)]

Maps each prime in the range primes(i) to its maximal prime power. ln is just an alias of log so it accepts alternate bases although its name suggests it can only use base e.

Thought this was python at first, saw the primes function and got really excited. Never trusting stackoverflow again.

@sagiksp I don't get it, what does it have to do with StackOverflow?

Haskell, 70 bytes
f n=[k|k<-[2..n],p:q<-[[d|d<-[2..k],mod k d<1]],k==p*p^length q,p*k>n]

Defines a function f.
Try it online!
Explanation
The idea is to filter the range [2..n] for those numbers k that satisfy k == p^length(divisors k) and p*k > n, where p is the smallest prime divisor of k.
f n=                -- Define f n as
 [k|                -- the list of numbers k, where
  k<-[2..n],        -- k is drawn from [2..n],
  p:q<-[            -- the list p:q is drawn from
   [d|              -- those lists of numbers d where
    d<-[2..k],      -- d is drawn from [2..k] and
    mod k d<1]      -- d divides k
   ],               -- (so p:q are the divisors of k except 1, and p is the smallest one),
  k==p*p^length q,  -- k equals p to the power of the divisor list's length
                    -- (so it's in particular a prime power), and
  p*k>n]            -- p*k, the next power of p, is not in the range [2..n].

Haskell, 110 90 bytes
s[]=[];s(x:t)=x:s[y|y<-t,y`rem`x>0];f n=[last.fst.span(<=n).scanl1(*)$repeat x|x<-s[2..n]]

--updated per Laikoni's feedback

This throws a Exception: Prelude.last: empty list for f 2 and f 3.

Also f 4 returns [2,3] instead of [4,3], I think your takeWhile(<n) needs to be takeWhile(<=n). However using fst.span instead of takeWhile is one byte shorter.

Vyxal, 6 bytes
~æ~•⌊e

Try it Online!
~      # Filter (implicit) range from 1 to n by
 æ     # Is prime?
  ~    # Without popping
   •   # Take the log of the input with base each of the primes
    ⌊  # Floor
     e # Raise the primes to those powers

PHP, 101 93 91 88 bytes
just a little bit of real maths ...
for($n=$argv[$i=1];$n>$j=$i++;$j?:$r[$p=$i**~~log($n,$i)]=$p)for(;$i%$j--;);print_r($r);

breakdown
for($n=$argv[$i=1];     // loop $i from 2 to $n
    $n>$j=$i++;             // 0.: init $j to $i-1
    $j?:                    // 2. if $i is prime
        $r[$p=$i**~~log($n,$i)]=$p) // 3. add maximum power to results
    for(;$i%$j--;);         // 1. prime check (if $i is prime, $j will be 0)
print_r($r);            // print results

JavaScript ES7, 93 bytes
Recursively iterate i from 0 up to and including n. If i is prime raise it to the highest floored exponent that makes it <= n (i ^ floor(log(n) / log(i)))
F=(n,i=n)=>i?[...((P=j=>i%--j?P(j):1==j)(i)?[i**((l=Math.log)(n)/l(i)|0)]:[]),...F(n,--i)]:[]

J-uby -rprime, 34 bytes
Port of Dennis' 9-byte Jelly solution; give him an upvote.
:+|:/&:lcm|:prime_division|:*&+:**

Attempt This Online!
Explanation
:+ | :/ & :lcm | :prime_division | :* & +:**
:+ |                                          # Range 1..n, then
     :/ & :lcm |                              # reduce by LCM, then
                 :prime_division |            # get prime factors as [factor, exponent] pairs, then
                                   :* & +:**  # map each pair as exponentiation

Created with the help of Luminespire.

05AB1E, 8 bytes
LÓ0ζεZk>

Port of @JonathanAllan's Jelly answer.
Try it online or verify (almost) all test cases.
Or alternatively (and faster):
ÅPIL.¿Óm

Port of @Dennis' (9-bytes) Jelly answer.
Try it online or verify all test cases.
Explanation:
L         # Push a list in the range [1, (implicit) input]
 Ó        # Map each value to a list of its prime exponents
   ζ      # Zip/transpose, swapping rows/columns,
  0       # using a 0 as filler-item for unequal length rows
    ε     # Map over each inner list:
     Z    #  Push the maximum (without popping the list)
      k   #  Get the (0-based) index of this maximum in the list
       >  #  Increase it by 1 to make it a 1-based index
          # (after which the resulting list is output implicitly)

ÅP        # Push a list of all primes smaller than or equal to the (implicit) input
  IL      # Push a list in the range [1,input]
    .¿    # Pop and get its Least Common Multiple (lcm)
      Ó   # Get the prime exponents of this lcm
       m  # Take each prime to each prime exponent at the same positions
          # (after which the resulting list is output implicitly)

APL(NARS), 19 chars
{a*⌊⍵⍟⍨a←k/⍨0πk←⍳⍵}

It use the fact if p is a number >1 r=floor(log_p(InputNumber))
is the max number with p^r<InputNumber. test:
  f←{a*⌊⍵⍟⍨a←k/⍨0πk←⍳⍵}
  ≢f 10000
1229
  f 20
16 9 5 7 11 13 17 19

source: Stack Exchange

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

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

sort: votes


text:
ASCII Dandelions
These are ASCII dandelions:
   \|/      \ /          |
   /|\       |    \|/    |
    |        |     |   _\|/_
    |        |     |    /|\

ASCII dandelions have three parameters: Length of the stem (positive number between 1 and 256, number of seeds (positive number between 0 and 7), and orientation (^ or v). The above dandelions have for length, seeds and orientation, (3,5,^), (3,2,^), (2,3,^) and (3,7,v) respectively.
Seeds are filled in in the following order (flipped upside down for head-down dandelions), illustrated on a dandelion with length 2:
seeds:  0    1    2    3    4    5     6      7

             |   \ /  \|/  \ /  \|/  _\ /_  _\|/_
        |    |    |    |   /|\  /|\   /|\    /|\
        |    |    |    |    |    |     |      |

The Challenge:
Write a program/function which when given an ASCII dandelion as input, returns its length, seed count, and orientation formatted similarly to the above examples and when given parameters in that format returns an ASCII dandelion with those parameters. You can ignore the parenthesis and assume the input/output will be a number, a comma, a number, a comma, and either ^ or v. You may substitute other characters for ^/v so long as they can still be easily interpreted as 'up'/'down' (for example, u/d). You need not distinguish between dandelions that look the same, such as (2,1,^) and (3,0,^) or (2,1,^) and (2,1,v). Given the ASCII art, either set of parameters would be an acceptable output, and both sets of parameters can give the same ASCII art.
This is code-golf, so shortest code in bytes wins.

An example program in C# (not even slightly golfed):
    string Dandelion(string s)
    {
        if (s.Contains(','))
        {
            //got parameters as input
            string[] p = s.Split(',');
            //depth and width (number of seeds)
            int d = int.Parse(p[0]);
            int w = int.Parse(p[1]);
            //draw stem
            string art = "  |";
            while (d > 2)
            {
                d--;
                art += "\n  |";
            }
            //draw head
            string uhead = (w % 2 == 1 ? "|" : " ");
            string dhead = uhead;
            if (w > 1)
            {
                uhead = "\\" + uhead + "/";
                dhead = "/" + dhead + "\\";
                if (w > 5)
                {
                    uhead = "_" + uhead + "_\n /|\\";
                    dhead = "_\\|/_\n " + dhead;
                }
                else if (w > 3)
                {
                    uhead = " " + uhead + " \n /|\\";
                    dhead = " \\|/ \n " + dhead;
                }
                else
                {
                    uhead = " " + uhead + " \n  |";
                    dhead = "  |\n " + dhead;
                }
            }
            else
            {
                uhead = "  " + uhead + "\n  |";
                dhead = "  |\n  " + dhead;
            }
            //add head to body
            if (p[2] == "^")
            {
                return uhead + "\n" + art;
            }
            return art + "\n" + dhead;
        }
        else
        {
            //ASCII input
            string[] p = s.Split('\n');
            int l = p.Length - 1;
            int offset = 0;
            //find first non-' ' character in art
            while (p[0][offset] == ' ')
            {
                offset++;
            }
            int w = 0;
            if (p[0][offset] == '|')
            {
                //if '|', either head-down or no head.
                if (offset == 0 || p[l][offset - 1] == ' ')
                {
                    //if no space for a head to the left or no head at the bottom, no head.
                    return l.ToString() + ",1,^";
                }
                //head must have at least size 2, or else indistinguishable from no head case
                w = 6;
                if (p[l][offset] == '|')
                {
                    //odd sized head
                    w = 7;
                }
                if (offset == 1 || p[l - 1][offset - 2] == ' ')
                {
                    //not size 6 or 7
                    w -= 2;
                    if (p[l - 1][offset - 1] == ' ')
                    {
                        //not size 4 or 5
                        w -= 2;
                    }
                }
                return l.ToString() + "," + w.ToString() + ",v";
            }
            else if (p[0][offset] == '\\')
            {
                //head at least size 2 and not 6/7, or indistinguishable from no head.
                w = 4;
                if (p[0][offset + 1] == '|')
                {
                    w = 5;
                }
                if (p[1][offset] == ' ')
                {
                    w -= 2;
                }
            }
            else
            {
                w = 6;
                if (p[0][offset + 2] == '|')
                {
                    w = 7;
                }
            }
            return l.ToString() + "," + w.ToString() + ",^";
        }
    }

Can we take some other distinct symbols instead of ^ and v?

@KritixiLithos So long as they can be easily interpreted as 'up' and 'down', sure.

How do you find the difference between a length 2 seed 1 and a length 3 seed 0 dandelion? For seeds 0 and 1 it is also impossible to tell if they're flipped...

@Luke You need not distinguish between trees that look the same. You should return the same ASCII art in the case of length 2 seed 1 as in length 3 seed 0, and can return either length 2 seed 1 or length 3 seed 0 when that art is the input.

Can you show an example program for this?

Can we specify the order of the output or does it have to be length, seeds, orientation?

@Okx Done. Sorry if it's not clear, had to hack it together quickly (with C# being the only language I can test at the moment...)

@PatrickRoberts I'm going to say you have to use the specified order, though I'm open to being convinced otherwise.

Unless I'm mistaken, it seems like we have an answer that translates from parameters to ASCII and another answer that translates from ASCII to parameters. But we're supposed to support both tasks, right?

Will the dandelions that we need to recognise have fixed widths or can they be any width that draws the dandelion.

@P... I fixed the program, and formatted my parameters differently. I just ensured that the input format matched the output format, but did not abide to the order you originally stated. I specified the format of the parameters in my submission though.

Can we write two programs, one to handle each case?

Bean, 321 bytes
Accepts input as single string in stdin without trailing newline. Parameters will be taken in the same manner, but formatted as
length (1-256)
orientation (u or d)
seeds (0-7)

The output parameters of the program when input is a dandelion will be in the same format as above.
Hexdump:
00000000 26 52 ca c1 20 5d d3 d0 80 d5 cd a0 5e 80 4c cc  &RÊÁ ]ÓÐ.ÕÍ ^.LÌ
00000010 a0 45 86 25 3e 88 4d a0 6b 80 4c a0 5e 80 23 60   E.%>.M k.L ^.#`
00000020 cd a0 63 80 43 cd a0 5f 80 50 84 a3 81 00 20 5e  Í c.CÍ _.P.£.. ^
00000030 d0 84 a3 81 01 4d a0 60 80 4a c1 4c a0 45 86 25  Ð.£..M `.JÁL E.%
00000040 3a d0 84 a3 81 02 4c a0 45 92 25 3a d0 84 a3 81  :Ð.£..L E.%:Ð.£.
00000050 03 20 60 a0 5f a3 81 04 cd a0 61 80 50 84 a3 81  . ` _£..Í a.P.£.
00000060 05 20 5e cf 52 cc a0 45 86 25 3c a3 81 06 23 81  . ^ÏRÌ E.%<£..#.
00000070 07 a0 61 cf 53 d0 80 a3 81 08 20 80 b5 4c a0 43  . aÏSÐ.£.. .µL C
00000080 8c 25 3a 00 52 a0 6b d3 50 80 a0 63 20 80 7e 20  .%:.R kÓP. c .~
00000090 63 20 80 7b 23 00 53 d0 80 c3 cc d0 80 a0 78 20  c .{#.SÐ.ÃÌÐ. x
000000a0 80 01 8c 25 3a d2 ce cc a0 5d 80 23 81 09 80 4c  ...%:ÒÎÌ ].#...L
000000b0 d0 84 a0 5e 25 3b 81 23 81 0a ce d3 50 80 a0 78  Ð. ^%;.#..ÎÓP. x
000000c0 20 80 7e 81 23 60 23 71 cc d2 cc d0 84 d0 84 a0   .~.#`#qÌÒÌÐ.Ð.
000000d0 78 25 3a 25 3a 81 23 81 0b cc a5 3d 8b 4c cc d0  x%:%:.#..Ì¥=.LÌÐ
000000e0 84 d0 84 a0 78 25 39 25 39 81 50 84 d0 84 a0 78  .Ð. x%9%9.P.Ð. x
000000f0 25 3a 25 39 8d 25 3b 4c cc d0 84 d0 84 a0 78 25  %:%9.%;LÌÐ.Ð. x%
00000100 39 25 3c 81 23 81 0b 8d 25 3b 8b 4c d0 84 d0 84  9%<.#...%;.LÐ.Ð.
00000110 a0 78 25 39 25 3b 81 23 81 0b 00 20 80 7b 23 81   x%9%;.#... .{#.
00000120 04 a0 df 20 a0 5c a0 7c a0 2f 0a a0 a0 5f af fc  . ß  \ | /.  _¯ü
00000130 5c a0 fc 20 8a a0 a0 fc a0 20 a0 a0 fc a0 20 7c  \ ü .  ü    ü  |
00000140 20
00000141

Equivalent JavaScript:
+a?                               // if input is parameters
  (
    b=(C>5)<<(o=b=="d"),          // encoding if seeds > 5 and if orientation is down
    g=[                           // storing dandelion as array of characters
      c=" _ "[b],                 // "_" if seeds > 5 and orientation is up, else " "
      " \\"[d=+(C>1)],            // "\" if seeds > 1, else " "
      " |"[C&1],                  // "|" if seeds is odd, else " "
      " /"[d],
      c,                          // "_" if seeds > 5 and orientation is up, else " "
      "\n",
      e="  _"[b],                 // "_" if seeds > 5 and orientation is down, else " "
      ...(                        // spread characters for .reverse() to be correct
        C>3?                      // if seeds > 3 "/|\" else " | "
          "/|\\":
          " | "
      ),
      e,                          // "_" if seeds > 5 and orientation is down, else " "
      ..."\n  |  ".repeat(A-1)    // repeat stem length - 1 times
    ],
    o?                            // if orientation is down, reverse
      g.reverse():
      g
  ).join(""):                     // join array of characters
  [                               // else if input is dandelion
    _.length-1,                   // length of stem is number of rows - 1
    a=="  |  "||b[2]!="|"?        // test orientation of dandelion
      _.reverse()&&"d":           // reverse rows if necessary and return "d" for down
      "u"                         // else return "u" for up
    ,
    (
      _[1][1]!=" "?               // if 1,1 is not " ", seeds is 4 or more
        4+(_[0][0]!=_[1][0])*2:   // if 0,0 or 1,0 is "_", seeds is 6 or 7
        (_[0][3]!=" ")*2          // if 0,3 is not " ", seeds is 2 or 3
    )+
    (_[0][2]!=" ")                // if 0,2 is not " ", seeds is odd
  ].join("\n")                    // join parameters with newline to match input format

Implicitly takes stdin as newline separated array of unformatted strings in _ and implicitly outputs the parameters as a triplet. Test suite below and demo here:

const js = String.raw`
+a?                               // if input is parameters
  (
    b=(C>5)<<(o=b=="d"),          // encoding if seeds > 5 and if orientation is down
    g=[                           // storing dandelion as array of characters
      c=" _ "[b],                 // "_" if seeds > 5 and orientation is up, else " "
      " \\"[d=+(C>1)],            // "\" if seeds > 1, else " "
      " |"[C&1],                  // "|" if seeds is odd, else " "
      " /"[d],
      c,                          // "_" if seeds > 5 and orientation is up, else " "
      "\n",
      e="  _"[b],                 // "_" if seeds > 5 and orientation is down, else " "
      ...(                        // spread characters for .reverse() to be correct
        C>3?                      // if seeds > 3 "/|\" else " | "
          "/|\\":
          " | "
      ),
      e,                          // "_" if seeds > 5 and orientation is down, else " "
      ..."\n  |  ".repeat(A-1)    // repeat stem length - 1 times
    ],
    o?                            // if orientation is down, reverse
      g.reverse():
      g
  ).join(""):                     // join array of characters
  [                               // else if input is dandelion
    _.length-1,                   // length of stem is number of rows - 1
    a=="  |  "||b[2]!="|"?        // test orientation of dandelion
      _.reverse()&&"d":           // reverse rows if necessary and return "d" for down
      "u"                         // else return "u" for up
    ,
    (
      _[1][1]!=" "?               // if 1,1 is not " ", seeds is 4 or more
        4+(_[0][0]!=_[1][0])*2:   // if 0,0 or 1,0 is "_", seeds is 6 or 7
        (_[0][3]!=" ")*2          // if 0,3 is not " ", seeds is 2 or 3
    )+
    (_[0][2]!=" ")                // if 0,2 is not " ", seeds is odd
  ].join("\n")                    // join parameters with newline to match input format`;

// bean binary
const bin = bean.compile(js);

// program as function
const prog = bean.program(bin);

(document.body.onchange = function () {
  const parameters = stem.value + '\n' + orientation.value + '\n' + seeds.value;
  dandelion.textContent = prog(parameters);
  params.value = prog(dandelion.textContent);
})();
textarea {
  resize: none;
}

<input id=stem type=number min=1 max=256 value=5>
<select id=orientation>
  <option value="u">u</option>
  <option value="d">d</option>
</select>
<input id=seeds type=number min=0 max=7 value=5>

Dandelion (output from program given parameters)

Parameters (output from program given dandelion)

<textarea id=params rows=3></textarea>

Javascript 513 391 379 355 bytes
Thanks to @Neil for helping golf off 134 bytes and @Kritixi Lithos for helping golf off 13 bytes
This program assumes that any ASCII dandelions it is trying to identify have a line width of 5 for all lines of the string. ie: the stem is 2 spaces, the vertical line then another 2 spaces. (It can not classify dandelions it creates due to this issue)
(x,y,z)=>{a=Array(x+1).fill(1);if(x.length>1){a=x.split`
`;h=a.length-1;t=b=i=0;for(;i<(h>1)+1;i++)for(j=0;j<5;a[h-i][j++]!=' '&&b++)a[i][j]!=' '&&t++;return[h,(t>b?t:b)-(h>1),t>b?'^':'v']}z<'v'?(a[0]=y&4?y-2:y,a[1]=y&4?7:1):(a[x-1]=1+(y>4)*2+(y>4)*(y&2),a[x]=y&1+(y>2)*6);return a.map(n=>',  |, \\ /, \\|/,_\\ /_,_\\|/_, / \\, /|\\'.split`,`[n]).join`
`}

How it Works
The function checks if the first argument it is given has a length >1 (is a string). If the first argument is a string, it identifies the details of the ASCII dandelion.
To get the height of the dandelion, it splits the string around newline characters and counts the number of elements - 1.
To get the number of seeds, it counts the number of non space characters on the top two and bottom two lines. if there are more characters in the top, it is declared to be upright and it uses the top count-1, otherwise it is declared to be upside down and uses the bottom count-1. If the total height is only 2, it determines uprightness by checking the counts of each line individually and choosing the side with more non space characters.
Otherwise, the function uses bitwise math in order to assign values from 0 to 7 according to the shape of each level of the dandelion to be drawn before converting each level into the appropriate string.
0:
1:  |
2: \\ /
3: \\|/
4:_\\ /_
5:_\\|/_
6: / \\
7: /|\\

Try it online

@JonathanAllan fixed it so that it will now categorise a dandelion input

Taking just your dandelion creator, I was then able to golf 125 bytes off. My code can't be directly pasted back into your solution, but maybe you can incorporate some of the savings: (x,y,z,a=[...Array(x+1)].fill(1))=>a.map(n=>',  |, \\ /, \\|/,_\\ //,_\\|/_, / \\, /|\\'.split\,`[n],z<'v'?(a[0]=y&4?y-2:y,a[1]=y&4?7:1):(a[x-1]=1+(y>4)2+(y>4)(y&2),a[x]=y&1+(y>2)*6)).join`\n``

You can remove the else because you return in the if part anyway. Also while I'm here, I just wanted to point out that some functions such as split and join don't need the ()s when you invoke them on ```-quoted string literals, which is why I didn't include them in my previous comment.

@Neil I didn't make those changes because I couldn't test that they worked as it was always saying error unexpected token and therefore couldn't make sure that the ','[n] wouldn't cause an error

You have to use the right sort of quotes, it only works with \``s, not 's or "`s.

You can change the \n in join\\n`to a newline (as in the character). Also you can change the(h>2?1:0)to justh>2and the(h>2?2:1)to(h>2)+1`. https://tio.run/#IRiKF

In your first for-loop with j, you can move a[h-i-1][j++]!=' '&&b++ into for like for(j=0;j<5;a[h-i-1][j++]!=' '&&b++). Now you can remove the braces around the one lone statement in that for-loop and save 2 bytes

Python 3.6, 476 453 448 413 394 bytes
Solution :
def h(i):
 l,s,o=i.split(",");s=int(s);z=["  |  "];q=(int(l)-1)*z;b,d,f,h,g,c,a=["  ","\\/"][s>1]+["  ","\\/"][s>3]+["| ","||"][s%2==1]+[" ","_"][s>5]
 if"d"==o:b,d,h,f,c,g=f,h,d,b,g,c
 r=[[a+b+c+d+a]+[" "+h+g+f+" "],z][s==0];return"\n".join([q+r,r+q]["u"==o])
def j(i):
 if","in i:print(h(i))
 else:[print(f"{m},{j},{k}")for m in range(257)for j in range(8)for k in"ud"if i==h(f"{m},{j},{k}")]

Result
>>> j("6,5,u")
 \|/
 /|\
  |
  |
  |
  |
  |
>>> j("5,2,d")
  |
  |
  |
  |
  |
 / \
>>> j("3,2,u")
 \ /
  |
  |
  |
>>> j("_\|/_\n /|\ \n  |  \n  |  \n  |  \n  |  \n  |  ")
6,7,u
>>> j(" \|/ \n /|\ \n  |  \n  |  \n  |  \n  |  ")
5,5,u
>>> j("  |  \n  |  \n  |  \n  |  \n  |  ")
4,1,u
4,1,d
5,0,u
5,0,d

Unfold
def g(i):
    def h(i):                       # this function draw dandelion
        l, s, o = i.split(",")      # split argument
        s = int(s)

        # Calcul the string in the flower for up case
        #   _\|/_   --> abcdb  --> when s=7 we have a=_ b=\ c=| d=/ h=/ g=| f=\
        #    /|\    -->  hgf
        a = "_" if s > 5 else " "
        b = "\\" if s > 1 else " "
        d = "/" if s > 1 else " "
        h = "/" if s > 3 else " "
        f = "\\" if s > 3 else " "
        c = "|" if s%2 == 1 else " "
        g = "|" if s%2 == 1 else "|"

        # Shuffle a bit if the position is down
        if"d"==o:
            b,d,h,f,c,g=f,h,d,b,g,c

        # treate the case to remove the line with ony white space
        if s==0:
            res=["  |  "]
        else:
            # assemble all piece of the flower
            res += [a+b+c+d+a]
            res += [" "+h+g+f+" "]

        # add stem up or down
        if o=="u":
            res = res + (int(l)-1) * ["  |  "]
        else:
            res = (int(l)-1) * ["  |  "] + res
        return "\n".join(res)

    if "," in i:
        print(h(i))
    else:
        # search in all flower posibility if we can recreate the input
        [print(m,j,k) for m in range(1, 257) for j in range(0, 8)for k in "ud"if i == h(f"{m},{j},{k}")]

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


text:
What's my Body Mass Index?
Problem:
Your task is to write a program that takes as input a height (in meters) and weight (in kilograms), and outputs the corresponding BMI category.
BMI is a measure of the ratio of your weight to your height. It's dated and inaccurate for many people, but that doesn't matter here!
BMI can be calculated using the following equation:
BMI = (mass in kilograms) / (height in meters)^2

The categories will be defined as follows:

BMI < 18.5: "Underweight"

18.5 <= BMI < 25: "Normal"

25 <= BMI: "Overweight"

For the sake of the challenge, I'm ignoring all the "extreme" categories. Also, since some numbers like "25" sit between 2 categories, I adjusted the bounds slightly so there's a definite answer.
You can write either a function, or a full program.
Input:
Input can be in any reasonable form. Two numbers (or strings), either as 2 separate arguments, or as a single string. An array/list of 2 numbers, a dictionary with "weight" and "height" keys... Decimal values should be supported. You can assume the input will always be valid (no negative values, and height will never be 0).
Output:
Output will be a string containing the case-insensitive category names. The strings must match the category names exactly as above, ignoring case. It can be output to the stdout, returned (in the case of a function), or written to file.
Test Cases (weight, height => result):
80, 1 =>   "Overweight"
80, 2 =>   "Normal"
80, 3 =>   "Underweight"

50, 1 =>   "Overweight"
50, 1.5 => "Normal"
50, 2 =>   "Underweight"

Edge Cases:

41, 1.5 => "Underweight" (18.2 BMI)
42, 1.5 => "Normal" (18.667 BMI)

56, 1.5 => "Normal" (24.889 BMI)
57, 1.5 => "Overweight" (25.3 BMI)

73, 2 =>   "Underweight" (18.25 BMI)
74, 2 =>   "Normal" (18.5 BMI)

99, 2 =>  "Normal" (24.75 BMI)
100, 2 => "Overweight" (25 BMI)

Here's some pseudocode that shows an example implementation:
function bmi_category(weight, height):
    var bmi = (weight / (height**2))

    if (bmi < 18.5):
        return "Underweight"

    if (18.5 <= bmi < 25):
        return "Normal"

    if (25 <= bmi):
        return "Overweight"

This is code-golf, so the fewest number of bytes wins.
(Yes, this task is exceedingly trivial in most languages. Most of the challenges lately seem to be harder than normal, so I thought I'd post a more accessible one).

NOTE! An hour after I posted this challenge, I had to modify the ranges slightly since the ranges as stated had "holes" as pointed out in the comments. Please see the new ranges.

Jelly, 24 bytes
÷÷⁹Ḥ“%2‘>Sị“$⁽¿“;ṅẒ“&ċ)»

Try it online!
How?
Calculates the BMI, doubles it, compares that with the greater than operator with each of the numbers 37 and 50 (18.5 and 25 doubled), sums the resulting ones and zeros (yielding 1, 2, or 0 for Normal, Underweight, and Overweight respectively) and indexes into the list of strings ["Normal","Underweight","Overweight"].
÷÷⁹Ḥ“%2‘>Sị“$⁽¿“;ṅẒ“&ċ)» - Main link: weight, height
÷                        - weight ÷ height
  ⁹                      - right argument, height
 ÷                       - ÷ by height again to get the BMI
   Ḥ                     - double the BMI
    “%2‘                 - list of code page indexes [37,50]
        >                - greater than? (vectorises) - i.e [18.5>bmi, 25>bmi]
         S               - sum -- both:=2 (Underweight), just 50:=1 (Normal) or neither:=0 (Overweight)
          ị              - index into (1-based)
           “$⁽¿“;ṅẒ“&ċ)» - compressed list of strings ["Normal","Underweight","Overweight"]
                         - implicit print

Wow.  Talk about obfuscation. If this is golf, I think you got a hole in one!  Or 24...

@cullub it is 24 characters and 24 bytes - Jelly uses it's own code-page linked to by the word "bytes" in the heading, mothereff.in is counting Unicode I believe.

@TheBitByte, yes, take a look at the TIO link counter "24 chars, 24 bytes (SBCS)" or count it by hand using the code-page linked to by bytes in the heading.

... as hex: 1C 1C 89 AF FE 25 32 FC 3E 53 D8 FE 24 8D 0B FE 3B F0 BD FE 26 E8 29 FB

Python, 69 bytes
lambda w,h:["UOnvd"[w/h/h>20::2]+"erweight","Normal"][18.5<=w/h/h<25]

Try it online!
Compare to 72 bytes:
lambda w,h:"Underweight"*(w/h/h<18.5)or"Normal"*(w/h/h<25)or"Overweight"

TI-Basic, 58 54 bytes
Input
X/Y²→C
"NORMAL
If 2C≤37
"UNDERWEIGHT
If C≥26
"OVERWEIGHT

Also, for fun, here's a more compact version that is more bytes:
Prompt A,B
sub("UNDERWEIGHTNORMAL      OVERWEIGHT ",sum(A/B²≥{18.5,25})11+1,11

All I can say is, thank you for making this case-insensitive ;)
P.S. Input takes graph input to X and Y similar to Prompt X,Y

Also, I've looked at this multiple times, and I don't think there's any way to save bytes even though the last two share the string ERWEIGHT

Out of curiosity, how would it have changed your answer if I enforced case-sensitivity?

@Carcigenicate In TI-Basic, the lowercase letters are two bytes each. Thus, it would have increased the byte count by a lot.

Ah, I see. That's odd.

@Carcigenicate It's important to remember that this version of TI-Basic was introduced in 1990 as a calculator language... no one knew I'd be golfing it 27 years later

Mathematica, 67 bytes
"Normal"["Underweight","Overweight"][[Sign@⌊(2#/#2^2-37)/13⌋]]&

Uses the fact that a[b,c][[Sign@d]] returns a if d equals 0, returns b if d is positive, and returns c if d is negative. ⌊...⌋ is Mathematica's Floor function using the three-byte characters U+230A and U+230B. Couldn't figure out how to do better than using weight twice.

Surprised Mathematica doesn't have a built-in for this

you have to go to the fan fiction for that ;)

JavaScript (ES6), 70 67 64 63 bytes
Saved 4B thanks to Arnauld
a=>b=>(a/=b*b)<25&a>=18.5?"Normal":(a<19?"Und":"Ov")+"erweight"

Usage
f=a=>b=>(a/=b*b)<25&a>=18.5?"Normal":(a<19?"Und":"Ov")+"erweight"
f(80)(1)

Output
"Overweight"

Explanation
This answer is quite trivial, though there is one clever trick: Underweight and Overweight both end in erweight, so we only have to change those characters.
I assumed that Normal means a BMI between 25 (exclusive) and 18.5 (inclusive). Underweight means a BMI less than 18.5, and Overweight means a BMI greater than or equal to 25.

Now the answer doesn't contain any ES7 features ;-)

Ruby, 91 77 74 67 bytes
First naive try:
->(w,h){case w/h/h
when 0..18.5
'underweight'
when 18.5..25
'normal'
else
'overweight'
end}

Second try with ”inspiration“ from previous answers:
->w,h{["#{(w/=h*h)<18.5?'und':'ov'}erweight",'normal'][(18.5..25)===(w)?1:0]}

Third try:
->w,h{["#{(w/=h*h)<18.5?'und':'ov'}erweight",'normal'][w>=18.5&&w<25?1:0]}

Fourth try:
->w,h{18.5<=(w/=h*h)&&w<25?'normal':"#{w<18.5?'und':'ov'}erweight"}

Try it online!

reitermarkus from homebrew-cask?! Woah, didn't expect to see you here! :o

@numbermaniac, haha, yes, it's me!

QBIC, 61 58 bytes
::m=a/b^2~m<18.5|?@Und`+@erweight`\~m>=25|?@Ov`+B\?@Normal

@Luke used the Force and chopped off two bytes. Thanks!
The rules change saved another byte.
Explanation:
::          gets weight and height as a and b
m=a/b^2     Calculates BMI
~m<18.5|    If BMI < 18.5 then
?@Und`      Print the string literal 'Und' (which is now A$)
+@erweight` and the string literal 'erweight'  (which is now B$)
\~m>=25|    else if the BMI is greater than or equal to 25
?@Ov`+B     Print 'Ov' and B$ ('erweight')
\?@Normal   Else, if we're here, BMI is normal.

C, 81 bytes
f(float m,float h){m/=h*h;puts(m<26?m<18.6?"Underweight":"Normal":"Overweight");}

05AB1E, 28 bytes
n/©37;‹®25‹O’‚Š‰ß îÂ ‚â‰ß’#è

Uses the CP-1252 encoding. Try it online!

Python 3, 97 95 bytes
a,b=map(int,input().split())
a/=b*b*5
print(["UOnvd"[a>93::2]+"erweight","Normal"][93<=a<=125])

Full program.
Multiply by five to save a byte. Thanks Jonathan Allan.
Line by line:

Map the two space separated user input numbers to ints. Unpack to a and b.

Calculate

If the bmi is between 18.6 and 25, inclusive, the expression on the right will evaluate to True. Booleans can be 0 or 1 when used as list indexes, so we get either "Normal" or the constructed string in the zero index. "erweight" is a shared suffix for the remaining two options, so it doesn't need to be repeated. Then we use the [start:stop:step] pattern of Python list/string slicing. c>18.6 will evaluate to either 0 or 1 (False or True) and becomes our start. Stop isn't indicated so we go to the end of the literal. Step is 2 so we take every second index. If start start evaluates to 1, we get "Ov", otherwise we get "Und". Either way, we append "erweight" to what we got and we have our final output.

Write it as a function for 79: def f(h,w):c=h/w/w;print(["UOnvd"[c>18.6::2]+"erweight","Normal"][18.6<=c<=25])

If you multiply up by five first you can save a byte by comparing to 93 and 125. If you use a lambda you have to calculate c in both places but don't need to name the function or use print(), so can do lambda h,w:["UOnvd"[h/w/w*5>93::2]+"erweight","Normal"][93<=h/w/w*5<=125] for 73.

...actually because you will be calculating c twice the multiply by 5 costs more than it saves in the lambda, so just lambda h,w:["UOnvd"[h/w/w>18.6::2]+"erweight","Normal"][18.6<=h/w/w<=25] for 72

Jonathan Allan Somebody already did it as just a function.

That's OK, your way will out-golf them :D

@mypetlion And note is on to post an identical answer as someone else, as long as it can be trusted that you didn't blantantly rip off their answer. More than one I've written a Clojure answer, only to look answers after the fact and see that someone else posted the same answer as me already.

Python 2, 72 bytes
lambda a,b:"UNOnovdreemrrawwlee ii gg hh tt"[(18.6<a/b/b)+(a/b/b>25)::3]

Try it online!

How do you get the colours for Python? I never figured it out.

@JackBates It's just <!-- language-all: lang-python --> which TIO automatically inserted for me.

PowerShell, 81 bytes
param($m,$h)('Underweight','Normal','Overweight')[(18.5,25-lt($m/($h*$h))).Count]

Try it online!
Explanation
The main bit that needs explaining is 18.5,25 -lt $b (where I'm substituting $b for the BMI which is calculated in place in the code). Most operators in PowerShell, when given an array on the left side, return an array of items that satisfy the test, instead of returning a boolean value. So this will return an empty array if $b is smaller than 18.5, an array containing only 18.5 if it's in the middle, and an array containing both 18.5 and 25 if it's larger than 25.
I use the count of the elements as an index into an array of the strings, so count 0 gets element 0 which is 'Underweight', etc.

R, 89 84 80 74 bytes
f=pryr::f(c('Overweight','Normal','Underweight')[sum(w/h^2<c(18.5,25),1)])

With a nod to StewieGriffin's Octave answer, creates an array of strings, then sums the result of BMI < c(18.5,25) and references the array at that position + 1.
First argument needs to be height, then weight; if that's not allowed, then
f=pryr::f(w,h,c('Overweight','Normal','Underweight')[sum(w/h^2<c(18.5,25),1)])

works for 4 more bytes.

Python, 75 74 bytes
lambda h,w:18.5<=w/h/h<=25and"normal"or["ov","und"][25>w/h/h]+"erweight"

Try it online!
Fairly basic solution that takes advantage of other people's techniques for solving it.
Thanks @ovs for saving a byte.
Alternatives
1. 73 bytes
lambda h,w:"normal"if 18.5<=w/h/h<=25 else"uonvd"[25<w/h/h::2]+"erweight"

I rejected this as it was too similar to another answer I saw.
2. 71 bytes
lambda h,w:"normal"if 18.5<w/h/h<25 else"uonvd"[25<w/h/h::2]+"erweight"

I rejected this because, despite working on all the tests in the question, there are some numbers it can fail on as it's missing the = in the <=.

You don't need the space between 25 and else - but anyway, using short circuiting and/or (as @ovs commented) is shorter.

@FlipTack: regarding the space between 25 and else, you definitely do need it with some (most?) interpreters (including CPython, IIRC). If you write it as 25else, the 25e is interpreted as the start of a scientific-notation numeric literal, and the interpreter then baulks when there are no following digits.

Clojure, 63 bytes
#(condp <(/ %(* %2 %2))25"Overweight"18.5"Normal""Underweight")

Damn. As always, this is a shorter version of what I was thinking of.

Common Lisp, 89 87 85 84 83 bytes
A function:
(lambda(w h)(if(< #1=(/ w(* h h))18.5)'underweight(if(< #1#25)'normal'overweight)))

Example of usage:
((lambda(w h)(if(< #1=(/ w(* h h))18.5)'underweight(if(< #1#25)'normal'overweight)))150 2)

Try it online!
(I added printing function to see output in TIO)
Ideas for improvement are welcomed.

dc, 58 bytes
Fk[Ov]?2^/d[[Normal]pq][[Und]26]sasb18.5>a25>bn[erweight]p

Takes input as 2 space separated numbers in the format <mass> <height> . Outputs a string on a separate line.
Try it online!
Explanation
For the purposes of this explanation, the input is 80 1.
Fk                                                         # Set decimal precision to `16`.
  [Ov]                                                     # Push the string "Ov" onto the main stack.
                                                           # Main Stack: [[Ov]]
      ?2^/d                                                # Take and evaluate input, squaring the 2nd one, and the dividing by the first one by the 2nd. Then duplicate the result.
                                                           # Main Stack: [[Ov],80.000000000000000,80.000000000000000]
           [[Normal]pq][[Und]26]sasb                       # Push and store the executable macros "[Normal]pq" and "[Und]26" on registers "a" and "b", respectively.
                                                           # Main Stack: [[Ov],80.000000000000000,80.000000000000000], reg. a: [[[Normal]pq]], reg. b: [[[Und]26]]
                                    18.5>a25>b             # Push, "18.5" onto stack, and then pop top 2 values. If "18.5 > (top of stack)", then execute the macro on top of reg. "a", which in turn pushes the string "Und" onto the main stack followed by the number 26.
                                                           # The "26" will automatically prompt the next comparison to not execute the macro on top of reg. "b", regardless of the value on top of the main stack.
                                                           # Otherwise, if "18.5 <= (top of stack) < 25", then execute "b"s macro, which in turn pushes the string "Normal" onto the main stack, outputs it, then quits the program.
                                                           # In this case, Main stack: [[Ov]], reg. a: [[[Normal]pq]], reg. b: [[[Und]26]]
                                              n[erweight]p # If "Normal" has not been output, only then will the program get to this point. Here, it will output whatever string, either "Und" or "Ov", on top of the main stack, followed by "erweight" and a new line.

C#, 63 62 61 bytes
Saved 1 more byte thanks to TheLethalCoder.
Saved 1 byte thanks to anonymous user.
w=>h=>w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight";

A pretty straightforward anonymous function. The whole trick is using the ternary operator to return directly (thus omitting the return keyword, a pair of curly braces and a variable declaration and assignment).
Full program with test cases:
using System;

class BodyMassIndex
{
    static void Main()
    {
        Func<double, Func<double, string>> f =
        w=>h=>w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight";

        // test cases:
        Console.WriteLine(f(80)(1));  // "Overweight"
        Console.WriteLine(f(80)(2));  // "Normal"
        Console.WriteLine(f(80)(3));  // "Underweight"
        Console.WriteLine(f(50)(1));  // "Overweight"
        Console.WriteLine(f(50)(1.5));  // "Normal"
        Console.WriteLine(f(50)(2));  // "Underweight"
    }
}

Octave, 64 bytes
@(w,h){'Underweight','Normal','Overweight'}{3-sum(2*w/h^2<'%2')}

Try it online
This is an anonymous function that takes two input arguments, h (height) and w (weight).
The function creates a cell array containing there strings 'Underweight','Normal','Overweight', and outputs string number 3-sum(2*w/h^2<'%2').
Yes, that one looks a bit strange. We want the first string if w/h^2<=18.5, the second string if (w/h^2 > 18.5) & (w/h^2 < 25) and the third string if none of the above conditions are true. Instead of creating a bunch of comparisons, we could simply compare the string to: w/h^2 < [18.5, 25], which would return one of the following arrays [1 1], [0 1], [0,0] for Underweight, Normal and Overweight respectively.
[18.5,25] takes 9 bytes, which is a lot. What we do instead, is multiply the BMI by 2, and compare the result with [37, 50], or '%2' in ASCII. This saves three bytes.

Perl 6, 59 bytes
{<Overweight Normal Underweight>[sum 18.5,25 X>$^a/$^b**2]}

How it works
{                                                         }  # A lambda.
                                               $^a/$^b**2    # Compute BMI from arguments.
                                     18.5,25 X>              # Compare against endpoints.
                                 sum                         # Add the two booleans together.
 <Overweight Normal Underweight>[                        ]   # Index into hard-coded list.

Too bad the string erweight has to be repeated, but all variations I tried in order to avoid that ended up increasing the overall byte count:

With string substitution, 62 bytes:
{<Ov_ Normal Und_>[sum 18.5,25 X>$^a/$^b**2].&{S/_/erweight/}}
With string interpolation, 67 bytes:
{$_='erweight';("Ov$_","Normal","Und$_")[sum 18.5,25 X>$^a/$^b**2]}
Rough translation of xnor's Python solution, 65 bytes:
{$_=$^a/$^b**2;25>$_>=18.5??"Normal"!!<Und Ov>[$_>19]~"erweight"}

OCaml, 93 bytes
let b w h=if w/.h/.h<18.5 then"underweight"else if w/.h/.h>=25.0 then"overweight"else"normal"

No, this is a function.

MATL, 54 45 44 42 bytes
U/E'%2'<sqt?q?'ov'}'und']'erweight'h}x17Y0

Try it at matl.io
Starts off by calculating the BMI and doubling it U\E, then creates the vector [37 50] with the string literal '%2'. Compares the BMI to this vector and uses if statements to get the answer, taking advantage of normal as a predefined literal 17Y0.

You can replace [BC]UQ with '%2' and save 2 bytes.

Thunno 2, 25 bytes
²/¿}ȯE¿©S‘Ọḃẋɠ Ḳẇ ṁẓẋɠ‘Oi

Try it online!
Explanation
²/...©S...i  # Implicit input
²/           # Divide the weight by the height squared
  ...        # Compressed numeric list [18.5, 25]
     ©       # Vectorised lesser than or equal to
      S      # Sum the list to get an integer from 0 to 2
             # (0=overweight, 1=normal, 2=underweight)
       ...i  # Index into compressed list of strings
             # ["Overweight", "Normal", "Underweight"]
             # Implicit output

K (ngn/k), 57 bytes
{((,"Normal"),("Ov";"Und"),\:"erweight")3!("%2"%2)'x%y*y}

Try it online!

you can replace ,"Normal" and ("Ov";"Und") with symbols and do a ,/$ at the end

like this: {,/$(`Normal,`Ov`Und,'`erweight)3!("%2"%2)'x%y*y}

("%2"%2)' -> 18.5 25'

same length but more straighforward: {$`Underweight^`Normal`Overweight@18.5 25'x%y*y}

I mostly just liked how (“%2”%2) looked.  :)  I do prefer the symbols though.

yeah, double "%2 looks nice, like a rhyme :)

Java 8, 61 bytes
w->h->w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight"

Assign to a DoubleFunction<DoubleFunction<String>> and call thusly:
bmi.apply(50).apply(1.5)

You can spare one byte by reusing w: w->h->(w/=h*h)<18.5?"Underweight":w<25?"Normal":"Overweight".

@OlivierGrégoire Nope :( Error: local variables referenced from a lambda expression must be final or effectively final Can't assign to w.

Oh... I checked with inlined stuff like int w = ... , h = ... ; System.out.println((w/=h*h)<18.5?"Underweight":w<25?"Normal":"Overweight"), sorry :)

@OlivierGrégoire No problem. I wish Java allowed it.

Japt, 46 bytes
/=V²U<25©U¨18½?`NŽµl`:ºU<19?`U˜`:"Ov")+`€³ight

Try it online!
Inspired by @Luke's answer.
Explanation
/=V²U<25©U¨18½?`NŽµl`:ºU<19?`U˜`:"Ov")+`€³ight

Decompresses to :
U=U/V**2,U<25&&U>18.5?"Normal":(U<19?"Und":"Ov")+"erweight"

Japt has an implicit input U. The second input is V.
Japt uses the shoco library for string compression. Backticks are used to decompress strings.
Unicode shortcuts used:
² : **2
© : &&
¨ : >=
½ : .5
º : ((

dc, 64 bytes
[erweight][[Und]PszPq]su[[Normal]Pq]sn9k?d*/d18.5>ud25>n[Ov]PszP

Try it online!

Dang it! Just beat me by a few seconds. I was about to post mine, until I saw this. Anyways, here is another 64 byte answer: 3k[Overweight]??2^/dsp[[Normal]][[Underweight]]sasb25>blp18.5>ap.

@R.Kap You can actually get yours to be one byte shorter than mine by omitting one of the question marks.

Oh yeah, I forgot that I could do that. You can post that as your own if you want.

No, that's fine -- go ahead and post it yourself, it's your solution.  (You can credit me for one byte if you want.)

By the way, I was able to get it down to 58 bytes. :)

@R.Kap  Nice :) .

PHP, 69 68/85 bytes
If you want it to be more as a program,
$a=$args;$b=$a[0]/($a[1]*$a[1]);echo$b>=18.5&&$b<25?normal:($b<18.5?und:ov).erweight; // 85

$b=$k/($h*$h);echo$b>=18.5&&$b<25?normal:($b<18.5?und:ov).erweight; // 68
$b=$k/pow($h,2);echo$b>=18.5&&$b<25?normal:($b<18.5?und:ov).erweight; // 69

You can test with $k=80; $h=1;. I had three choices, via $args, like this or as defined values (K&H). I choose the middle as most fair.

Javascript (ES6), 63 bytes
(m,h)=>(w="erweight",b=m/h/h)<18.5?"Und"+w:b<25?"Normal":"Ov"+w

Example

f=(m,h)=>(w="erweight",b=m/h/h)<18.5?"Und"+w:b<25?"Normal":"Ov"+w

console.log(f(80, 1));
console.log(f(80, 2));
console.log(f(80, 3));

Swift, 97 bytes
{(w:Float,h)->String in return 18.5<=w/h/h&&w/h/h<25 ?"normal":"\(w/h/h>25 ?"ov":"und")erweight"}

PHP, 121 bytes
function f($a,$b){$i=$a/($b*$b);$x = 18.5;print ($i<$x?"Underweight":($i>=$x&&$i<25?"Normal":($i>=25?"Overweight":"")));}

Try it online!

Scala, 124 bytes
val x="erweight"
def b(i:Float,a:Float):Any=i/a/a match{case z if(z<18.5)=>"Und"+x
case z if(z<25)=>"Normal"
case z=>"Ov"+x}

REXX, 113 bytes
arg m h
b=m/h**2
e=erweight
select
  when b<18.5 then say 'UND'e
  when b>=25 then say 'OV'e
  otherwise say Normal
end

REXX is on now on TIO!

C, 94 bytes
char const*f(float a,float b){return a/b/b<18.5?"Underweight":a/b/b<25?"Normal":"Overweight";}

Simply calculates the BMI and returns the appropriate range using the ternary operator. Not using an intermediate variable to store the BMI saves 6 bytes.


text:
Tell me I'm pretty!
I only very recently discovered code golf and just found this part of the Stackexchange network, and naturally after looking at so many clever answers, I feel inferior. Inner me knows I'll get better over time, but inner me is also vain and needs validation.
At the same time, I don't take kindly to pandering, so you'd better not write me a program that looks like it took 15 seconds. You have to mean it.
Goal:
Print the phrase "you're pretty!" or write a function that returns that string. All letters can be upper-case or lower-case, but the punctuation and the spacing must be the same.
How to mean it:
If you're sensitive and can sympathize with all the emotions associated with feeling like a noobie, you should aim to make your program look like it does something entirely different and innocuous. I like to be surprised :) You may achieve this by not using any of the alphabetical characters in "you're pretty".
Winner is decided by shortest byte count. -5 bytes for each positive or neutral adjective you extend the phrase by, i.e. "you're pretty and effulgent and green", up to a possible 20 byte reduction.

I feel like jelly can get a negative score on this one..

Welcome to PPCG! I'm afraid to say that, as it stands, your challenge is quite vague. It should have objective winning criterion. If the challenge is just to output you're pretty, then it's a dupe of the Hello, World! question. If it's about adding adjectives, then what defines a neutral/positive adjective?

Since you're new here, you should really take a look at the Sandbox before posting a challenge.

@briantist Oh ok, thanks, I will! Sorry, I was getting the impression that really all I had the power to do with my current rep was answer questions and post them, but I'll do that next time :)

@ConorO'Brien can you link me to this Hello, World! question?

You're pretty..

Hello, World!

Jelly, 29 28 - 20 = 9 8 points
“+vẇSȮv¿⁷“ñż“ÞỌ“Ḋ;“ʠK»j“ and

Try it online!
The bonus turns out to be just marginally worth it for Jelly: “+vẇSȮv¿⁷» (the compressed representation of you're pretty) is 10 bytes. (Now with another byte saved per @ConorOBrien; I'd forgotten that as the final and is uncompressed, it wouldn't need a trailing delimeter.)
Explanation
“+vẇSȮv¿⁷“ñż“ÞỌ“Ḋ;“ʠK»j“ and
“+vẇSȮv¿⁷“ñż“ÞỌ“Ḋ;“ʠK»        ["you're pretty"," airy"," agile"," calm"," brave"]
                      j       join with
                       “ and  " and"

This is pretty much just a case of using Jelly's built-in string compression. Picking adjectives that come near the start of the alphabet makes it slightly shorter than it would be otherwise.
Incidentally, this program would be quite a bit shorter if Jelly's dictionary were more complete. It has plenty of obscure words in, but for some reason is missing and (likely because it's only three letters long and thus doesn't gain much from the compression, but it'd benefit from being included in the dictionary for when it's used as part of a longer string, because “¡ÞṄɱ» is longer than just writing out the word would be).

You can leave off the trailing quote: Try it online!

Jelly's dictionary contains all words from my distro's /usr/share/dict/words that are composed of two or more ASCII letters. For whatever reason, said dictionary contains AND, but not and...

Japt, 10 bytes
`YŒ'œ pÎ5y

Japt uses the shoco library for string compresstion. Backticks are used to decompress strings.
Try it online!

Wow, the entire program is shorter than the string "you're pretty!"...

Not that it matters (since the question is closed), but this doesn't seem to be a valid answer: it uses 'Y', 'p', 'y', all of which are characters from the required phrase "You're pretty!"


text:
Quining, but with Windows files!
Write a quine, that when run, creates itself in the current directory, in a source file named itself. We will be using Windows in this, so the file name (and therefore quine) must have the following limitations:

None of these characters \ / : ? * < > |
Fewer than 211 255 characters

Limitations and assumptions

Your code must be a full program (It's going to be run after all).

No copying from the source file.

You can assume that there isn't another file with your Quine as its name (as it would produce Quine (1)).

Errors are allowed (as long as they don't get into the source code

This is code-golf, shortest code in bytes wins!
Edit
Maybe I wasn't clear, the file with the name of the quine has to actually contain the quine. My bad.

What are the limitations on non-ASCII characters in the program? (On Windows, this might quite possibly depend on what language version of Windows is installed; I forget the exact rules and whether they've changed over time.)

Why fewer than 211 bytes? That's kind of an arbitrary restriction...

@mbomb007 Max filename size, I believe.

@VoteToClose It's 255. http://stackoverflow.com/a/265782/2415524

@mbomb007 Typo, perhaps?

Why do we have to make it for windows?

@theonlygusti because i use windows

I don't know if that have changed but Windows 10 don't accept double quote " in file name

Node.js, 56 52 bytes
function f(){require('fs').writeFile(f+='f()',f)}f()

This prints the warning

DeprecationWarning: Calling an asynchronous function without callback is deprecated.

If you want the all-green, it costs 4 bytes to change writeFile to writeFileSync.

Vitsy, 10 27 bytes
'rddd++&"rdd8++a[v}v1-D);].

If : was allowed, I could shorten this to 11 bytes. :(
Explanation:
'rddd++&"rdd8++a[v}v1-D);].
'                           Capture all instructions as a string until encountering
                              ' again, looping if necessary.
 r                          Reverse the current stack (output is top-down).
  ddd++                     Push char literal ' to the stack.
       &                    Push a new stack to the stack stack.
        "                   Same as ', but " specific.
         r                  Reverse the current stack.
          dd8++             Push char literal " to the stack.
               a            Push 10 to the stack.
                [        ]  Loop forever.
                 v          Capture the top value as a variable.
                  }         Take the bottom item of the stack and put it on the top.
                   v        Dump the variable to the stack.
                    1-      Subtract 1.
                      D     Duplicate the top item.
                       );   Pop n; if n is 0, exit the loop.
               a[v v1-D);]  This is a makeshift for loop with 10 iterations.
                          . Pop the top stack as n, and the second stack as o.
                              Write a file called "n" with the contents of "o".

The two stacks will be identical at the end. On some Java versions, this may throw a FileNotFoundException due to different implementations of the FileInputStream class.
Previous answer before edit:
&'rddd++}.

Explanation:
&           Push a new stack to the stack stack.
 'rddd++    Modified standard quine.
        }   Move the ' to the right place.
         .  Pop the top stack as n, and the second stack as o. Write a file called
                 "n" with the contents of "o". (Quine name, no content)

Because I might as well, here's a diagram of the steps that occur within the stacks (each stack is represented by []):
Initial state: [[]]

&              [[], []]
                  Push a new stack to the stack stack.

 '             [[], ["r", "d", "d", "d", "+", "+", "}", ".", "&"]]
                  This stack state occurs because ' will loop around the line
                    until finding the next '.

  r            [[], ["&", ".", "}", "+", "+", "d", "d", "d", "r"]]
                  Reverses the top (last) stack.

   ddd         [[], ["&", ".", "}", "+", "+", "d", "d", "d", "r", 13, 13, 13]
                  Push thirteen thrice.

      ++       [[], ["&", ".", "}", "+", "+", "d", "d", "d", "r", "'"]
                  Because char ' is 39 = 13 + 13 + 13.

        }      [[], [".", "}", "+", "+", "d", "d", "d", "r", "'", "&"]]
                  Takes the bottom item, then puts it on the top.

         .     []
                  Writes a file with content from the second-to-top stack and the
                    name as the concatenation of all elements in the top stack,
                    with top member priority (backwards from my representation).

I'm actually not sure how this works right; minute changes cause this to break. For example, placing the & in various other locations should work just as well, but it causes ClassCastExceptions, IOExceptions, and ArrayOutOfBoundsExceptions depending on where you put it. I might need to do some bugfixing.

+1 for Push a new stack to the stack stack.

+1 from me if you can push a new stack stack to a stack stack stack, otherwise forget it! ... Kidding +1, I laughed too.

@carusocomputing What if I told you I can with o? ;)

Sigh unzip...

@Pavel I have added a stack diagram to demonstrate the creation of stacks within the stack stack, along with the manipulation of individual stacks within the stack stack to make sure that the stacks are stacked correctly.

Uhm... I think that the generated file is supposed to contain the code (i.e. its content should be equal to its filename)

@Leo The challenge does not mention this anywhere, I don't think... If that's a requirement, I'll alter it. It'll be a pretty steep bytecount change.

See revised edit

@VoteToClose Even after the edit, it's still half the next answer.

@Thunda No - this puts the source code in the output file as well. Both the stacks are filled at the end with identical contents, which means that the content matches the name, and, as they are both quines, they are all the same.

Lua, 96 bytes.
s="s=%qs=string.format(s,s)f=io.open(s)f.write(f,s)"s=string.format(s,s)f=io.open(s)f.write(f,s)

Typed this on my phone, should work, but I'll test it when I get to a computer.

I think at the very least you'll need to change sting.format to string.format twice.

@PeterTaylor you don't like Sting, do you?

@KeyWeeUsr, I have nothing against him personally, and in fact he helped pay for my upbringing, but I think that the Lua standard library was probably designed for general usability by people familiar with similar APIs rather than specifically for Police fans.

C, 134 bytes
s[255];fd;char p[255]="s[255];fd;char p[255]=%c%s%c;main(){sprintf(s,p,34,p,34);creat(s,0);}";main(){sprintf(s,p,34,p,34);creat(s,0);}

The source here contains * so it doesn't look like it's allowed according to the rules.

@ValueInk Fixed. Thanks for pointing that out!

Python 3, 51 bytes
a="s='a=%r;exec(a)'%a;open(s,'w').write(s)";exec(a)

Try it online!
Python 3, 87 79 71 62 bytes
Since windows is not allowing double quote " anymore (more infos), I made an other solution verifying the new convention:
w='w=%r;open(w%%w,w[0]).write(w%%w)';open(w%w,w[0]).write(w%w)

Try it online!