Ein Lipogramm ist ein Wortblock, in dem ein bestimmtes Symbol fehlt. Im Moment vermeide ich unser fünftes Symbol von 26, das häufig auftaucht. Sie sollten jetzt wissen, was ich auslasse. Wenn nicht, schauen Sie nach "Lipogramm" und Sie werden es wissen.

Deine Aufgabe

Mit einem Zeichen, einem Leerzeichen und einer folgenden Zeichenfolge (in dieser werden möglicherweise Leerzeichen angezeigt; mit nur ASCII 32-126-Zeichen) in der Eingabe wird die Ausgabe falsch, wenn dieses Zeichen in der Eingabezeichenfolge enthalten ist, und wenn nicht, wahr. Dieses Zeichen, nach dem Sie suchen müssen, passt immer in zwei Bereiche: "A" bis "Z" oder "a" bis "z" (ASCII 65-90, 97-122). Unterscheiden Sie nicht zwischen Hauptstädten und Nicht-Hauptstädten. Sorgen Sie sich auch nicht um Leerzeichen oder Satzzeichen. Sowohl Programme als auch Funktionen erfüllen. Sie können auch Eingabezeichen und Zeichenfolge für Programme oder Funktionen in zwei Argumente aufteilen, und Zeichenfolge als erstes Argument ist in Ordnung.

Abbildungen

Wahrheit

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

Falsch

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.

Nicht lipogrammierte Version

Ein Lipogramm ist eine Reihe von Wörtern, die einen Buchstaben auslassen. Ich habe den Buchstaben "e" oben weggelassen.

Ihre Aufgabe ist es, ein Zeichen und eine Zeichenfolge (die Leerzeichen enthalten kann) als Eingabe zu verwenden, die durch ein Leerzeichen oder eine neue Zeile getrennt sind, und eine falsche Ausgabe zu erhalten, wenn sich das Zeichen in der Zeichenfolge befindet, und ansonsten die Wahrheit. Sie können davon ausgehen, dass die Zeichenfolge nur aus druckbaren ASCII-Zeichen besteht (Zeichencodes 32-126). Das Zeichen wird immer im englischen Alphabet geschrieben und es gibt keinen Unterschied zwischen Klein- und Großbuchstaben. Das Zeichen wird kein Leerzeichen oder Symbol sein. Sie können ein Programm oder eine Funktion schreiben. In beiden Fällen können Sie das Zeichen und die Zeichenfolge als separate Argumente verwenden, wobei die Zeichenfolge an erster Stelle stehen kann.

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)

8 bytes rasiert danke @ martinbüttner

05AB1E , 7 6 4 3 Bytes

Code:

