Herausforderung :

Überprüfen Sie mit einem bestimmten Wort, ob es sich um ein Isogramm handelt.

Was:

Ein Isogramm ist ein Wort, das nur aus Buchstaben ohne Duplikate besteht (Groß- / Kleinschreibung wird nicht berücksichtigt). Die leere Zeichenfolge ist ein Isogramm.

Beispiele:

"Dermatoglyphics"     ---> true
"ab"                  ---> true
"aba"                 ---> false
"moOse"               ---> false
"abc1"                ---> false
""                    ---> true

Eingabe:

Sie können Eingaben in jedem angemessenen Format akzeptieren

Die Eingabe enthält nur Buchstaben und / oder Zahlen, keine Leerzeichen ( [a-zA-Z0-9])

Ausgabe :

• true oder ein beliebiger Wahrheitswert, wenn die Eingabe ein Isogramm ist
• false oder irgendein falscher Wert anders

Dies ist Code-Golf, so dass der kürzeste Code in Bytes in jeder Sprache gewinnt.

Python 2/ 3 36 52 48 Bytes

lambda s:len(s)==len({*s.lower()}-{*str(56**7)})

Probieren Sie es online!

Ich nutze die Tatsache, dass setnur einzigartige Elemente enthält. Durch Aufrufen der __len__jeweiligen Methode kann ich feststellen, ob sauch nur eindeutige Elemente enthalten sind (Groß- / Kleinschreibung wird ignoriert).

BEARBEITEN: Aktualisiert, um die zuvor übersehene Anforderung zu erfüllen, bei numerischen Eingaben Falsch zurückzugeben. Der Satz aller Ziffern wird als codiert set(str(56**7)).

BEARBEITEN 2: Nach diesem Benutzervorschlag nutze ich jetzt das Auspacken der Argumente, um das Verständnis festzulegen. Dies bricht die Kompatibilität mit Python 2 förmlich.

05AB1E , 5 Bytes

lDáÙQ

Probieren Sie es online!

Erläuterung

l        # convert input to lower-case
 D       # duplicate
  á      # keep only letters
   Ù      # remove duplicates
    Q     # compare for equality

R , 41 Bytes

!grepl("(.).*\\1|\\d",tolower(scan(,"")))

Probieren Sie es online!

Regex-Ansatz. !grepl(regex,scan(,""),F)hat nicht funktioniert, weshalb die Erfassung in R wohl nicht ohne Berücksichtigung der Groß- / Kleinschreibung funktioniert? Ich bin im Allgemeinen schlecht im Regex, daher wundere ich mich nicht, wenn ich es nur falsch mache ...

R , 58 Bytes

!anyDuplicated(c(el(strsplit(tolower(scan(,"")),"")),0:9))

Probieren Sie es online!

Hängt die Ziffern 0:9an die (in Kleinbuchstaben gesetzte ) Liste der Zeichen an und prüft, ob Duplikate vorhanden sind.

Ruby , 25 23 21 Bytes

-2 Bytes auf beiden dank Giuseppe

->s{/(.).*\1|\d/i!~s}

Probieren Sie es online!

-2 Bytes dank Kirill L.

Ruby -n , 21 19 18 16 Bytes

p !/(.).*\1|\d/i

Probieren Sie es online!

Brachylog , 4 Bytes

ḷo⊆Ạ

Probieren Sie es online!

Das Prädikat ist erfolgreich, wenn die Eingabe ein Isogramm ist, und schlägt fehl, wenn dies nicht der Fall ist. Wenn dies erfolgreich ist, wird das lateinische Kleinbuchstaben ausgegeben. Da das ⊆eingebaute Prädikat von Brachylog nicht genau mit der gewöhnlichen Beziehung zwischen einer Teilmenge und einer Obermenge übereinstimmt, musste ich ein Byte für das Sortieren der Eingabe in Kleinbuchstaben ausgeben, aber ein Byte einsparen, weil ich nicht explizit nach Duplikaten suchen musste. (Wenn es nicht mit Zahlen fehlschlagen musste, könnten wir einfach verwenden ḷ≠.)

Schale , 6 Bytes

§=f√ü_

Probieren Sie es online!

Erläuterung

§=f√ü_  -- takes a string as argument, eg: "sAad2"
§       -- fork the argument..
  f√    -- | filter out non-letters: "sad"
    ü_  -- | deduplicate by lower-case: "sAd2"
 =      -- ..and compare: 0

Japt , 12 Bytes

;v
oC ‰ eUq

Erläuterung:

;v
;         // Set alternative default vars, where C is the lowercase alphabet
 v        // Make the implicit input lowercase and reassign it
oC ‰ eUq
oC        // Remove all items from the input that are not in the alphabet
   ‰     // Split into chars and select unique array items
      eUq // Check if the result is equal to the input split into chars

Probieren Sie es hier aus.

MATL , 9 Bytes

