Pangram checker

From Rosetta Code
Revision as of 19:08, 25 October 2015 by Trizen (talk | contribs) (→‎{{header|Sidef}}: minor code simplification)
Task
Pangram checker
You are encouraged to solve this task according to the task description, using any language you may know.

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

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.

360 Assembly

<lang 360asm>* 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</lang>
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

<lang Lisp>(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)))</lang>

ActionScript

Works with: ActionScript version 2.0

<lang ActionScript>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;

}</lang>

Ada

Using Sets <lang Ada> 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; </lang>

Output:
FALSE
TRUE
TRUE
FALSE

ALGOL 68

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)

<lang algol68># 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;
  1. 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

)</lang>

Output:
"Big fjiords vex quick waltz nymph" is a pangram!
"The quick brown fox jumps over a lazy dog" is a pangram!

APL

<lang apl> 

   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 </lang>

AutoHotkey

<lang autohotkey>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</lang>

AutoIt

<lang autoit> 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 </lang>

AWK

Solution using string-operations

<lang AWK>#!/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;

}</lang>

Output:
1
0

Solution using associative arrays and split

Works with: gawk version 4.1.0
Works with: mawk version 1.3.3

<lang AWK># usage: awk -f pangram.awk -v p="The five boxing wizards dump quickly." input.txt

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

}</lang>

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

Works with: QBasic

<lang 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</lang>

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

<lang dos>@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</lang>

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

<lang bbcbasic> 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$</lang>
Output:
"The quick brown fox jumped over the lazy dog" is not a pangram
"The five boxing wizards jump quickly" is a pangram

Bracmat

<lang bracmat>(isPangram= 

 k

. low$!arg:?arg 

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

);</lang> 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

<lang brat>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</lang>

Alternative version:

<lang brat>pangram? = { sentence | 

 sentence.downcase.dice.unique.select(:alpha?).length == 26

}</lang>

C

<lang C>#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; }</lang>

Using bitmask

<lang c>#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; }</lang>

Output:
yes: The quick brown fox jumps over lazy dogs.
no : The five boxing wizards dump quickly.

C#

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

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

}</lang>

Any version of C# language and .NET Framework

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

}</lang>

C++

<lang cpp>#include <algorithm>

  1. include <cctype>
  2. include <string>

using namespace std;

const string alphabet("abcdefghijklmnopqrstuvwxyz"); // sorted, no duplicates

bool is_pangram(string s) { 

 // Convert to lower case.
 transform(s.begin(), s.end(), s.begin(), ::tolower);
 // Convert to a sorted sequence of (not necessarily unique) characters.
 sort(s.begin(), s.end());
 // Is the second sequence a subset of the first sequence?
 // Repeated letters in "s" are okay, since it still "includes" the single letter
 return includes(s.begin(), s.end(), alphabet.begin(), alphabet.end());

}</lang>

Clojure

<lang lisp>(defn pangram? [s] 

 (let [letters (into #{} "abcdefghijklmnopqrstuvwxyz")]
   (= (->> s .toLowerCase (filter letters) (into #{})) letters)))</lang>

CoffeeScript

<lang coffeescript> 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}"

</lang>


Common Lisp

<lang lisp>(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))))</lang>

Component Pascal

BlackBox Component Builder <lang oberon2> 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. </lang> 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

ASCII Bitmask version

<lang d>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);

}</lang>

Unicode version

<lang d>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));

}</lang>

Delphi

<lang Delphi>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.</lang>

E

<lang e>def isPangram(sentence :String) { 

   return ("abcdefghijklmnopqrstuvwxyz".asSet() &! sentence.toLowerCase().asSet()).size() == 0

}</lang>

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

Elixir

<lang elixir>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}"</lang>

Output:
true    The quick brown fox jumps over the lazy dog.
false   ABCDEFGHIJKLMNOPQRSUVWXYZ

Erlang

<lang Erlang>-module(pangram). -export([is_pangram/1]).

is_pangram(String) -> 

 ordsets:is_subset(lists:seq($a, $z), ordsets:from_list(string:to_lower(String))).</lang>

F#

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: <lang fsharp>let isPangram (str: string) = (set['a'..'z'] - set(str.ToLower())).IsEmpty</lang>

Factor

Translation of: E

<lang factor>: pangram? ( str -- ? ) 

   [ "abcdefghijklmnopqrstuvwxyz" ] dip >lower diff length 0 = ;

"How razorback-jumping frogs can level six piqued gymnasts!" pangram? .</lang>

Forth

<lang forth>: 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</lang>

