text:
Find the sets of sums
I've enjoyed reading this site; this is my first question. Edits are welcome.
Given positive integers \$n\$ and \$m\$, compute all ordered partitions of \$m\$ into exactly \$n\$ positive integer parts, and print them delimited by commas and newlines. Any order is fine, but each partition must appear exactly once.
For example, given \$m=6\$ and \$n=2\$, possible partitions are pairs of positive integers that sum to 6:
1,5
2,4
3,3
4,2
5,1

Note that [1,5] and [5,1] are different ordered partitions. Output should be exactly in the format above, with an optional trailing newline. (EDIT: The exact order of the partitions does not matter). Input/output are via standard code-golf I/O.
Another example output for \$m=7, n=3\$:
1,1,5
1,2,4
2,1,4
1,3,3
2,2,3
3,1,3
1,4,2
2,3,2
3,2,2
4,1,2
1,5,1
2,4,1
3,3,1
4,2,1
5,1,1

The smallest code in bytes after 1 week wins.
Again, please edit if necessary.
Addendum:
@TimmyD asked what size of integer input the program has to support. There is no hard minimum beyond the examples; indeed, the output size increases exponentially, roughly modelled by: lines = \$e^{(0.6282 n - 1.8273)}\$.
n | m | lines of output
2 | 1 | 1
4 | 2 | 2
6 | 3 | 6
8 | 4 | 20
10 | 5 | 70
12 | 6 | 252
14 | 7 | 924
16 | 8 | 3432
18 | 9 | 12870
20 | 10 | 48620
22 | 11 | 184756
24 | 12 | 705432

Do the answers need to support arbitrarily large integers, or is a reasonable upper bound like 2^31-1 suitable?

The term "sets" is confusing because order matters. I think the term you're looking for is ordered partitions.

Although it isn't necessary to change, we usually have a looser output format than this.

I've changed your wording to allow I/O through function arguments, prompts, and other I/O methods we usually consider acceptable.

@TimmyD, the size of the output grows rather explosively so that it's not practical to try m and n past a few hundred, let alone 2^31-1.

Usually I would expect to be able to just return a list of lists, instead of something with an exact format. Making my Perl 6 follow that makes it 1½ times the size it would otherwise be.

Pyth, 14 bytes
V^SQEIqsNQj\,N

Try it online: Demonstration or Test Suite
Explanation:
V^SQEIqsNQj\,N   implicit: Q = first input number
  SQ             create the list [1, 2, ..., Q]
    E            read another number
 ^               cartesian product of the list
                 this creates all tuples of length E using the numbers in SQ
V                for each N in ^:
     IqsNQ          if sum(N) == Q:
          j\,N         join N by "," and print

Also 14 bytes, different approach: jjL\,fqsTQ^SQE.

Python 3, 77 bytes
def f(n,m,s=''):[f(i,m-1,',%d'%(n-i)+s)for i in range(n)];m|n or print(s[1:])

A recursive function that builds each output string and prints it. Tries every possible first number, recursing down to find a solution with the corresponding decreased sum n, and one fewer summand m, and a string prefix s with that number. If both the required sum and the number of terms are equal 0, we've hit the mark, so we print the result, cutting off the initial comma. This is checked as m|n being 0 (Falsey).
79 chars in Python 2:
def f(n,m,s=''):
 if m|n==0:print s[1:]
 for i in range(n):f(i,m-1,','+`n-i`+s)

CJam, 22 bytes
q~:I,:)m*{:+I=},',f*N*

Try it online in the CJam interpreter.
How it works
q~                      Read and evaluate all input. Pushes n and m.
  :I                    Save m in I.
    ,:)                 Turn it into [1 ... I].
       m*               Push all vectors of {1 ... I}^n.
         {    },        Filter; for each vector:
          :+I=            Check if the sum of its elements equals I.
                        Keep the vector if it does.
                ',f*    Join all vectors, separating by commas.
                    N*  Join the array of vectors, separating by linefeeds.

Pyth, 20 18 bytes
-2 bytes by @Dennis!
jjL\,fqQlT{s.pM./E

This takes n as the first line of input, and m as the second.
Try it here.

Haskell, 68 bytes
n#m=unlines[init$tail$show x|x<-sequence$replicate n[1..m],sum x==m]

Usage example:
*Main> putStr $ 2#6
1,5
2,4
3,3
4,2
5,1

How it works: sequence $ replicate n list creates all combinations of n elements drawn form list. We take all such x of [1..m] where the sum equals m. unlines and init$tail$show produce the required output format.

Dyalog APL, 33 bytes
{↑1↓¨,/',',¨⍕¨↑⍺{⍵/⍨⍺=+/¨⍵},⍳⍵/⍺}

Takes m as left argument, n as right argument.
Almost half (between { and ⍺) is for the required formatting.

Python 3, 112
from itertools import*
lambda m,n:'\n'.join(','.join(map(str,x))for x in product(range(m),repeat=n)if sum(x)==m)

I haven't managed a 1 liner in a while. :)

Mathematica, 65 bytes
StringRiffle[Permutations/@#~IntegerPartitions~{#2},"
","
",","]&

IntegerPartitions does the task. The rest is just to order the tuples and format the result.

Jelly, 11 bytes
ṗS=¥Ƈ⁸j€”,Y

Try it online!
Boo to restrictive output formats. +5 bytes because of that.
How it works
ṗS=¥Ƈ⁸j€”,Y - Main link. Takes m on the left and n on the right
ṗ           - Take the cartesian power of m and n
              This returns all lists of length n consisting of the integers 1,...,m
   ¥Ƈ       - Keep those where the following is true:
 S          -   Their sum...
  =         -   Is equal to...
     ⁸      -   m
        ”,  - Yield ","
      j€    - Join each sublist by ","
          Y - Join by newlines

Python 2.7, 174 170 152 bytes
Fat answer. At least it's readable :)
import sys,itertools
m=int(sys.argv[1])
for k in itertools.product(range(1,m),repeat=int(sys.argv[2])):
    if sum(k)==m:print str(k)[1:-1].replace(" ","")

You can remove the spaces around >, after replace, and after the comma.

Julia, 105 bytes
f(m,n)=for u=∪(reduce(vcat,map(i->collect(permutations(i)),partitions(m,n)))) println("$u"[2:end-1])end

This is a function that reads two integer arguments and writes the results to STDOUT with a single trailing line feed.
Ungolfed:
function f(m::Integer, n::Integer)
    # Get the integer partitions of m of length n
    p = partitions(m, n)

    # Construct an array of all permutations
    c = reduce(vcat, map(i -> collect(permutations(i)), p))

    # Loop over the unique elements
    for u in unique(c)
        # Print the array representation with no brackets
        println("$u"[2:end-1])
    end
end

Husk, 14 bytes
moJ',msfo=¹Σπ²

Try it online!
with the correct output format.
Husk, 7 bytes
fo=¹Σπ²

Try it online!
Inputs are taken as \$n,m\$.
Explanation
fo=¹Σπ²
     π   cartesian power of n, with range 1..m
f        filter the terms where
    Σ    sum
  =      equals
   ¹     m

Perl 6, 54 bytes
If the output could be a list of lists
{[X] (1..$^m)xx$^n .grep: $m==*.sum} # 36 bytes

my &code = {[X] (1..$^m)xx$^n .grep: $m==*.sum}
say .join(',') for code 7,3;

The way it's currently worded I have to add a join into the lambda.
{say .join(',')for [X] (1..$^m)xx$^n .grep: $m==*.sum} # 54 bytes

{...}( 7,3 );

1,1,5
1,2,4
1,3,3
1,4,2
1,5,1
2,1,4
2,2,3
2,3,2
2,4,1
3,1,3
3,2,2
3,3,1
4,1,2
4,2,1
5,1,1

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


text:
Minimum number of numbers to sum to exactly n
First question here, don't yell at me if this is a duplicate or a bad challenge.
Introduction
I thought of this challenge myself, and it seems to be a good basic puzzle for beginner code-golfers. It also might help me decide which code-golfing language to learn.
Challenge
Given an array of integers that are less than or equal to n, output or return the minimum number of numbers from the array that sum up to exactly n.
You can choose to write a function or a full program.
Input
You can safely assume 0 <= n < 2^31.
Take an array or list of any kind (vector for C++ or Java's LinkedList are allowed), along with n and an optional parameter length, which specifies the length of the array.
You can also take the input as a space-separated string, separated from n by either a comma or a space:
1 5 7 3 7 3 6 3 2 6 3,10

1 5 7 3 7 3 6 3 2 6 3 10

if it is easier.
Output
Output, or return the minimum number of numbers from the array that sum up to exactly n. Using the above example:
1 5 7 3 7 3 6 3 2 6 3,10

Your program should print:
2

because the minimum number of numbers that sum up to 10 is 2 (7 and 3).
In the case that there is no solution, print or return either a negative, 0, "No solution" (though that would not be smart), ∞ (as suggested), or any other falsy value, with the exception of an empty string.
Example Input and Output
Input:
1 5 7 3 7 3 6 3 2 6 3,10
143 1623 1646 16336 1624 983 122,18102
5 6 9,12

Output:
2
3
-1

Scoring
This is code-golf, so shortest code in bytes wins.
The top answer will be accepted on Christmas.

I've edited your spec, because we usually allow the same I/O methods for functions and programs; see the consensus here. Feel free to roll back if you disagree.

May we output false for cases with no solutions?

@ETHproductions Sure, will add that.

Do you consider empty output falsey, since the empty string is falsey in Pyth?

@ThomasKwa I don't like empty string outputs, but you can include that as "if x was allowed..." in your answer...

Would ∞ be falsey?

@LegionMammal978 No, but it makes sense. Will add to challenge description.

Pyth, 12 11 bytes
lhafqsTQyEY

This takes n as the first line of input and the list on the second line.
lhafqsTQyEY     (Implicit: Q = 1st line of input; E = 2nd line)
         E      The list
        yE      Powerset (sorted by increasing length; empty set first)
   f            Filter by lambda T:
     sT         sum(T)
    q                  ==
       Q                  Q
   fqSTQyE      Sublists that sum to Q, sorted by increasing length
  a       Y     append an empty array (in case none match)
lh              take the length of the first element (0 for empty array)

Try it here.

Your code and your explanation don't match.

@isaacg Now fixed.

Japt, 30 21 18 bytes
Turns out there was a much more efficient method. ;)
Uà f_x ¥V} ml n- g

Test it online! (Note: n- has been changed to n@X-Y} for compatibility reasons)
This takes input as a space- or comma-separated array, followed by a number. Outputs undefined for test cases without solutions.
Uà f_  x ¥ V} ®   l} n- g
UàfmZ{Zx ==V} mZ{Zl} n- g

            // Implicit: U = input array, V = input integer
Uà fZ{   }  // Generate all possible combinations of U, then filter to only items Z where
Zx ==V      //   the sum of Z is equal to V.
mZ{Zl}      // Map each remaining combination to its length.
n-          // Sort by subtraction; smaller items end up in the front.
g           // Take the first item.
            // Implicit: output last expression

I can't believe I didn't think of this version when I originally wrote this...
Several optimizations have been made since then which come in handy here:

A U at the beginning of the program can usually be left out.
Ã is a shortcut for } .
n now sorts numbers properly by default.

Each of these takes off a byte, for a total of 15:
à f_x ¥VÃml n g

Test it online!

That's 25 bytes, not 21.

@AlbertRenshaw Japt supports the IEC_8859-1 encoding, under which each of these characters is 1 byte. You can save this program as a IEC_8859-1-encoded text file, then upload it to the online interpreter.

Ah, nice! Thanks for informing me

