Um lipograma é um bloco de palavras que omite um símbolo específico. No momento, estou evitando nosso quinto símbolo de 26, que geralmente aparece. Você já deve saber o que estou omitindo. Caso contrário, procure "lipograma" e você saberá.

Sua tarefa

Com um caractere, um espaço em branco e uma sequência a seguir (os espaços em branco podem aparecer nisso; somente com caracteres ASCII 32-126) na entrada, saída falsa se esse caractere estiver na sequência de entrada, na verdade, se não. Esse caractere que você deve procurar sempre caberá em dois intervalos: "A" a "Z" ou "a" a "z" (ASCII 65-90, 97-122). Não faça distinção entre capitais e não capitais. Além disso, não se preocupe com espaços em branco ou símbolos de pontuação. Ambos os programas e funções satisfazem. Além disso, você pode dividir a entrada char e string em dois argumentos para programas ou funções, e a string como o primeiro argumento é aceitável.

Ilustrações

Truthy

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

Falsy

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.

Versão não lipogramada

Um lipograma é uma série de palavras que deixa de fora uma carta. Eu deixei de fora a letra "e" acima.

Sua tarefa é pegar um caractere e uma string (que podem incluir espaços) como entrada, separados por um espaço ou nova linha, e gerar falsas se o caractere estiver na string e, na verdade, de outra forma. Você pode assumir que a string é composta somente de caracteres ASCII imprimíveis (códigos de caracteres 32-126). O caractere sempre estará no alfabeto inglês e não há diferença entre letras minúsculas e maiúsculas. O personagem não será um espaço ou símbolo. Você pode escrever um programa ou uma função. Para ambos, você pode usar o caractere e a sequência como argumentos separados, e a sequência pode vir primeiro.

C, 42 bytes

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

Javascript ES6 34 26 23 Bytes

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

raspado 8 bytes obrigado @ MartinBüttner

05AB1E , 7 6 4 3 bytes

Código:

l`-

Explicação:

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"

Experimente online!

Verdade é quando a letra atual é emitida. Falsy é quando nada é produzido.

TeaScript, 5 3 bytes

AµN

Aha \ o /! Eu esqueci a entrada implícita! O TeaScript inserirá automaticamente x.(a entrada) no início. Posso então verificar se tem a outra entrada (na variável µ) e, portanto, um NOT ( N). Eu acho que a melhor vantagem do TeaScript aqui é a sua entrada implícita

Experimente online

Explicação

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

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

Bash, 16 11 bytes

grep -iv $1

-ié o sinalizador que não -vdiferencia maiúsculas de minúsculas, inverte (verifica se não há correspondência).

O caractere deve ser fornecido como um argumento de linha de comando e a sequência de teste em STDIN.

Reduzido em 5 bytes com a ajuda do @ DigitalTrauma !

Amostras de execuções:

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

Japonês, 12 6 4 bytes

!VoU

Teste online!

A resposta TeaScript da @ Downgoat me lembrou que o Japt possui exatamente o mesmo built-in, cortando os dois bytes finais.

Como funciona

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

lel(&!

Experimente online! lel

Explicação

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 bytes

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

Python 3, 36

Ter que ignorar a caixa é surpreendentemente caro.

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

Aceita os argumentos como (char, string)

Pitão, 8 7 bytes

-rz0rw0

Explicação

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

Obrigado @FryAmTheEggman por me dizer que posso usar em -vez de!}

Experimente aqui

O, 8 bytes

{_.@_-=}

Uma função anônima que recebe um caractere e uma string.

Experimente online.

Explicação

{_.@_-=}

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

Perl, 11 + 1 = 12 bytes

$_=lc!~lc<>

Requer a -pchave e recebe as entradas como$string\n$letter

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

Como funciona:

            # -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 bytes.

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

MATL , 5 bytes

kikm~

Experimente online!

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

Sério, 6 bytes

,ù,ùíu

Experimente online!

Aceita entrada como 'string'\n'char'

Explicação:

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

Julia 0,3, 22 20 bytes

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

uppercaseé uma palavra longa .

Como funciona

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.

Retina, 11

iA`^(.).*\1

Não sei ao certo o que conta como verdade / falsidade na Retina, isso ecoará a linha se for um lipograma para o caractere especificado e retornará a string vazia, se não for.

Isso também funcionará para entrada de várias linhas.

Experimente online!

Minkolang 0.15 , 10 bytes

$or7Z0Z,N.

Experimente aqui.

Explicação

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

Ferrugem, 75 bytes

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

Maior pontuação significa que eu ganho, certo? > _ <

Experimente aqui.

Gelatina, 8 bytes

ḢO^O&95P

Experimente online!

Como funciona

Ḣ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 bytes

{el\ele=!}

Uma função anônima (bloco) que recebe um caractere (não uma string!) E uma string.

Experimente online.

Explicação

{el\ele=!}

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

PowerShell, 36 32 30 29 25 bytes

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

Usa o -notmatchoperador e simplesmente gera Trueou False.

Python, 34 bytes

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

Verifica se o caractere cestá na sequência s, ignorando maiúsculas e minúsculas, anexando uma cópia trocada por maiúsculas de spara s. A negação está terminada not, que parece longa, mas não vejo melhor. Este é o mesmo comprimento:

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

Você não pode omitir os parênteses ou o Python interceptará a expressão como uma desigualdade de forma encadeada de três valores _ in _ < _.

O Python 3.5 deve permitir 33 bytes por meio de conversões definidas, embora eu não possa testá-lo agora.

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

Pyke, 7 bytes

Dl3+R{!

Explicação:

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

JavaScript ES6, 41 40 bytes

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

Pega a cadeia inteira como argumento. Não consigo salvar bytes aceitando dois argumentos diferentes, porque minha resposta se fundiria com a outra resposta ES6 :(

R, 26 bytes

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

x é a string, y é a letra, o T na chamada para grepl faz com que não seja sensível a maiúsculas e minúsculas.

Jolf, 6 7 bytes

Assim. Muitos. Seis. SMS? Bem, tente aqui mesmo assim. Substitua ⌂por \x7f.

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

Ruby, 17 bytes

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

Lote, 53 bytes

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

Aceita entrada como dois argumentos de linha de comando. (Cite o segundo argumento, se necessário.) Produz 1 em caso de sucesso, nada se o primeiro argumento for (insensível) encontrado no segundo.

Mathematica, 33 32 bytes

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

Adoro quando ## pode ser usado. Entrada é string e, em seguida, char.

Ou, uma versão que diferencia maiúsculas de minúsculas: (11 bytes :)

StringFreeQ

Sim, apenas um builtin.