Вызов :

По заданному слову проверьте, является ли это изограммой.

Какая :

Изограмма - это слово, состоящее только из букв без дубликатов (без учета регистра). Пустая строка является изограммой.

Примеры :

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

Вход:

Вы можете принять ввод в любом разумном формате

Ввод будет содержать только буквы и / или цифры, без пробелов ( [a-zA-Z0-9])

Выход :

• true или любое истинное значение, если вход является изограммой
• false или любое ложное значение в противном случае

Это код-гольф, поэтому выигрывает самый короткий код в байтах на каждом языке.

Python 2/ 3, 36 52 48 байт

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

Попробуйте онлайн!

Я пользуюсь тем, что setсодержит только уникальные элементы. Вызывая __len__метод каждого из них, я могу определить, sсодержит ли он также только уникальные элементы (без учета регистра).

РЕДАКТИРОВАТЬ: Обновлено, чтобы удовлетворить ранее пропущенное требование возвращать False для числовых входов. Набор всех цифр кодируется как set(str(56**7)).

РЕДАКТИРОВАТЬ 2: После этого предложения пользователя , я теперь пользуюсь распаковкой аргументов, чтобы установить понимание. Это формально нарушает совместимость с Python 2.

05AB1E , 5 байтов

lDáÙQ

Попробуйте онлайн!

объяснение

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

R , 41 байт

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

Попробуйте онлайн!

Подход Regex. !grepl(regex,scan(,""),F)не сработало, так что я думаю, что захват не соответствует регистронезависимому в R? Я вообще плохо отношусь к регулярным выражениям, поэтому я не удивлюсь, если я просто делаю это неправильно ...

R , 58 байт

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

Попробуйте онлайн!

Добавляет цифры 0:9в (нижний регистр) список символов и проверяет наличие дубликатов.

Рубин , 25 23 21 байт

-2 байта на обоих благодаря Джузеппе

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

Попробуйте онлайн!

-2 байта благодаря Кириллу Л.

Рубин -n , 21 19 18 16 байт

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

Попробуйте онлайн!

Брахилог , 4 байта

ḷo⊆Ạ

Попробуйте онлайн!

Предикат будет успешным, если вход является изограммой, и потерпит неудачу, если это не так, и выдает строчный латинский алфавит, если он успешен Так как ⊆встроенный предикат Brachylog не совсем соответствует обычным отношениям между подмножеством и надмножеством, мне пришлось потратить байт на сортировку входных данных в нижнем регистре, но сэкономил байт на том, что нет необходимости явно проверять наличие дубликатов в нем. (Если это не нужно с ошибками с числами, мы могли бы просто использовать ḷ≠.)

Шелуха , 6 байт

§=f√ü_

Попробуйте онлайн!

объяснение

§=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 байт

;v
oC ‰ eUq

Объяснение:

;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

Попробуй это здесь.

MATL, 9 bytes

kt2Y2X&X=

Try it 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()})

Try it online!

Japt 2.0, 12 11 bytes

-1 byte thanks to Nit

v
f\l â eUq

Test it online!

JavaScript (Node.js), 29 25 bytes

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

Try it online!

Thanks for the update on answer to @BMO , @l4m2 , @KevinCruijssen

-4 bytes thanks to @KevinCruijssen

Retina, 16 bytes

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

Returns 1 as Truthy and 0 as Falsey values.
Thanks @Neil for discovering and fixing a bug in my initial code.

Try it online.

Explanation:

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 bytes

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

Try it online!

Naive solution, but I can't come up with a better algorithm. Takes input $b, converts it ToUppercase, casts it as a char-array. Pipes that array into Group-Object which constructs a object that has name/count pairs for each input letter. We then sort that based on the count and take the 0th one thereof. We check that its .Count is -equal to the .Count of the last [-1] pair. If so, then the counts are all equal, otherwise we have a different amount of letters.

We then -and that with checking whether the input -notmatches against \d to rule out any digits in the input. That Boolean result is left on the pipeline and output is implicit.

Jelly, 8 bytes

ŒufØA⁼QƲ

Try it online!

Python 2 , 57 56 байт

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

Попробуйте онлайн!

Сначала он поворачивается, затем вводится в набор, удаляя дубликаты, затем удаляет цифры (закодированные в `763**4`), а затем проверяет, совпадает ли длина с исходным вводом.

Java 8, 61 39 байт

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

Объяснение:

Попробуйте онлайн.

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

Regex объяснение:

String#matchesнеявно добавляет ^...$.

^(?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 байт

Анонимная молчаливая функция.

(∪≡~∘⎕D)819⌶

Попробуйте онлайн!

819⌶ в нижнем регистре

(… ) Примените к этому следующую молчаливую функцию:

 ~∘⎕D удалить D igits от аргумента

 ∪≡ уникальные элементы аргумента идентичны этому?

Perl 6 , 22 байта

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

Попробуйте онлайн!

Нет совпадений для какого-либо персонажа, затем того же персонажа. Неявная функция как блок кода, неявно совпадает с $ _, инвертирует книгу с !. Добавлено |\d(та Адам), но также необходимо.uc~~ , что необходимо скобки ...

Альтернатива с сумками, 23 байта

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

Попробуйте онлайн!

Этот случай нормализует, а затем делает мешок (набор с подсчетом случаев). Подмножество или равно только истина, если все участники являются членами Мешка сравнения, и все показатели заболеваемости меньше или равны количеству в Мешке сравнения. Таким образом, любые повторения или цифры сделают сравнение ложным.

Swift , 81 байт

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

Попробуйте онлайн!

Visual Basic для приложений (32 бита), 102 байта

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

Используется тот факт, что в VBA 0^xвыдает 1, если x равен нулю, и 0 в противном случае. Запустить в немедленном (отладочном) окне.

Редактировать: как отметил Тейлор в комментариях, это работает только в 32-битных установках MS Office.

05AB1E , 4 байта

lDÔQ

Попробуйте онлайн!

объяснение

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

• Saved two four bytes thanks to 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;}

Try it online!

К (нгн / к), 18 bytes

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

Попробуйте онлайн!

CJam , 11 байт

qelA,s+_L|=

Try it online!

Explanation

Основная идея состоит в том, чтобы добавить каждую цифру, а затем проверить на наличие дубликатов. Поскольку добавление гарантирует, что каждая цифра уже присутствует один раз, любое дальнейшее присутствие цифр будет дубликатом, в результате чего он будет возвращать false.

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

Красный , 76 байт

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

Попробуйте онлайн!

Smalltalk, 57 байт

Метод, который будет определен в классе String:

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

Это, скорее всего, говорит само за себя.

Pyth , 17 байт

.Am&!t/rz0d}dGrz0

Тестирование

.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())))

C #, 82 байта

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

редактировать: добавлен тест для символа

редактировать: используя GroupBy, чтобы сократить его на 5 байт

APL (Dyalog Unicode) , 25 20 22 байта

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

Попробуйте онлайн!

Возвращает 1 для истины, иначе 0.

Сохранено 5 байтов благодаря @ H.PWiz

Исправлено и сохранено еще один байт благодаря @ Adám

Как?

''≡'(.).*\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 байт

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

Попробуйте онлайн!

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}

Попробуйте онлайн!

Все еще слишком долго, на мой вкус!