Desafío :

Dada una palabra, verifique si es o no un isograma.

Qué :

Un isograma es una palabra que consta solo de letras sin duplicados (sin distinción entre mayúsculas y minúsculas). La cadena vacía es un isograma.

Ejemplos:

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

Entrada:

Puede aceptar entradas en cualquier formato razonable

La entrada solo contendrá letras y / o números, sin espacios ( [a-zA-Z0-9])

Salida:

• true o cualquier valor verdadero si la entrada es un isograma
• false o cualquier valor falso de lo contrario

Este es el código de golf, por lo que gana el código más corto en bytes en cada idioma.

Python 2/ 3, 36 52 48 bytes

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

Pruébalo en línea!

Aprovecho el hecho de que setcontiene solo elementos únicos. Al invocar el __len__método de cada uno, puedo determinar si stambién contiene elementos únicos (ignorando mayúsculas y minúsculas).

EDITAR: actualizado para satisfacer el requisito anteriormente ignorado de devolver False para entradas numéricas. El conjunto de todos los dígitos se codifica como set(str(56**7)).

EDITAR 2: Siguiendo esta sugerencia del usuario , ahora aprovecho para desempaquetar los argumentos para establecer la comprensión. Esto rompe formalmente la compatibilidad con Python 2.

05AB1E , 5 bytes

lDáÙQ

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Enfoque de expresiones regulares. !grepl(regex,scan(,""),F)no funcionó, así que supongo que la captura no coincide con mayúsculas y minúsculas en R? Sin embargo, soy malo en expresiones regulares en general, así que no me sorprenderé si lo estoy haciendo mal ...

R , 58 bytes

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

Pruébalo en línea!

Agrega los dígitos 0:9a la lista (minúscula) de caracteres y prueba si hay duplicados.

Ruby , 25 23 21 bytes

-2 bytes en ambos gracias a Giuseppe

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

Pruébalo en línea!

-2 bytes gracias a Kirill L.

Ruby -n , 21 19 18 16 bytes

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

Pruébalo en línea!

Brachylog , 4 bytes

ḷo⊆Ạ

Pruébalo en línea!

El predicado tendrá éxito si la entrada es un isograma y fallará si no lo es, generando el alfabeto latino en minúsculas si tiene éxito. Dado que el ⊆predicado incorporado de Brachylog no coincide exactamente con la relación ordinaria entre un subconjunto y un superconjunto, tuve que gastar un byte en ordenar la entrada en minúsculas, pero guardé un byte al no tener que buscar explícitamente duplicados en él. (Si no necesita fallar con los números, podríamos usarlo ḷ≠).

Casco , 6 bytes

§=f√ü_

Pruébalo en línea!

Explicación

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

Explicación:

;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

Pruébalo aquí.

MATL , 9 bytes

kt2Y2X&X=

Pruébalo en línea!

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

Pruébalo en línea!

Japt 2.0, 12 11 bytes

-1 byte gracias a Nit

v
f\l â eUq

¡Pruébalo en línea!

JavaScript (Node.js) , 29 25 bytes

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

Pruébalo en línea!

Gracias por la actualización sobre la respuesta a @BMO , @ l4m2 , @KevinCruijssen

-4 bytes gracias a @KevinCruijssen

Retina , 16 bytes

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

Devuelve 1como 0valores de Verdad y Falsey.
Gracias @Neil por descubrir y corregir un error en mi código inicial.

Pruébalo en línea.

Explicación:

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'

Pruébalo en línea!

Solución ingenua, pero no puedo encontrar un algoritmo mejor. Toma datos $b, los convierte en ToUppermayúsculas y minúsculas, lo convierte en una charmatriz. Tuberías en esa matriz en la Group-Objectque se construye un objeto que tiene pares de nombre / recuento para cada letra de entrada. Luego, basamos sorteso en la cbúsqueda y tomamos la 0tercera. Verificamos que .Countsea -equal al .Countdel último [-1]par. Si es así, los recuentos son todos iguales, de lo contrario, tenemos una cantidad diferente de letras.

Luego, -andcomprobamos si la entrada -notmatchestá en contra \dpara descartar cualquier dígito en la entrada. Ese resultado booleano se deja en la tubería y la salida es implícita.

Jalea , 8 bytes

ŒufØA⁼QƲ

Pruébalo en línea!

Python 2 , 57 56 bytes

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

Pruébalo en línea!

Primero convierte la entrada en un conjunto, elimina los duplicados, luego elimina los dígitos (codificados `763**4`), luego verifica si la longitud es la misma que la entrada original

Java 8, 61 39 bytes

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

Explicación:

Pruébalo en línea.

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

Explicación de expresiones regulares:

String#matchesagrega implícitamente ^...$.

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

Función tácita anónima.

(∪≡~∘⎕D)819⌶

Pruébalo en línea!

819⌶ minúsculas

(... ) aplique la siguiente función tácita sobre eso:

 ~∘⎕D eliminar D igits del argumento

 ∪≡ ¿Son los elementos únicos del argumento idénticos a eso?

Perl 6 , 22 bytes

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

Pruébalo en línea!

No hay coincidencias para algún personaje, luego el mismo personaje. Función implícita como un bloque de código, coincide implícitamente en $ _, invierte el libro con !. Agregado |\d(ta Adam) pero también necesario .uc~~, que necesitaba paréntesis ...

Alternativa con bolsas, 23 bytes

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

Pruébalo en línea!

Este caso normaliza entonces hace una bolsa (con recuentos de incidencia). Subconjunto o igual solo es cierto si todos los miembros son miembros de la Bolsa de comparación, y todos los recuentos de incidencia son menores o iguales a los de la Bolsa de comparación. Entonces, cualquier repetición o dígito haría que la comparación sea falsa.

Rápido , 81 bytes

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

Pruébalo en línea!

Visual Basic para aplicaciones (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

Usó el hecho de que en VBA 0^xproduce 1 si x es cero y 0 en caso contrario. Ejecutar en la ventana inmediata (depuración).

Editar: como señaló Taylor en los comentarios, esto solo funciona en instalaciones de 32 bits de MS Office.

05AB1E , 4 bytes

lDÔQ

Pruébalo en línea!

Explicación

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

• Guardado dos de cuatro bytes gracias a 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;}

Pruébalo en línea!

K (ngn / k) , 18 bytes

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

Pruébalo en línea!

CJam , 11 bytes

qelA,s+_L|=

Pruébalo en línea!

Explicación

La idea básica es agregar cada dígito y luego verificar si hay duplicados. Dado que el anexo asegura que cada dígito ya esté presente una vez, cualquier presencia adicional de dígitos será un duplicado, lo que hará que devuelva 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

Rojo , 76 bytes

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

Pruébalo en línea!

Smalltalk, 57 bytes

Método a definir en la clase Cadena:

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

Esto es muy probable que se explique por sí mismo.

Pyth , 17 bytes

.Am&!t/rz0d}dGrz0

Banco de pruebas

.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: prueba agregada para char

editar: usar GroupBy para acortarlo en 5 bytes

APL (Dyalog Unicode) , 25 20 22 bytes

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

Pruébalo en línea!

Devuelve 1 para verdadero, de lo contrario 0.

Guardado 5 bytes gracias a @ H.PWiz

Se corrigió y guardó otro byte gracias a @ Adám

¿Cómo?

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

Pruébalo en línea!

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}

Pruébalo en línea!

Todavía es demasiado largo para mi gusto!