Mathematica, 73 65 bytes
Min[Length/@Select[IntegerPartitions[#2,#2,#],Sort@#==Union@#&]]&

Pure function, returns ∞ if there is no solution.

Python 3, 128 bytes
This isn't as golfed as I'd like it to be, but I'll work on it later.
from itertools import*
def s(a,n):
 for i in range(len(a)):
  for j in permutations(a,i+1):
   if sum(j)==n:return i+1
 return 0

Mathematica, 45 bytes
Min@Cases[Subsets@#,i_/;Tr@i==12:>Length@#2]&

CJam, 34 bytes
0q~_,2,m*\f.*{:+1$=},\;0f-{,}$0=,+

Try it online. The input format is the sum followed by the list of values, e.g.:
18102 [143 1623 1646 16336 1624 983 122]

Note that this will raise an exception if no solution is found. The exception goes to stderr when CJam is run from the command line, and the correct result (0) is still printed to stdout. So this meets the consensus established at Should submissions be allowed to exit with an error?
The code may look longer than you would expect. The main reason is that CJam has no built-in for generating combinations. Or at least that's my excuse, and I'm sticking to it.
Explanation:
0       Push 0 result for exception case.
q~      Get and interpret input.
_,      Copy and get length of input value list.
2,      Push [0 1].
m*      Cartesian power. This generates all possible lists of 0/1 values with the
        same length as the input value list.
\       Swap input value list to top.
f.*     Apply element-wise product of input value list with all 0/1 lists.
        We now have all combinations of values, with 0 in place of unused values.
{       Start filter block.
  :+      Sum values.
  1$      Copy target sum to top.
  =       Compare.
},      Filter.
\;      Swap target sum to top and discard.
0f-     Remove 0 values. We now have all solution lists.
{,}$    Sort by length.
0=      Get first solution, which after sorting is the shortest.
        This will raise an exception if the list of solutions is empty, bailing
        out with the initial 0 on the stack.
,       Get length of solution.
+       Add the 0 we initially pushed for the exception case.

JavaScript (ES6), 84 bytes
f=(a,n,m=1e999,x)=>n&&a.map((v,i)=>(x=[...a],x.splice(i,1),x=f(x,n-v)+1)<m?m=x:0)&&m

Explanation
Takes an Array of Numbers and a Number as arguments. Returns a number of Infinity if no result. It is a recursive function that subtracts from n and removes each element from the array one-by-one until n == 0.
f=(a,n,m=1e999,x)=> // m and x are not passed, they are here to declare them in the local
                    //     scope instead of globally, initialise m to Infinity
  n&&               // if n == 0, return 0
  a.map((v,i)=>     // iterate over each number in a
    (x=[...a],      // x = copy of a
    x.splice(i,1),  // remove the added number from the array
    x=f(x,n-v)+1)   // x = result for the numbers in this array
      <m?m=x:0      // set m to minimum result
  )
  &&m               // return m

Test
This test sets m to Infinity later instead of as a default argument to make it work in Chrome (instead of just Firefox).

var solution = f=(a,n,m,x)=>n&&a.map((v,i)=>(x=[...a],x.splice(i,1),x=f(x,n-v)+1)<m?m=x:0,m=1e999)&&m
Array (space-delimited) = <input type="text" id="array" value="143 1623 1646 16336 1624 983 122" />

n = <input type="number" id="N" value="18102" />

<button onclick="result.textContent=solution(array.value.split` `,N.value)">Go</button>

Haskell, 72 bytes
import Data.List
n#l=head$sort[length x|x<-subsequences l,sum x==n]++[0]

Returns 0 if there's no solution.
Usage example: 10 # [1,5,7,3,7,3,6,3,2,6,3] -> 2.
Find all sub-lists of the input list l which have a sum of n. Take the length of each such sub-list and sort. Append a 0 and take the first element.
If a singleton list is allowed for output, e.g. [2], we can save 7 bytes:  n#l=minimum[length x|x<-subsequences l,sum x==n]. In case of no solution, the empty list [] is returned.

Vyxal, 9 bytes
ṗ'∑₀=;vLg

Try it Online!
ṗ         # Powerset
 '   ;    # Filtered by
  ∑₀=     # Sublists that sum to input
      vL  # Get length of each
        g # Minimum

Jelly, 8 bytes
ŒPS=¥ƇẈṂ

Try it online!
Outputs 0 if there's no solution
How it works
ŒPS=¥ƇẈṂ - Main link. Takes L on the left and n on the right
ŒP       - Powerset of L
    ¥Ƈ   - Keep those lists for which the following is true:
  S      -   The sum...
   =     -   ...equals n
      Ẉ  - Lengths of those kept
       Ṃ - Minimum

Python 3.9, 101 bytes
def f(l,t):
 s={0:0}
 for i in l:s|={k+i:min(s[k]+1,s.get(k+i,s[k]+1))for k in s}
 return s.get(t,-1)

Try it online!
Note : the |= operators was introduced in python 3.9 but TIO doesn't support that version.
Python 3, 105 bytes
def f(l,t):s={0:0};[s.update({k+i:min(s[k]+1,s.get(k+i,s[k]+1))for k in s})for i in l];return s.get(t,-1)

Try it online!
Ungolfed version:
def f(l,t):
  s={0:0}              # initialize the reached numbers
  for i in l:          # iterate through the list
    new_s = {}           # create a dict for the newly reached numbers
    for k in s:          # iterate through all the reached numbers
      new_s[k+i] = min(s[k]+1,s.get(k+i,s[k]+1)) # set the new number to the minimal number of steps
    s.update(new_s)      # update out dict with the new values
  return s.get(t,-1)   # returns the number of steps or -1 if the number is unreachable

Try it online!
Note:
there is probably some potential

source: Stack Exchange

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

sort: votes


text:
Sums of Consecutive Integers
Before anyone says anything, similar and similar. But this is not a dupe.

Some positive integers can be written as the sum of at least two consecutive positive integers. For example, 9=2+3+4=4+5. Write a function that takes a positive integer as its input and prints as its output the longest sequence of increasing consecutive positive integers that sum to it (any format is acceptable, though -5 bytes if the output is the increasing sequence separated by + as shown above. If there exists no such sequence, then the number itself should be printed.
This is code golf. Standard rules apply. Shortest code in bytes wins.

Samples (note that formatting varies)
Input:   9
Output:  2,3,4

Input:   8
Output:  8

Input:   25
Output:  [3,4,5,6,7]

Do the numbers outputted have to be in a specific order (like increasing)?

Do the numbers have to be >0 : 6=0+1+2+3 or 6=1+2+3

Also related.

As a side note, if there are closely related challenges, saying "this is not a dupe" will do little to convince people of that if they do think it's a dupe. It would be more helpful if you explained why you think it isn't.

@Damien, or even input = 9, output = -1,0,1,2,3,4

@Damien "positive" normally means >0. If 0 was included, it would be called "non-negative".

cc @Vixen ^ (also if negative numbers were allowed, the optimal solution would always be the range from -n+1 to n)

Ok, it looks like positive integer have not same meaning between English and French.

Looking at those similar questions shows how far golfing has advanced over the years!

Can we skip 1 too?  :)  I can save 3 bytes if so.

Python, 67 bytes
f=lambda n,R=[1]:n-sum(R)and f(n,[R+[R[-1]+1],R[1:]][sum(R)>n])or R

An oddly straightforward strategy: search for the interval R with the right sum.

If the sum is too small, shift the right endpoint of the interval up
one by appending the next highest number.
If the sum is too large, shift up the left endpoint by removing the smallest element
If the sum is correct, output R.

Since the bottom end of the interval only increases, longer intervals are found before shorter ones.

Oddly efficient as well. The recursion stack does eventually overflow, e.g. n=8192.

idk if this uses an acceptable output format, but it's also 67 bytes and can probably be golfed farther

@c-- I would guess that the range call should be in the function itself for I/O, which puts it at 73 bytes, but maybe it can be shortened.

Pyth, 12 10 bytes
j\+hfqsTQ}M^SQ2

The code is 15 bytes long and qualifies for the -5 bytes bonus. Try it online in the Pyth Compiler.
Thanks to @Jakube for golfing off 2 bytes!
How it works
j\+hfqsTQ}M^SQ2    (implicit) Store evaluated input in Q.

            S      Compute [1, ..., Q].
           ^  2    Get all pairs of elements of [1, ..., Q].
         }M        Reduce each pair by inclusive range. Maps [a, b] to [a, ..., b].
    f              Filter; for each pair T:
      sT             Add the integers in T.
     q  Q            Check if the sum equals Q.
                   Keep the pair if it does.
   h               Retrieve the first match.
                   Since the ranges [a, ..., b] are sorted by the value of a,
                   the first will be the longest, in ascending order.
j\+                Join, using '+' as separator.

For those of us not enlightened in the area of Pyth, could you add an explanation please? :)

I've edited my answer.

Awesome, thanks! I like your technique.

Input 1000: 30 minutes and counting...

K (ngn/k), 40 32 bytes
{^/!'1+i@'*>-/i:&x=s-\:s:+\!1+x}

Try it online!
-8 bytes thanks to @ngn

Can save a couple of bytes if I ignore 1

Hmm..  actually maybe not.

Wolfram Language (Mathematica), 73 68 65 56 43 42 35 bytes
Range@#/.{___,x__,___}/;+x==#:>{x}&

Try it online!

+1 I ended up with a similar solution last night, but my internet went down. Also you can make Tuples an infix expression.

Haskell, 49 48 bytes
f n=[[a..b]|a<-[1..n],b<-[a..n],sum[a..b]==n]!!0

1 byte to save: use [...]!!0 instead of head[...].

Jelly (fork), 5 bytes
ẆSƘ¹Ṫ

