Un lipograma es un bloque de palabras que omite un símbolo en particular. En este momento, estoy evitando nuestro quinto símbolo de 26 que comúnmente aparece. Ya deberías saber lo que estoy omitiendo. Si no, busque "lipograma" y lo sabrá.

Tu tarea

Con un carácter, un espacio en blanco y una cadena siguiente (pueden aparecer espacios en blanco en esto; con solo caracteres ASCII 32-126) en la entrada, salida falsa si este carácter está en la cadena de entrada, verdad si no. Este carácter que debe buscar siempre encajará en dos tramos: "A" a "Z" o "a" a "z" (ASCII 65-90, 97-122). No distinga capitales y no capitales. Además, no se preocupe por los espacios en blanco o los signos de puntuación. Tanto los programas como las funciones satisfacen. Además, puede dividir input char y string en dos argumentos para programas o funciones, y string como primer argumento está bien.

Ilustraciones

Verdad

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

Falsa

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.

Versión no lipogramada

Un lipograma es una serie de palabras que omiten una letra. Dejé la letra "e" arriba.

Su tarea es tomar un carácter y una cadena (que puede incluir espacios) como entrada, separados por un espacio o una nueva línea, y generar una salida falsa si el carácter está en la cadena y, de lo contrario, la verdad. Puede suponer que la cadena se compone únicamente de caracteres ASCII imprimibles (códigos de caracteres 32-126). El carácter siempre estará en el alfabeto inglés, y no hay diferencia entre minúsculas y mayúsculas. El personaje no será un espacio o símbolo. Puedes escribir un programa o una función. Para cualquiera, puede tomar el carácter y la cadena como argumentos separados, y la cadena puede ser lo primero.

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)

afeitado 8 bytes gracias @ MartinBüttner

05AB1E , 7 6 4 3 bytes

Código:

l`-

Explicación:

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"

Pruébalo en línea!

La verdad es cuando se emite la letra actual. Falsy es cuando no se emite nada.

TeaScript, 5 3 bytes

AµN

¡Ajá! ¡Olvidé la entrada implícita! TeaScript insertará automáticamente x.(la entrada) al principio. Luego puedo verificar si tiene la otra entrada (en variable µ) y, por lo tanto, un NOT ( N). Supongo que la mejor ventaja de TeaScript aquí es su entrada implícita

Pruébalo en línea

Explicación

  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

-ies la marca que no distingue entre mayúsculas y minúsculas, -vinvierte (comprueba si no coincide).

El carácter debe proporcionarse como un argumento de línea de comando y la cadena de prueba en STDIN.

¡Reducido en 5 bytes con la ayuda de @ DigitalTrauma !

Ejecuciones de muestra:

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 bytes

!VoU

¡Pruébalo en línea!

La respuesta TeaScript de @ Downgoat me recordó que Japt tiene exactamente el mismo incorporado, cortando los dos bytes finales.

Cómo 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(&!

Pruébalo en línea! lel

Explicación

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)

Pitón 3, 36

Tener que ignorar el caso es sorprendentemente costoso.

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

Toma los argumentos como (char, string)

Pyth, 8 7 bytes

-rz0rw0

Explicación

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

Gracias @FryAmTheEggman por decirme que puedo usar en -lugar de!}

Pruébalo aquí

O, 8 bytes

{_.@_-=}

Una función anónima que toma un carácter y una cadena.

Pruébalo en línea.

Explicación

{_.@_-=}

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

Perl, 11 + 1 = 12 bytes

$_=lc!~lc<>

Requiere el -pinterruptor y toma la entrada como$string\n$letter

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

Cómo 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~

Pruébalo en línea!

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

En serio, 6 bytes

,ù,ùíu

Pruébalo en línea!

Toma entrada como 'string'\n'char'

Explicación:

,ù,ùí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

uppercaseEs una palabra larga .

Cómo 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

No estoy seguro de lo que cuenta como verdadero / falso en Retina, esto hará eco de la línea si es un lipograma para el carácter dado, y devolverá la cadena vacía si no lo es.

Esto también funcionará para la entrada multilínea.

Pruébalo en línea!

Minkolang 0.15 , 10 bytes

$or7Z0Z,N.

Pruébalo aquí.

Explicación

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

Óxido, 75 bytes

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

Mayor puntaje significa que gano, ¿verdad? > _ <

Pruébalo aquí.

Jalea, 8 bytes

ḢO^O&95P

Pruébalo en línea!

Cómo 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=!}

Una función anónima (bloque) que toma un carácter (¡no una cadena!) Y una cadena.

Pruébalo en línea.

Explicación

{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

Utiliza el -notmatchoperador y simplemente genera Trueo False.

Python, 34 bytes

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

Comprueba si hay caracteres cestar en cadena s, ignorando mayúsculas y minúsculas anexando una copia de casos y de intercambiarse sa s. La negación ha terminado not, lo que parece largo pero no veo mejor. Esta es la misma longitud:

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

No puede omitir los parens o Python interpretará la expresión como una desigualdad de forma encadenada de tres valores _ in _ < _.

Python 3.5 debería permitir 33 bytes a través de conversiones establecidas, aunque no puedo probarlo ahora.

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

Pyke, 7 bytes

Dl3+R{!

Explicación:

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

Toma toda la cadena como argumento. No puedo guardar bytes aceptando dos argumentos diferentes porque entonces mi respuesta se fundiría con la otra respuesta de ES6 :(

R, 26 bytes

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

x es la cadena, y es la letra, la T en la llamada a grepl hace que no distinga entre mayúsculas y minúsculas.

Jolf, 6 7 bytes

Entonces. Muchos. Seis ¿SMS? Bueno, inténtalo aquí, no obstante. Reemplazar ⌂con \x7f.

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

Rubí, 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

Acepta entradas como dos argumentos de línea de comandos. (Cite el segundo argumento si es necesario.) Emite 1 en caso de éxito, nada si el primer argumento se encuentra (insensiblemente) en el segundo.

Mathematica, 33 32 bytes

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

Me encanta cuando se puede usar ##. La entrada es cadena, luego char.

O una versión sensible a mayúsculas y minúsculas: (11 bytes :)

StringFreeQ

Sí, solo un incorporado.