Un lipogramma è un blocco di parole che omette un particolare simbolo. In questo momento, sto evitando il nostro quinto simbolo di 26 che compare comunemente. Ormai dovresti sapere cosa sto omettendo. Altrimenti, cerca "lipogram" e lo saprai.

Il tuo compito

Con un carattere, uno spazio vuoto e una stringa seguente (gli spazi vuoti possono apparire in questo; con solo caratteri ASCII 32-126) nell'input, l'output è falso se questo carattere è nella stringa di input, in verità in caso contrario. Questo carattere che devi cercare si adatta sempre a due span: da "A" a "Z" o da "a" a "z" (ASCII 65-90, 97-122). Non distinguere maiuscole e minuscole. Inoltre, non preoccuparti di spazi vuoti o simboli di punteggiatura. Sia i programmi che le funzioni soddisfano. Inoltre, puoi dividere il carattere di input e la stringa in due argomenti per programmi o funzioni e la stringa come primo argomento va bene.

Illustrazioni

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.

Versione non lipogrammata

Un lipogramma è una serie di parole che lascia fuori una lettera. Ho lasciato fuori la lettera "e" sopra.

Il tuo compito è quello di prendere un carattere e una stringa (che possono includere spazi) come input, separati da uno spazio o da una nuova riga, e generare falsi se il personaggio è nella stringa, e in verità altrimenti. Si può presumere che la stringa sia composta esclusivamente da caratteri ASCII stampabili (codici char 32-126). Il personaggio sarà sempre nell'alfabeto inglese e non c'è differenza tra lettere minuscole e maiuscole. Il personaggio non sarà uno spazio o un simbolo. È possibile scrivere un programma o una funzione. Per entrambi, è possibile prendere il carattere e la stringa come argomenti separati e la stringa potrebbe venire prima.

C, 42 byte

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

Javascript ES6 34 26 23 byte

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

rasato 8 byte grazie @ MartinBüttner

05AB1E , 7 6 4 3 byte

Codice:

l`-

Spiegazione:

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"

Provalo online!

La verità è quando viene emessa la lettera corrente. Falsy è quando non viene emesso nulla.

TeaScript, 5 3 byte

AµN

Aha \ o /! Ho dimenticato l'input implicito! TeaScript inserirà automaticamente x.(l'input) all'inizio. Posso quindi verificare se ha l'altro input (in variabile µ) e quindi un NOT ( N). Suppongo che il miglior vantaggio di TeaScript qui sia il suo input implicito

Provalo online

Spiegazione

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

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

Bash, 16 11 byte

grep -iv $1

-iè il flag senza distinzione tra maiuscole e minuscole, -vinverte (verifica una non corrispondenza).

Il carattere deve essere fornito come argomento della riga di comando e la stringa di test su STDIN.

Ridotto di 5 byte con l' aiuto di @ DigitalTrauma !

Esecuzioni campione:

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 byte

!VoU

Provalo online!

La risposta TeaScript di @ Downgoat mi ha ricordato che Japt ha esattamente lo stesso built-in, tagliando gli ultimi due byte.

Come funziona

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

lel(&!

Provalo online! lel

Spiegazione

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 byte

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

Python 3, 36

Dover ignorare il caso è sorprendentemente costoso.

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

Prende gli argomenti come (char, string)

Pyth, 8 7 byte

-rz0rw0

Spiegazione

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

Grazie @FryAmTheEggman per avermi detto che posso usare al -posto di!}

Provalo qui

O, 8 byte

{_.@_-=}

Una funzione anonima che accetta un carattere e una stringa.

Provalo online.

Spiegazione

{_.@_-=}

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

Perl, 11 + 1 = 12 byte

$_=lc!~lc<>

Richiede l' -pinterruttore e accetta input come$string\n$letter

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

Come funziona:

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

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

MATL , 5 byte

kikm~

Provalo online!

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

Scherzi a parte, 6 byte

,ù,ùíu

Provalo online!

Accetta input come 'string'\n'char'

Spiegazione:

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

Julia 0,3, 22 20 byte

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

uppercaseè una parola lunga .

Come funziona

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

Non sono sicuro di ciò che conta come verità / falsità in Retina, questo farà eco alla linea se si tratta di un lipogramma per il dato carattere e restituirà la stringa vuota se non lo è.

Questo funzionerà anche per input multilinea.

Provalo online!

Minkolang 0,15 , 10 byte

$or7Z0Z,N.

Provalo qui.

Spiegazione

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

Ruggine, 75 byte

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

Il punteggio più alto significa che vinco, giusto? > _ <

Provalo qui.

Gelatina, 8 byte

ḢO^O&95P

Provalo online!

Come funziona

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

{el\ele=!}

Una funzione anonima (blocco) che accetta un carattere (non una stringa!) E una stringa.

Provalo online.

Spiegazione

{el\ele=!}

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

PowerShell, 36 32 30 29 25 byte

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

Utilizza l' -notmatchoperatore e genera semplicemente output Trueo False.

Python, 34 byte

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

Verifica la presenza di caratteri cnella stringa s, ignorando il caso aggiungendo una copia di maiuscole / minuscole sa s. La negazione è finita not, che sembra lunga ma non vedo meglio. Questa è la stessa lunghezza:

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

Non puoi omettere le parentesi, altrimenti Python interpreterà l'espressione come una disuguaglianza della forma concatenata a tre valori _ in _ < _.

Python 3.5 dovrebbe consentire 33 byte tramite conversioni impostate, anche se non posso provarlo ora.

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

Pyke, 7 byte

Dl3+R{!

Spiegazione:

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

JavaScript ES6, 41 40 byte

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

Prende l'intera stringa come argomento. Non riesco a salvare byte accettando due argomenti diversi perché la mia risposta si fonderebbe con l'altra risposta ES6 :(

R, 26 byte

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

x è la stringa, y è la lettera, la T nella chiamata a grepl la rende insensibile alle maiuscole.

Jolf, 6 7 byte

Così. Molti. Sei. SMS? Bene, provalo qui comunque. Sostituisci ⌂con \x7f.

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

Rubino, 17 byte

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

Lotto, 53 byte

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

Accetta input come due argomenti della riga di comando. (Citare il secondo argomento, se necessario.) Emette 1 in caso di successo, nulla se il primo argomento è (insensibilmente) trovato nel secondo.

Mathematica, 33 32 byte

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

Adoro quando ## può essere usato. L'input è stringa, quindi char.

Oppure, una versione con distinzione tra maiuscole e minuscole: (11 byte :)

StringFreeQ

Sì, solo un built-in.