Try it online! (or rather, don't)
For an extra 3 bytes (again, doesn't work on TIO), we can get a score of 3
How it works
ẆSƘ¹Ṫ - Main link. Takes N on the left
Ẇ     - Cast N to range and get all contiguous, non-empty sublists
  Ƙ¹  - Keep those for which the following is equal to N:
 S    -   Sum
    Ṫ - Take the last (and longest) one

Vyxal, 11 - 5 = 6 bytes
ɾÞS≬∑?=c\+j

Just like most of the other answers in golfing languages.
Try it Online!
Explanation:
ɾ            # Range from 1 to n
 ÞS          # All sublists
   ≬         # Three element lambda
    ∑        #   Sum
      =      #   Equals
     ?       #   The input
       c     # First truthy item under function application
          j  # Join by:
        \+   # "+"

Brachylog, 8 bytes
⟦₁s.+?!∧

Try it online!
Explanation
⟦₁s.+?!∧
⟦₁         Inclusive range from 1 to the input number
  s        A consecutive sublist (trying longest sublists first)
   .       is the output
    +      Its sum
     ?     is the input
      !    Don't try any further possibilities
       ∧   Break unification with the output

K (ngn/k), 61 41 bytes
h:{i{x':y}\:i:1+!x}
f:{i@*|&x=+/'i:,/h@x}

Try it online!
¯20 bytes thanks to @doug

K (ngn/k), 27 26 bytes
{*|(x=+/')#{y+!'x}.1+!2#x}

Try it online!
Uses doug's insight that to get a run you just need a pair of numbers.

Interestingly, I was using start&end for my two numbers but you used start&length.  Neat insight that odometer provides this with increasing lengths.

I think {*(x=+/')#&'&'+1+!2#x} works for 22 bytes. (The generated ranges will be sorted by their first element, so the first one summing to x will be the longest.

MATLAB, 87 79 bytes
I know there is already a MATLAB answer, but this one is significantly different in approach.
x=input('');m=1:x;n=.5-m/2+x./m;l=max(find(~mod(n(n>0),1)));disp(m(1:l)+n(l)-1)

This also works on Octave. You can try online here. I've already added the code to consecutiveSum.m in the linked workspace, so just enter consecutiveSum at the command prompt, then enter the value (e.g. 25).
I am still working on reducing it down (perhaps adjusting the equation used a bit), but basically it finds the largest value n for which m is an integer, then displays the first m numbers starting with n.
So why does this work? Well basically there is a mathematical equation governing all those numbers. If you consider that they are all consecutive, and start from some point, you can basically say:
n+(n+1)+(n+2)+(n+3)+...+(n+p)=x

Now, from this it becomes apparent that the sequence is basically just the first p triangle numbers (including the 0'th), added to p+1 lots of n. Now if we let m=p+1, we can say:
m*(n+(m-1)/2)==x

This is actually quite solvable. I am still looking for the shortest code way of doing it, I have some ideas to try and reduce the above code.

For an input of 25, the output would be:
3     4     5     6     7

With regards to your point about the triangle numbers, this challenge is essentially trying to find triangular numbers with a positive difference of the input such that the indices of the triangular numbers in the sequence 1,3,6,10,... is maximized.

awk, 51 bytes
{while($0!=s+=s<$0?++j:-++i);while(++i-j)r=r i"+"}$0=r j

The code is 56 bytes, minus 5 bytes for the output format. I had to use 4 extra bytes to produce that format, so I actually saved 1 byte. Hooray! ;)
It's actually doing the hard work of summing up starting from 1 until the sum is bigger than the input. Then it begins substracting numbers starting from 1 until the number is smaller than the input. It keeps changing the start and end number this way until it found a result, which it then prints.
Usage example
echo 303 | awk '{while($0!=s+=s<$0?++j:-++i);while(++i-j)r=r i"+"}$0=r j'

Output of example

48+49+50+51+52+53

I've tried this for an input of 1e12 and it gave the correct result (464562+...+1488562) almost immediately. Though it took a while printing it of course...

Love the Awk approach.  I'm have trouble working out the order of precedence in the bindings.  Would you mind please including a version with more parentheses added to make it a bit more obvious?  :)

Hope this helps: {while($0!=s)s+=(s<$0) ? (++j) : -(++i); while(++i<j)r=r i"+"}$0=r j i is always the last integer that got subtracted from the start of the chain, j is always the last integer added at the end of the chain

Jelly, 8 bytes
ẆS⁼¥Ðf⁸Ṫ

Try it online!
If I understand correctly, this could be an (11-5=6)-byte version:
ẆS⁼¥Ðf⁸Ṫj”+

For interest's sake, there are 12 similar solutions (including this one) by swapping the non-vectorizing equals for the vectorizing equals, changing left-argument to first-argument or to identity, and swapping equals with not-equals and filter-in for filter-out for both vectorizing and non-vectorizing. :O

Let's say I posted the one that makes most sense, but with speed optimization.

Pyth, 12 - 5 = 7 bytes
j\+efqQsT.:S

Test suite
The existing Pyth answer uses an older version of the language; new features have been added since.
Explanation:
j\+efqQsT.:S  | Full code
j\+efqQsT.:SQ | with implicit variables
--------------+----------------------------------------------------
           SQ | Get the range [1, ... input]
         .:   | Get all substrings, sorted by length
    f         | Filter for T such that
       sT     |  the sum of T
     qQ       |  equals the input
   e          | Get the last (longest) element of the filtered list
j\+           | Join by "+"

Prolog (SWI), 64 62 51 bytes
-2 bytes thanks to Steffan
-11 bytes thanks to Razetime's tip
N+Z:-numlist(1,N,A),append([_,Z,_],A),sumlist(Z,N).

Try it online!

Technically this predicate is returning All solutions <N, even though it renders the longest one first. Are there any rules allowing this?

@Razetime An interesting question. The opposite, that it can unify with all possibilities, has been discussed and allowed, but I can't find any other discussion. It would only cost two bytes (,!) to modify it, but it might be worth opening a meta question on it

I'm not sure of the golf rules, but prolog does have once/1.

Python 2, 94 bytes
n=input()
r=int((2*n)**.5)
while r:
 if~r%2*r/2==n%r:print range(n/r-~-r/2,n/r-~r/2);r=1
 r-=1

Input is taken from stdin. This solution is suitable for very large inputs.
This iterates over the possible solution lengths, r, having r ≤ √(2n), and checks for a solution explicitly. In order for a solution to exist, if r is odd, n mod r must be zero, and if r is even, n mod r must be r/2.

Sample Usage
$ echo 8192 | python sum-con-int.py
[8192]

$ echo 1000002 | python sum-con-int.py
[83328, 83329, 83330, 83331, 83332, 83333, 83334, 83335, 83336, 83337, 83338, 83339]

$ echo 1000000006 | python sum-con-int.py
[250000000, 250000001, 250000002, 250000003]

I've deliberately choosen examples with relatively small outputs.

Octave, 89 Bytes
This is the best I could do in Octave. The algorithm is the same as xnor's.
x=input('');k=i=1;while x;s=sum(k:i);if s<x;i++;elseif s>x;k++;else;x=0;end;end;disp(k:1)

In MATLAB this would be 95 bytes:
x=input('');k=1;i=1;while x;s=sum(k:i);if s<x;i=i+1;elseif s>x;k=k+1;else x=0;end;end;disp(k:i)

In MATLAB this runs in approx 0.1 seconds for input 2000000 and 1 second for input 1000002.

05AB1E, 11 - 5 = 6 bytes
Taking that bonus of course :)
LŒʒOQ}é¤'+ý

Try it online!
LŒʒOQ}é¤'+ý  Argument: n
LŒ           Sublists of range 1 to n
  ʒOQ}       Filter by total sum equals n
      é¤     Get longest element
        '+ý  Join on '+'

PHP, 70 bytes
while(fmod($q=sqrt(2*$argn+(++$p-.5)**2)-.5,1));print_r(range($p,$q));

Run as pipe with -nR or try it online.
increments p until it finds an integer solution for argument==(p+q)*(q-p+1)/2,
then prints the range from p to q.

Husk, 12 - 5 = 7 bytes
J'+msḟo=¹ΣQḣ

Try it online!
Removing the first 5 bytes for joining, it still scores the same.
Explanation
J'+msḟo=¹ΣQḣ
           ḣ range from 1..n
          Q  all possible sublists
     ḟ       get the first value which satisfies:
       =¹Σ   sum = input.
   ms        convert each number to string
J'+          join on '+'

Note that you can also do all sublists of natural numbers for the same amount of bytes

Prolog (SWI), 72 bytes
L/X/H:-between(L,H,X).
N*Z:-1/A/N,A/X/N,findall(Y,A/Y/X,Z),sumlist(Z,N).

Try it online!
-4 bytes thanks to DLosc.

Knight, 66 bytes
;=i+=a 0P W;=r""!>=a+1=b a=c iW!>0c;=c-c=b+1b;=r+r+"+"bI?0cQ Or 0

Try it online!
Annotated code:
;=i+ =a 0 PROMPT                        # set a to 0, i to input
WHILE ;=r "" !>(=a +1(=b a)) (=c i)     # set r to "", b to a, a to a+1, c to i, check if a less than c
  WHILE !< c 0                          # while c >= 0:
    ;=c (-c (=b +1b))                   # set b to b+1, c to c-b
    ;=r (+ r + " " b)                   # append b to r
    IF (? c 0) (QUIT OUTPUT r) 0        # if c is 0, output r and break; else, do nothing

C (gcc), 66 bytes
i,j;f(n){for(i=j=0;n;)n+=n>0?--j:++i;for(;i+j;)printf("%d ",++i);}

Inspired by xnor's sliding window solution, keeps track of the ends of the window.
Try it online!

05AB1E, (10-5=) 5 bytes
Åœ.Δ¥P}'+ý

Try it online or verify all test cases.
Explanation:
Åœ        # Get all lists of positive integers that sum to the (implicit) input,
          # which is sorted from longest (all 1s) to shortest (just the number)
  .Δ      # Find the first list which is truthy for:
    ¥     #  Get the deltas/forward-differences of the list
     P    #  Take the product (only 1 is truthy in 05AB1E)
   }'+ý  '# After we've found a list: join it with "+" delimiter
          # (after which it is output implicitly as result)

Thunno 2, 10 - 5 = 5 bytes
RƑæS=;h'+j

Try it online!
Port of tybocopperkettle's Vyxal answer.
Explanation
RƑæS=;h'+j  '# Implicit input
RƑ           # All sublists of [1..n]
  æ  ;       # Filtered by:
   S=        #  Sum equals input
      h      # First item
       '+j  '# Joined by "+"
             # Implicit output

Python 3, 239 236 215 203 bytes
This is a little cumbersome. I'll have to golf it down later.
def x(n):
 r=[n]
 for i in range(2,n):
  t=[]
  if i%2*(n%i<1):t=[j+n//i-i//2for j in range(i)]
  elif i%2<1and n%i==i//2:t=[j+n//i-i//2+1for j in range(i)]
  if t[:1]>[0]*(sum(t)==n):r+=t,
 return r[-1]

The k is because if you check t[0] on an empty t, Python makes rude noises at you. Again, this is in need of golfing. Thanks to t[:1], no more rude noises! You just need to check against another array.

Japt, 33 bytes
This uses Dennis's Pyth technique, although it's considerably longer...
1oU à2 £W=Xg o1+Xg1¹x ¥U©W} rª ªU

Try it online! Warning: For larger inputs (<= 20), it takes a while to finish, and freezes your browser until it does.
Ungolfed and explanation
1oU à2 £    W=Xg o1+Xg1¹ x ¥ U© W} rª  ª U
1oU à2 mXYZ{W=Xg o1+Xg1) x ==U&&W} r|| ||U

          // Implicit: U = input integer
1oU à2    // Generate a range from 1 to U, and take all combinations of length 2.
mXYZ{     // Map each item X in this range to:
W=Xg o    //  Set variable W to the range of integers starting at the first item in X,
1+Xg1)    //  and ending at 1 + the second item in X.
x ==U&&W  //  If the sum of this range equals U, return W; otherwise, return false.
r||       // Reduce the result with the || operator, returning the first non-false value.
||U       // If this is still false, there are no consecutive ranges that sum to U,
          // so resort to U itself.
          // Implicit: output last expression

Bonus-earning version: (38 bytes - 5 = 33)
1oU à2 £W=Xg o1+Xg1¹x ¥U©W} rª ªU² q'+

Julia, 92 bytes
x->(t=filter(i->all(j->j==1,diff(sort(i))),partitions(x));collect(t)[indmax(map(length,t))])

This is an anonymous function that accepts an integer and returns an array. To call it, give it a name, e.g. f=x->....
Ungolfed:
function f(x::Integer)
    # Get all arrays of integers that sum to x
    p = partitions(x)

    # Filter these down to only consecutive runs by checking whether
    # all differences are 1
    t = filter(i -> all(j -> j == 1, diff(sort(i))), p)

    # Find the index of the longest element of t
    i = indmax(map(length, t))

    return collect(t)[i]
end

Ruby, 94 bytes
->n{([*1..n].permutation(2).map{|i,j|[*i..j]if(i..j).reduce(:+)==n}-[p]).max_by{|k|k.size}||n}

Ungolfed:
-> n {
  ([*1..n].permutation(2).map { |i,j|   # Finds all the possible sets of size 2
     [*i..j] if(i..j).reduce(:+) == n   # Adds a set to an array if sum of the set is n.
   }-[p]                                # Removes nil from the array
  ).max_by { |k|                        # Finds the longest sequence
    k.size
  } || n                                # Returns n if no sequence found.
}

Usage:
->n{([*1..n].permutation(2).map{|i,j|[*i..j]if(i..j).reduce(:+)==n}-[p]).max_by{|k|k.size}||n}[25]
=> [3, 4, 5, 6, 7]

