Un lipogramme est un bloc de mots qui omet un symbole particulier. En ce moment, j'évite notre cinquième symbole de 26 qui apparaît généralement. Vous devriez savoir maintenant ce que je suis en train d'omettre. Sinon, cherchez "lipogramme" et vous saurez.

Ta tâche

Avec un caractère, un blanc et une chaîne suivante (des blancs peuvent apparaître dans ceci; avec seulement des caractères ASCII 32-126) en entrée, sortie en faux si ce caractère est dans la chaîne en entrée, truey sinon. Ce caractère que vous devez rechercher tiendra toujours dans deux plages: "A" à "Z" ou "a" à "z" (ASCII 65-90, 97-122). Ne pas distinguer les capitales et les non-capitales. Ne vous inquiétez pas non plus des blancs et des symboles de ponctuation. Les programmes et les fonctions satisfont. En outre, vous pouvez diviser le caractère et la chaîne en entrée en deux arguments pour les programmes ou les fonctions, et chaîne en tant que premier argument est acceptable.

Des illustrations

Vérité

e This is a lipogram.
a You need to consider other letters too.
E Capitals also count.

Fausseté

e This sentence is not a lipogram (for e).
t This particular letter is surprisingly hard.
A You don't need to care about any non-alphabetic symbols.

Version sans lipogramme

Un lipogramme est une série de mots qui omet une lettre. J'ai oublié la lettre "e" ci-dessus.

Votre tâche consiste à prendre un caractère et une chaîne (pouvant inclure des espaces) en entrée, séparés par un espace ou une nouvelle ligne, et une sortie falsy si le caractère est dans la chaîne, et une vérité sinon. Vous pouvez supposer que la chaîne est composée uniquement de caractères ASCII imprimables (codes de caractère 32-126). Le caractère sera toujours dans l'alphabet anglais et il n'y a pas de différence entre minuscules et majuscules. Le personnage ne sera ni un espace ni un symbole. Vous pouvez écrire un programme ou une fonction. Dans les deux cas, vous pouvez prendre le caractère et la chaîne comme arguments séparés et la chaîne peut figurer en premier.

C, 42 octets

#define f(c,s)!strchr(s,c)&!strchr(s,c^32)

Javascript ES6 34 26 23 octets

x=>!/^(.).*\1/i.test(x)

rasé 8 octets merci @ MartinBüttner

05AB1E , 7 6 4 3 octets

Code:

l`-

Explication:

l     # Convert both elements to lowercase
 `    # Flatten the array
  -   # Loop over the second line of text and substract each char from the first character
        For example: "abcde""ba"- would result in "cde"

Essayez-le en ligne!

La vérité est quand la lettre courante est sortie. La fausseté est quand rien n'est sorti.

TeaScript, 5 3 octets

AµN

Aha \ o /! J'ai oublié l'entrée implicite! TeaScript insérera automatiquement x.(l'entrée) au début. Je peux alors vérifier s'il a l'autre entrée (variable µ) et donc un NOT ( N). Je suppose que le meilleur avantage de TeaScript est son entrée implicite

Essayez-le en ligne

Explication

  A µ  N
x.A(y).N  // At compile time

x.A // input, has...
(y) // second input
N   // Logical NOT

Bash, 16 à 11 octets

grep -iv $1

-iest l'indicateur insensible à la casse, -vinversé (recherche d'une non-correspondance).

Le caractère doit être fourni en tant qu'argument de ligne de commande et la chaîne de test sous STDIN.

Réduit de 5 octets avec l'aide de @ DigitalTrauma !

Échantillons:

llama@llama:~$ echo 'This is a lipogram' | ./lipogram.sh e
This is a lipogram.
llama@llama:~$ echo 'This sentence is not a lipogram (for e).' | ./lipogram.sh e

Japt, 12 6 4 octets

!VoU

Testez-le en ligne!

La réponse TeaScript de @ Downgoat m'a rappelé que Japt a exactement la même fonction intégrée, coupant deux derniers octets.

Comment ça fonctionne

       // Implicit: U = input char, V = input string
VoU    // Keep only the chars in V that are equal to U, ignoring case.
!      // Take logical NOT. Returns true if no matches were found, false otherwise.

CJam, 6 octets