Fortran

Works with: Fortran version 90 and later

<lang fortran>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</lang> Example: <lang fortran>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</lang>

Output:
This is a sentence.
F
The five boxing wizards jumped quickly.
T

Go

<lang go>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

}</lang>

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

<lang haskell>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!"</lang>

HicEst

<lang HicEst>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</lang>

Icon and Unicon

A panagram procedure: <lang Icon>procedure panagram(s) #: return s if s is a panagram and fail otherwise if (map(s) ** &lcase) === &lcase then return s end</lang>

And a main to drive it: <lang Icon>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</lang>

Ioke

<lang ioke>Text isPangram? = method( 

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

)</lang>

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

<lang ioke> 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</lang>

J

Solution: <lang j>require 'strings' isPangram=: (a. {~ 97+i.26) */@e. tolower</lang>

Example use: <lang j> isPangram 'The quick brown fox jumps over the lazy dog.' 1 

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

0</lang>

Java

Works with: Java version 1.5+

<lang java5>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
   }

}</lang>

Output:
true
false
true
false
false
true
false

JavaScript

Translation of: Java

<lang javascript>function is_pangram(str) { 

   var s = str.toLowerCase();
   // sorted by frequency ascending (http://en.wikipedia.org/wiki/Letter_frequency)
   var letters = "zqxjkvbpygfwmucldrhsnioate";
   for (var i = 0; i < 26; i++)
       if (s.indexOf(letters.charAt(i)) == -1)
           return false;
   return true;

}

print(is_pangram("is this a pangram")); // false print(is_pangram("The quick brown fox jumps over the lazy dog")); // true</lang>


Works with: underscorejs version 1.8.2+

<lang javascript> var _ = require("underscore");

// Curried mixin function // Utility Methods _.mixin({ 

 checkAToZ: function(s) {
   return function(letter) {
     if (s.indexOf(letter) != -1) { return true};
   }
 }

});

_.mixin({ 

 toLower: function(str) {
     return str.toLowerCase();
 }

});

_.mixin({ 

 isPangram: function(lstr) {
   var letters = "zqxjkvbpygfwmucldrhsnioate".split();
   return _.every(letters, _.checkAToZ(lstr));
 }

});


var panGramStr = "The quick brown fox jumps over the lazy dog"; var IsPanGram = function(panGramStr) { 

   return _.chain(panGramStr).toLower().isPangram().value();

};

console.log("Result IsPanGram - \"", panGramStr,"\" - " , IsPanGram.call(this,panGramStr)); console.log("Result IsPanGram - \"", "the World","\" - ", IsPanGram.call(this, "the World"));

// Result IsPanGram - " The quick brown fox jumps over the lazy dog " - true // Result IsPanGram - " the World " - false </lang>

jq

<lang jq>def is_pangram: 

 explode
 | map( if 65 <= . and . <= 90 then . + 32 # uppercase
        elif 97 <= . and . <= 122 then .   # lowercase
        else empty
        end )
 | unique
 | length == 26;
  1. Example:

"The quick brown fox jumps over the lazy dog" | is_pangram</lang>

Output:
$ jq -M -n -f pangram.jq
true

Julia

makepangramchecker creates a function to test for pangramity based upon the contents of its input string, allowing one to create arbitrary pangram checkers. <lang Julia> 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 </lang>

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

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

Example: <lang k> panagram "The quick brown fox jumps over the lazy dog" 1 

 panagram "Panagram test"

0</lang>

Liberty BASIC

<lang lb>'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</lang>

<lang logo>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</lang>

Lua

<lang lua>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")</lang>

Mathematica

<lang Mathematica>pangramQ[msg_]:=Complement[CharacterRange["a", "z"], Characters[ToLowerCase[msg]]]=== {}</lang> 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: <lang Mathematica>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]]]]</lang>

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

<lang MATLAB>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</lang>

Output:

<lang MATLAB>isPangram('The quick brown fox jumps over the lazy dog.')

ans = 

    1</lang>

NetRexx

NetRexx's verify built–in method is all you need! <lang NetRexx>/* 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

</lang>

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]

Nim

<lang nim>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: ")</lang> Example usage: 

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

Objeck

Translation of: Java

<lang objeck> 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
   }
 }

} </lang>

OCaml

<lang ocaml>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</lang>

<lang ocaml>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.";
</lang>
Output:
false -- this is a sentence
true -- The quick brown fox jumps over the lazy dog.

MATLAB / Octave

<lang matlab>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</lang>

Output:
>>isPangram('The quick brown fox jumps over the lazy dog.')
ans = 1