Seriously, 53 - 5 = 48 bytes
,;;;╝`;u@n╟(D;)`n(XXk`iu@u@x;Σ╛=[])Ii`╗`ñ╜M`M;░p@X'+j

Hex Dump
2c3b3b3bbc603b75406ec728443b29606e2858586b60697540754
0783be4be3d5b5d29496960bb60a4bd4d604d3bb0704058272b6a

Try It Online!
It's the brute force approach, similar to Dennis's Pyth.
Everything up to the k just reads input n into register 1 and then creates the list [[1],[2,2],[3,3,3],[4,4,4,4],...] up to n n's.
The next bit up to ╗ is a function stored in register 0 that takes a pair, increments both elements, converts them to a range, finds the sum of the range, and checks whether that sum is the value in register 1. If it is, it returns the corresponding range, and if it's not, it returns an empty list.
The part up to the last occurrence of M maps a function over the fancy list of lists described above, doing enumerate on each list, then mapping the stored function over it. When it is done, we have a list of lists each of which is empty or a range which sums to n.
;░ removes the empty lists. p@X takes the first list which remains (0@E would also work). '+j puts + between each number as it converts the list to a string for the bonus.

ES6, 72 bytes
n=>{for(l=u=1;n;)n>0?n-=u++:n+=l++;return[...Array(u).keys()].slice(l);}

Straight port of @Cabbie407's awk solution, but without the formatting bonus, since it's a penalty here.

Excel VBA, 119 - 5 = 114 Bytes
Subroutine that takes input n of expected type integer and outputs the longest sequence of consecutive numbers which sum to it to the cell [A1]
Sub a(n)
For i=1To n
s=0
For j=i To n
s=s+j
If s=n Then:For k=i To j-1:r=r &k &"+":Next:[A1]=r &j:End
Next
Next
End Sub

Japt -h, 9 bytes
õ ã f@¶Xx

Try it
Japt, 13-5 = 8 bytes
õ ã f@¶XxÃÌq+

Try it

R, 57 bytes
for(i in (n=scan()):1)for(j in n:i)if(sum(i:j)==n)x=i:j;x

Try it online!

Retina, 36 32 bytes
(^_+?|_\1)+$
$1 $#1*
vI`(_*) \1_

Try it online!
Input in unary _, output a newline-separated list of decimal numbers

Desmos, 118 bytes
f(n)=[l[1]...l[2]]
l=∑_{a=1}^n∑_{b=a}^n[a,b]0^{([a...b].total-n)^2}∏_{c=2}^a∏_{d=c}^nsign([c-1...d].total-n)^2

100% can be golfed but whatever.
In theory this should work with any number as long as the output list has at most 10000 elements, but in reality, an input like \$n=100\$ is already very slow.
Try It On Desmos!
Try It On Desmos! - Prettified

Factor + math.unicode, 49 bytes
[ dup [1,b] all-subseqs [ Σ = ] with find-last ]

Try it online!

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


text:
Is it a pangram?
Write a function or program that takes as its input a string and prints a truthy value if the string is a pangram (a sequence of letters containing at least one of each letter in the English alphabet) and a falsey value otherwise.
Case of letters should be ignored; If the string is abcdefghijklmnopqrstuvwXYZ, then the function should still return a truthy value. Note that the string can contain any other characters in it, so 123abcdefghijklm NOPQRSTUVWXYZ321 would return a truthy value. An empty input should return a falsey value.

Test cases
AbCdEfGhIjKlMnOpQrStUvWxYz

==> True

ACEGIKMOQSUWY
BDFHJLNPRTVXZ

==> True

public static void main(String[] args)

==> False

The quick brown fox jumped over the lazy dogs. BOING BOING BOING

==> True

This is code golf. Standard rules apply. Shortest code in bytes wins.

Plus points if your code can check if input is a Pungram.

Question name request: Did the quick brown fox jump over the lazy dog?

Pyth, 7 bytes
L!-Grb0

Explanation:
L             lambda (implicit b:)
    rb0       Convert b to lowercase
   G          Lowercase alphabet, "abcd...z"
  -           Set difference, all elts of first that aren't in second
 !            Logical NOT (The empty string is falsey)

Try the full-program, single-line version here.

I think the shortest way to fix this for newlines in the input is to make a function: L!-Grb0. !-Grs.z0 would also work but is longer.

Oh, I didn't see the question updated to include \n in the string. Thanks.

6 bytes: http://pyth.herokuapp.com/?code=%21-GrQZ&input=%22ACEGIKMOQSUWY%5CnBDFHJLNPRTVXZ%22&debug=0

@Maltysen While there is a (weak) consensus on allowing strings from input to be delimited by quotes, I'm not sure about this as it goes further in requiring Python string syntax.

I never would have thought an alphabet built-in would be useful...

Perl 6, 20 bytes
'a'..'z'⊆*.lc.comb

usage:
my &code = 'a'..'z'⊆*.lc.comb;
#  the parameter is ^ there

say code '123abcdefghijklm NOPQRSTUVWXYZ321' # True
say code '123abcdefghijklm NOPQRSTUVWXY'     # False

I used the 3 byte "french" version (⊆) of U+2286 SUBSET OF OR EQUAL TO operator instead of the 4 byte "texas" version ((<=)) which would have also required an extra space in front of it.

GS2, 11 9 bytes
☺ 6ΘàB1."

Thanks to @MitchSchwartz for golfing off 2 bytes!
The source code uses the CP437 encoding. Try it online!
How it works
☺              Push 32 (code point of space).
  6            Bitwise OR.
   Θ           Make a block of these two instructions and map it over the input.
               This turns uppercase letters into their lowercase counterparts.
      à        Push the lowercase alphabet.
       B1      Swap and apply set difference.
         ."    Push the logical NOT of the length of the result.

quick block m2 (\xe9) saves 2 bytes.

@MitchSchwartz Oh, so that's how you use those. Thanks!

JavaScript ES6, 51 57
Edit 6 bytes save thx @user81655
a=>new Set(a.toUpperCase().match(/[A-Z]/g)).size>25

Test snippet

F=a=>new Set(a.toUpperCase().match(/[A-Z]/g)).size>25

function update() {  O.innerHTML=F(I.value) }
I.value='qwertyuiopasdfghjklzxcvbnm';update()
input { width: 70% }
<input id=I oninput='update()'>

Would a.replace(/[^A-Z]|[^a-z]/g,'') or a.replace(/[^A-Z]/gi,'') work?

@ev3commander no. A and a must become the same character, else the set will keep them as distinct and the size will be > 26

What if you use the spread operator with [...a.toUpperCase().replace(/[^A-Z]/g,'')].length>25 ?

@ScottKaye obviously no. Try it with 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'

Wouldn't match(/[A-Z]/g) work just as good as replace?

This post clearly needs en explanation... @user81655: no, lowercase letters would be lost. As it's 3am here now, I'll try to add an explanation tomorrow.

a=>new Set(a.toUpperCase().match(/[A-Z]/g)).size>25 seems to work for me. 51 bytes. toUpperCase() means there are no lower-case letters in the string being matched. Feel free to implement it tomorrow though. xD

@user81655 right, it works, great. Thanks. I should not answer comments while asleep

R 50 ,46 39 bytes
all(sapply(letters,grepl,readline(),T))

Edit drops the need for tolower by adding ignore.case=TRUE (T)

Not too familiar with R, but shouldn't ignore.case=TRUE (T) be included in the count as well then?

@Ruslan It is! It is the Tas the end, thanks to argument placement matching there is no need to actually specify the name of the argument (and T is the default alias for TRUE). The code written here performs the needed action as is, without any need to add anything.

Python 2, 53 51 bytes
f=lambda s,c=65:c>90or(chr(c)in s.upper())*f(s,c+1)

Alternate solutions:
lambda s:all(chr(c)in s.upper()for c in range(65,91))

lambda s:not set(range(65,91))-set(map(ord,s.upper()))

Thanks to xnor for pointing out that sets have an <= operator, for an alternate 51:
lambda s:set(range(65,91))<=set(map(ord,s.upper()))

If I'm not mistaken, the last expression is the same as lambda s:set(range(65,91))<=set(map(ord,s.upper())), also for 51.

Python 3.5 can save bytes here: p=lambda s:{*range(65,91)}<={*map(ord,s.upper())}. By the way, I can't seem to find any rules on whether a lambda needs to be assigned (as in your first case) or not (as in your later ones). Help?

@TimPederick Naming the lambda is unnecessary unless you need to use the function elsewhere, like in the first recursive solution.

@TimPederick Thanks for pointing that out. I renamed my answer as Python 2 instead of just Python. You have my blessing to post that as a new answer if you want, which I think would be ok by community norms although I'm not sure.

@FryAmTheEggman: Thanks for clarifying. That distinction hadn't occurred to me! I've also found a meta post explaining the rule. There goes two bytes from a few things I've written...

O, 11 bytes
GQ_s{n-}dS=

Try it online.
Sadly, O does not have set difference :/
Explanation
G            Pushes the alphabet to the stack
 Q           Pushes input to the stack
  _          Converts the string to lowercase
   s         Split string into char array
    {  }d    Iterate through array
     n       Pushes current element to the stack
      -      String subtraction
         S   Pushes a blank string to the stack
          =  Equals

All of these regexes use their engines' respective case insensitivity flags, so that has not been counted towards the byte counts. Even though some use \pL (a shorthand for \p{L}) instead of [A-Z], they still need the flag, due to comparing characters via backreference. Without it, they would need to apply the flag inline, (?i) inserted at the beginning, costing 4 extra bytes.
Regex (Perl 5 / PCRE / Boost / Pythonregex), 21, 22, 24, or 25 bytes
Quite simply, this regex works by asserting that there are at least 26 alphabetical characters in the string that do not match with any character to the right of themselves. Each of these characters will be the last occurrence of a given letter of the alphabet in the string; as such, they are all guaranteed to be different letters, and asserting that there are 26 of them implies that the full set A-Z is covered.
(.*(\pL)(?!.*\2)){26} (21 bytes)  - Try it online! (Perl 5)
Using \pL instead of [A-Z] to match alphabetical characters imposes the requirement that the input must be in ASCII, because \pL matches all Unicode alphabetical characters (including those that are extended ASCII in common codepages); so an accented letter, for example, would count towards consuming the target of 26 loop iterations. Some other regex engines only support this syntax in the form of \p{L} (which offers no advantage over [A-Z] for this particular problem, being equal in length) and not with the shortened syntax of \pL.
This bare-bones version of the regex is extremely slow, due to an excessively huge amount of backtracking both for pangrams and non-pangrams, but will always give the correct result when given enough time. Its search for the 26 matches proceeds in the most pessimal way possible.
Using a lazy quantifier speeds it up greatly when matching pangrams, but it's still incredibly slow to yield non-matches when given non-pangrams:
(.*?(\pL)(?!.*\2)){26} (22 bytes)
Try it online! (Perl 5)
Try it online! (PCRE2 / C++, with backtrack limit adjusted)
Try it online! (PCRE2 / PHP, with backtrack limit adjusted)
Changing the main loop to an atomic group allows the regex to also yield non-matches at a reasonable speed:
(?>.*?(\pL)(?!.*\1)){26} (24 bytes)
Try it on regex101 (PCRE1)
Try it online! (Python import regex)
Adding an anchor is not necessary to make the regex yield correct results, but speeds up non-matches further, by preventing the regex engine from continuing to try for a match at every character of the string (because if it fails to match at the beginning, we know it's guaranteed not to match anywhere in the same string, but the regex engine can't know that):
^(?>.*?(\pL)(?!.*\1)){26} (25 bytes)
Try it on regex101 (PCRE1)
Try it online! (Python import regex)
Try it online! (Perl 5)
Try it online! (PCRE2 / C++)
Try it online! (PCRE2 / PHP)
Try it online! (Boost / C++)
Regex (.NET / Java / Ruby), 23, 24, 26, or 27 bytes
These regex engines don't support \pL (they support \p{L}, but that isn't useful when we already need the case insensitivity flag anyway), thus [A-Z] is used:
(.*([A-Z])(?!.*\2)){26} (23 bytes)
(.*?([A-Z])(?!.*\2)){26} (24 bytes)
(?>.*?([A-Z])(?!.*\1)){26} (26 bytes)
^(?>.*?([A-Z])(?!.*\1)){26} (27 bytes)
^            # 1. Anchor to the start of the string (without this, the regex would still
             #    work but would be slower in its non-matches, due to trying to match at
             #    every character position in the string, which we know will fail, but
             #    the regex engine can't know)
(?>          # 2. Start an atomic group (every complete iteration of matching this group
             #    is set in stone, and will not be backtracked); without only a normal
             #    group, the regex would still work, but with most non-pangram inputs,
             #    would take longer than the age of the universe to yield a non-match,
             #    due to trying every way of matching ".*?" at every iteration of the loop
    .*?      # 3. Skip zero or more characters, as few as possible in order to make the
             #    following match
    ([A-Z])  # 4. Capture and consume an alphabetical character in \1
    (?!      # 5. Negative lookahead: Match outside (with zero-width) only if the inside
             #    does not match
        .*   # 6. Skip forward by zero characters or more in an attempt to make the
             #    following expresison match
        \1   # 7. Match the character captured in \1
    )        # 8. The effect of this negative lookahead is to assert that at no point
             #    right of where \1 was captured does any character match \1
){26}        # 9. Only match if this group can be matched exactly 26 times in a row,
             #    i.e. if we can find 26 characters in the range A-Z that don't match
             #    any character right of themselves, i.e. that we can find the last
             #    occurrence of 26 different alphabetical character in the string.

Try it online! (.NET / C#)
Try it online! (Java)
Try it online! (Ruby)
Regex (ECMAScript / Python), 23, 24, 32, or 33 bytes
The same progression of speed applies:
(.*([A-Z])(?!.*\2)){26} (23 bytes)  - Try it online! (ECMAScript) / (Python)
(.*?([A-Z])(?!.*\2)){26} (24 bytes)  - Try it online! (ECMAScript) / (Python)
ECMAScript and Python lack atomic groups, so they must be emulated using lookahead+capture+backref:
((?=(.*?([A-Z])(?!.*\3)))\2){26} (32 bytes) - Try it online! (ECMAScript) / (Python)
^((?=(.*?([A-Z])(?!.*\3)))\2){26} (33 bytes) - Try it online! (ECMAScript) / (Python)

Edit: Silly me, I assumed that this problem required variable-length lookbehind or other tricks that substitute for it, without even trying to do it without that. Thanks to @Neil for pointing this out.

You can save a byte by using positive lookahead instead of negative. This matches the last of each letter rather than the first, but the overall result is the same, excecpt of course that it works in less powerful regex engines such as ES6.

Try it online!

@Neil Oops! How embarrassing. Thanks for letting me know. (A shame, since I thought this problem was even better than Do you make me up? for illustrating the differences between engines.) I guess I'm guilty here of "When you have a hammer, every problem looks like a nail."  I'll try to avoid that pitfall in the future.

Downvoting this because these (at least the Perl ones) are snippets, not programs or functions.  They are just the regex pattern that needs to be incorporated into a program.

@Xcali They are full programs with Regex as the language. I never claim anywhere in this answer that they are programs in Perl, Ruby, Java, etc. They are programs in various flavors of Regex, with the regex engine of Perl, for example, being the language in use, not Perl itself.

@Xcali If you really want to insist on "full program" rather than a regex snippet, consider these to be single line Retina programs, as most of them work in Retina

@ChartZBelatedly They're not Retina programs; those are forced to use the .NET regex engine only. The point here is that pure regex forces challenges to be solved differently, in interesting ways, including exploring the differences between regex flavors. It's not Turing-complete without the bells and whistles of Retina, which is also interesting. And Retina itself is flawed; for one thing it's extremely slow – Martin Ender forgot to enable the RegexOptions.Compiled flag, and provided no way to even manually enable it. .NET is slow even with that, but significantly slower without it.

Julia, 38 bytes
s->endof(∩('a':'z',lowercase(s)))>25

This is simple - lowercase deals with the uppercase/lowercase issue, 'a':'z' holds all of the lowercase letters, ∩ is intersection, removes any character that isn't a letter and, because 'a':'z' comes first, will only have one of each letter that appears in s. endof is the shortest way to get the length of the resulting array, and if it's 26, then it's a pangram (it can't be more than 26, and >25 saves a byte relative to ==26).

Ruby, 41 33
->s{(?a..?z).all?{|c|s[/#{c}/i]}}

Usage
p=->s{(?a..?z).all?{|c|s[/#{c}/i]}}
p["AbCdEfGhIjKlMnOpQrStUvWxYz"]
  #=> true
p["ACEGIKMOQSUWY
BDFHJLNPRTVXZ"]
  #=> true
p["public static void main(String[] args)"]
  #=> false
p["The quick brown fox jumped over the lazy dogs. BOING BOING BOING"]
  #=> true

Thanks to Vasu Adari for saving me 8 bytes

05AB1E, 4 bytes
lêAå

Try it online!
l    # Push lowercase input.
 ê   # Push sorted, uniquified lowercase input.
  A  # Push lowercase alphabet.
   å # Is lowercase alphabet in sorted, uniquified, lowercase input?
     # True if panagram, false if not.

Retina, 22 bytes
Msi`([a-z])(?!.*\1)
26

Try it online.
The first line matches any letter which does not appear again later in the string. That ensures that we don't match each letter at most once, no matter how often it occurs. Match mode will by default replace the string with the number of matches found. So in the second stage, we match 26 against the result of the first input, which will give either 0 or 1, depending on whether we found the maximum of 26 matches or not.

Python 3.5, 47 bytes
lambda s:{*map(chr,range(65,91))}<={*s.upper()}

Same principle as Mitch Schwartz's answer, but using the PEP 0448 enhancements to * unpacking, first introduced in Python 3.5.
This version differs slightly from what I wrote in my comment to Mitch's post, in that I turn the numbers into letters rather than vice versa. That's because that's how I wrote my original attempts at a solution, before discovering that I couldn't out-golf Mitch without outright copying his approach. So consider that tweak my one remaining shred of originality!

Haskell, 59 56 53 51 bytes
p s=and[any(`elem`map toEnum[a,a+32])s|a<-[65..90]]

Try it online!
Explanation:
Give an input string s, for each a in range 65 to 90 (the ASCII codes for A to Z) it is checked whether any character in s is equal to either a (the upper case character) or a+32 (the lower case character), converted to a character by toEnum. This generates a list of booleans. and checks if they're all True.
Old version:
import Data.Char
p s=and[any((==)a.toUpper)s|a<-['A'..'Z']]

For every upper case alphabet letter, check whether some letter from s in upper case is equal to it. any(==a)s is the same as elem a s but allows to modify the elements of s before the comparison - in this case, covert them to upper case.

Haskell, 43 bytes
f s=until(all(`notElem`s))(succ<$>)"Aa">"["

Try it online!
Iterates through the lowercase/uppercase pairs until it finds one where both are not elements of the input, and checks that this failure is past the alphabet.

These have the same regex as in my regex answer. I felt it was worth posting a standalone answer showing its use in languages that don't require an import to access regex functions (resulting in very effective golf). In order of how favorably it compares against the current best non-regex answer.
This answer previously showed programs/functions that couldn't handle multiline input (as the challenge demonstrates is required by its second test case), but they all do so properly now unless otherwise noted.
Java, 46 bytes
a->a.matches("(?si:.*([A-Z])(?!.*\\1)){26}.*") (46 bytes, always slow) - Try it online!
a->a.matches("(?si:.*?([A-Z])(?!.*\\1)){26}.*") (47 bytes, slow for non-matches) - Try it online!
a->a.matches("(?si)(?>.*?([A-Z])(?!.*\\1)){26}.*") (50 bytes, reasonable speed) - Try it online!
PHP, 53 or 55 bytes
PHP imposes a strict backtracking limit (or time limit?) on its regexes, so the version that would be 52 bytes doesn't work at all; it always returns an empty result (except for very short non-pangram strings, for which it prints 0).
<?=preg_match('/(.*?(\pL)(?!.*\2)){26}/si',$argv[1]); (53 bytes) - Try it online!
The 53 byte version, however, actually runs fast; it prints an empty result or 0 for false, and prints 1 for true. However, with sufficiently long pangram strings having a long separation between occurrences of new letters, it returns a false negative, due to taking too long to process the string.
<?=preg_match('/(?>.*?(\pL)(?!.*\1)){26}/si',$argv[1]); (55 bytes) - Try it online!
<?=preg_match('/^(?>.*?(\pL)(?!.*\1)){26}/si',$argv[1]); (56 bytes) - Try it online!
These versions print 0 for false and 1 for true.
This beats 640KB's answer when it is ported to handle multiline input:
<?=!array_diff(range(a,z),str_split(strtolower($argv[1]))); (59 bytes) - Try it online!
JavaScript ES9, 38 bytes
a=>/(.*([A-Z])(?!.*\2)){26}/si.test(a) (38 bytes, always slow) - Try it online!
a=>/(.*?([A-Z])(?!.*\2)){26}/si.test(a) (39 bytes, slow for non-matches) - Try it online!
a=>/((?=(.*?([A-Z])(?!.*\3)))\2){26}/si.test(a) (47 bytes, fairly reasonable speed) - Try it online!
a=>/^((?=(.*?([A-Z])(?!.*\3)))\2){26}/si.test(a) (48 bytes, very reasonable speed) - Try it online!
When looping this set of test cases, it can be seen that the 48 byte version is about 12 times as fast as the 47 byte version (in SpiderMonkey's regex engine).
This now ties in length with l4m2's answer, which counts individual regex matches. Given the speed difference, that answer obviously wins.
Ruby, 35 bytes
->s{s=~/(.*([A-Z])(?!.*\2)){26}/mi} (35 bytes, always slow) - Try it online!
->s{s=~/(.*?([A-Z])(?!.*\2)){26}/mi} (36 bytes, slow for non-matches) - Try it online!
->s{s=~/(?>.*?([A-Z])(?!.*\1)){26}/mi} (38 bytes, fairly reasonable speed) - Try it online!
->s{s=~/^(?>.*?([A-Z])(?!.*\1)){26}/mi} (39 bytes, very reasonable speed) - Try it online!
When looping this set of test cases, the same result is seen: the 39 byte version is 12 times as fast as the 38 byte version.
This is 2 bytes longer than Alexis Andersen's mixed code/regex answer.
Ruby -n0, 30 bytes
Prints nil for false and 0 for true, which are respectively falsey and truthy in Ruby. If printing 0 or 1 is desired, replace ~ with !! (+1 byte).
p ~/(.*([A-Z])(?!.*\2)){26}/mi (30 bytes, always slow) - Try it online!
p ~/(.*?([A-Z])(?!.*\2)){26}/mi (31 bytes, slow for non-matches) - Try it online!
p ~/(?>.*?([A-Z])(?!.*\1)){26}/mi (33 bytes, fairly reasonable speed) - Try it online!
p ~/^(?>.*?([A-Z])(?!.*\1)){26}/mi (34 bytes, very reasonable speed) - Try it online!
This is 2 bytes longer than Alexis Andersen's answer when it is ported to be a full program using -n0 instead of a lambda (and it prints false or true):
p (?a..?z).all?{|c|~/#{c}/i} (28 bytes) - Try it online!
Perl 5 -p0, 28 bytes
$_=/(.*(\pL)(?!.*\2)){26}/si (28 bytes, always slow) - Try it online!
$_=/(.*?(\pL)(?!.*\2)){26}/si (29 bytes, slow for non-matches) - Try it online!
$_=/(?>.*?(\pL)(?!.*\1)){26}/si (31 bytes, fairly reasonable speed) - Try it online!
$_=/^(?>.*?(\pL)(?!.*\1)){26}/si (32 bytes, very reasonable speed) - Try it online!
This is 2 bytes longer than Xcali's regex + hash answer when its [a-z] is replaced with \pL. Also, for some reason that answer only requires the -p command-line parameter yet still works with multiline input, while this one requires -p0 to do so.
Perl 5, 40 bytes
say@ARGV[0]=~/(.*(\pL)(?!.*\2)){26}/si+0 (40 bytes, always slow) - Try it online!
say@ARGV[0]=~/(.*?(\pL)(?!.*\2)){26}/si+0 (41 bytes, slow for non-matches) - Try it online!
say@ARGV[0]=~/(?>.*?(\pL)(?!.*\1)){26}/si+0 (43 bytes, fairly reasonable speed) - Try it online!
say@ARGV[0]=~/^(?>.*?(\pL)(?!.*\1)){26}/si+0 (44 bytes, very reasonable speed) - Try it online!
This is 4 bytes longer than a port of Xcali's regex + hash answer with [a-z] replaced with \pL:
++@a{(uc@ARGV[0])=~/\pL/g};say%a==26 (36 bytes) - Try it online!
Reading multiline input from stdin instead of a command-line argument would be 4 bytes longer, replacing @ARGV[0] with  join('',<>).

Vim, 30 26 bytes
:%s/\A*/\r/g
:sor ui
26Dr1

Try it online!
Let's get this language of the month started!
I am still a beginner in Vim, so golfing suggestions are much appreciated :)
Explanation
The first line of the program uses a regex to substitute any (possibly empty) sequence of non-alphabetic characters (\A*) with a newline; since the empty string also gets matched, this will result in a series of lines each containing at most one character, which will be a letter. The first line will always be empty (the initial empty string became a newline).
:sor ui sorts the lines ignoring case, and removes duplicates (also ignoring case). If the input was a pangram we will now have an empty line followed by 26 lines each with a character from a to z; if the input was not a pangram, some of those lines will be missing.
26D deletes the first 26 lines, which will leave us with either z (for a pangram) or an empty string (for a non-pangram). The only truthy values in Vim are non-zero numbers (or strings starting with a non-zero number), so our last step will be r1 (replace the first character with 1) which will result in 1 for a pangram, and an empty string otherwise.

MATLAB / Octave, 35 33 bytes
@(x)~nnz(setdiff(65:90,upper(x)))

Try it online!

The anonymous function returns a logical 1 if the input x is a pangram, or a logical 0 if it isn't.
Essentially it uses the same approach as @ThomasKwa's Pyth solution. The set difference between all characters in the upper case alphabet range (65:91) and the input string (converted to upper case). Any characters that are in the alphabet but not in the input string are returned by setdiff. Only if the array returned by the set difference is empty is the string a pangram.
Using upper case instead of lower case saves a couple of bytes compared with 'a':'z' because the ASCII value can be used instead to make the range.

Great answer! Mine was 10 bytes longer

CJam, 11 bytes
'[,65>qeu-!

This is a complete program. Try it online.
Explanation:
'[,65>  Build upper case alphabet (see CJam tips thread).
q       Get input.
eu      Convert to all upper case.
-       Set difference between alphabet and upper cased input.
!       Negate.

Minkolang 0.14, 18 bytes
$o7$ZsrlZ'26'$ZN.

Try it here.
Explanation
$o                    Read in whole input as characters
  7$Z                 Uppercase every letter
     s                Sort
      r               Reverse
       lZ             Alphabet - uppercase and lowercase
         '26'         Pushes 26 on the stack
             0$Z      Count how often the top 26 numbers of the stack appear in the stack
                N.    Output as number and stop.

R, 53 45 bytes
all(97:122%in%utf8ToInt(tolower(readline())))

Old version at 53 bytes:
all(letters%in%strsplit(tolower(readline()),"")[[1]])

Usage:
> all(97:122%in%utf8ToInt(tolower(readline())))
The quick brown fox jumps over the lazy dog
[1] TRUE
> all(97:122%in%utf8ToInt(tolower(readline())))
Write a function or program that takes as its input a string and prints a truthy value if the string is a pangram and a falsey value otherwise.
[1] FALSE
> all(97:122%in%utf8ToInt(tolower(readline())))
123abcdefghijklm NOPQRSTUVWXYZ321
[1] TRUE
> all(97:122%in%utf8ToInt(tolower(readline())))
Portez ce vieux whisky au juge blond qui fume
[1] TRUE

PowerShell v3+, 65 56 52 Bytes
($args.ToLower()-split''|sls [a-z]|group).Count-eq26

Thanks to TessellatingHeckler for the 9-byte golf.

Takes the input string, converts it .ToLower()case, then -splits on every character
Those are fed into an alias sls for Select-String which matches based on a regex [a-z] to pull out only the letters
Those are then fed into Group-Object, so we're only selecting one individual instance of each letter
That is then .Counted to see if it's -equal to 26, and prints True or False accordingly
Requires PowerShell v3 or newer for the sls alias

It's a lot easier to pinch someone else's effort and try and shorten it a bit, than to read the questions from scratch - and more fun to compete within PowerShell than to go directly up against CJam and friends. But I can stop chasing your answers if it's annoying, sorry.

@TessellatingHeckler Not annoying! :D I'm just trying to give you more encouragement!

2sable, 6 5 bytes
6 byte version:
AIl-g_

Try it online!
Explanation:
A        Push alphabet
 Il      Push lowercase input
   -     Remove all chars of input from alphabet
    g    Get length of the remainder
     _   Print negative bool, where length < 1 = 1 (true), length > 0 = 0 (false)

5 byte version, inspired by carusocomputing's 05AB1E answer:
lÙ{Aå

Try it online!
Explanation:
l        Push lowercase input
 Ù{      Push sorted uniquified input
   A     Push alphabet
    å    Is alphabet in sorted, uniquified input?

J, 23 bytes
(u:65+i.26)*/@e.toupper

Try it online!

Brachylog, 4 bytes
ḷo⊇Ạ

Try it online!
        The input
ḷ       lowercased
 o      sorted
  ⊇     is a superlist of
   Ạ    the lowercase alphabet.

Julia, 26 25 bytes
!s='a':'z'⊆lowercase(s)

remove . by @MarcMush

Attempt This Online!

you can remove the dot for -1 byte

K (ngn/k), 36 19 17 bytes
{~#(97+!26)^0+_x}

Try it online!
-2 bytes thanks to ngn!
Return 1 for true, 0 for false.
Explanation:
{~#(97+!26)^0+_x}      / Main program. x is input
              _        / Lowercase
            0+         / Convert each character to ASCII value
           ^           / Without (set function)
   (97+!26)            / Lowercase alphabet (ASCII value)
  #                    / Length
 ~                     / Not

What do you mean by "Doesn't work with strings that contains characters other than the alphabet"? Your test harness shows it working with such strings.

@Deadcode I mean strings that are valid pangrams but contain other characters, like 123abcdefghijklmnopqrstuvwxyz. My fault, will correct it in the post.

But what does it do wrong? I tried your example of 123abcdefghijklmnopqrstuvwxyz and it correctly identifies it as a pangram. If I remove any letter, it correctly identifies it as not a pangram.

@Deadcode I just realized that it works for some reason, which I didn't expect it to work. Either way, thanks for helping me! Will edit the post.

""~ -> ~#

you could use a train instead of a lambda: ~#(`c$97+!26)^_:

it's cheaper to convert chars to numbers than numbers to chars: ~#(97+!26)^0+_:

Prolog (SWI), 57 bytes
\O:- \+ (between(97,122,Z),\+sub_atom_icasechk(O,_,[Z])).

Try it online!
Buried deep within the Prolog library is the very convenient predicate sub_atom_icasechk, which is a "half case-insensitive" check for a substring (half as in lowercase characters can match uppercase but not vice-versa). We just need to surround this in a check that all lowercase letters succeed this check.

Javascript, 110 109 99 95 93 bytes
a=prompt(b=0).toUpperCase();for(i=65;i++<91;)b+=!~a.indexOf(String.fromCharCode(i));alert(!b)

Saved 6 bytes thanks to Thomas Kwa, and 10 thanks in part to ev3.

Would b=0 work for b=[]?

Not with this approach. But I may be able to make that work.

I don't know Javascript, but can you do for(i=65;i++<91;)b+=!~a.indexOf(String.fromCharCode(i));alert(!b)?

Wow. That's even shorter than what I just did.

Japt, 14 bytes
#ao#{ e@Uv fXd

Try it online!
How it works
        // Implicit: U = input string
#ao#{   // Generate a range of integers from charCode("a") to charCode("{").
e@      // Check if every item X in this range returns truthily to:
Uv fXd  //  convert U to lowercase, and put all instances of X.toCharCode() in an array.
        // This returns false if U does not contain one of the characters.
        // Implicit: output last expression

Bash, 45 42 bytes
41 byte program, plus 1 because it must be invoked with bash -e:
for i in {a..z}
{ [ ${1//[^$i${i^}]} ]
}

Amazingly, I managed a Bash answer with no quote characters! (yes, I checked with inputs beginning with -f  and the like).
This assumes a locale where the lower-case English letters are contiguous from a to z.  Input is via the first argument to the program.
The way this works is, for each alphabetic letter $i, we test whether the string contains $i or its upper-case equivalent ${i^} by removing all other characters.  If this results in the empty string, then the input did not contain that letter, and we exit with 1 (false). If we have a non-empty result, then we passed the test and move on to the next letter.   If the input string contains every English letter, we will reach the end of the program, thus exiting with 0 (true).

Very nice.   Less golfy but kinda fun alternative: comm -23 <(printf %s\\n {A..Z}) <(sort <(printf %s\\n ${1^^})) has no output iff true.  Try it online!

Rust, 64 bytes
|s:&str|(65u8..91).all(|c|s.to_uppercase().contains(c as char))

You can take a range over chars in Rust,
'a'..'{'

but it's presently useless since you can't iterate over it or collect it or do anything with it. They say arithmetic with characters doesn't make sense, so they won't implement the Add and One traits for it.
Still, lambdas and iterators and type inference keeps it reasonably small.

APL (Dyalog Extended), 6 bytes
∧/⎕A∊⌈

Try it online!
Explanation:
∧/⎕A∊⌈  ⍝ Monadic function train
      ⌈  ⍝ Convert the input to uppercase
  ⎕A∊   ⍝ For each item in the set of uppercase
         ⍝ letters, determine if it exists in the
         ⍝ uppercased input
∧/       ⍝ And-reduce: test if all letters exist

Retina, 20 bytes
T`L`l
D`.
C`[a-z]
26

Try it online!
Explained
T`L`l        Transliterate stage. Replaces uppercase letters with lowercase letters.
D`.          Deduplicate stage - keep one copy of every match (meaning every character in this case), discarding suplicates.
C`[a-z]      Count stage - Count lowercase letters
26           (implicit) Count stage - Match the string "26"
             (Since there can't be duplicates, a match means each character occurred once.)
             (output the result of the last stage - 1 for pangrams, 0 for non-pangrams)

APL (Dyalog Extended), 1̶8̶ 1̶4̶ 12 bytes
{⎕A(∧/∊)⌈⍕⍵}
 ⎕A(∧/∊) ⍝ Check membership in Alphabet array and bitwise reduce by logical AND.
        ⌈ ⍝ Convert to uppercase
         ⍕⍵ ⍝ Encode as character array (handles matrices, empty sets and integers)

Edit: Changed 1⎕C to ⌈ thanks to rak1507
Edit: Changed 1(819⌶) to 1⎕C thanks to Razetime.
Try it online!

I think ⎕C can be used in the latest version instead of 819⌶

@Razetime Thanks! I didn't know about that.

⎕A≡⎕A∩⌈ using ⌈ from extended to uppercase

@rak1507 Very cool solution, but I think it fails the second test case.

You don't need to support matrices

The second test case is literally a matrix...

Vyxal r, 5 bytes
⇩kaF¬

Try it Online!
How?
⇩kaF¬
⇩       # Push the input converted to lowercase
 ka     # Push the lowercase alphabet
   F    # Filter - Remove items from the lowercase alphabet that are in the
        # lowercase-converted input.
    ¬   # Logical Not - Returns truthy for an empty list, falsey otherwise.

I managed to get 5 bytes.

Obligatory "ka can simply be n outside of a context" golfing suggestion for 4 bytes

Vyxal, 6 5 bytes
ɽǍkaƈ

Try it Online!
ɽ   # Convert input to lowercase.
Ǎ   # Remove non-alphabetical characters.
ka  # Push the lowercase alphabet.
ƈ   # Are the set of characters in the two strings the same?

Recent updates have gotten this down to 4 bytes or 3.75 bytes if you're so inclined

Thunno 2, 4 bytes
LḳẠƇ

Attempt This Online!
Explanation
LḳẠƇ  # Implicit input
L     # Convert to lowercase
 ḳ    # Sort and uniquify
   Ƈ  # Does this string contain...
  Ạ   # ...the lowercase alphabet?
      # Implicit output

JavaScript ES6, 124 114 113 bytes
I'm sure this can be golfed more.
v=(Q,s=[...Array(26)].map((x,i)=>String.fromCharCode(i+97)))=>s.length-1?Q.search(RegExp(s.pop(),"i"))+1&&v(Q,s):1

Generates an anonymous function.

v=(Q,s=[...Array(26)].map((x,i)=>String.fromCharCode(i+97)))=>s.length-1?Q.search(RegExp(s.pop(),"i"))+1&&v(Q,s):1

alert(v(prompt("Enter pangram:")));

@apsillers I think I found the problem. Please test it again (my browser does not support ES6 atm)

Yep, looks good now!

TeaScript, 12 bytes
Sz.e»xL.I(l©

First TeaScript post since I killed TeaScript :p
Try it online
Ungolfed
Sz.e(#xL.I(l))

Sz   // Lower case alphabet
.e(#   // Loop through alphabet, ensure
       // for every character, below returns true
    xL    // Input lowercased
    .I(l) // Checks if above contains current char
)

;-; I feel bad now. TBH I like TeaScript the most.

C, 107 bytes
#include<string.h>
int p(char*i){int a=64;while(++a<91)if(!strchr(i,a)&!strchr(i,a+32))return 0;return 1;}

68 bytes

ES6, 68 bytes
s=>[..."abcdefghijklmnopqrstuvwxyz"].every(x=>RegExp(x,"i").test(s))

That string looks awfully wasteful, but I don't know any better way.

Maybe using a range of charcodes?

@Cyoce That got me thinking and I tried a range of base 36 digits but so far it still takes 70 bytes: s=>[...Array(x=9,26)].every(z=>RegExp((++x).toString(36),"i").test(s))

Scala, 59 48 46 bytes
print(('a'to'z'diff(readLine.map(_|32)))==Nil)

Using 32| rather than _|32 will (yield a warning but) shave off one more byte

C#, 91 bytes
Requires (18 bytes):
using System.Linq;

Actual function (73 bytes):
bool P(string s)=>s.ToUpper().Distinct().Where(x=>x>64&&x<91).Count()>25;

How it works: the function first converts everything to uppercase, then removes all duplicates and only keeps the letters. If count of items in the resulting enumerable exceeds 25 (then it must be 26), it's a pangram.

&& can be golfed to &, and bool p(string s)=> can be golfed to s=>

You can save 8 bytes by removing redundant Where method and moving condition to Count method.

PlatyPar, 14 bytes
'a'z_,X,F(x;l!

Explanation (stack visualizer feature coming soon!):
               ## Implicit: push the input (as a string) to the stack
'a'z_          ## Push the range of a-z (the alphabet) to the stack
     ,X        ## Invert stack, expand input string into individual characters
       ,       ## Invert again
        F  ;   ## Fold (While stack.length > 1)
         (      ## Rotate left, moving the first letter of the input string to the top
          x     ## remove any occurences of that letter from the alphabet array
            l! ## Negate the length of the array, so if there's nothing left
               ## output true, else output false

If I had a ridiculous "push all letters of the alphabet" function this would be 10...
Try it online!

Batch, 126 + 2 = 128 bytes
@set p="%*"
@for %%a in (a b c d e f g h i j k l m n o p q r s t u v w x y z)do @set q=!p:%%a=!&if !q!==!p! exit/b 1
@exit/b

Requires CMD /V /C <filename> <input string> so I added 2 bytes for the /V. Alternative 87 + 2 + 26 = 115 byte version:
@set p="%*"
@for %%a in (?)do set q=!p:%%a=!&if !q!==%p% exit/b 1
@exit/b

(+26 for the files named a, b, c ... z that need to exist in the current directory.)

Pyke, 6 bytes
l1GR-!

Try it here!
l1     -   input().lower()
  G -  -  set_difference(alphabet,^)
     ! - not ^

Java 8, 69 bytes
s->s.toUpperCase().chars().distinct().filter(c->c>64&c<91).count()>25

Alternatives with same byte count:
s->s.chars().map(c->c&~32).distinct().filter(c->c>64&c<91).count()>25
s->s.chars().map(c->c|32).distinct().filter(c->c>96&c<123).count()>25

Try it online.
Similar to @ProgramFOX' C# answer.

Perl 5 -p, 30 28 bytes
@a{lc=~/[a-z]/g}++;$_=26==%a

Try it online!

-2 bytes by using the \pL shorthand for \p{L} instead of [a-z] (as I see you already did in your 22 byte module-requiring answer): ++@a{uc=~/\pL/g};$_=%a==26 Try it online! – it ends with its own length now :-)  Also, why does this only require -p and not -p0?

Along with the \pl from @Deadcode's comment, you can use %; as the hash and omit it for another byte! Try it online!

@Deadcode the reason this gives the right output without -0 is the list is added to throughout each iteration, but only has exactly 26 entries once (in your test, I assume in the last line) and Perl's false is empty string.The whole alphabet in the first line: Try it online!. Coercing the result to int: Try it online!

PHP, 59 56 bytes
<?=!array_diff(range(a,z),str_split(strtolower($argn)));

Try it online!
Alt version 67 bytes
<?=array_intersect($a=range(a,z),str_split(strtolower($argn)))==$a;

Try it online!
Call with php -nF input is from STDIN.

MathGolf, 11 7 bytes
!▀_▄+▀=

Try it online!
Explanation
MathGolf just got a lowercase operator!, ! is the factorial operator for ints, floats and lists, but now it also works as a lowercase operator for strings.
!          convert input to lowercase
 ▀         get unique characters as string
  _        duplicate
   ▄+      add the lowercase alphabet to the second copy
     ▀=    get unique elements and check that they are unchanged

GolfScript, 18 bytes
Port of the GS2 answer.
{32|}%[123,97>]\-!

Try it online!
Explanation
{   }%             # Map for every item in input
 32|               # Toggle the 6th bit (turning capitalization on)
      [123,        # Generate exclusive range from '}' (previous 'z') to 0
           97>]    # Select all that are >= 'a'
                   # Yielding the lowercase alphabet
               \-  # Set difference between them
                 ! # Negate the value

Dyalog APL, 13 bytes
∧/⎕A∊1(819⌶)⊢

explanation:
1(819⌶)⊢ ⍝ uppercase
⎕A∊      ⍝ check if all uppercase letters belong to the string
∧/        ⍝ AND reduction of the boolean vector

https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v//Ud/UR20THnUs1weyHB91dBlqWBhaPurZpvmoa5F6YnKqu6d3bn5hcGh4ZVKKm4eXgoKCoZExkMzJKwgKCauoUv//HwA

Somehow I missed your solution when I went to submit my own. Anyway, this comment applies to you as well. https://codegolf.stackexchange.com/questions/66197/is-it-a-pangram/222534#comment516154_222534

Kotlin, 47 bytes
{s:String->('a'..'z').all{s.contains(it,true)}}

Try it online!

It seems that both this answer and the other one operate on an existing variable, when the challenge requires that a function be built.

@PostRockGarfHunter Thanks for letting me know. I've updated the answer by adding a Try it online! link so that the solution can be tested. I hope it's OK like this, as I've seen this approach used by others.

@JoKing Thanks, I'll keep that in mind! I've updated my answer. I hope it's OK now.

C# (Visual C# Interactive Compiler), 48 bytes
x=>x.ToUpper().Distinct().Count(c=>c>64&c<91)>25

Try it online!

Husk, 9 bytes
¦m_⁰…'a'z

Try it online!
Explanation
¦m_⁰…'a'z
    …'a'z inclusive range from a to z
 m_⁰      convert input to lowercase
¦         are all alphabets present in it?

Perl 5 -MList::Util=uniq -p0, 22 bytes
$_=26==uniq uc=~/\pL/g

Try it online!

Jelly, 7 6 bytes
ŒlØaḟṆ

Try it online!
Unless I'm missing something, this is the first jelly answer here.
-1 thanks to the Jelly gurus (caird/chartz and unrelatedstring) in the JHT chat room. Y'all are poggers.
Explained (old)
ŒlQṢØaẇ → a monadic link. Takes a single string as input. We will call that string "S". The flow value of the chain starts as S.
Œl      → The lower case atom. The flow value of the chain is now S.lowercase()
  Q     → The uniquify atom. The flow value of the chain is now unique_elements(S.lowercase())
   Ṣ    → The sort atom. The flow value is now sorted(unique_elements(S.lowercase()))
    Øaẇ → A nilad-dyad pair of the lower case alphabet atom and the is sublist atom. ẇ requires the needle to search for to be on the left and the haystack to search to be on the right. The flow value is now "abcd...xyz" in sorted(unique_elements(S.lowercase())). This consequently has the effect of testing if S, when sorted and case ignored, has every letter of the alphabet.

Explanation of the 6 byter coming in maybe 12 hours.

Zsh --nocaseglob, 19 bytes
>_${1//\/}<*{a..z}*
Attempt This Online!
Outputs via exit code: 0 for pangram, 1 for non-pangram
If we don't have to handle the empty string, then the _ can be removed for -1 byte.
If we don't have to handle strings with slashes in them, the ${1//\/} can be changed to just $1 for -6 bytes:
Zsh --nocaseglob, 12 bytes
>$1<*{a..z}*
Attempt This Online!
Zsh ties APL and K, and beats J??
Explanation

$1: input
//\/: remove all slashes (because filenames can't contain them)
_: prepend underscore (because you can't create files with empty names, so we have to ensure it is non-empty)
>: create a file with that name
<*{a..z}*: search for files matching each of the patterns *a*, *b*, etc.

This effectively checks that the created file contains each letter between a and z. If any check fails, the program with exit with status code 1. Otherwise, it exits with 0.

What's the shortest you can get without --nocaseglob?

@Deadcode This 25 byter is the shortest I've got, but that also uses grep -i which is basically equivalent to --nocaseglob. Or here's 27 bytes without something like that.

@Deadcode Actually here's 22 bytes

Beats Japt, does it?!

@Shaggy Oops, no.

Prolog (SWI), 103 bytes
_^[].
S^[H|T]:-member(H,S),S^T.
\B:-string_lower(B,O),string_codes(O,C),C^`abcdefghijklmnopqrstuvwxyz`.

Try it online!

Kotlin, 56 bytes
{print(('A'..'Z').all{a->it.toUpperCase().contains(a)})}

Using a list of characters where every character has to be found within the input.
Try it online!

APL, 10 bytes
∧/⊃∊/⎕C⎕A⍞

Explanation:
⍞   ⍝ Character input and…
⎕A  ⍝ …alphabet are enclosed into a nested array
⎕C  ⍝ Convert both to lower case
∊/  ⍝ Put membership function between them
⊃   ⍝ Disclose the nested array
∧/  ⍝ Reduce by conjuction

K (ngn/k), 13 bytes
~#(!26)^97!_:

Try it online!

_: lowercase the (implicit) input
97! mod the ASCII character codes by 97 (so a becomes 0, f 6, z 25, etc. etc.)
(!26)^ remove the character codes that are present from 0..25
~# do any character codes corresponding to letters remain?

An alternative 14-byte answer is:
~26-/~"a{"'?_:

Try it online!

?_: get the distinct lowercased characters in the input
~"a{"' identify which characters in the input are letters (1 in the resulting bitmask) and which are not letters (these become 0s)
~26-/ not the result of a minus-reduce seeded with 26 (if all letters are present in the input, this will return 1, and otherwise 0)

JavaScript (ES6), 80
I wrote out a solution virtually identical to edc65's entry before I scrolled to the bottom of the page and saw it was already there! Anyway, here's still another alternate JavaScript approach:
s=>[...Array(26)].every((v,i)=>~s.search(RegExp(String.fromCharCode(i+65),"i")))

My original solution (83) with toUpperCase, before I got the idea to use a case-insensitive RegExp from Cᴏɴᴏʀ O'Bʀɪᴇɴ's solution:
s=>[...Array(26)].every((v,i)=>~s.toUpperCase().indexOf(String.fromCharCode(i+65)))

The code uses every to test whether or not every value of i from 0 to 25 casues the expression String.fromCharCode(i+65) to produce a character that exists in the input string (according to a case-insensitive match).

I wanted to use .every but I couldn't figure out! :D Nice solution!

Java, 97 96 bytes
boolean s(String t){for(int a=65;++a<91;)if(t.toUpperCase().indexOf(a)<0)return 1<0;return 0<1;}

Assumes ASCII or compatible character encoding.
It loops over the capital letters (65-90), checking if each one is present with indexOf, which takes an int.

++a<=90; can be shortened by one byte to ++a<91;.

@KevinCruijssen Thanks.  I've updated my answer based on your suggestion.

Mathematica, 44 bytes
Characters@ToLowerCase@#~SubsetQ~Alphabet[]&

Usage:
In[1]:= Characters@ToLowerCase@#~SubsetQ~Alphabet[]&[
         "The quick brown fox jumps over the lazy doge."]

Out[1]= True

PHP, 92 bytes
The code:
echo!array_diff(range(a,z),array_keys(array_count_values(str_split(strtolower($argv[1])))));

There is not much golfing in it (the clear code is 102 bytes).
Prepend it with the PHP marker <?php  (technically, it is not part of the code), put it into a file (is-it-a-pangram.php) and run it like:
$ php -d error_reporting=0 is-it-a-pangram.php '123abcdefghijklm NOPQRSTUVWXYZ321'

Or put the code directly in the command line:
$php -d error_reporting=0 '... the code here ...' AbCdEfGhIjKlMnOpQrStUvWxYz

It outputs 1 when the input string is a pangram; it doesn't output anything when the string is not a pangram. This is the default representation for boolean values in PHP.
An unambiguous output can be obtained by adding a + sign in front of the echo-ed expression (echo+!array_diff(...);). This way, the boolean value is converted to an integer (1 or 0).
How the code works
It makes the input string lowercase, splits it to individual characters, count the number of occurrences for each character that appears in the string, then makes the difference between the alphabet characters (a to z) and the characters found in the string. If the difference is not empty then not all the letters are found in the string (i.e. the string is not a pangram).
The code and the testcase (using the samples provided in the question) can be found on Github.

You actually don't need the array_keys(array_count_values()) at all, and can get the score down to 63.  https://tio.run/##K8go@G9jX5BRoJBaVJRfFF@UWpBfVJKZl65hoGn9PzU5I18xsagosTI@JTMtTUMl0bYoMS89VSNRp0pTp7ikKL64ICezRAPIKsnPyS9PLQIqKUovizaM1dQE6v//3zHJOcU1zT3DM8s7xzfPvyCwKLgktCy8IrIKAA  Otherwise your answer is virtually the same as the second one I just posted for this! :)

Indeed, sometimes I am not seeing the simplest solution and I tend to find complicated ways to solve the problems.

R, 97 92 bytes
Not competing with @mnel's excellent answer, but nevertheless :
function(s){a=strsplit(s,"")[[1]];m=match;sum(unique(c(m(a,letters,0),m(a,LETTERS,0))))=351}

This function takes your input, breaks it into its letters (strsplit), matches (match function, obviously) each letters of the input with both letters and LETTERS, built-in constant containing lowercases and uppercases letters. The unmatched positions are replaced with 0's.
Then, it eliminates all the redundant positions (unique), and make their sum. Considering there are 26 letters in the alphabet and the 1-indexed positions in R, if all the letters are contained at least once in your input, the sum of their positions will be 1+2+...+25+26, which is 351
- 5 bytes thanks to @plannapus !

if you were defining a as strsplit(s,"")[[1]] you wouldn't have to repeat a[[1]] twice and thus save 5 bytes.

Japt -!, 6 4 bytes
;CkU

Try it here

Due to a quirk in how S.k() works, you actually don't need the v :-)

APL(NARS), 22 chars, 44 bytes
{∧/×↑+/↑¨{+/⍵=⎕a⎕A}¨⍵}

test:
  h←{∧/×↑+/↑¨{+/⍵=⎕a⎕A}¨⍵}
  h 'abcdefghijklmnopqrstuvwXYZ'
1
  h '123abcdefghijklm NOPQRSTUVWXYZ321'
1
  h 'public static void main(String[] args)'
0
  h 'The quick brown fox jumped over the lazy dogs. BOING BOING BOING'
1

Charcoal, 9 6 bytes
⬤β№↧θι

Try it online! Link is to verbose version of code. Outputs a Charcoal boolean (- for true, nothing for false). Just checks that each lowercase letter appears at least once in the lowercase input Explanation:
 β      Lowercase alphabet
⬤       All characters satisfy
  №     (Non-zero) count of
     ι  Current lowercase letter in
    θ   First input
   ↧    Lowercased
        Implicitly print

Burlesque, 16 bytes
zzXX@azr@Jx/IN=s

Try it online!
                                                 [IN]
zz    # Lowercase input                          [in]
XX    # Split into characters                    [i,n]
@azr@ # Push lowercase alphabet                  [i,n],[a,..,z]
Jx/   # Duplicate and bring the input to the top [a,..,z],[a,..,z],[i,n]
IN    # Intersection of the two                  [a,..,z],alpha IN input
=s    # Is equal to the alphabet when sorted     1/0

BaCon, 49 bytes
?IIF(AMOUNT(UNIQ$(EXPLODE$(LCASE$(s$))))>25,1,0)

Stax, 5 bytes
é►Ö_Z

Run and debug it

Factor + math.unicode, 34 23 bytes
[ >lower ALPHABET ⊃ ]

Try it online!
-11 bytes thanks to @Bubbler!
Explanation:
This is a quotation (anonymous function) that takes a string as input and leaves a boolean value as output.

>lower Convert a string to lowercase.
ALPHABET Push a string containing the lowercase alphabet to the data stack.
⊃ Is the input a superset of the alphabet?

subset? is two bytes shorter than diff "" =. Kudos to all set operations working on plain sequences :)

Also, if you accept to use sets.extras, you can shorten swap subset? further to superset? (which has that exact definition).

@Bubbler Thanks for that insight. superset? also exists in math.unicode as ⊃ for further reduction.

C, 87 bytes
For platforms that use ASCII character coding.
f(char*s){char*t=s,i,r=0;for(;*t;)*t++|=32;for(i=97;i<123;)r|=!strchr(s,i++);return!r;}

This first modifies the input string to make it all lower-case (it doesn't matter what happens to non-letters, as they will not become letters or NUL).  Then we test each lower-case letter to see whether it's present.
For an EBCDIC version, we need to replace *t++|=32; with *t++|=64; and for(i=97;i<123;) with for(i=193;i<234;i+=7*(i&16==9)+i==161).
Simple test program:
#include<stdio.h>
int main(int argc, char **argv)
{
    while (*++argv) {
        printf("%s: ", *argv);
        printf("%s\n", f(*argv) ? "Yes" : "No");
    }
}

Online test

85 bytes

Scratch, 145 bytes
define(s
set[z v]to[abcdefghijklmnopqrstuvwxyz
set[i v]to[
set[o v]to[1
repeat[26
change[i v]by(1
set[o v]to((o)*<(s)contains(letter(l)of(z
say(o

Uses scratchblocks syntax.
Function should have "Run before screen refresh" checked. Defines a function with an empty name and one argument (s). Output is 1 if s is a pangram and 0 if it is not.
<[]contains[]> works in scratchblocks syntax (which I used), but <[]contains[]?> is used in Scratch. This adds an extra byte, but because I'm using scratchblocks syntax, I don't think it should count.

set[i v]to((i)+(1 is a byte shorter than change[i v]by(1 if I've gotten my byte count correct. Also, very nice scratch answer!

@Lyxal Thanks, but it looks like it's two bytes longer to me.

C, 64 bytes
n=63<<26;f(char*s){while(*s)n|=1<<(tolower(*s++)-97);return!~n;}

Explanation

Create a mask of 32-26 = 0b111111 = 63 and shl by 26 (you will understand why) with n=63<<26;

Iterate over string, set bit at index tolower(*s) - 'a' with while(*s)n|=1<<(tolower(*s++)-97);
NB: Characters beyond 'z', {|}~, do not matter, as flags are already
set.

Reverse all bits with ~, if all letters were encountered it should give 0, else it would give value of all letters that were missing in the char array. We return the opposite with !, so it becomes true if it is a pangram, else false.

Is n ever reseted on second call?

it is not, it is a trick to save 4 bytes (int and space), if you want it to be reset you just move n declaration inside the function (68 bytes).

53 bytes

JavaScript (ES9), 38 bytes
a=>a.match(/$|([A-Z])(?!.*\1)/igs)[25]

Try it online!
$| just to not crash if there's no letter. Worth mentioned competitor

I like this; it may not be the shortest overall but it's the shortest that runs fast. Here is a JavaScript ES9 way of doing it: Try it online! Please note that it's good manners to credit the code your answer is based on.

Oh damn, my ES9 variant isn't always correct: Try it online! it fails when the first character is a non-letter and there are 25 unique letters.

@Deadcode We all missed that the +1 can be easily saved

Well done. But I suggest you name the language "JavaScript (ES6)" or "JavaScript ES6" because it doesn't have anything specific to SpiderMonkey (the test harness doesn't count).

I just realized this doesn't accept multi-line input like the challenge requires. I've fixed my answer at +1 byte cost, and here's the same fix for yours: Try it online! – note that this requires changing your language spec to "JavaScript (ES9)".

a=>/(([a-z])(?!.*\2).*){26}/si.test(a) is 38 bytes too, but very very slow.

@tsh That's Deadcode's solution

Fig, \$9\log_{256}(96)\approx\$ 7.408 bytes
lca+//KUa

Try it online!
Returns -1 for falsy, and a non-negative integer for truthy.

-1 is an integer…

Uiua, 17 14 bytes
/↧/↥∊⊠+"aA"⇡26

Try it!
-3 thanks to Lynn
/↧/↥∊⊠+"aA"⇡26
           ⇡26  # 0..25
     ⊠+"aA"     # get lowercase and uppercase alphabet
    ∊           # masks of which letters are in the input
  /↥            # max of each column
/↧              # minimum

Interesting language! /↧/↥∊⊠+"aA"⇡26 seems to work.

Ah geez that's smart. Thanks!

Seriously, 14 13 12 bytes
,ûOk"A["Ox-Y

Hex Dump:
2c964f6b22415b224f782d59

Try it online!
Explanation:
,                  read in the string from stdin
 û                 make it uppercase
  O                push all the character codes to the stack
   k               listify the stack
    "A["           push this string
        O          pop it and push all of its character codes
         x         push range(65,91)
          -        do set subtraction with the lists
           Y       logical not the result (so a zero length list becomes 1)

EDIT: moved input to the beginning to save a byte, thanks to @Mego

Bash 4+, 86 48 bytes
Thanks to @Dennis for saving me 38 bytes!
Since return codes are what's checked by test/[ for truthy-ness in bash, the return code should be valid truthy/falsy output, right? If not, I'll edit to echo more typical truthy/falsy values (since bash true/false values are inverted compared to most things)
for x in {a..z}
{ [[ ${1,,} =~ $x ]] || exit 1
}

The exit code works as valid truthy/falsy output, since an exit code is a valid way of outputting an integer.

do and done can be replaced with { and }. 2. [[ ... ]]||exit 1 is shorter than if...fi. 3. I don't think the tr command is required at all; ${1,,} =~ $x should work just fine.

@Dennis I think my tr command got leftover from when I was doing the search more as "is each character of the input in {a..z}" and it just never occurred to me to remove it when I changed that. Wouldn't have caught the other stuff, still getting the hang of this golfing thing

Ruby, 39 33 bytes
This is the case insensitive version.
->s{(?a..?z).all?{|x|s[/#{x}/i]}}

Ruby, 32 bytes
Invalid (lowercase only)
No one has posted a ruby answer yet, so I made this. Nice and simple.
->s{(?a..?z).all?{|x|s.index x}}

It only works for lowercase letters.

More love for ruby! ->s{(?a..?z).all?{|x|s[/#{x}/i]}} is 33 bytes.

C, 97 bytes
c;t=26;i=26;f[26];p(char*s){while(*s)(c=*s++&~32-65)>=0&c<t?f[c]=1:0;while(i)t-=f[--i];return!t;}

Assumes ASCII or compatible character encoding.
C is not the best tool when it comes to string-related golf, nevertheless it was fun to code.
Globals are not reset, so this function will work as expected only once, but, hey, nobody said it should work the second time! ;-)
Test main:
#include <stdio.h>

int main(int argc, char **argv) {
  if (argc < 2) {
    fprintf(stderr, "Usage: %s <phrase>\n", argv[0]);
    return 1;
  }

  printf("%d\n", p(argv[1]));
}

SpecBAS - 107 bytes
1 INPUT a$: LET a$=UP$(a$),c=0
2 FOR EACH l$ IN ["A" TO "Z"]: IF POS(l$,a$)>0 THEN INC c: NEXT l$
3 TEXT c=26

Set a counter to 0, loops through "A" to "Z" and increments the counter if found.
Prints 0 (false) or 1 (true) if counter is 26.

Mumps, 86 bytes
R S F I=65:1:90{S J(I)=0} F I=1:1:$L(S){S Q=$A($E(S,I)) S:Q>92 Q=Q-32 K J(Q)} W '$D(J)

I built an array of nodes with all the ordinals of upper case characters, took the ordinal of each character in the string, converted lowercase to uppercase if necessary, and killed the associating node in the array. Here's my routine a bit more 'ungolfed':
R S                   ; Read STDIN into S
F I=65:1:90{S J(I)=0} ; Create an array of J() with all the uppercase ASCII ordinals
F I=1:1:$L(S)         ; loop through the # of characters in S
    {S Q=$A($E(S,I))  ; Set Q=the ordinal number of each character
    S:Q>92            ; if Q>92 (above the upper case, below the lower case ordinals
    Q=Q-32            ; subtract 32 from Q to convert to upper case.
    K J(Q)}           ; Kill the J(Ordinal) node of the array.
    W '$D(J)          ; $D will output False if there's no nodes in the array, true if some remain. \
                      ; write out the binary 'NOT' of this value.

The braces enable one-liners a bit more easily (multiple lines could add a few characters) and is a function of InterSystems Cache's version of Mumps.

Groovy, 57 bytes
u={print it.toLowerCase().toList().containsAll('a'..'z')}

Will groovy ever win?

R, 77 bytes
g=function(x){length(intersect(unlist(strsplit(tolower(x),"")),letters))==26}

Test cases:
> g("AbCdEfGhIjKlMnOpQrStUvWxYz")
[1] TRUE
> g("ACEGIKMOQSUWY
+ BDFHJLNPRTVXZ")
[1] TRUE
> g("public static void main(String[] args)")
[1] FALSE
> g("The quick brown fox jumped over the lazy dogs. BOING BOING BOING")
[1] TRUE
> g("")
[1] FALSE

You don't need the curly braces here since there is only one statement, thus saving 2 bytes

C++, 121 bytes
int P(char *s){int c;bitset<26> a;while(c=*s){c=tolower(c)-'a';if(c>=0&&c<26)a.set(c);if(a.all())return 1;s++;}return 0;}

32-bit x86 machine code, 27 bytes
In hex:
31c031d2ac48780d344024df3c1977f40fabc2ebef31d0c1e006c3

Input: ESI: NULL-terminated string. Returns: EFLAGS.ZF (1=truthy, 0=falsey).
0:  31 c0               xor eax, eax
2:  31 d2               xor edx, edx  ;Bit array to keep track of letters
_loop :
4:  ac                  lodsb         ;Read next char
5:  48                  dec eax       ;Align 'A' to the power of two boundary, i.e. 0x40
6:  78 0d               js _break     ;...which also tests for NULL
8:  34 40               xor al, 0x40  ;Swap block [0x40..0x7f] (with letters) with [0..0x3f]
a:  24 df               and al, 0xdf  ;Map [0x60..0x7f] to [0x40..0x5f], that's toupper()
c:  3c 19               cmp al, 25    ;Letter are now in the [0..25] range
e:  77 f4               ja _loop      ;Anything else is greater if taken as unsigned
10: 0f ab c2            bts edx, eax  ;Set AL-th bit in EDX
13: eb ef               jmp _loop
_break :
15: 31 d0               xor eax, edx  ;EAX=~EDX (EAX==-1 here), for pangram EDX==0x03FFFFFF
17: c1 e0 06            shl eax, 6    ;Shift out 6 unused bits. EFLAGS.ZF=EAX<<6==0?1:0
1a: c3                  ret

Javascript (using external library - Enumerable) (83 bytes)
 n=>_.From("abcdefghijklmnopqrstuvwxyz").All(x=>_.From(n.toLowerCase()).Contains(x))

Link to library: https://github.com/mvegh1/Enumerable
Code explanation: Load the lowercase alphabet as char array, then test that every single char is contained in the lowercased input

K4, 12 bytes
Solution
&/.Q.a in\:_

Examples:
q)k)&/.Q.a in\:_"AbCdEfGhIjKlMnOpQrStUvWxYz"
1b
q)k)&/.Q.a in\:_"ACEGIKMOQSUWY\nBDFHJLNPRTVXZ"
1b
q)k)&/.Q.a in\:_"public static void main(String[] args)"
0b
q)k)&/.Q.a in\:_"The quick brown fox jumped over the lazy dogs. BOING BOING BOING"
1b

Explanation:
Lowercase the input, check whether each letter in a..z is in this. Take the min.
&/.Q.a in\:_ / the solution
           _ / lowercase
       in\:  / apply in to left and each-right (\:)
  .Q.a       / "abcdefghijklmnopqrstuvwxyz"
&/           / take the minimum

Smalltalk, 44 bytes
(($ato:$z)intersection:s asLowercase)size=26

05AB1E, 5 bytes
lA€åP

Try it online!
lA€åP  # full program
    P  # product of...
  €    # each letter of...
 A     # "abcdefghijklmnopqrstuvwxyz"...
   å   # in...
       # implicit input...
l      # in lowercase
       # implicit output

Pxem, Filename: 118 bytes + Content: 0 bytes = 118 bytes.

Filename: @@€€.!.!.!.cX.w.i.c`.x .-XX.a.c@.x.c[.yA.-.t.m.w.!.m.-.c.t.a.t.c.m.$.%.z.m.+XX.aXX@.aXX.a.+.a.t.!.-.m.z.d.aY.o

Escaped: \100\100\200\200.!.!.!.cX.w.i.c\140.x\040.-XX.a.c@.x.c[.yA.-.t\001.m.w\002.!\001.m.-.c.t.a.t.c.m.$\002.%\001.z.m.+XX.aXX@.aXX.a\001.+.a.t\002.!\001.-.m.z.d.aY.o

Content: empty.

Try it online!
Usage

Input from stdin
Y to stdout for truthy, no output for falsey

With comments
XX.z
# push 2^26; dup; push non-zero value;
## NOTE 2^26 is initialized table
# while empty||pop!=0; do
.a\100\100\200\200.!.!.!.cX.wXX.z
  # push getchar
  .a.iXX.z
  ## NOTE capitalizing here
  .a.c\140.x\040.-XX.aXX.z
  # if isalpha top; then
  .a.c@.x.c[.yXX.z
      # let c is difference between 'A' and the character
      .aA.-.tXX.z
      # let m is 1; what digit to see
      ## NOTE m==2^c
      .a\001.m.w\002.!\001.m.-.c.t.aXX.z
      ## NOTE actual updating table
      # if tbl&m!=1; then tbl&=m; fi
      ## NOTE no logical operators
      .a.t.c.m.$\002.%%\001.z.m.+XX.aXX.z
      # push rando character and get out
      .aXX@.aXX.z
  .aXX.aXX.z
  # get out if EOF (-1)
.a\001.+.aXX.z
# finally: if tbl==2^27-1; then putchar Y; fi
.a.t\002.!\001.-.m.z.d.aY.o

PHP, 172 bytes
function is_pangram ($s) {
return  preg_match("#^".implode(
   array_map(function ($x) {return "(?=.*{$x})" ;} ,
   str_split("ABCDEFGHIJKLMNOPQRSTUVWXYZ")))."#uis", $s);
}

I don't know PHP but it looks like there's a lot of whitespace that can be removed here, and using a shorter function name than is_pangram will help -- remember that the point of code golf is to solve the problem in as few bytes as possible!