lel(&!

Essayez-le en ligne! lel

Explication

l  e# Read a line of input.
el e# Convert to lower case.
(  e# Pull off the first character.
&  e# Set intersection with the rest of the input.
!  e# Logical NOT.

JavaScript (ES6), 29 octets

(c,s)=>!RegExp(c,'i').test(s)

Python 3, 36

Avoir à ignorer le cas est étonnamment coûteux.

lambda a,b:a.lower()not in b.lower()

Prend les arguments comme (char, chaîne)

Pyth, 8 7 octets

-rz0rw0

Explication

 rw0    -  input().lower()
-       - ^ - V
    rw0 -  input().lower()

Merci @FryAmTheEggman de me dire que je peux utiliser -au lieu de!}

Essayez-le ici

O, 8 octets

{_.@_-=}

Une fonction anonyme qui prend un caractère et une chaîne.

Essayez-le en ligne.

Explication

{_.@_-=}

{      }
 _        Lowercase string
  .       Duplicate
   @      Rotate stack
    _     Lowercase character
     -    Remove all instances of the character
      =   Compare to original

Perl, 11 + 1 = 12 octets

$_=lc!~lc<>

Nécessite le -pcommutateur et prend les entrées comme$string\n$letter

$ perl -pe'$_=lc!~lc<>' <<< $'this is a lipogram\ne'
1

Comment ça fonctionne:

            # -p auto reads input into $_ and auto prints at the end
   lc       # lowercase $_
     !~     # Check against regex
       lc<> # Read next line and lowercase it. '=~' will expect the rValue to be
            # a regex and therefore the result from 'lc<>' will be treated as such
$_=         # Assign result ('1' or '') to $_ which will be printed

Java, 63 octets.

boolean f(String s,char c){return!s.matches("(?i:.*"+c+".*)");}

MATL , 5 octets

kikm~

Essayez-le en ligne!

k        % take first input (letter) implicitly. Convert to lowercase
ik       % take second input (text). Convert to lowercase
m        % ismember function
~        % negate

Sérieusement, 6 octets

,ù,ùíu

Essayez-le en ligne!

Prend en tant que 'string'\n'char'

Explication:

,ù,ùíu
,ù      get string (lowercase)
  ,ù    get char (lowercase)
    íu  1-based index (0 if not found)

Julia 0.3, 22 20 octets

c%s=c&95∉[s...]&95

uppercaseest un long mot.

Comment ça fonctionne

c%s=c&95∉[s...]&95

c%s=                Redefine the binary operator % so it takes a character c and
                    a string s and...
     c&95                Compute lo bitwise AND of c and 95.
                         This casts the character c to uppercase.
          [s...]         Yield the list of the characters of the string s.
                &95      Compute lo bitwise AND of each chararacter and 95.
                         This casts the characters of s to uppercase.
         ∉               Return a Boolean, signaling non-membership.

Rétine, 11

iA`^(.).*\1

Je ne suis pas sûr que ce qui compte comme véracité / fausseté dans Retina, cela fera écho à la ligne s'il s'agit d'un lipogramme pour le caractère donné, et la chaîne vide sera renvoyée si ce n'est pas le cas.

Cela fonctionnera également pour une entrée multiligne.

Essayez-le en ligne!

Minkolang 0,15 , 10 octets

$or7Z0Z,N.

Essayez ici.

Explication

$o            Read in whole input as characters
  r           Reverse stack
   7Z         Lowercase everything
     0Z       Pop top of stack (a) and count how many 'a's are in the stack
       ,      'not' the top of stack
        N.    Output as number and stop.

Rouille, 75 octets

|c:char,s:&str|!s.to_lowercase().contains(c.to_lowercase().next().unwrap())

Le plus gros score signifie que je gagne, non? > _ <

Essayez ici.

Gelée, 8 octets

ḢO^O&95P

Essayez-le en ligne!

Comment ça fonctionne

ḢO^O&95P  Main link. Input: S (string)

Ḣ         Pop the first character of S.
 O        Ordinal; compute its code point.
  ^O      XOR it with the code points of the remaining characters.
    &95   AND each result with 95.
       P  Take the product of the results.

CJam, 10 octets

{el\ele=!}

Une fonction anonyme (bloc) qui prend un caractère (pas une chaîne!) Et une chaîne.

Essayez-le en ligne.

Explication

{el\ele=!}

{        }
 el\el      lowercase both args
      e=    count occurrences of the character
        !   logical not

PowerShell, 36 32 30 29 25 octets

param($a,$b)$b-notmatch$a

Utilise l' -notmatchopérateur et affiche simplement Trueou False.

Python, 34 octets

lambda c,s:c not in s+s.swapcase()

Vérifie que le caractère cest dans la chaîne s, ignorant la casse en ajoutant une copie de casse sà s. La négation est terminée not, ce qui a l'air long mais je ne vois pas mieux. C'est la même longueur:

lambda c,s:(c in s+s.swapcase())<1

Vous ne pouvez pas omettre les parens sinon Python interprétera l'expression comme une inégalité de forme chaînée à trois valeurs _ in _ < _.

Python 3.5 devrait autoriser 33 octets via des conversions définies, bien que je ne puisse pas le tester pour le moment.

lambda c,s:{*c}-{*s+s.swapcase()}

Pyke, 7 octets

Dl3+R{!

Explication:

D       -     eval_or_not(input()).lower()
 l3     -    ^.swapcase()
   +    -   ^+^
    R   -  rotate 2
     {  -  ^ in ^
      ! - not ^

JavaScript ES6, 41 à 40 octets

x=>!~x.slice(2).search(RegExp(x[0],"i"))

Prend la chaîne entière comme argument. Je ne peux pas économiser d'octets en acceptant deux arguments différents car ma réponse se fondrait alors dans l'autre réponse ES6 :(

R, 26 octets

 function(x,y)!grepl(y,x,T)

x est la chaîne, y est la lettre, le T dans l'appel à grepl la rend insensible à la casse.

Jolf, 6 7 octets

Alors. Beaucoup. Six. SMS? Eh bien, essayez néanmoins ici . Remplacer ⌂par \x7f.

⌂ MiI'i
⌂_M      match with flags
   i     the input
    I    with another input
     'i  using i as a flag

Ruby, 17 octets

->c,s{/#{c}/i!~s}

->c,s{  # lambda with two arguments
/#{c}/  # turn the input character into a regexp w/ interpolation
i       # case insensitive
!~      # does not match
s       # input string
}

Lot, 53 octets

@set s=%2
@call set t=%%s:%1=%%
@if %s%==%t% echo 1

Accepte les entrées en tant que deux arguments de ligne de commande. (Citez le deuxième argument si nécessaire.) Affiche 1 en cas de succès, rien si le premier argument est (insensiblement) trouvé dans le second.

Mathematica, 33 32 octets

StringFreeQ[##,IgnoreCase->1>0]&

J'adore quand ## peut être utilisé. L'entrée est une chaîne, puis char.

Ou, une version sensible à la casse: (11 octets :)

StringFreeQ

Oui, juste un construit.