Desafio:

Dada uma palavra, verifique se é um isograma.

O que :

Um isograma é uma palavra que consiste apenas em letras sem duplicatas (sem distinção entre maiúsculas e minúsculas). A cadeia vazia é um isograma.

Exemplos :

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

Entrada :

Você pode aceitar entrada em qualquer formato razoável

A entrada conterá apenas letras e / ou números, sem espaços ( [a-zA-Z0-9])

Resultado :

• true ou qualquer valor verdadeiro se a entrada for um isograma
• false ou qualquer valor falso, caso contrário

Este é o código-golfe, pelo que o código mais curto em bytes em cada idioma vence.

Python 2/ 3, 36 52 48 bytes

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

Experimente online!

Aproveito o fato de que setcontém apenas elementos únicos. Invocando o __len__método de cada um, posso determinar se stambém contém apenas elementos únicos (ignorando maiúsculas e minúsculas).

EDIT: Atualizado para satisfazer o requisito anteriormente esquecido de retornar False para entradas numéricas. O conjunto de todos os dígitos é codificado como set(str(56**7)).

EDIÇÃO 2: Seguindo esta sugestão do usuário , agora aproveito a descompactação dos argumentos para definir a compreensão. Isso formalmente quebra a compatibilidade com o Python 2.

05AB1E , 5 bytes

lDáÙQ

Experimente online!

Explicação

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

Experimente online!

Abordagem Regex. !grepl(regex,scan(,""),F)não funcionou, então acho que capturar não corresponde a maiúsculas e minúsculas no R? Eu sou ruim em regex em geral, no entanto, então não ficarei surpreso se estiver fazendo errado ...

R , 58 bytes

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

Experimente online!

Anexa os dígitos 0:9à lista (em minúsculas) de caracteres e testa se há duplicatas.

Ruby , 25 23 21 bytes

-2 bytes em ambos graças a Giuseppe

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

Experimente online!

-2 bytes graças a Kirill L.

Ruby -n , 21 19 18 16 bytes

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

Experimente online!

Braquilog , 4 bytes

ḷo⊆Ạ

Experimente online!

O predicado será bem-sucedido se a entrada for um isograma e falhará se não for, exibindo o alfabeto latino em minúsculas se for bem-sucedido. Como o ⊆predicado interno do Brachylog não corresponde exatamente ao relacionamento comum entre um subconjunto e um superconjunto, tive que gastar um byte na classificação da entrada em minúsculas, mas economizei um byte por não ter que procurar explicitamente por duplicatas. (Se não precisasse falhar com os números, poderíamos usar ḷ≠.)

Casca , 6 bytes

§=f√ü_

Experimente online!

Explicação

§=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

Japonês , 12 bytes

;v
oC ‰ eUq

Explicação:

;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

Experimente aqui.

MATL , 9 bytes

kt2Y2X&X=

Experimente 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()})

Experimente online!

Japonês 2.0, 12 11 bytes

-1 byte graças a Nit

v
f\l â eUq

Teste online!

JavaScript (Node.js) , 29 25 bytes

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

Experimente online!

Obrigado pela atualização da resposta para @BMO , @ l4m2 , @KevinCruijssen

-4 bytes graças a @KevinCruijssen

Retina , 16 bytes

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

Retorna 1como valores Truthy e 0Falsey.
obrigado @ Neil por descobrir e corrigir um bug no meu código inicial.

Experimente online.

Explicação:

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'

Experimente online!

Solução ingênua, mas não consigo criar um algoritmo melhor. Pega entrada $b, converte ToUppercaixa, lança como charmatriz. Canais na matriz na Group-Objectqual constrói um objeto que possui pares nome / contagem para cada letra de entrada. Nós, então, sortque, com base na count e tomar o 0th um dos mesmos. Verificamos se .Counté -equal ao .Countúltimo [-1]par. Nesse caso, as contagens são todas iguais, caso contrário, temos uma quantidade diferente de letras.

Em seguida, -andverificamos se a entrada -notmatché contra \dpara excluir algum dígito na entrada. Esse resultado booleano é deixado no pipeline e a saída é implícita.

Geléia , 8 bytes

ŒufØA⁼QƲ

Experimente online!

Python 2 , 57 56 bytes

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

Experimente online!

Primeiro, ele transforma a entrada em um conjunto, removendo as duplicatas, depois remove os dígitos (codificados `763**4`), depois verifica se o comprimento é igual ao da entrada original

Java 8, 61 39 bytes

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

Explicação:

Experimente online.

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

Explicação Regex:

String#matchesadiciona implicitamente ^...$.

^(?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 bytes

Função tácita anônima.

(∪≡~∘⎕D)819⌶

Experimente online!

819⌶ minúsculas

(… ) Aplique a seguinte função tácita nisso:

 ~∘⎕D remover D igits do argumento

 ∪≡ os elementos únicos do argumento são idênticos a isso?

Perl 6 , 22 bytes

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

Experimente online!

Não há correspondências para algum caractere e depois o mesmo caractere. Função implícita como um bloco de código, corresponde implicitamente a $ _, inverte livro com !. Adicionado |\d(ta Adam), mas também necessário .uc~~, que precisava de parênteses ...

Alternativa com malas, 23 bytes

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

Experimente online!

Este caso normaliza, em seguida, faz uma bolsa (definida com contagens de incidência). Subconjunto ou igual a true somente se todos os membros forem membros da Bolsa de comparação e todas as contagens de incidência forem menores ou iguais às da Bolsa de comparação. Portanto, qualquer repetição ou dígito tornaria a comparação falsa.

Rápido , 81 bytes

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

Experimente online!

Visual Basic for Applications (32 bits), 102 bytes

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

Usou o fato de que no VBA 0^xproduz 1 se x for zero e 0 caso contrário. Execute na janela imediata (depuração).

Edit: como apontado por Taylor nos comentários, isso só funciona em instalações de 32 bits do MS Office.

05AB1E , 4 bytes

lDÔQ

Experimente online!

Explicação

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

• Salvou dois quatro bytes graças ao 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;}

Experimente online!

K (ngn / k) , 18 bytes

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

Experimente online!

CJam , 11 bytes

qelA,s+_L|=

Experimente online!

Explicação

A idéia básica é acrescentar cada dígito e procurar duplicatas. Como o apêndice garante que cada dígito já esteja presente uma vez, qualquer presença adicional de dígitos será duplicada, fazendo com que ele retorne falso.

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

Vermelho , 76 bytes

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

Experimente online!

Smalltalk, 57 bytes

Método a ser definido na classe String:

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

Isso é provavelmente auto-explicativo.

Pitão , 17 bytes

.Am&!t/rz0d}dGrz0

Suíte de teste

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

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

editar: teste adicionado para char

edit: usando GroupBy para encurtá-lo em 5 bytes

APL (Dyalog Unicode) , 25 20 22 bytes

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

Experimente online!

Retorna 1 para true, caso contrário 0.

Guardado 5 bytes graças a @ H.PWiz

Corrigido e salvo outro byte graças a @ Adám

Quão?

''≡'(.).*\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}

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

Experimente online!

Ainda é muito longo para o meu gosto!