Pangram checker: Difference between revisions

{{omit from|Lilypond}}

 

 

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

with Ada.Strings.Maps; use Ada.Strings.Maps;

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

procedure pangram is

 

 

begin

end pangram;

{{out}}

<pre>

FALSE

</pre>

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Standard - no extensions to language used}}

 

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

"The quick brown fox jumps over a lazy dog" is a pangram!

</pre>

=={{header|APL}}==

0

1

 

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

 

{{out}}

 

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

 

{

char ch, wasused[26] = {0};

int total = 0;

 

 

continue;

 

}

}

 

{

int i;

for (i = 0; i < 2; i++)

printf("\"%s\" is %sa pangram\n",

return 0;

===Using bitmask===

 

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|Clojure}}==

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

 

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

'abcdefghijklmnopqrstuvwxyz' is pangram?:> $TRUE

'A simple text' is pangram?:> $FALSE

</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|Erlang}}==

-export([is_pangram/1]).

 

is_pangram(String) ->

 

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

The five boxing wizards jumped quickly.

T</pre>

=={{header|Go}}==

 

import "fmt"

 

func pangram(s string) bool {

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

 

=={{header|JavaScript}}==

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

for (var i = 0; i < 26; i++)

}

 

 

 

 

 

 

 

 

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

end

end

 

 

 

for s in tests

 

{{out}}

 

=={{header|K}}==

ucase : _ci 65+!26

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

 

Example:

1

panagram "Panagram test"

 

 

 

 

=={{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")

 

Usage:

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

True</pre>

 

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

Bored? Craving a pub quiz fix? Why, just come to the Royal Oak! [OK, a pangram]

</pre>

 

=={{header|Nim}}==

 

var sentset: set[char] = {}

for c in sentence: sentset.incl c

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

false -- this is a sentence

true -- The quick brown fox jumps over the lazy dog.

 

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

 

 

 

 

 

 

{{out}}

 

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

ABC.D.E.FGHI*J/KL-M+NO*PQ R STUVWXYZ : T

</pre>

 

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

test_pangram: procedure options (main);

 

 

end test_pangram;

 

{{out}}

<pre>

 

the quick brown fox jumps over the lazy dog

</pre>

 

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

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

True</pre>

 

=={{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|Retro}}==

 

=={{header|REXX}}==

 

 

<pre>

 

 

 

 

 

 

 

 

</pre>

 

=={{header|Ruby}}==

end

 

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

 

 

 

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

TRUE

FALSE

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

This 41-character string: it's a pangram!

Pangram: False</pre>

=={{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|XPL0}}==

string 0; \use zero-terminated strings

 

CrLf(0);

];

 

{{out}}

 

=={{header|zkl}}==

{{out}}

<pre>