kt2Y2X&X=

Probieren Sie es online!

k   % Lowercase implicit input
t   % Duplicate that
2Y2 % Push lowercase alphabet
X&  % Intersection of alphabet and duplicate lowercase input
X=  % Check for exact equality.

Python 3 , 46 Bytes

lambda s:s.isalpha()*len(s)==len({*s.lower()})

Probieren Sie es online!

Japt 2.0, 12 11 Bytes

-1 Byte dank Nit

v
f\l â eUq

Online testen!

JavaScript (Node.js) , 29 25 Bytes

s=>!/(.).*\1|\d/i.test(s)

Probieren Sie es online!

Vielen Dank für das Update auf Antwort an @BMO , @ l4m2 , @KevinCruijssen

-4 Bytes dank @KevinCruijssen

Netzhaut , 16 Bytes

Ci`(.).*\1|\d
^0

Gibt 1als Truthy- und 0als Falsey-Werte zurück.
Vielen Dank an @Neil, dass Sie einen Fehler in meinem ursprünglichen Code entdeckt und behoben haben .

Probieren Sie es online aus.

Erläuterung:

C             Check if the input matches part of the following regex:
 i`            Case insensitivity enabled
               Check if part of the input matches either:
  (.)           A character `C`
     .*         followed by zero or more characters
       \1       followed by the same character `C` again
         |     Or
          \d    A digit
^0             Invert Truthy/Falsey, basically replacing every 0 with a 1,
               and every other value with a 1

PowerShell , 91 Byte

param($b)($a=[char[]]$b.ToUpper()|group|sort c*)[0].Count-eq$a[-1].count-and$b-notmatch'\d'

Probieren Sie es online!

Naive Lösung, aber ich kann mir keinen besseren Algorithmus ausdenken. Nimmt Eingaben auf $b, konvertiert die ToUpperGroß- / Kleinschreibung und wandelt sie in ein char-array um. Leitet das Array weiter, in Group-Objectdas ein Objekt mit Name / Anzahl-Paaren für jeden Eingabebuchstaben erstellt wird. Wir machen das dann sortanhand der cAnzahl und nehmen die0 th davon. Wir prüfen, ob sein .Countist -equal zu dem .Countdes letzten [-1]Paar. Wenn ja, dann sind die Zählungen alle gleich, ansonsten haben wir eine unterschiedliche Anzahl von Buchstaben.

Wir -andüberprüfen dann , ob die Eingabe -notmatchdagegen ist \d, Ziffern in der Eingabe auszuschließen. Dieses boolesche Ergebnis verbleibt in der Pipeline und die Ausgabe ist implizit.

Gelee , 8 Bytes

ŒufØA⁼QƲ

Probieren Sie es online!

Python 2 , 57 56 Bytes

x=input().lower()
print len(set(x)-set(`763**4`))/len(x)

Probieren Sie es online!

Zuerst wird eine Menge erstellt, dann werden die Duplikate entfernt und die Ziffern (kodiert `763**4`) entfernt. Anschließend wird überprüft, ob die Länge mit der ursprünglichen Eingabe übereinstimmt

Java 8, 61 39 Bytes

s->!s.matches("(?i).*((.).*\\2|\\d).*")

Erläuterung:

Probieren Sie es online aus.

s->  // Method with String parameter and boolean return-type
  !s.matches("(?i).*((.).*\\2|\\d).*")
     //  Return whether the input does not match the regex

Regex Erklärung:

String#matchesimplizit fügt hinzu ^...$.

^(?i).*((.).*\2|\d).*$
 (?i)                      Enable case insensitivity
^    .*                    Zero or more leading characters
       (       |  )        Followed by either:
        (.)                 Any character `C`
           .*               with zero or more characters in between
             \2             followed by that same character `C` again
               |           Or:
                \d          Any digit
                   .*$     Followed by zero or more trailing characters

APL (Dyalog Unicode) , 12 Byte

Anonyme stillschweigende Funktion.

(∪≡~∘⎕D)819⌶

Probieren Sie es online!

819⌶ Kleinbuchstaben

(… ) Wenden darauf folgende implizite Funktion an:

 ~∘⎕D Entfernen D igits aus dem Argument

 ∪≡ Sind die eindeutigen Elemente des Arguments damit identisch?

Perl 6 , 22 Bytes

{!(.uc~~/(.).*$0|\d/)}

Probieren Sie es online!

Keine Übereinstimmungen für ein Zeichen, später dasselbe Zeichen. Implizite Funktion als Codeblock, implizite Übereinstimmung mit $ _, Buch mit invertieren !. Hinzugefügt |\d(ta Adam), aber auch benötigt .uc~~, was Klammern benötigt ...

Alternative mit Taschen, 23 Bytes

{.uc.ords.Bag⊆65..97}

Probieren Sie es online!

