Pangram checker

From Rosetta Code
Task
Pangram checker
You are encouraged to solve this task according to the task description, using any language you may know.

A pangram is a sentence that contains all the letters of the English alphabet at least once.

For example:   The quick brown fox jumps over the lazy dog.


Task

Write a function or method to check a sentence to see if it is a   pangram   (or not)   and show its use.

360 Assembly[edit]

*        Pangram RC                11/08/2015
PANGRAM CSECT
USING PANGRAM,R12
LR R12,R15
BEGIN LA R9,SENTENCE
LA R6,4
LOOPI LA R10,ALPHABET loop on sentences
LA R7,26
LOOPJ LA R5,0 loop on letters
LR R11,R9
LA R8,60
LOOPK MVC BUFFER+1(1),0(R10) loop in sentence
CLC 0(1,R10),0(R11) if alphabet[j=sentence[i]
BNE NEXTK
LA R5,1 found
NEXTK LA R11,1(R11) next character
BCT R8,LOOPK
LTR R5,R5 if found
BNZ NEXTJ
MVI BUFFER,C'?' not found
B PRINT
NEXTJ LA R10,1(R10) next letter
BCT R7,LOOPJ
MVC BUFFER(2),=CL2'OK'
PRINT MVC BUFFER+3(60),0(R9)
XPRNT BUFFER,80
NEXTI LA R9,60(R9) next sentence
BCT R6,LOOPI
RETURN XR R15,R15
BR R14
ALPHABET DC CL26'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
SENTENCE DC CL60'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
DC CL60'THE FIVE BOXING WIZARDS DUMP QUICKLY.'
DC CL60'HEAVY BOXES PERFORM WALTZES AND JIGS.'
DC CL60'PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS.'
BUFFER DC CL80' '
YREGS
END PANGRAM
Output:
OK THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
?J THE FIVE BOXING WIZARDS DUMP QUICKLY.
?C HEAVY BOXES PERFORM WALTZES AND JIGS.
OK PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS.

ACL2[edit]

(defun contains-each (needles haystack)
(if (endp needles)
t
(and (member (first needles) haystack)
(contains-each (rest needles) haystack))))
 
(defun pangramp (str)
(contains-each (coerce "abcdefghijklmnopqrstuvwxyz" 'list)
(coerce (string-downcase str) 'list)))

ActionScript[edit]

Works with: ActionScript version 2.0
function pangram(k:string):Boolean {
var lowerK:String = k.toLowerCase();
var has:Object = {}
 
for (var i:Number=0; i<=k.length-1; i++) {
has[lowerK.charAt(i)] = true;
}
 
var result:Boolean = true;
 
for (var ch:String='a'; ch <= 'z'; ch=String.fromCharCode(ch.charCodeAt(0)+1)) {
result = result && has[ch]
}
 
return result || false;
}

Ada[edit]

Using Sets

 
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Maps; use Ada.Strings.Maps;
with Ada.Characters.Handling; use Ada.Characters.Handling;
procedure pangram is
 
function ispangram(txt: String) return Boolean is
lowtxt : String := To_Lower(txt);
letset,txtset : Character_Set;
begin
letset := To_Set("abcdefghijklmnopqrstuvwxyz");
txtset := To_Set(lowtxt);
return (letset-txtset)=Null_Set;
end ispangram;
 
begin
put_line(Boolean'Image(ispangram("This is a test")));
put_line(Boolean'Image(ispangram("The quick brown fox jumps over the lazy dog")));
put_line(Boolean'Image(ispangram("NOPQRSTUVWXYZ abcdefghijklm")));
put_line(Boolean'Image(ispangram("abcdefghijklopqrstuvwxyz"))); --Missing m, n
end pangram;
 
Output:
FALSE
TRUE
TRUE
FALSE

ALGOL 68[edit]

Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards)
# init pangram: #
INT la = ABS "a", lz = ABS "z";
INT ua = ABS "A", uz = ABS "Z";
IF lz-la+1 > bits width THEN
put(stand error, "Exception: insufficient bits in word for task");
stop
FI;
 
PROC is a pangram = (STRING test)BOOL: (
BITS a2z := BIN(ABS(2r1 SHL (lz-la))-1); # assume: ASCII & Binary #
FOR i TO UPB test WHILE
INT c = ABS test[i];
IF la <= c AND c <= lz THEN
a2z := a2z AND NOT(2r1 SHL (c-la))
ELIF ua <= c AND c <= uz THEN
a2z := a2z AND NOT(2r1 SHL (c-ua))
FI;
# WHILE # a2z /= 2r0 DO
SKIP
OD;
a2z = 2r0
);
 
main:(
[]STRING test list = (
"Big fjiords vex quick waltz nymph",
"The quick brown fox jumps over a lazy dog",
"A quick brown fox jumps over a lazy dog"
);
FOR key TO UPB test list DO
STRING test = test list[key];
IF is a pangram(test) THEN
print(("""",test,""" is a pangram!", new line))
FI
OD
)
Output:
"Big fjiords vex quick waltz nymph" is a pangram!
"The quick brown fox jumps over a lazy dog" is a pangram!

APL[edit]

 
a←'abcdefghijklmnopqrstuvwxyz'
A←'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
Panagram←{∧/ ∨⌿ 2 26⍴(a,A) ∊ ⍵}
Panagram 'This should fail'
0
Panagram 'The quick brown fox jumps over the lazy dog'
1
 


AppleScript[edit]

Out of the box, AppleScript lacks many library basics – no regex, no higher order functions, not even string functions for mapping to upper or lower case.

From OSX 10.10 onwards, we can, however, use ObjC functions from AppleScript by importing the Foundation framework. We do this below to get a toLowerCase() function. If we also add generic filter and map functions, we can write and test a simple isPangram() function as follows:

use framework "Foundation"
 
on run
map(isPangram, {¬
"is this a pangram", ¬
"The quick brown fox jumps over the lazy dog"})
end run
 
-- isPangram :: String -> Bool
on isPangram(s)
length of ¬
filter(mClosure(my charUnused, ¬
{lowerCaseString:toLowerCase(s)}), ¬
"abcdefghijklmnopqrstuvwxyz") = 0
end isPangram
 
-- charUnUsed :: Character -> Bool
on charUnused(c)
my closure's lowerCaseString does not contain c
end charUnused
 
 
-- GENERIC HIGHER ORDER FUNCTIONS (FILTER AND MAP)
 
-- (a -> Bool) -> [a] -> [a]
on filter(f, xs)
set mf to mReturn(f)
 
set lst to {}
set lng to length of xs
repeat with i from 1 to lng
set v to item i of xs
if mf's lambda(v, i, xs) then
set end of lst to v
end if
end repeat
return lst
end filter
 
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
set mf to mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to mf's lambda(item i of xs, i, xs)
end repeat
return lst
end map
 
-- Handler -> Record -> Script
on mClosure(f, recBindings)
script
property closure : recBindings
property lambda : f
end script
end mClosure
 
-- Lift 2nd class function into 1st class wrapper
-- handler function --> first class script object
on mReturn(f)
if class of f is script then return f
script
property lambda : f
end script
end mReturn
 
-- OBJC function: lowercaseStringWithLocale
 
-- toLowerCase :: String -> String
on toLowerCase(str)
set ca to current application
unwrap(wrap(str)'s ¬
lowercaseStringWithLocale:(ca's NSLocale's currentLocale))
end toLowerCase
 
-- wrap :: AS value -> NSObject
on wrap(v)
set ca to current application
ca's (NSArray's arrayWithObject:v)'s objectAtIndex:0
end wrap
 
-- unwrap :: NSObject -> AS value
on unwrap(objCValue)
if objCValue is missing value then
return missing value
else
set ca to current application
item 1 of ((ca's NSArray's arrayWithObject:objCValue) as list)
end if
end unwrap
 
Output:
{false, true}

AutoHotkey[edit]

Gui, -MinimizeBox
Gui, Add, Edit, w300 r5 vText
Gui, Add, Button, x105 w100 Default, Check Pangram
Gui, Show,, Pangram Checker
Return
 
GuiClose:
ExitApp
Return
 
ButtonCheckPangram:
Gui, Submit, NoHide
Loop, 26
If Not InStr(Text, Char := Chr(64 + A_Index)) {
MsgBox,, Pangram, Character %Char% is missing!
Return
}
MsgBox,, Pangram, OK`, this is a Pangram!
Return

AutoIt[edit]

 
Pangram("The quick brown fox jumps over the lazy dog")
Func Pangram($s_String)
For $i = 1 To 26
IF Not StringInStr($s_String, Chr(64 + $i)) Then
Return MsgBox(0,"No Pangram", "Character " & Chr(64 + $i) &" is missing")
EndIf
Next
Return MsgBox(0,"Pangram", "Sentence is a Pangram")
EndFunc
 

AWK[edit]

Solution using string-operations[edit]

#!/usr/bin/awk -f
BEGIN {
allChars="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
print isPangram("The quick brown fox jumps over the lazy dog.");
print isPangram("The quick brown fo.");
}
 
function isPangram(string) {
delete X;
for (k=1; k<length(string); k++) {
X[toupper(substr(string,k,1))]++; # histogram
}
for (k=1; k<=length(allChars); k++) {
if (!X[substr(allChars,k,1)]) return 0;
}
return 1;
}
Output:
1
0

Solution using associative arrays and split[edit]

Works with: gawk version 4.1.0
Works with: mawk version 1.3.3
# usage: awk -f pangram.awk -v p="The five boxing wizards dump quickly." input.txt
#
# Pangram-checker, using associative arrays and split
BEGIN {
alfa="ABCDEFGHIJKLMNOPQRSTUVWXYZ"; ac=split(alfa,A,"")
print "# Checking for all",ac,"chars in '" alfa "' :"
 
print testPangram("The quick brown fox jumps over the lazy dog.");
print testPangram(p);
}
 
{ print testPangram($0) }
 
function testPangram(str, c,i,S,H,hit,miss) {
print str ##
split( toupper(str), S, "")
for (c in S) {
H[ S[c] ]++
#print c, S[c], H[ S[c] ] ##
}
for (i=1; i<=ac; i++) {
c = A[i]
#printf("%2d %c : %4d\n", i, c, H[c] ) ##
if (H[c]) { hit=hit c } else { miss=miss c }
}
print "# hit:",hit, "# miss:",miss, "." ##
if (miss) return 0
return 1
}
Output:
# Checking for all 26 chars in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' :
The quick brown fox jumps over the lazy dog.
# hit: ABCDEFGHIJKLMNOPQRSTUVWXYZ # miss:  .
1
The five boxing wizards dump quickly.
# hit: ABCDEFGHIKLMNOPQRSTUVWXYZ # miss: J .
0
Heavy boxes perform waltzes and jigs
# hit: ABDEFGHIJLMNOPRSTVWXYZ # miss: CKQU .
0
The quick onyx goblin jumps over the lazy dwarf.
# hit: ABCDEFGHIJKLMNOPQRSTUVWXYZ # miss:  .
1
Pack my box with five dozen liquor jugs
# hit: ABCDEFGHIJKLMNOPQRSTUVWXYZ # miss:  .
1

BASIC[edit]

Works with: QBasic
DECLARE FUNCTION IsPangram! (sentence AS STRING)
 
DIM x AS STRING
 
x = "My dog has fleas."
GOSUB doIt
x = "The lazy dog jumps over the quick brown fox."
GOSUB doIt
x = "Jackdaws love my big sphinx of quartz."
GOSUB doIt
x = "What's a jackdaw?"
GOSUB doIt
 
END
 
doIt:
PRINT IsPangram!(x), x
RETURN
 
FUNCTION IsPangram! (sentence AS STRING)
'returns -1 (true) if sentence is a pangram, 0 (false) otherwise
DIM l AS INTEGER, s AS STRING, t AS INTEGER
DIM letters(25) AS INTEGER
 
FOR l = 1 TO LEN(sentence)
s = UCASE$(MID$(sentence, l, 1))
SELECT CASE s
CASE "A" TO "Z"
t = ASC(s) - 65
letters(t) = 1
END SELECT
NEXT
 
FOR l = 0 TO 25
IF letters(l) < 1 THEN
IsPangram! = 0
EXIT FUNCTION
END IF
NEXT
 
IsPangram! = -1
END FUNCTION
Output:
  0            My dog has fleas.
 -1            The quick brown fox jumps over the lazy dog.
 -1            Jackdaws love my big sphinx of quartz.
  0            What's a jackdaw?

Batch File[edit]

@echo off
setlocal enabledelayedexpansion
 
%===The Main Thing===%
call :pangram "The quick brown fox jumps over the lazy dog."
call :pangram "The quick brown fox jumped over the lazy dog."
echo.
pause
exit /b 0
 
%===The Function===%
:pangram
set letters=abcdefgihjklmnopqrstuvwxyz
set cnt=0
set inp=%~1
set str=!inp: =!
 
:loop
set chr=!str:~%cnt%,1!
if "!letters!"=="" (
echo %1 is a pangram^^!
goto :EOF
)
if "!chr!"=="" (
echo %1 is not a pangram.
goto :EOF
)
set letters=!letters:%chr%=!
set /a cnt+=1
goto loop
Output:
"The quick brown fox jumps over the lazy dog." is a pangram!
"The quick brown fox jumped over the lazy dog." is not a pangram.

Press any key to continue . . .

BBC BASIC[edit]

      FOR test% = 1 TO 2
READ test$
PRINT """" test$ """ " ;
IF FNpangram(test$) THEN
PRINT "is a pangram"
ELSE
PRINT "is not a pangram"
ENDIF
NEXT test%
END
 
DATA "The quick brown fox jumped over the lazy dog"
DATA "The five boxing wizards jump quickly"
 
DEF FNpangram(A$)
LOCAL C%
A$ = FNlower(A$)
FOR C% = ASC("a") TO ASC("z")
IF INSTR(A$, CHR$(C%)) = 0 THEN = FALSE
NEXT
= TRUE
 
DEF FNlower(A$)
LOCAL A%, C%
FOR A% = 1 TO LEN(A$)
C% = ASCMID$(A$,A%)
IF C% >= 65 IF C% <= 90 MID$(A$,A%,1) = CHR$(C%+32)
NEXT
= A$
Output:
"The quick brown fox jumped over the lazy dog" is not a pangram
"The five boxing wizards jump quickly" is a pangram

Bracmat[edit]

(isPangram=
k
. low$!arg:?arg
& a:?k
& whl
' ( @(!arg:? !k ?)
& chr$(1+asc$!k):?k:~>z
)
& !k:>z
&
);

Some examples:

isPangram$("the Quick brown FOX jumps over the lazy do")
no
isPangram$("the Quick brown FOX jumps over the lazy dog")
yes
isPangram$"My dog has fleas."
no
isPangram$"The quick brown fox jumps over the lazy dog."
yes
isPangram$"Jackdaws love my big sphinx of quartz."
yes
isPangram$"What's a jackdaw?"
no
isPangram$"Lynx c.q. vos prikt bh: dag zwemjuf!"
yes

Brat[edit]

pangram? = { sentence |
letters = [: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]
 
sentence.downcase!
 
letters.reject! { l |
sentence.include? l
}
 
letters.empty?
}
 
p pangram? 'The quick brown fox jumps over the lazy dog.' #Prints true
p pangram? 'Probably not a pangram.' #Prints false

Alternative version:

pangram? = { sentence |
sentence.downcase.dice.unique.select(:alpha?).length == 26
}

C[edit]

#include <stdio.h>
 
int isPangram(const char *string)
{
char ch, wasused[26] = {0};
int total = 0;
 
while ((ch = *string++)) {
int index;
 
if('A'<=ch&&ch<='Z')
index = ch-'A';
else if('a'<=ch&&ch<='z')
index = ch-'a';
else
continue;
 
total += !wasused[index];
wasused[index] = 1;
}
return (total==26);
}
 
int main()
{
int i;
const char *tests[] = {
"The quick brown fox jumps over the lazy dog.",
"The qu1ck brown fox jumps over the lazy d0g."
};
 
for (i = 0; i < 2; i++)
printf("\"%s\" is %sa pangram\n",
tests[i], isPangram(tests[i])?"":"not ");
return 0;
}

Using bitmask[edit]

#include <stdio.h>
 
int pangram(const char *s)
{
int c, mask = (1 << 26) - 1;
while ((c = (*s++)) != '\0') /* 0x20 converts lowercase to upper */
if ((c &= ~0x20) <= 'Z' && c >= 'A')
mask &= ~(1 << (c - 'A'));
 
return !mask;
}
 
int main()
{
int i;
const char *s[] = { "The quick brown fox jumps over lazy dogs.",
"The five boxing wizards dump quickly.", };
 
for (i = 0; i < 2; i++)
printf("%s: %s\n", pangram(s[i]) ? "yes" : "no ", s[i]);
 
return 0;
}
Output:
yes: The quick brown fox jumps over lazy dogs.
no : The five boxing wizards dump quickly.

C#[edit]

C# 3.0 or higher (.NET Framework 3.5 or higher)

using System;
using System.Linq;
 
static class Program
{
static bool IsPangram(this string text, string alphabet = "abcdefghijklmnopqrstuvwxyz")
{
return alphabet.All(text.ToLower().Contains);
}
 
static void Main(string[] arguments)
{
Console.WriteLine(arguments.Any() && arguments.First().IsPangram());
}
}

Any version of C# language and .NET Framework

using System;
 
namespace PangrammChecker
{
public class PangrammChecker
{
public static bool IsPangram(string str)
{
bool[] isUsed = new bool[26];
int ai = (int)'a';
int total = 0;
for (CharEnumerator en = str.ToLower().GetEnumerator(); en.MoveNext(); )
{
int d = (int)en.Current - ai;
if (d >= 0 && d < 26)
if (!isUsed[d])
{
isUsed[d] = true;
total++;
}
}
return (total == 26);
}
}
 
class Program
{
static void Main(string[] args)
{
string str1 = "The quick brown fox jumps over the lazy dog.";
string str2 = "The qu1ck brown fox jumps over the lazy d0g.";
Console.WriteLine("{0} is {1}a pangram", str1,
PangrammChecker.IsPangram(str1)?"":"not ");
Console.WriteLine("{0} is {1}a pangram", str2,
PangrammChecker.IsPangram(str2)?"":"not ");
Console.WriteLine("Press Return to exit");
Console.ReadLine();
}
}
}

C++[edit]

#include <algorithm>
#include <cctype>
#include <string>
#include <iostream>
 
const std::string alphabet("abcdefghijklmnopqrstuvwxyz");
 
bool is_pangram(std::string s)
{
std::transform(s.begin(), s.end(), s.begin(), ::tolower);
std::sort(s.begin(), s.end());
return std::includes(s.begin(), s.end(), alphabet.begin(), alphabet.end());
}
 
int main()
{
const auto examples = {"The quick brown fox jumps over the lazy dog",
"The quick white cat jumps over the lazy dog"};
 
std::cout.setf(std::ios::boolalpha);
for (auto& text : examples) {
std::cout << "Is \"" << text << "\" a pangram? - " << is_pangram(text) << std::endl;
}
}
 

Ceylon[edit]

shared void run() {
 
function pangram(String sentence) =>
let(alphabet = set('a'..'z'),
letters = set(sentence.lowercased.filter(alphabet.contains)))
letters == alphabet;
 
value sentences = [
"The quick brown fox jumps over the lazy dog",
"""Watch "Jeopardy!", Alex Trebek's fun TV quiz game.""",
"Pack my box with five dozen liquor jugs.",
"blah blah blah"
];
for(sentence in sentences) {
print("\"``sentence``\" is a pangram? ``pangram(sentence)``");
}
}

Clojure[edit]

(defn pangram? [s]
(let [letters (into #{} "abcdefghijklmnopqrstuvwxyz")]
(= (->> s .toLowerCase (filter letters) (into #{})) letters)))

COBOL[edit]

       identification division.
program-id. pan-test.
data division.
working-storage section.
1 text-string pic x(80).
1 len binary pic 9(4).
1 trailing-spaces binary pic 9(4).
1 pangram-flag pic x value "n".
88 is-not-pangram value "n".
88 is-pangram value "y".
procedure division.
begin.
display "Enter text string:"
accept text-string
set is-not-pangram to true
initialize trailing-spaces len
inspect function reverse (text-string)
tallying trailing-spaces for leading space
len for characters after space
call "pangram" using pangram-flag len text-string
cancel "pangram"
if is-pangram
display "is a pangram"
else
display "is not a pangram"
end-if
stop run
.
end program pan-test.
 
identification division.
program-id. pangram.
data division.
1 lc-alphabet pic x(26) value "abcdefghijklmnopqrstuvwxyz".
linkage section.
1 pangram-flag pic x.
88 is-not-pangram value "n".
88 is-pangram value "y".
1 len binary pic 9(4).
1 text-string pic x(80).
procedure division using pangram-flag len text-string.
begin.
inspect lc-alphabet converting
function lower-case (text-string (1:len))
to space
if lc-alphabet = space
set is-pangram to true
end-if
exit program
.
end program pangram.

CoffeeScript[edit]

 
is_pangram = (s) ->
# This is optimized for longish strings--as soon as all 26 letters
# are encountered, we will be done. Our worst case scenario is a really
# long non-pangram, or a really long pangram with at least one letter
# only appearing toward the end of the string.
a_code = 'a'.charCodeAt(0)
required_letters = {}
for i in [a_code...a_code+26]
required_letters[String.fromCharCode(i)] = true
 
cnt = 0
for c in s
c = c.toLowerCase()
if required_letters[c]
cnt += 1
return true if cnt == 26
delete required_letters[c]
false
 
do ->
tests = [
["is this a pangram", false]
["The quick brown fox jumps over the lazy dog", true]
]
 
for test in tests
[s, exp_value] = test
throw Error("fail") if is_pangram(s) != exp_value
# try long strings
long_str = ''
for i in [1..500000]
long_str += s
throw Error("fail") if is_pangram(long_str) != exp_value
console.log "Passed tests: #{s}"
 


Common Lisp[edit]

(defun pangramp (s)
(null (set-difference
(loop for c from (char-code #\A) upto (char-code #\Z) collect (code-char c))
(coerce (string-upcase s) 'list))))

Component Pascal[edit]

BlackBox Component Builder

 
MODULE BbtPangramChecker;
IMPORT StdLog,DevCommanders,TextMappers;
 
PROCEDURE Check(str: ARRAY OF CHAR): BOOLEAN;
CONST
letters = 26;
VAR
i,j: INTEGER;
status: ARRAY letters OF BOOLEAN;
resp : BOOLEAN;
BEGIN
FOR i := 0 TO LEN(status) -1 DO status[i] := FALSE END;
 
FOR i := 0 TO LEN(str) - 1 DO
j := ORD(CAP(str[i])) - ORD('A');
IF (0 <= j) & (25 >= j) & ~status[j] THEN status[j] := TRUE END
END;
 
resp := TRUE;
FOR i := 0 TO LEN(status) - 1 DO;
resp := resp & status[i]
END;
RETURN resp;
END Check;
 
PROCEDURE Do*;
VAR
params: DevCommanders.Par;
s: TextMappers.Scanner;
BEGIN
params := DevCommanders.par;
s.ConnectTo(params.text);
s.SetPos(params.beg);
s.Scan;
WHILE (~s.rider.eot) DO
IF (s.type = TextMappers.char) & (s.char = '~') THEN
RETURN
ELSIF (s.type # TextMappers.string) THEN
StdLog.String("Invalid parameter");StdLog.Ln
ELSE
StdLog.Char("'");StdLog.String(s.string + "' is pangram?:> ");
StdLog.Bool(Check(s.string));StdLog.Ln
END;
s.Scan
END
END Do;
 
END BbtPangramChecker.
 

Execute: ^Q BbtPangramChecker.Do "The quick brown fox jumps over the lazy dog"~
^Q BbtPangramChecker.Do "abcdefghijklmnopqrstuvwxyz"~
^Q BbtPangramChecker.Do "A simple text"~

Output:
'The quick brown fox jumps over the lazy dog' is pangram?:>  $TRUE
'abcdefghijklmnopqrstuvwxyz' is pangram?:>  $TRUE
'A simple text' is pangram?:>  $FALSE

D[edit]

ASCII Bitmask version[edit]

bool isPangram(in string text) pure nothrow @safe @nogc {
uint bitset;
 
foreach (immutable c; text) {
if (c >= 'a' && c <= 'z')
bitset |= (1u << (c - 'a'));
else if (c >= 'A' && c <= 'Z')
bitset |= (1u << (c - 'A'));
}
 
return bitset == 0b11_11111111_11111111_11111111;
}
 
void main() {
assert("the quick brown fox jumps over the lazy dog".isPangram);
assert(!"ABCDEFGHIJKLMNOPQSTUVWXYZ".isPangram);
assert(!"ABCDEFGHIJKL.NOPQRSTUVWXYZ".isPangram);
assert("ABC.D.E.FGHI*J/KL-M+NO*PQ R\nSTUVWXYZ".isPangram);
}

Unicode version[edit]

import std.string, std.traits, std.uni;
 
// Do not compile with -g (debug info).
enum Alphabet : dstring {
DE = "abcdefghijklmnopqrstuvwxyzßäöü",
EN = "abcdefghijklmnopqrstuvwxyz",
SV = "abcdefghijklmnopqrstuvwxyzåäö"
}
 
bool isPangram(S)(in S s, dstring alpha = Alphabet.EN)
pure /*nothrow*/ if (isSomeString!S) {
foreach (dchar c; alpha)
if (indexOf(s, c) == -1 && indexOf(s, std.uni.toUpper(c)) == -1)
return false;
return true;
}
 
void main() {
assert(isPangram("the quick brown fox jumps over the lazy dog".dup, Alphabet.EN));
assert(isPangram("Falsches Üben von Xylophonmusik quält jeden größeren Zwerg"d, Alphabet.DE));
assert(isPangram("Yxskaftbud, ge vår wczonmö iqhjälp"w, Alphabet.SV));
}

Delphi[edit]

program PangramChecker;
 
{$APPTYPE CONSOLE}
 
uses StrUtils;
 
function IsPangram(const aString: string): Boolean;
var
c: char;
begin
for c := 'a' to 'z' do
if not ContainsText(aString, c) then
Exit(False);
 
Result := True;
end;
 
begin
Writeln(IsPangram('The quick brown fox jumps over the lazy dog')); // true
Writeln(IsPangram('Not a panagram')); // false
end.

E[edit]

def isPangram(sentence :String) {
return ("abcdefghijklmnopqrstuvwxyz".asSet() &! sentence.toLowerCase().asSet()).size() == 0
}

&! is the “but-not” or set difference operator.

Elixir[edit]

defmodule Pangram do
def checker(str) do
unused = Enum.to_list(?a..?z) -- to_char_list(String.downcase(str))
Enum.empty?(unused)
end
end
 
text = "The quick brown fox jumps over the lazy dog."
IO.puts "#{Pangram.checker(text)}\t#{text}"
text = (Enum.to_list(?A..?Z) -- 'Test') |> to_string
IO.puts "#{Pangram.checker(text)}\t#{text}"
Output:
true    The quick brown fox jumps over the lazy dog.
false   ABCDEFGHIJKLMNOPQRSUVWXYZ

Erlang[edit]

-module(pangram).
-export([is_pangram/1]).
 
is_pangram(String) ->
ordsets:is_subset(lists:seq($a, $z), ordsets:from_list(string:to_lower(String))).

F#[edit]

If the difference between the set of letters in the alphabet and the set of letters in the given string (after conversion to lower case) is the empty set then every letter appears somewhere in the given string:

let isPangram (str: string) = (set['a'..'z'] - set(str.ToLower())).IsEmpty

Factor[edit]

Translation of: E
: pangram? ( str -- ? )
[ "abcdefghijklmnopqrstuvwxyz" ] dip >lower diff length 0 = ;
 
"How razorback-jumping frogs can level six piqued gymnasts!" pangram? .

Forth[edit]

: pangram? ( addr len -- ? )
0 -rot bounds do
i c@ 32 or [char] a -
dup 0 26 within if
1 swap lshift or
else drop then
loop
1 26 lshift 1- = ;
 
s" The five boxing wizards jump quickly." pangram? . \ -1

Fortran[edit]

Works with: Fortran version 90 and later
module pangram
 
implicit none
private
public :: is_pangram
character (*), parameter :: lower_case = 'abcdefghijklmnopqrstuvwxyz'
character (*), parameter :: upper_case = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
contains
 
function to_lower_case (input) result (output)
 
implicit none
character (*), intent (in) :: input
character (len (input)) :: output
integer :: i
integer :: j
 
output = input
do i = 1, len (output)
j = index (upper_case, output (i : i))
if (j /= 0) then
output (i : i) = lower_case (j : j)
end if
end do
 
end function to_lower_case
 
function is_pangram (input) result (output)
 
implicit none
character (*), intent (in) :: input
character (len (input)) :: lower_case_input
logical :: output
integer :: i
 
lower_case_input = to_lower_case (input)
output = .true.
do i = 1, len (lower_case)
if (index (lower_case_input, lower_case (i : i)) == 0) then
output = .false.
exit
end if
end do
 
end function is_pangram
 
end module pangram

Example:

program test
 
use pangram, only: is_pangram
 
implicit none
character (256) :: string
 
string = 'This is a sentence.'
write (*, '(a)') trim (string)
write (*, '(l1)') is_pangram (string)
string = 'The five boxing wizards jumped quickly.'
write (*, '(a)') trim (string)
write (*, '(l1)') is_pangram (string)
 
end program test
Output:
This is a sentence.
F
The five boxing wizards jumped quickly.
T

Go[edit]

package main
 
import "fmt"
 
func main() {
for _, s := range []string{
"The quick brown fox jumps over the lazy dog.",
`Watch "Jeopardy!", Alex Trebek's fun TV quiz game.`,
"Not a pangram.",
} {
if pangram(s) {
fmt.Println("Yes:", s)
} else {
fmt.Println("No: ", s)
}
}
}
 
func pangram(s string) bool {
var rep [26]bool
var count int
for _, c := range s {
if c >= 'a' {
if c > 'z' {
continue
}
c -= 'a'
} else {
if c < 'A' || c > 'Z' {
continue
}
c -= 'A'
}
if !rep[c] {
if count == 25 {
return true
}
rep[c] = true
count++
}
}
return false
}
Output:
Yes: The quick brown fox jumps over the lazy dog.
Yes: Watch "Jeopardy!", Alex Trebek's fun TV quiz game.
No:  Not a pangram.

Haskell[edit]

import Data.Char (toLower)
import Data.List ((\\))
 
pangram :: String -> Bool
pangram = null . (['a' .. 'z'] \\) . map toLower
 
main = print $ pangram "How razorback-jumping frogs can level six piqued gymnasts!"

HicEst[edit]

PangramBrokenAt("This is a Pangram.") ! => 2 (b is missing)
PangramBrokenAt("The quick Brown Fox jumps over the Lazy Dog") ! => 0 (OK)
 
FUNCTION PangramBrokenAt(string)
CHARACTER string, Alfabet="abcdefghijklmnopqrstuvwxyz"
PangramBrokenAt = INDEX(Alfabet, string, 64)
! option 64: verify = 1st letter of string not in Alfabet
END

Icon and Unicon[edit]

A panagram procedure:

procedure panagram(s)     #: return s if s is a panagram and fail otherwise
if (map(s) ** &lcase) === &lcase then return s
end

And a main to drive it:

procedure main(arglist)
 
if *arglist > 0 then
every ( s := "" ) ||:= !arglist || " "
else
s := "The quick brown fox jumps over the lazy dog."
 
writes(image(s), " -- is")
writes(if not panagram(s) then "n't")
write(" a panagram.")
end

Io[edit]

Sequence isPangram := method(
letters := " " repeated(26)
ia := "a" at(0)
foreach(ichar,
if(ichar isLetter,
letters atPut((ichar asLowercase) - ia, ichar)
)
)
letters contains(" " at(0)) not // true only if no " " in letters
)
 
"The quick brown fox jumps over the lazy dog." isPangram println // --> true
"The quick brown fox jumped over the lazy dog." isPangram println // --> false
"ABC.D.E.FGHI*J/KL-M+NO*PQ R\nSTUVWXYZ" isPangram println // --> true

Ioke[edit]

Text isPangram? = method(
letters = "abcdefghijklmnopqrstuvwxyz" chars
text = self lower chars
letters map(x, text include?(x)) reduce(&&)
)

Here is an example of it's use in the Ioke REPL:

 
iik> "The quick brown fox jumps over the lazy dog" isPangram?
"The quick brown fox jumps over the lazy dog" isPangram?
+> true
 
iik> "The quick brown fox jumps over the" isPangram?
"The quick brown fox jumps over the" isPangram?
+> false

J[edit]

Solution:

require 'strings'
isPangram=: (a. {~ 97+i.26) [email protected] tolower

Example use:

   isPangram 'The quick brown fox jumps over the lazy dog.'
1
isPangram 'The quick brown fox falls over the lazy dog.'
0

Java[edit]

Works with: Java version 1.5+
public class Pangram {
public static boolean isPangram(String test){
for (char a = 'A'; a <= 'Z'; a++)
if ((test.indexOf(a) < 0) && (test.indexOf((char)(a + 32)) < 0))
return false;
return true;
}
 
public static void main(String[] args){
System.out.println(isPangram("the quick brown fox jumps over the lazy dog"));//true
System.out.println(isPangram("the quick brown fox jumped over the lazy dog"));//false, no s
System.out.println(isPangram("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));//true
System.out.println(isPangram("ABCDEFGHIJKLMNOPQSTUVWXYZ"));//false, no r
System.out.println(isPangram("ABCDEFGHIJKL.NOPQRSTUVWXYZ"));//false, no m
System.out.println(isPangram("ABC.D.E.FGHI*J/KL-M+NO*PQ R\nSTUVWXYZ"));//true
System.out.println(isPangram(""));//false
}
}
Output:
true
false
true
false
false
true
false

JavaScript[edit]

Iterative[edit]

function isPangram(s) {
var letters = "zqxjkvbpygfwmucldrhsnioate"
// sorted by frequency ascending (http://en.wikipedia.org/wiki/Letter_frequency)
s = s.toLowerCase().replace(/[^a-z]/g,'')
for (var i = 0; i < 26; i++)
if (s.indexOf(letters[i]) < 0) return false
return true
}
 
console.log(isPangram("is this a pangram")) // false
console.log(isPangram("The quick brown fox jumps over the lazy dog")) // true

Functional (ES 5)[edit]

// isPangram :: String -> Bool
function isPangram(s) {
var lc = s.toLowerCase();
 
return 'abcdefghijklmnopqrstuvwxyz'
.split('')
.filter(function (c) {
return lc.indexOf(c) === -1;
})
.length === 0;
}
 
[
'is this a pangram',
'The quick brown fox jumps over the lazy dog'
].map(isPangram);
Output:
[false, true]

jq[edit]

def is_pangram:
explode
| map( if 65 <= . and . <= 90 then . + 32 # uppercase
elif 97 <= . and . <= 122 then . # lowercase
else empty
end )
| unique
| length == 26;
 
# Example:
"The quick brown fox jumps over the lazy dog" | is_pangram
Output:
$ jq -M -n -f pangram.jq
true

Julia[edit]

makepangramchecker creates a function to test for pangramity based upon the contents of its input string, allowing one to create arbitrary pangram checkers.

 
function makepangramchecker{T<:String}(a::T)
abet = sort(unique(split(uppercase(a), "")))
alen = length(abet)
function ispangram{T<:String}(s::T)
alen <= length(s) || return false
ps = filter(c->(c in abet), unique(split(uppercase(s), "")))
return length(ps) == alen
end
end
 
tests = ["Pack my box with five dozen liquor jugs.",
"The quick brown fox jumps over a lazy dog.",
"The quick brown fox jumps\u2323over the lazy dog.",
"The five boxing wizards jump quickly.",
"This sentence contains A-Z but not the whole alphabet."]
 
isenglishpang = makepangramchecker("abcdefghijklmnopqrstuvwxyz")
 
for s in tests
print("The sentence \"", s, "\" is ")
if !isenglishpang(s)
print("not ")
end
println("a pangram.")
end
 
Output:
The sentence "Pack my box with five dozen liquor jugs." is a pangram.
The sentence "The quick brown fox jumps over a lazy dog." is a pangram.
The sentence "The quick brown fox jumps⌣over the lazy dog." is a pangram.
The sentence "The five boxing wizards jump quickly." is a pangram.
The sentence "This sentence contains A-Z but not the whole alphabet." is not a pangram.

K[edit]

lcase   : _ci 97+!26
ucase  : _ci 65+!26
tolower : {@[x;p;:;[email protected]@p:&26>n:ucase?/:x]}
panagram: {&/lcase _lin tolower x}

Example:

  panagram "The quick brown fox jumps over the lazy dog"
1
panagram "Panagram test"
0

Liberty BASIC[edit]

'Returns 0 if the string is NOT a pangram or >0 if it IS a pangram
string$ = "The quick brown fox jumps over the lazy dog."
 
Print isPangram(string$)
 
Function isPangram(string$)
string$ = Lower$(string$)
For i = Asc("a") To Asc("z")
isPangram = Instr(string$, chr$(i))
If isPangram = 0 Then Exit Function
Next i
End Function

[edit]

to remove.all :s :set
if empty? :s [output :set]
if word? :s [output remove.all butfirst :s remove first :s :set]
output remove.all butfirst :s remove.all first :s :set
end
to pangram? :s
output empty? remove.all :s "abcdefghijklmnopqrstuvwxyz
end
 
show pangram? [The five boxing wizards jump quickly.]  ; true

Lua[edit]

require"lpeg"
S, C = lpeg.S, lpeg.C
function ispangram(s)
return #(C(S(s)^0):match"abcdefghijklmnopqrstuvwxyz") == 26
end
 
print(ispangram"waltz, bad nymph, for quick jigs vex")
print(ispangram"bobby")
print(ispangram"long sentence")

Mathematica[edit]

pangramQ[msg_]:=Complement[CharacterRange["a", "z"], Characters[ToLowerCase[msg]]]=== {}

Usage:

pangramQ["The quick brown fox jumps over the lazy dog."]
True

Or a slightly more verbose version that outputs the missing characters if the string is not a pangram:

pangramQ[msg_] := 
Function[If[# === {}, Print["The string is a pangram!"],
Print["The string is not a pangram. It's missing the letters " <>
ToString[#]]]][
Complement[CharacterRange["a", "z"], Characters[ToLowerCase[msg]]]]

Usage:

pangramQ["The quick brown fox jumps over the lazy dog."]
The string is a pangram!
pangramQ["Not a pangram"]
The string is not a pangram. It's missing the letters {b, c, d, e, f, h, i, j, k, l, q, s, u, v, w, x, y, z}

MATLAB[edit]

function trueFalse = isPangram(string)
 
%This works by histogramming the ascii character codes for lower case
%letters contained in the string (which is first converted to all
%lower case letters). Then it finds the index of the first letter that
%is not contained in the string (this is faster than using the find
%without the second parameter). If the find returns an empty array then
%the original string is a pangram, if not then it isn't.
 
trueFalse = isempty(find( histc(lower(string),(97:122))==0,1 ));
 
end
Output:
isPangram('The quick brown fox jumps over the lazy dog.')
 
ans =
 
1

NetRexx[edit]

NetRexx's verify built–in method is all you need!

/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
 
A2Z = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
pangrams = create_samples
 
loop p_ = 1 to pangrams[0]
pangram = pangrams[p_]
q_ = A2Z.verify(pangram.upper) -- <= it basically all happens in this function call!
say pangram.left(64)'\-'
if q_ == 0 then -
say ' [OK, a pangram]'
else -
say ' [Not a pangram. Missing:' A2Z.substr(q_, 1)']'
end p_
 
method create_samples public static returns Rexx
 
pangrams = ''
 
x_ = 0
x_ = x_ + 1; pangrams[0] = x_; pangrams[x_] = 'The quick brown fox jumps over a lazy dog.' -- best/shortest pangram
x_ = x_ + 1; pangrams[0] = x_; pangrams[x_] = 'The quick brown fox jumps over the lazy dog.' -- not as short but at least it's still a pangram
x_ = x_ + 1; pangrams[0] = x_; pangrams[x_] = 'The quick brown fox jumped over the lazy dog.' -- common misquote; not a pangram
x_ = x_ + 1; pangrams[0] = x_; pangrams[x_] = 'The quick onyx goblin jumps over the lazy dwarf.'
x_ = x_ + 1; pangrams[0] = x_; pangrams[x_] = 'Bored? Craving a pub quiz fix? Why, just come to the Royal Oak!' -- (Used to advertise a pub quiz in Bowness-on-Windermere)
 
return pangrams
 
Output:
The quick brown fox jumps over a lazy dog.                       [OK, a pangram]
The quick brown fox jumps over the lazy dog.                     [OK, a pangram]
The quick brown fox jumped over the lazy dog.                    [Not a pangram.  Missing: S]
The quick onyx goblin jumps over the lazy dwarf.                 [OK, a pangram]
Bored? Craving a pub quiz fix? Why, just come to the Royal Oak!  [OK, a pangram]

NewLISP[edit]

 
(context 'PGR)
(define (is-pangram? str) ;; Poorly optimized
(setf chars (explode (upper-case str)))
(setf is-pangram-status true)
(for (c (char "A") (char "Z") )
(if (not (find (char c) chars))
(setf is-pangram-status nil)
)
)
is-pangram-status
)
(context 'MAIN)
(println (PGR:is-pangram? "abcdefghijklmnopqrstuvwxyz")) ;; Return true
(println (PGR:is-pangram? "abcdef")) ;; Return nil
(exit)
 


Nim[edit]

import rdstdin
 
proc isPangram(sentence; alphabet = {'a'..'z'}): bool =
var sentset: set[char] = {}
for c in sentence: sentset.incl c
alphabet <= sentset
 
echo isPangram(readLineFromStdin "Sentence: ")

Example usage:

Sentence: The quick brown fox jumps over the lazy dog
true

Objeck[edit]

Translation of: Java
 
bundle Default {
class Pangram {
function : native : IsPangram(test : String) ~ Bool {
for(a := 'A'; a <= 'Z'; a += 1;) {
if(test->Find(a) < 0 & test->Find(a->ToLower()) < 0) {
return false;
};
};
 
return true;
}
 
function : Main(args : String[]) ~ Nil {
IsPangram("the quick brown fox jumps over the lazy dog")->PrintLine(); # true
IsPangram("the quick brown fox jumped over the lazy dog")->PrintLine(); # false, no s
IsPangram("ABCDEFGHIJKLMNOPQRSTUVWXYZ")->PrintLine(); # true
IsPangram("ABCDEFGHIJKLMNOPQSTUVWXYZ")->PrintLine(); # false, no r
IsPangram("ABCDEFGHIJKL.NOPQRSTUVWXYZ")->PrintLine(); # false, no m
IsPangram("ABC.D.E.FGHI*J/KL-M+NO*PQ R\nSTUVWXYZ")->PrintLine(); # true
IsPangram("")->PrintLine(); # false
}
}
}
 

OCaml[edit]

let pangram str =
let ar = Array.make 26 false in
String.iter (function
| 'a'..'z' as c -> ar.(Char.code c - Char.code 'a') <- true
| _ -> ()
) (String.lowercase str);
Array.fold_left ( && ) true ar
let check str =
Printf.printf " %b -- %s\n" (pangram str) str
 
let () =
check "this is a sentence";
check "The quick brown fox jumps over the lazy dog.";
;;
Output:
false -- this is a sentence
true -- The quick brown fox jumps over the lazy dog.

MATLAB / Octave[edit]

function trueFalse = isPangram(string)
% X is a histogram of letters
X = sparse(abs(lower(string)),1,1,128,1);
trueFalse = full(all(X('a':'z') > 0));
end
Output:
>>isPangram('The quick brown fox jumps over the lazy dog.')
ans = 1

ML[edit]

mLite[edit]

fun to_locase s = implode ` map (c_downcase) ` explode s
 
fun is_pangram
(h :: t, T) =
let
val flen = len (filter (fn c = c eql h) T)
in
if (flen = 0) then
false
else
is_pangram (t, T)
end
| ([], T) = true
| S = is_pangram (explode "abcdefghijklmnopqrstuvwxyz", explode ` to_locase S)
 
fun is_pangram_i
(h :: t, T) =
let
val flen = len (filter (fn c = c eql h) T)
in
if (flen = 0) then
false
else
is_pangram (t, T)
end
| ([], T) = true
| (A,S) = is_pangram (explode A, explode ` to_locase S)
 
fun test (f, arg, res, ok, notok) = if (f arg eql res) then ("'" @ arg @ "' " @ ok) else ("'" @ arg @ "' " @ notok)
fun test2 (f, arg, res, ok, notok) = if (f arg eql res) then ("'" @ ref (arg,1) @ "' " @ ok) else ("'" @ ref (arg,1) @ "' " @ notok)
 
;
println ` test (is_pangram, "The quick brown fox jumps over the lazy dog", true, "is a pangram", "is not a pangram");
println ` test (is_pangram, "abcdefghijklopqrstuvwxyz", true, "is a pangram", "is not a pangram");
val SValphabet = "abcdefghijklmnopqrstuvwxyzåäö";
val SVsentence = "Yxskaftbud, ge vår wczonmö iq hjälp";
println ` test2 (is_pangram_i, (SValphabet, SVsentence), true, "is a Swedish pangram", "is not a Swedish pangram");
 
Output:
'The quick brown fox jumps over the lazy dog' is a pangram
'abcdefghijklopqrstuvwxyz' is not a pangram
'Yxskaftbud, ge vår wczonmö iq hjälp' is a Swedish pangram


Oz[edit]

declare
fun {IsPangram Xs}
{List.sub
{List.number &a &z 1}
{Sort {Map Xs Char.toLower} Value.'<'}}
end
in
{Show {IsPangram "The quick brown fox jumps over the lazy dog."}}

PARI/GP[edit]

pangram(s)={
s=vecsort(Vec(s),,8);
for(i=97,122,
if(!setsearch(s,Strchr(i)) && !setsearch(s,Strchr(i-32)),
return(0)
)
);
1
};
 
pangram("The quick brown fox jumps over the lazy dog.")
pangram("The quick brown fox jumps over the lazy doe.")

Pascal[edit]

See Delphi

Perl[edit]

use List::MoreUtils 'all';
 
sub pangram {all {$_[0] =~ /$_/i} 'a' .. 'z';}
 
print "Yes.\n" if pangram 'Cozy lummox gives smart squid who asks for job pen.';

Perl 6[edit]

constant Eng = set 'a' .. 'z';
constant Cyr = set <а б в г д е ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я ё>;
constant Hex = set 'a' .. 'f';
 
sub pangram($str, Set $alpha = Eng) {
$alpha$str.lc.comb;
}
 
say pangram("The quick brown fox jumps over the lazy dog.");
say pangram("My dog has fleas.");
say pangram("My dog has fleas.", Hex);
say pangram("My dog backs fleas.", Hex);
say pangram "Съешь же ещё этих мягких французских булок, да выпей чаю", Cyr;
Output:
True
False
False
True
True

PicoLisp[edit]

(de isPangram (Str)
(not
(diff
'`(chop "abcdefghijklmnopqrstuvwxyz")
(chop (lowc Str)) ) ) )

PHP[edit]

Translation of: D
function isPangram($text) {
foreach (str_split($text) as $c) {
if ($c >= 'a' && $c <= 'z')
$bitset |= (1 << (ord($c) - ord('a')));
else if ($c >= 'A' && $c <= 'Z')
$bitset |= (1 << (ord($c) - ord('A')));
}
return $bitset == 0x3ffffff;
}
 
$test = array(
"the quick brown fox jumps over the lazy dog",
"the quick brown fox jumped over the lazy dog",
"ABCDEFGHIJKLMNOPQSTUVWXYZ",
"ABCDEFGHIJKL.NOPQRSTUVWXYZ",
"ABC.D.E.FGHI*J/KL-M+NO*PQ R\nSTUVWXYZ"
);
 
foreach ($test as $str)
echo "$str : ", isPangram($str) ? 'T' : 'F', '</br>';
the quick brown fox jumps over the lazy dog : T
the quick brown fox jumped over the lazy dog : F
ABCDEFGHIJKLMNOPQSTUVWXYZ : F
ABCDEFGHIJKL.NOPQRSTUVWXYZ : F
ABC.D.E.FGHI*J/KL-M+NO*PQ R STUVWXYZ : T

PL/I[edit]

 
test_pangram: procedure options (main);
 
is_pangram: procedure() returns (bit(1) aligned);
 
declare text character (200) varying;
declare c character (1);
 
get edit (text) (L);
put skip list (text);
 
text = lowercase(text);
 
do c = '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';
if index(text, c) = 0 then return ('0'b);
end;
return ('1'b);
end is_pangram;
 
put skip list ('Please type a sentence');
 
if is_pangram() then
put skip list ('The sentence is a pangram.');
else
put skip list ('The sentence is not a pangram.');
 
end test_pangram;
 
Output:
Please type a sentence 

the quick brown fox jumps over the lazy dog
The sentence is a pangram. 

PowerShell[edit]

Cyrillic test sample borrowed from Perl 6.

Works with: PowerShell version 4
 
function Test-Pangram ( [string]$Text, [string]$Alphabet = 'abcdefghijklmnopqrstuvwxyz' )
{
$Text = $Text.ToLower()
$Alphabet = $Alphabet.ToLower()
 
$IsPangram = $Alphabet.ToCharArray().Where{ $Text.Contains( $_ ) }.Count -eq $Alphabet.Length
 
return $IsPangram
}
 
Test-Pangram 'The quick brown fox jumped over the lazy dog.'
Test-Pangram 'The quick brown fox jumps over the lazy dog.'
Test-Pangram 'Съешь же ещё этих мягких французских булок, да выпей чаю' 'абвгдежзийклмнопрстуфхцчшщъыьэюяё'
 
Output:
False
True
True
Works with: PowerShell version 2
 
function Test-Pangram ( [string]$Text, [string]$Alphabet = 'abcdefghijklmnopqrstuvwxyz' )
{
$Text = $Text.ToLower()
$Alphabet = $Alphabet.ToLower()
 
$IsPangram = ( $Alphabet.ToCharArray() | Where { $Text.Contains( $_ ) } ).Count -eq $Alphabet.Length
 
return $IsPangram
}
 
Test-Pangram 'The quick brown fox jumped over the lazy dog.'
Test-Pangram 'The quick brown fox jumps over the lazy dog.'
Test-Pangram 'Съешь же ещё этих мягких французских булок, да выпей чаю' 'абвгдежзийклмнопрстуфхцчшщъыьэюяё'
 
Output:
False
True
True

Prolog[edit]

Works with SWI-Prolog

pangram(L) :-
numlist(0'a, 0'z, Alphabet),
forall(member(C, Alphabet), member(C, L)).
 
pangram_example :-
L1 = "the quick brown fox jumps over the lazy dog",
( pangram(L1) -> R1= ok; R1 = ko),
format('~s --> ~w ~n', [L1,R1]),
 
L2 = "the quick brown fox jumped over the lazy dog",
( pangram(L2) -> R2 = ok; R2 = ko),
format('~s --> ~w ~n', [L2, R2]).
 
Output:
?- pangram_example.
the quick brown fox jumps over the lazy dog --> ok 
the quick brown fox jumped over the lazy dog --> ko 
true.

PureBasic[edit]

Procedure IsPangram_fast(String$)
String$ = LCase(string$)
char_a=Asc("a")
; sets bits in a variable if a letter is found, reads string only once
For a = 1 To Len(string$)
char$ = Mid(String$, a, 1)
pos = Asc(char$) - char_a
check.l | 1 << pos
Next
If check & $3FFFFFF = $3FFFFFF
ProcedureReturn 1
EndIf
ProcedureReturn 0
EndProcedure
 
Procedure IsPangram_simple(String$)
String$ = LCase(string$)
found = 1
For a = Asc("a") To Asc("z")
; searches for every letter in whole string
If FindString(String$, Chr(a), 0) = 0
found = 0
EndIf
Next
ProcedureReturn found
EndProcedure
 
Debug IsPangram_fast("The quick brown fox jumps over lazy dogs.")
Debug IsPangram_simple("The quick brown fox jumps over lazy dogs.")
Debug IsPangram_fast("No pangram")
Debug IsPangram_simple("No pangram")

Python[edit]

Using set arithmetic:

import string, sys
if sys.version_info[0] < 3:
input = raw_input
 
def ispangram(sentence, alphabet=string.ascii_lowercase):
alphaset = set(alphabet)
return alphaset <= set(sentence.lower())
 
print ( ispangram(input('Sentence: ')) )
Output:
Sentence: The quick brown fox jumps over the lazy dog
True

R[edit]

Using the built-in R vector "letters":

checkPangram <- function(sentence){
my.letters <- tolower(unlist(strsplit(sentence, "")))
is.pangram <- all(letters %in% my.letters)
 
if (is.pangram){
cat("\"", sentence, "\" is a pangram! \n", sep="")
} else {
cat("\"", sentence, "\" is not a pangram! \n", sep="")
}
}
 
Output:
s1 <- "The quick brown fox jumps over the lazy dog"
s2 <- "The quick brown fox jumps over the sluggish dog"
checkPangram(s1)
"The quick brown fox jumps over the lazy dog" is a pangram!
checkPangram(s2)
"The quick brown fox jumps over the sluggish dog" is not a pangram!

Racket[edit]

 
#lang racket
(define (pangram? str)
(define chars (regexp-replace* #rx"[^a-z]+" (string-downcase str) ""))
(= 26 (length (remove-duplicates (string->list chars)))))
(pangram? "The quick Brown Fox jumps over the Lazy Dog")
 

Retro[edit]

: isPangram? ( $-f )
^strings'toLower
heap [ 27 allot ] preserve
[ @ 'a - dup 0 25 within [ [ 'a + ] [ here + ] bi ! ] &drop if ]
^types'STRING each@ here "abcdefghijklmnopqrstuvwxyz" compare ;

REXX[edit]

/*REXX program  verifies  if an  entered/supplied  string  (sentence)  is a pangram.    */
@abc= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' /*a list of all (Latin) capital letters*/
 
do forever; say /*keep promoting 'til null (or blanks).*/
say '──────── Please enter a pangramic sentence (or a blank to quit):'; say
pull y /*this also uppercases the Y variable.*/
if y='' then leave /*if nothing entered, then we're done.*/
 ?=verify(@abc, y) /*Are all the (Latin) letters present? */
if ?==0 then say '──────── Sentence is a pangram.'
else say "──────── Sentence isn't a pangram, missing:" substr(@abc, ?, 1)
say
end /*forever*/
 
say '──────── PANGRAM program ended. ────────' /*stick a fork in it, we're all done. */

output

──────── Please enter a pangramic sentence   (or a blank to quit):

The quick brown fox jumped over the lazy dog.      ◄■■■■■■■■■■ user input.
──────── Sentence isn't a pangram, missing: S


──────── Please enter a pangramic sentence   (or a blank to quit):

The quick brown fox JUMPS over the lazy dog!!!     ◄■■■■■■■■■■ user input.
──────── Sentence is a pangram.


──────── Please enter a pangramic sentence   (or a blank to quit):
                                                   ◄■■■■■■■■■■ user input   (null  or  some blanks). 

──────── PANGRAM program ended. ────────

Ring[edit]

 
pangram = 0
s = "The quick brown fox jumps over the lazy dog."
see "" + pangram(s) + " " + s + nl
 
s = "My dog has fleas."
see "" + pangram(s) + " " + s + nl
 
func pangram str
str = lower(str)
for i = ascii("a") to ascii("z")
bool = substr(str, char(i)) > 0
pangram = pangram + bool
next
pan = (pangram = 26)
return pan
 

Ruby[edit]

def pangram?(sentence)
unused_letters = ('a'..'z').to_a - sentence.downcase.chars.to_a
unused_letters.empty?
end
 
p pangram?('this is a sentence') # ==> false
p pangram?('The quick brown fox jumps over the lazy dog.') # ==> true

Run BASIC[edit]

s$ = "The quick brown fox jumps over the lazy dog."
Print pangram(s$);" ";s$
 
s$ = "My dog has fleas."
Print pangram(s$);" ";s$
 
function pangram(str$)
str$ = lower$(str$)
for i = asc("a") to asc("z")
pangram = pangram + (instr(str$, chr$(i)) <> 0)
next i
pangram = (pangram = 26)
end function
1 The quick brown fox jumps over the lazy dog.
0 My dog has fleas.

Scala[edit]

def is_pangram(sentence: String) = sentence.toLowerCase.filter(c => c >= 'a' && c <= 'z').toSet.size == 26
 
 
scala> is_pangram("This is a sentence")
res0: Boolean = false
 
scala> is_pangram("The quick brown fox jumps over the lazy dog")
res1: Boolean = true
 

Seed7[edit]

$ include "seed7_05.s7i";
 
const func boolean: isPangram (in string: stri) is func
result
var boolean: isPangram is FALSE;
local
var char: ch is ' ';
var set of char: usedChars is (set of char).value;
begin
for ch range lower(stri) do
if ch in {'a' .. 'z'} then
incl(usedChars, ch);
end if;
end for;
isPangram := usedChars = {'a' .. 'z'};
end func;
 
const proc: main is func
begin
writeln(isPangram("This is a test"));
writeln(isPangram("The quick brown fox jumps over the lazy dog"));
writeln(isPangram("NOPQRSTUVWXYZ abcdefghijklm"));
writeln(isPangram("abcdefghijklopqrstuvwxyz")); # Missing m, n
end func;
Output:
FALSE
TRUE
TRUE
FALSE

Sidef[edit]

Translation of: Perl 6
define Eng = 'a'..'z';
define Hex = 'a'..'f';
define Cyr = %w(а б в г д е ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я ё);
 
func pangram(str, alpha=Eng) {
var lstr = str.lc;
alpha.all {|c| lstr.contains(c) };
}
 
say pangram("The quick brown fox jumps over the lazy dog.");
say pangram("My dog has fleas.");
say pangram("My dog has fleas.", Hex);
say pangram("My dog backs fleas.", Hex);
say pangram("Съешь же ещё этих мягких французских булок, да выпей чаю", Cyr);
Output:
true
false
false
true
true

Smalltalk[edit]

!String methodsFor: 'testing'!
isPangram
^((self collect: [:c | c asUppercase]) select: [:c | c >= $A and: [c <= $Z]]) asSet size = 26
 
 
'The quick brown fox jumps over the lazy dog.' isPangram
 

SNOBOL4[edit]

Works with: Macro Spitbol
Works with: Snobol4+
Works with: CSnobol
        define('pangram(str)alfa,c') :(pangram_end)
pangram str = replace(str,&ucase,&lcase)
alfa = &lcase
pgr_1 alfa len(1) . c = :f(return)
str c :s(pgr_1)f(freturn)
pangram_end
 
define('panchk(str)tf') :(panchk_end)
panchk output = str
tf = 'False'; tf = pangram(str) 'True'
output = 'Pangram: ' tf :(return)
panchk_end
 
* # Test and display
panchk("The quick brown fox jumped over the lazy dogs.")
panchk("My girl wove six dozen plaid jackets before she quit.")
panchk("This 41-character string: it's a pangram!")
end
Output:
The quick brown fox jumped over the lazy dogs.
Pangram: True
My girl wove six dozen plaid jackets before she quit.
Pangram: True
This 41-character string: it's a pangram!
Pangram: False

Swift[edit]

import Foundation
 
let str = "the quick brown fox jumps over the lazy dog"
 
func isPangram(str:String) -> Bool {
let stringArray = Array(str.lowercaseString)
for char in "abcdefghijklmnopqrstuvwxyz" {
if (find(stringArray, char) == nil) {
return false
}
}
return true
}
 
isPangram(str) // True
isPangram("Test string") // False

Swift 2.0:

func isPangram(str: String) -> Bool {
let (char, alph) = (Set(str.characters), "abcdefghijklmnopqrstuvwxyz".characters)
return !alph.contains {!char.contains($0)}
}

Tcl[edit]

proc pangram? {sentence} {
set letters [regexp -all -inline {[a-z]} [string tolower $sentence]]
expr {
[llength [lsort -unique $letters]] == 26
}
}
puts [pangram? "This is a sentence"]; # ==> false
puts [pangram? "The quick brown fox jumps over the lazy dog."]; # ==> true

TI-83 BASIC[edit]

:Prompt Str1
:For(L,1,26
:If not(inString(Str1,sub("ABCDEFGHIJKLMNOPQRSTUVWXYZ",L,1))
:L=28
:End
:If L<28
:Disp "IS A PANGRAM"

(not tested yet)

TUSCRIPT[edit]

 
$$ MODE TUSCRIPT,{}
alfabet="abcdefghijklmnopqrstuvwxyz"
sentences = *
DATA The quick brown fox jumps over the lazy dog
DATA the quick brown fox falls over the lazy dog
LOOP s=sentences
getchars =STRINGS (s," {&a} ")
sortchars =ALPHA_SORT (getchars)
reducechars =REDUCE (sortchars)
chars_in_s =EXCHANGE (reducechars," ' ")
IF (chars_in_s==alfabet) PRINT " pangram: ",s
IF (chars_in_s!=alfabet) PRINT "no pangram: ",s
ENDLOOP
 
Output:
   pangram: The quick brown fox jumps over the lazy dog
no pangram: the quick brown fox falls over the lazy dog

TXR[edit]

@/.*[Aa].*&.*[Bb].*&.*[Cc].*&.*[Dd].*& \
.*[Ee].*&.*[Ff].*&.*[Gg].*&.*[Hh].*& \
.*[Ii].*&.*[Jj].*&.*[Kk].*&.*[Ll].*& \
.*[Mm].*&.*[Nn].*&.*[Oo].*&.*[Pp].*& \
.*[Qq].*&.*[Rr].*&.*[Ss].*&.*[Tt].*& \
.*[Uu].*&.*[Vv].*&.*[Ww].*&.*[Xx].*& \
.*[Yy].*&.*[Zz].*/
Run:
$ echo "The quick brown fox jumped over the lazy dog." | txr is-pangram.txr -
$echo $? # failed termination
1
$ echo "The quick brown fox jumped over the lazy dogs." | txr is-pangram.txr -
$ echo $?   # successful termination
0

UNIX Shell[edit]

Works with: Bourne Again SHell
function pangram? {
local alphabet=abcdefghijklmnopqrstuvwxyz
local string="$*"
string="${string,,}"
while [[ -n "$string" && -n "$alphabet" ]]; do
local ch="${string%%${string#?}}"
string="${string#?}"
alphabet="${alphabet/$ch}"
done
[[ -z "$alphabet" ]]
}

Ursala[edit]

 
#import std
 
is_pangram = ^jZ^([email protected],*+ @rlp -:~&) ~=`A-~ letters
 

example usage:

 
#cast %bL
 
test =
 
is_pangram* <
'The quick brown fox jumps over the lazy dog',
'this is not a pangram'>
 
Output:
<true,false>

VBA[edit]

The function pangram() in the VBScript section below will do just fine.

Here is an alternative version:

 
Function pangram2(s As String) As Boolean
Const sKey As String = "abcdefghijklmnopqrstuvwxyz"
Dim sLow As String
Dim i As Integer
 
sLow = LCase(s)
For i = 1 To 26
If InStr(sLow, Mid(sKey, i, 1)) = 0 Then
pangram2 = False
Exit Function
End If
Next
pangram2 = True
End Function
 

Invocation e.g. (typed in the Immediate window):

print pangram2("the quick brown dog jumps over a lazy fox")
print pangram2("it is time to say goodbye!")

VBScript[edit]

Implementation[edit]

function pangram( s )
dim i
dim sKey
dim sChar
dim nOffset
sKey = "abcdefghijklmnopqrstuvwxyz"
for i = 1 to len( s )
sChar = lcase(mid(s,i,1))
if sChar <> " " then
if instr(sKey, sChar) then
nOffset = asc( sChar ) - asc("a") + 1
if nOffset > 1 then
sKey = left(sKey, nOffset - 1) & " " & mid( sKey, nOffset + 1)
else
sKey = " " & mid( sKey, nOffset + 1)
end if
end if
end if
next
pangram = ( ltrim(sKey) = vbnullstring )
end function
 
function eef( bCond, exp1, exp2 )
if bCond then
eef = exp1
else
eef = exp2
end if
end function

Invocation[edit]

wscript.echo eef(pangram("a quick brown fox jumps over the lazy dog"), "is a pangram", "is not a pangram")
wscript.echo eef(pangram(""), "is a pangram", "is not a pangram")"

XPL0[edit]

include c:\cxpl\codes;          \intrinsic 'code' declarations
string 0; \use zero-terminated strings
 
func StrLen(Str); \Return number of characters in an ASCIIZ string
char Str;
int I;
for I:= 0 to -1>>1-1 do
if Str(I) = 0 then return I;
 
func Pangram(S);
char S;
int A, I, C;
[A:= 0;
for I:= 0 to StrLen(S)-1 do
[C:= S(I);
if C>=^A & C<=^Z then C:= C or $20;
if C>=^a & C<=^z then [C:= C - ^a; A:= A or 1<<C];
];
return A = $3FFFFFF;
]; \Pangram
 
int Sentence, I;
[Sentence:=
["The quick brown fox jumps over the lazy dog.",
"Pack my box with five dozen liquor jugs.",
"Now is the time for all good men to come to the aid of their country."];
for I:= 0 to 3-1 do
[Text(0, if Pangram(Sentence(I)) then "yes" else "no");
CrLf(0);
];
]
Output:
yes
yes
no

zkl[edit]

var letters=["a".."z"].pump(String); //-->"abcdefghijklmnopqrstuvwxyz"
fcn isPangram(text){(not (letters-text.toLower()))}
Output:
isPangram("The quick brown fox jumps over the lazy dog.")
True
isPangram("Pack my box with five dozen liquor jugs.")
True
isPangram("Now is the time for all good men to come to the aid of their country.")
False