l`-

Erläuterung:

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"

Probieren Sie es online!

Wahrheit ist, wenn der aktuelle Brief ausgegeben wird. Falsch ist, wenn nichts ausgegeben wird.

TeaScript, 5 3 Bytes

AµN

Aha \ o /! Ich habe die implizite Eingabe vergessen! TeaScript fügt x.am Anfang automatisch die Eingabe ein. Ich kann dann überprüfen, ob es den anderen Eingang (in Variable µ) und damit ein NOT ( N) hat. Ich denke, der beste Vorteil von TeaScript ist die implizite Eingabe

Probieren Sie es online aus

Erläuterung

  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

-iIst das Flag, bei dem die Groß- / Kleinschreibung nicht beachtet wird, -vinvertiert (prüft auf Nichtübereinstimmung).

Das Zeichen muss als Befehlszeilenargument und die Testzeichenfolge für STDIN angegeben werden.

Mit Hilfe von @ DigitalTrauma um 5 Byte reduziert !

Probeläufe:

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

Online testen!

Die TeaScript-Antwort von @Downgoat hat mich daran erinnert, dass Japt genau das Gleiche enthält und die letzten zwei Bytes abgeschnitten hat.

Wie es funktioniert

       // 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(&!

Probieren Sie es online! lel

Erläuterung

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

Groß- und Kleinschreibung ignorieren zu müssen, ist überraschend teuer.

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

Nimmt die Argumente als (char, string)

Pyth, 8 7 Bytes

-rz0rw0

Erläuterung

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

Vielen Dank an @FryAmTheEggman, dass Sie mir gesagt haben , dass ich -anstelle von verwenden kann!}

Probieren Sie es hier aus

O, 8 Bytes

{_.@_-=}

Eine anonyme Funktion, die ein Zeichen und eine Zeichenfolge akzeptiert.

Probieren Sie es online aus.

Erläuterung

{_.@_-=}

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

Perl, 11 + 1 = 12 Bytes

$_=lc!~lc<>

Benötigt den -pSchalter und nimmt die Eingabe als$string\n$letter

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

Wie es funktioniert:

            # -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~

Probieren Sie es online!

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

Im Ernst, 6 Bytes

,ù,ùíu

Probieren Sie es online!

Übernimmt die Eingabe als 'string'\n'char'

Erläuterung:

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

uppercaseist ein langes Wort.

Wie es funktioniert

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

Ich bin nicht sicher, was in Retina als wahr / falsch gilt. Dies gibt die Zeile wieder, wenn es sich um ein Lipogramm für das angegebene Zeichen handelt, und gibt die leere Zeichenfolge zurück, wenn dies nicht der Fall ist.

Dies funktioniert auch bei mehrzeiliger Eingabe.

Probieren Sie es online!

Minkolang 0,15 , 10 Bytes

$or7Z0Z,N.

Probieren Sie es hier aus.

Erläuterung

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

Rust, 75 Bytes

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

Die höchste Punktzahl bedeutet, dass ich gewinne, oder? > _ <

Probieren Sie es hier aus.

Gelee, 8 Bytes

ḢO^O&95P

Probieren Sie es online!

Wie es funktioniert

Ḣ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=!}

Eine anonyme Funktion (Block), die ein Zeichen (keine Zeichenfolge!) Und eine Zeichenfolge enthält.

Probieren Sie es online aus.

Erläuterung

{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

Verwendet den -notmatchOperator und gibt einfach Trueoder aus False.

Python, 34 Bytes

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

Prüft , ob ein Zeichen cin einer Zeichenfolge enthalten ist s, und ignoriert die Groß- / Kleinschreibung, indem eine Kopie von san angehängt wird s. Die Verneinung ist damit erledigt not, was zwar langwierig aussieht, aber ich sehe nicht besser. Das ist die gleiche Länge:

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

Sie können die Parens nicht weglassen, sonst interpretiert Python den Ausdruck als verkettete Ungleichung der Form mit drei Werten _ in _ < _.

Python 3.5 sollte 33 Bytes über Set-Konvertierungen zulassen, obwohl ich es jetzt nicht testen kann.

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

Pyke, 7 Bytes

Dl3+R{!

Erläuterung:

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

Nimmt den gesamten String als Argument. Ich kann keine Bytes speichern, indem ich zwei verschiedene Argumente akzeptiere, weil dann meine Antwort mit der anderen ES6-Antwort verschmelzen würde :(

R, 26 Bytes

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

x ist der String, y ist der Buchstabe, das T im Aufruf von grepl unterscheidet nicht zwischen Groß- und Kleinschreibung.

Jolf, 6 7 Bytes

Damit. Viele. Sixes. SMS? Nun, versuchen Sie es trotzdem hier . Ersetzen ⌂durch \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
}

Batch, 53 Bytes

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

Akzeptiert Eingaben als zwei Befehlszeilenargumente. (Geben Sie bei Bedarf das zweite Argument an.) Gibt 1 bei Erfolg aus, nichts, wenn das erste Argument (unempfindlich) im zweiten gefunden wird.

Mathematica, 33 32 Bytes

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

Ich liebe es, wenn ## verwendet werden kann. Eingabe ist String, dann char.

Oder eine Version, bei der zwischen Groß- und Kleinschreibung unterschieden wird: (11 Bytes :)

StringFreeQ

Ja, nur eine eingebaute.