Dieser eine normalisiert den Fall, macht dann eine Tasche (gesetzt mit Inzidenzzählern). Teilmenge oder gleich nur wahr, wenn alle Mitglieder Mitglieder des Vergleichsbeutels sind und alle Inzidenzzahlen kleiner oder gleich denen des Vergleichsbeutels sind. Alle Wiederholungen oder Ziffern würden den Vergleich falsch machen.

Schnell , 81 Bytes

let s=readLine()!.lowercased().characters;print(s.count<1||Set(s).count==s.count)

Probieren Sie es online!

Visual Basic für Applikationen (32 Bit), 102 Byte

s=LCase(InputBox(u)):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^Instr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>0

Verwendet die Tatsache, dass in VBA 0^x 1 ergibt, wenn x Null ist und 0 sonst. Im sofortigen (Debug-) Fenster ausführen.

Bearbeiten: Wie Taylor in den Kommentaren ausgeführt hat, funktioniert dies nur bei 32-Bit-Installationen von MS Office.

05AB1E , 4 Bytes

lDÔQ

Probieren Sie es online!

Erläuterung

l      # convert input to lowercase
 D     # duplicate and push to stack
  Ô    # uniquify the list of characters
   Q   # check for equality

C (GCC) , 87 85 83 Bytes

• Gespeichert zwei vier Bytes dank ceilingcat .

f(s,p,b,P)char*s,*p;{for(b=s;*s;++s)for(p=b*=*s>64;b&&p<s;b=(*s^*p++)&95?b:0);s=b;}

Probieren Sie es online!

K (ngn / k) , 18 Bytes

{(a^,/$!10)~?a:_x}

Probieren Sie es online!

CJam , 11 Bytes

qelA,s+_L|=

Probieren Sie es online!

Erläuterung

Die Grundidee ist, jede Ziffer anzuhängen und dann nach Duplikaten zu suchen. Da durch das Anhängen sichergestellt wird, dass jede Ziffer bereits einmal vorhanden ist, ist jedes weitere Vorhandensein von Ziffern ein Duplikat, wodurch False zurückgegeben wird.

q      e# read the input:            | "MOoSE1"
el     e# convert to lowercase:      | "moose1"
A      e# push 10:                   | "moose1" 10
,      e# range [0,N):               | "moose1" [0 1 2 3 4 5 6 7 8 9]
s      e# string representation:     | "moose1" "0123456789"
+      e# concatenate:               | "moose10123456789"
_      e# duplicate:                 | "moose10123456789" "moose10123456789"
L|     e# union with the empty list: | "moose10123456789" "mose1023456789"
       e# (this gets rid of duplicates)
=      e# Equal to original:         | 0

Rot , 76 Bytes

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]parse s[any[copy c a ahead not to c]]]

Probieren Sie es online!

Smalltalk, 57 Bytes

Methode, die in der Klasse String definiert werden soll:

s^(self select:#isLetter)asUppercase asSet size=self size

Dies ist höchstwahrscheinlich selbsterklärend.

Pyth , 17 Bytes

.Am&!t/rz0d}dGrz0

Testsuite

.Am&!t/rz0d}dGrz0 # Code
  m           rz0 # Map the following over the lowercase input:
      /rz0d       #  Count occurrences of d in lowercase input
     t            #   minus 1
    !             #    inverted (0 -> True)
   &              #     and
           }dG    #      d is in the lowercase alphabet
.A                # Print whether all values are truthy

z=input()
print(all(map(lambda d:not z.lower().count(d)-1and d in "abcdefghijklmnopqrstuvwxyz",z.lower())))

82 Bytes

bool f(string s)=>!!(s.GroupBy(c=>c).Any(c=>c.Count()>1|(!Char.IsLetter(c.Key))));

edit: test für char hinzugefügt

edit: mit GroupBy um 5 Byte kürzen

APL (Dyalog Unicode) , 25 - 20 - 22 Byte

''≡'(.).*\1|\d'⎕S'&'⍠1

Probieren Sie es online!

Gibt 1 für true zurück, sonst 0.

5 Bytes gespart dank @ H.PWiz

Behoben und ein weiteres Byte dank @ Adám gespeichert

Wie?

''≡'(.).*\1|\d'⎕S'&'⍠1 ⍝ Tacit fn
                    ⍠1 ⍝ Ignore case
               ⎕S'&'   ⍝ Search and return the match(es)
   '(.).*\1|\d'        ⍝ For this regex
''≡                    ⍝ And compare to the empty string

Tcl , 114 Bytes

proc I w {lmap c [set L [split $w ""]] {if {[regexp -all -nocase $c $w]>1|![string is alp $c]} {return 0}}
expr 1}

Probieren Sie es online!

proc I w {lmap c [set L [split $w ""]] {if {[llength [lsearch -al -noc $L $c]]>1|![string is alp $c]} {return 0}}
expr 1}

Probieren Sie es online!

Für meinen Geschmack noch zu lang!