Pangram checker: Difference between revisions

[[Category:String manipulation]]

 

{{omit from|Lilypond}}

 

 

=={{header|11l}}==

R Set(sentence.lowercase().filter(ch -> ch C ‘a’..‘z’)).len == 26

 

L(sentence) [‘The quick brown fox jumps over the lazy dog.’,

‘The quick brown fox jumped over the lazy dog.’]

 

{{out}}

 

=={{header|360 Assembly}}==

PANGRAM CSECT

USING PANGRAM,R12

LA R5,1 found

NEXTK LA R11,1(R11) next character

LTR R5,R5 if found

BNZ NEXTJ

B PRINT

NEXTJ LA R10,1(R10) next letter

MVC BUFFER(2),=CL2'OK'

PRINT MVC BUFFER+3(60),0(R9)

XPRNT BUFFER,80

NEXTI LA R9,60(R9) next sentence

RETURN XR R15,R15

BR R14

DC CL60'PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS.'

BUFFER DC CL80' '

{{out}}

<pre>OK THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.

 

=={{header|ACL2}}==

(if (endp needles)

t

(defun pangramp (str)

(contains-each (coerce "abcdefghijklmnopqrstuvwxyz" 'list)

 

=={{header|ActionScript}}==

{{works with|ActionScript|2.0}}

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;

 

=={{header|Ada}}==

=== Using character sets ===

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

(Is_Subset(To_Set(Span => ('a','z')), To_Set(To_Lower(txt))));

begin

put_line(Boolean'Image(ispangram("This is a test")));

put_line(Boolean'Image(ispangram("abcdefghijklopqrstuvwxyz"))); --Missing m, n

end pangram;

=== Using quantified expressions ===

with Ada.Characters.Handling; use Ada.Characters.Handling;

procedure pangram is

function ispangram(txt : in String) return Boolean is

(for all Letter in Character range 'a'..'z' =>

put_line(Boolean'Image(ispangram("abcdefghijklopqrstuvwxyz"))); --Missing m, n

end pangram;

{{out}}

<pre>

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards)}}

INT la = ABS "a", lz = ABS "z";

INT ua = ABS "A", uz = ABS "Z";

FI

OD

{{out}}

<pre>

 

=={{header|APL}}==

0

1

 

=={{header|AppleScript}}==

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:

 

 

--------------------- PANGRAM CHECKER --------------------

end |λ|

end script

0 = length of filter(charUnUsed, ¬

"abcdefghijklmnopqrstuvwxyz")

"is this a pangram", ¬

"The quick brown fox jumps over the lazy dog"})

--> {false, true}

end run

 

 

-- mReturn :: Handler -> Script

on mReturn(f)

((ca's NSString's stringWithString:(str))'s ¬

lowercaseStringWithLocale:(ca's NSLocale's currentLocale())) as text

{{Out}}

 

=={{header|Arturo}}==

pangram?: function [sentence][

every? chars 'ch ->

 

print pangram? "this is a sentence"

 

{{out}}

 

=={{header|ATS}}==

(* ****** ****** *)

//

 

(* ****** ****** *)

 

An alternate implementation that makes a single pass through the string:

 

val letters: arrayref(bool, 26) = arrayref_make_elt<bool>(i2sz(26), false)

fn check(): bool = loop(0) where {

end

}

 

=={{header|AutoHotkey}}==

Gui, Add, Edit, w300 r5 vText

Gui, Add, Button, x105 w100 Default, Check Pangram

}

MsgBox,, Pangram, OK`, this is a Pangram!

 

=={{header|AutoIt}}==

Pangram("The quick brown fox jumps over the lazy dog")

Func Pangram($s_String)

Return MsgBox(0,"Pangram", "Sentence is a Pangram")

EndFunc

 

=={{header|AWK}}==

 

===Solution using string-operations===

BEGIN {

allChars="ABCDEFGHIJKLMNOPQRSTUVWXYZ";

for (k=1; k<=length(allChars); k++) {

if (!X[substr(allChars,k,1)]) return 0;

return 1;

 

{{out}}

{{Works with|gawk|4.1.0}}

{{Works with|mawk|1.3.3}}

#

# Pangram-checker, using associative arrays and split

}

print "# hit:",hit, "# miss:",miss, "." ##

return 1

 

{{out}}

 

=={{header|BASIC}}==

 

 

DIM x AS STRING

 

IsPangram! = -1

{{out}}

<pre>

0 What's a jackdaw?

</pre>

 

==={{header|Sinclair ZX81 BASIC}}===

Works (just) with the 1k RAM model. The "37" that crops up a couple of times stops being a mystery if we remember that the ZX81 character code for <code>A</code> is 38 and that strings (like arrays) are indexed from 1, not from 0.

20 LET L=26

30 INPUT P$

160 GOTO 180

170 PRINT "NOT A PANGRAM"

{{in}}

<pre>THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.</pre>

<pre>NOT A PANGRAM</pre>

 

 

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

 

set letters=!letters:%chr%=!

set /a cnt+=1

{{Out}}

<pre>"The quick brown fox jumps over the lazy dog." is a pangram!

 

Press any key to continue . . .</pre>

 

=={{header|BCPL}}==

 

// Test if s is a pangram. The ASCII character set is assumed.

$( check("The quick brown fox jumps over the lazy dog.")

check("The five boxing wizards dump quickly.")

{{out}}

<pre>The quick brown fox jumps over the lazy dog. -> yes

Reads the sentence to test from stdin.

 

^#*`\*93\`0<::-"@"-*<^40!%2g4:_

"pangram."<v*84<_v#-":"g40\" a"

 

{{in}}

 

=={{header|Bracmat}}==

k

. low$!arg:?arg

)

& !k:>z

Some examples:

<pre>isPangram$("the Quick brown FOX jumps over the lazy do")

 

=={{header|Brat}}==

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]

 

p pangram? 'The quick brown fox jumps over the lazy dog.' #Prints true

 

Alternative version:

 

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

 

=={{header|C}}==

 

int is_pangram(const char *s)

tests[i], is_pangram(tests[i])?"":"not ");

return 0;

===Using bitmask===

Assumes an execution environment using the ASCII character set (will invoke undefined behavior on other systems).

 

 

int pangram(const char *s)

 

return 0;

{{out}}

<pre>yes: The quick brown fox jumps over lazy dogs.

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

 

using System.Linq;

 

Console.WriteLine(arguments.Any() && arguments.First().IsPangram());

}

 

Any version of C# language and .NET Framework

 

 

namespace PangrammChecker

}

}

 

=={{header|C++}}==

#include <cctype>

#include <string>

}

}

 

=={{header|Ceylon}}==

function pangram(String sentence) =>

let(alphabet = set('a'..'z'),

print("\"``sentence``\" is a pangram? ``pangram(sentence)``");

}

 

=={{header|Clojure}}==

(let [letters (into #{} "abcdefghijklmnopqrstuvwxyz")]

 

=={{header|COBOL}}==

program-id. pan-test.

data division.

exit program

.

 

=={{header|CoffeeScript}}==

is_pangram = (s) ->

# This is optimized for longish strings--as soon as all 26 letters

for i in [a_code...a_code+26]

required_letters[String.fromCharCode(i)] = true

cnt = 0

for c in s

throw Error("fail") if is_pangram(long_str) != exp_value

console.log "Passed tests: #{s}"

 

=={{header|Common Lisp}}==

(null (set-difference

(loop for c from (char-code #\A) upto (char-code #\Z) collect (code-char c))

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE BbtPangramChecker;

IMPORT StdLog,DevCommanders,TextMappers;

 

PROCEDURE Check(str: ARRAY OF CHAR): BOOLEAN;

letters = 26;

VAR

i,j: INTEGER;

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

END;

resp := TRUE;

FOR i := 0 TO LEN(status) - 1 DO;

 

END BbtPangramChecker.

Execute: ^Q BbtPangramChecker.Do "The quick brown fox jumps over the lazy dog"~ <br/>

^Q BbtPangramChecker.Do "abcdefghijklmnopqrstuvwxyz"~<br/>

 

=={{header|Cowgol}}==

 

sub pangram(str: [uint8]): (r: uint8) is

var letters: uint8[26];

MemZero(&letters[0], 26);

loop

var chr := [str];

letters[chr] := letters[chr] | 1;

end loop;

r := 1;

chr := 0;

print(yesno[pangram(test[i])]);

i := i + 1;

 

{{out}}

Copied and modified from the Ruby version.

 

('a'..'z').all? {|c| sentence.downcase.includes?(c) }

end

p pangram?("not a pangram")

 

<pre>

=={{header|D}}==

===ASCII Bitmask version===

uint bitset;

 

assert(!"ABCDEFGHIJKL.NOPQRSTUVWXYZ".isPangram);

assert("ABC.D.E.FGHI*J/KL-M+NO*PQ R\nSTUVWXYZ".isPangram);

 

===Unicode version===

 

// Do not compile with -g (debug info).

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

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(IsPangram('The quick brown fox jumps over the lazy dog')); // true

Writeln(IsPangram('Not a panagram')); // false

 

=={{header|E}}==

 

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

 

<code>&amp;!</code> is the “but-not” or set difference operator.

 

=={{header|EDSAC order code}}==

it in a text file, making that file the active file, and clicking Reset.

The string must be terminated by a blank row of tape (represented by '.' in EdsacPC).

[Pangram checker for Rosetta Code.

EDSAC program, Initial Orders 2.]

P F [acc = 0 on entry]

THE!QUICK!BROWN!FOX!JUMPS!OVER!THE!LAZY!DOG.

{{out}}

<pre>

 

=={{header|Elixir}}==

def checker(str) do

unused = Enum.to_list(?a..?z) -- to_char_list(String.downcase(str))

IO.puts "#{Pangram.checker(text)}\t#{text}"

text = (Enum.to_list(?A..?Z) -- 'Test') |> to_string

 

{{out}}

 

=={{header|Erlang}}==

-export([is_pangram/1]).

 

is_pangram(String) ->

 

=={{header|Excel}}==

 

{{works with|Office 265 Betas 2010}}

=LAMBDA(s,

LET(

)

)

 

And assuming that the name CHARS is also bound in the Name Manager

to the generic (String -> Array Char) lambda:

 

=LAMBDA(s,

MID(s, ROW(INDIRECT("1:" & LEN(s))), 1)

{{Out}}

|-

|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx

! colspan="2" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=ISPANGRAM(A2)

|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"

| A

| B

|- style="text-align:left;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1

| style="font-weight:bold" | Verdicts

|- style="text-align:right;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2

| style="background-color:#cbcefb; text-align:left; " | TRUE

|- style="text-align:right;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3

| style="text-align:left; | FALSE

|- style="text-align:right;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4

| style="text-align:left;" | TRUE

|- style="text-align:right;"

| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5

| style="text-align:left;| TRUE

|}

=={{header|F Sharp|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:

 

=={{header|Factor}}==

{{trans|E}}

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

 

 

=={{header|Forth}}==

0 -rot bounds do

i c@ 32 or [char] a -

1 26 lshift 1- = ;

 

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

implicit none

end function is_pangram

 

Example:

 

use pangram, only: is_pangram

write (*, '(l1)') is_pangram (string)

 

{{out}}

<pre>This is a sentence.

T</pre>

 

 

 

 

 

 

 

 

</pre>

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import "fmt"

}

return false

{{out}}

<pre>

=={{header|Haskell}}==

 

import Data.List ((\\))

 

pangram = null . (['a' .. 'z'] \\) . map toLower

 

 

=={{header|HicEst}}==

PangramBrokenAt("The quick Brown Fox jumps over the Lazy Dog") ! => 0 (OK)

 

PangramBrokenAt = INDEX(Alfabet, string, 64)

! option 64: verify = 1st letter of string not in Alfabet

 

=={{header|Icon}} and {{header|Unicon}}==

if (map(s) ** &lcase) === &lcase then return s

 

And a main to drive it:

 

if *arglist > 0 then

s := "The quick brown fox jumps over the lazy dog."

 

writes(image(s), " -- is")

writes(if not panagram(s) then "n't")

 

=={{header|Io}}==

letters := " " repeated(26)

ia := "a" at(0)

"The quick brown fox jumps over the lazy dog." isPangram println // --> true

"The quick brown fox jumped over the lazy dog." isPangram println // --> false

 

=={{header|Ioke}}==

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?

iik> "The quick brown fox jumps over the" isPangram?

"The quick brown fox jumps over the" isPangram?

 

=={{header|J}}==

'''Solution:'''

 

'''Example use:'''

1

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

 

=={{header|Java}}==

{{works with|Java|1.5+}}

public static boolean isPangram(String test){

for (char a = 'A'; a <= 'Z'; a++)

System.out.println(isPangram(""));//false

}

{{out}}

<pre>true

====Iterative====

 

var letters = "zqxjkvbpygfwmucldrhsnioate"

// sorted by frequency ascending (http://en.wikipedia.org/wiki/Letter_frequency)

 

console.log(isPangram("is this a pangram")) // false

 

===ES6===

====Functional====

 

"use strict";

 

"The quick brown fox jumps over the lazy dog"

].map(isPangram);

 

{{Out}}

 

=={{header|jq}}==

explode

| map( if 65 <= . and . <= 90 then . + 32 # uppercase

 

# Example:

{{Out}}

$ jq -M -n -f pangram.jq

=={{header|Julia}}==

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

alphabet = Set(uppercase.(alphabet))

function ispangram(s)

for s in tests

println("The sentence \"", s, "\" is ", is_english_pangram(s) ? "" : "not ", "a pangram.")

 

{{out}}

 

=={{header|K}}==

ucase : _ci 65+!26

tolower : {@[x;p;:;lcase@n@p:&26>n:ucase?/:x]}

 

Example:

1

panagram "Panagram test"

 

=={{header|Kotlin}}==

 

fun isPangram(s: String): Boolean {

if (c !in t) return false

return true

 

fun main(args: Array<String>) {

"A very mad quack might jinx zippy fowls" // no 'b' now!

)

println("'$candidate' is ${if (isPangram(candidate)) "a" else "not a"} pangram")

 

{{out}}

</pre>

 

 

 

 

=={{header|Logo}}==

if empty? :s [output :set]

if word? :s [output remove.all butfirst :s remove first :s :set]

end

 

 

=={{header|Lua}}==

S, C = lpeg.S, lpeg.C

function ispangram(s)

print(ispangram"waltz, bad nymph, for quick jigs vex")

print(ispangram"bobby")

 

=={{header|Maple}}==

is_pangram := proc(str)

local present := StringTools:-LowerCase~(select(StringTools:-HasAlpha, StringTools:-Explode(str)));

return evalb(present = alphabets);

end proc;

{{out|Usage}}

is_pangram("The 2 QUIck brown foxes jumped over the lazy DOG!!");

{{out|Output}}

<pre>

</pre>

 

Usage:

<pre>pangramQ["The quick brown fox jumps over the lazy dog."]

 

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

ToString[#]]]][

Usage:

<pre>pangramQ["The quick brown fox jumps over the lazy dog."]

 

=={{header|MATLAB}}==

 

%This works by histogramming the ascii character codes for lower case

trueFalse = isempty(find( histc(lower(string),(97:122))==0,1 ));

 

 

{{out}}

 

ans =

 

 

=={{header|MATLAB}} / {{header|Octave}}==

% X is a histogram of letters

X = sparse(abs(lower(string)),1,1,128,1);

trueFalse = full(all(X('a':'z') > 0));

 

{{out}}

=={{header|min}}==

{{works with|min|0.19.3}}

('alphabet dip lowercase (swap match) prepend all?) :pangram?

 

 

=={{header|MiniScript}}==

"Peter Piper picked a peck of pickled peppers.",

"Waltz job vexed quick frog nymphs."]

alphabet = "abcdefghijklmnopqrstuvwxyz"

pangram = function (toCheck)

sentence = toCheck.lower

return true

end function

for sentence in sentences

if pangram(sentence) then

print """" + sentence + """ is a Pangram"

print """" + sentence + """ is not a Pangram"

end if

{{out}}

<pre>

=={{header|ML}}==

==={{header|mLite}}===

 

val flen = len (filter (fn c = c eql h) T)

in

is_pangram (t, T)

end

| S = is_pangram (explode "abcdefghijklmnopqrstuvwxyz", explode ` to_locase S)

val flen = len (filter (fn c = c eql h) T)

in

is_pangram (t, T)

end

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

;

val SValphabet = "abcdefghijklmnopqrstuvwxyzåäö";

val SVsentence = "Yxskaftbud, ge vår wczonmö iq hjälp";

{{out}}

<pre>'The quick brown fox jumps over the lazy dog' is a pangram

'Yxskaftbud, ge vår wczonmö iq hjälp' is a Swedish pangram

</pre>

 

=={{header|NetRexx}}==

NetRexx's <code>verify</code> built&ndash;in method is all you need!

options replace format comments java crossref savelog symbols nobinary

 

 

return pangrams

{{out}}

<pre style="overflow:scroll">

 

=={{header|NewLISP}}==

(context 'PGR) ;; Switch to context (say namespace) PGR

(define (is-pangram? str)

(println (PGR:is-pangram? "abcdef")) ;; Print nil

(exit)

 

=={{header|Nim}}==

 

proc isPangram(sentence: string, alphabet = {'a'..'z'}): bool =

alphabet <= sentset

 

Example usage:

<pre>Sentence: The quick brown fox jumps over the lazy dog

=={{header|Objeck}}==

{{trans|Java}}

bundle Default {

class Pangram {

}

}

 

=={{header|OCaml}}==

 

let ar = Array.make 26 false in

String.iter (function

| _ -> ()

) (String.lowercase str);

 

Printf.printf " %b -- %s\n" (pangram str) str

 

check "this is a sentence";

check "The quick brown fox jumps over the lazy dog.";

 

{{out}}

 

=={{header|Oz}}==

fun {IsPangram Xs}

{List.sub

end

in

 

=={{header|PARI/GP}}==

s=vecsort(Vec(s),,8);

for(i=97,122,

 

pangram("The quick brown fox jumps over the lazy dog.")

 

=={{header|Pascal}}==

=={{header|Perl}}==

Get an answer with a module, or without.

use warnings;

use feature 'say';

say pangram1($_,@alpha) ? 'Yes' : 'No';

say pangram2($_,@alpha) ? 'Yes' : 'No';

{{out}}

<pre>Yes

 

=={{header|Phix}}==

 

{{out}}

<pre>

no - no a

</pre>

 

=={{header|PHP}}==

{{trans|D}}

foreach (str_split($text) as $c) {

if ($c >= 'a' && $c <= 'z')

 

foreach ($test as $str)

 

<pre>the quick brown fox jumps over the lazy dog : T

 

Using array

 

// define "alphabet"

echo is_pangram( $txt ) ? "Yes" : "No", PHP_EOL, PHP_EOL;

}

 

{{Out}}

Yes

</pre>

 

=={{header|PicoLisp}}==

(not

(diff

'`(chop "abcdefghijklmnopqrstuvwxyz")

 

=={{header|PL/I}}==

test_pangram: procedure options (main);

 

 

end test_pangram;

 

{{out}}

<pre>

 

the quick brown fox jumps over the lazy dog

</pre>

 

Cyrillic test sample borrowed from Raku.

{{works with|PowerShell|2}}

function Test-Pangram ( [string]$Text, [string]$Alphabet = 'abcdefghijklmnopqrstuvwxyz' )

{

$Text = $Text.ToLower()

$Alphabet = $Alphabet.ToLower()

$IsPangram = @( $Alphabet.ToCharArray() | Where-Object { $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 'Съешь же ещё этих мягких французских булок, да выпей чаю' 'абвгдежзийклмнопрстуфхцчшщъыьэюяё'

{{out}}

<pre>

</pre>

A faster version can be created using .Net HashSet to do what the F# version does:

Function Test-Pangram ( [string]$Text, [string]$Alphabet = 'abcdefghijklmnopqrstuvwxyz' )

{

return $alSet.Count -eq 0 # any alphabet letters still remaining?

}

 

=={{header|Prolog}}==

Works with SWI-Prolog

 

numlist(0'a, 0'z, Alphabet),

forall(member(C, Alphabet), member(C, L)).

( pangram(L2) -> R2 = ok; R2 = ko),

format('~s --> ~w ~n', [L2, R2]).

{{out}}

<pre>?- pangram_example.

true.</pre>

 

=={{header|Python}}==

Using set arithmetic:

if sys.version_info[0] < 3:

input = raw_input

return alphaset <= set(sentence.lower())

 

 

{{out}}

 

=={{header|Quackery}}==

[ dup char A char [ within

swap char a char { within

$ "This is a sentence." pangram echo cr ( 0 )

$ "The five boxing wizards jumped quickly." pangram echo cr ( 1 )

 

=={{header|R}}==

Using the built-in R vector "letters":

my.letters <- tolower(unlist(strsplit(sentence, "")))

is.pangram <- all(letters %in% my.letters)

if (is.pangram){

cat("\"", sentence, "\" is a pangram! \n", sep="")

}

}

 

{{out}}

=={{header|Racket}}==

 

#lang racket

(define (pangram? str)

(= 26 (length (remove-duplicates (string->list chars)))))

(pangram? "The quick Brown Fox jumps over the Lazy Dog")

 

=={{header|Raku}}==

(formerly Perl 6)

constant Hex = set 'a' .. 'f';

 

sub pangram($str, Set $alpha = Eng) {

}

 

say pangram("My dog has fleas.", Hex);

say pangram("My dog backs fleas.", Hex);

{{out}}

<pre>True

 

=={{header|Retro}}==

'__________________________ 'TEST s:const

:s:pangram? (s-f)

[ dup $a - &TEST + store ] s:for-each

&TEST &FULL s:eq? ;

 

=={{header|REXX}}==

@abc= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' /*a list of all (Latin) capital letters*/

 

end /*forever*/

 

{{out|output|:}}

<pre>

 

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

 

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

 

=={{header|Ring}}==

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)

bool = substr(str, char(i)) > 0

pangram = pangram + bool

pan = (pangram = 26)

return pan

 

=={{header|Ruby}}==

end

 

p pangram?('this is a sentence') # ==> false

 

=={{header|Rust}}==

 

extern crate test;

is_pangram_hashset);

}

 

=={{header|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

 

=={{header|Seed7}}==

 

const func boolean: isPangram (in string: stri) is func

writeln(isPangram("NOPQRSTUVWXYZ abcdefghijklm"));

writeln(isPangram("abcdefghijklopqrstuvwxyz")); # Missing m, n

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

define Hex = 'a'..'f';

define Cyr = %w(а б в г д е ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я ё);

say pangram("My dog has fleas.", Hex);

say pangram("My dog backs fleas.", Hex);

{{out}}

<pre>

 

=={{header|Smalltalk}}==

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

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

pangram str = replace(str,&ucase,&lcase)

alfa = &lcase

 

define('panchk(str)tf') :(panchk_end)

tf = 'False'; tf = pangram(str) 'True'

output = 'Pangram: ' tf :(return)

panchk("My girl wove six dozen plaid jackets before she quit.")

panchk("This 41-character string: it's a pangram!")

 

{{out}}

 

=={{header|Swift}}==

 

let str = "the quick brown fox jumps over the lazy dog"

 

isPangram(str) // True

Swift 2.0:

 

let (char, alph) = (Set(str.characters), "abcdefghijklmnopqrstuvwxyz".characters)

return !alph.contains {!char.contains($0)}

 

=={{header|Tcl}}==

set letters [regexp -all -inline {[a-z]} [string tolower $sentence]]

expr {

}

puts [pangram? "This is a sentence"]; # ==> false

 

=={{header|TI-83 BASIC}}==

:For(L,1,26

:If not(inString(Str1,sub("ABCDEFGHIJKLMNOPQRSTUVWXYZ",L,1))

:End

:If L<28

(not tested yet)

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

alfabet="abcdefghijklmnopqrstuvwxyz"

IF (chars_in_s!=alfabet) PRINT "no pangram: ",s

ENDLOOP

{{out}}

<pre>

 

=={{header|TXR}}==

.*[Ee].*&.*[Ff].*&.*[Gg].*&.*[Hh].*& \

.*[Ii].*&.*[Jj].*&.*[Kk].*&.*[Ll].*& \

.*[Qq].*&.*[Rr].*&.*[Ss].*&.*[Tt].*& \

.*[Uu].*&.*[Vv].*&.*[Ww].*&.*[Xx].*& \

 

{{out|Run}}

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

done

 

=={{header|Ursala}}==

#import std

 

is_pangram = ^jZ^(!@l,*+ @rlp -:~&) ~=`A-~ letters

example usage:

#cast %bL

 

 

is_pangram* <

'The quick brown fox jumps over the lazy dog',

'this is not a pangram'>

{{out}}

<pre>

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

pangram2 = True

End Function

 

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

=={{header|VBScript}}==

====Implementation====

dim i

dim sKey

pangram = ( ltrim(sKey) = vbnullstring )

end function

function eef( bCond, exp1, exp2 )

if bCond then

eef = exp2

end if

 

====Invocation====

 

=={{header|Wren}}==

{{libheader|Wren-str}}

 

var isPangram = Fn.new { |s|

for (candidate in candidates) {

System.print(" %(candidate) -> %(isPangram.call(candidate))")

 

{{out}}

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

CrLf(0);

];

 

{{out}}

no

</pre>

 

=={{header|zkl}}==

{{out}}

<pre>