ML

mLite

<lang ocaml>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"); </lang>

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

<lang oz>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."}}</lang>

PARI/GP

<lang parigp>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.")</lang>

Pascal

See Delphi

Perl

<lang perl>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.';</lang>

Perl 6

<lang perl6>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;</lang>

Output:
True
False
False
True
True

PicoLisp

<lang PicoLisp>(de isPangram (Str) 

  (not
     (diff
        '`(chop "abcdefghijklmnopqrstuvwxyz")
        (chop (lowc Str)) ) ) )</lang>

PHP

Translation of: D

<lang php>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', '
';</lang>

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

<lang PL/I> 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; </lang>

Output:
Please type a sentence 

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

Prolog

Works with SWI-Prolog

<lang 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]). </lang>

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

<lang PureBasic>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")</lang>

Python

Using set arithmetic: <lang python>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: ')) )</lang>

Output:
Sentence: The quick brown fox jumps over the lazy dog
True

R

Using the built-in R vector "letters": <lang R>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="")
 }

} 

</lang>
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

<lang Racket>

  1. 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") </lang>

Retro

<lang Retro>: isPangram? ( $-f ) 

 ^strings'toLower
 heap [ 27 allot ] preserve
 [ @ 'a - dup 0 25 within [ [ 'a + ] [ here + ] bi ! ] &drop if ]
 ^types'STRING each@ here "abcdefghijklmnopqrstuvwxyz" compare ;</lang>

REXX

<lang REXX>/*REXX program checks to see if an entered 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:';       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. */</lang>
Output:
───── Please enter a pangramic sentence   (or a blank to quit):

The quick brown fox jumped over the lazy dog.
───── 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!!!
───── Sentence is a pangram.


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


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

Ruby

<lang ruby>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</lang>

Run BASIC

<lang runbasic>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</lang>

1 The quick brown fox jumps over the lazy dog.
0 My dog has fleas.

Scala

<lang scala>def is_pangram(sentence: String) = sentence.toLowerCase.filter(c => c >= 'a' && c <= 'z').toSet.size == 26 </lang>

<lang scala> 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 </lang>

Seed7

<lang seed7>$ 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;</lang>
Output:
FALSE
TRUE
TRUE
FALSE

Sidef

Translation of: Perl 6

<lang ruby>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);</lang>

Output:
true
false
false
true
true

Smalltalk

<lang smalltalk>!String methodsFor: 'testing'! isPangram ^((self collect: [:c | c asUppercase]) select: [:c | c >= $A and: [c <= $Z]]) asSet size = 26 </lang>

<lang smalltalk> 'The quick brown fox jumps over the lazy dog.' isPangram </lang>

SNOBOL4

Works with: Macro Spitbol
Works with: Snobol4+
Works with: CSnobol

<lang SNOBOL4> 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</lang>

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

<lang Swift>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</lang> Swift 2.0:

<lang swift>func isPangram(str: String) -> Bool { 

 let (char, alph) = (Set(str.characters), "abcdefghijklmnopqrstuvwxyz".characters)
 return !alph.contains {!char.contains($0)}

}</lang>

Tcl

<lang tcl>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</lang>

TI-83 BASIC

<lang ti83b>:Prompt Str1

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

(not tested yet)

TUSCRIPT

<lang tuscript> $$ 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 </lang>

Output:
   pangram: The quick brown fox jumps over the lazy dog
no pangram: the quick brown fox falls over the lazy dog

TXR

<lang txr>@/.*[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].*/</lang>
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

Works with: Bourne Again SHell

<lang bash>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"

}</lang>

Ursala

<lang Ursala>

  1. import std

is_pangram = ^jZ^(!@l,*+ @rlp -:~&) ~=`A-~ letters </lang> example usage: <lang Ursala>

  1. cast %bL

test =

is_pangram* < 

  'The quick brown fox jumps over the lazy dog',
  'this is not a pangram'>

</lang>

Output:
<true,false>

VBA

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

Here is an alternative version:

<lang vb> 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 </lang>

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

Implementation

<lang vb>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</lang>

Invocation

<lang vb>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")"</lang>

XPL0

<lang XPL0>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);
   ];

]</lang>

Output:
yes
yes
no

zkl

<lang zkl>var letters=["a".."z"].pump(String); //-->"abcdefghijklmnopqrstuvwxyz" fcn isPangram(text){(not (letters-text.toLower()))}</lang>

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
Retrieved from "https://rosettacode.org/wiki/Pangram_checker?oldid=137363"