Escriba una función / programa que acepte una cadena de letras minúsculas / mayúsculas [A-Za-z] como entrada, que verifique si las letras que aparecen son únicas y están en orden alfabético (ignorando mayúsculas y minúsculas) o no. El resultado debe ser verdadero si son únicos y en orden alfabético y falso si no.

Aquí algunos casos de prueba

a                           true
abcdefGHIjklmnopqrSTUVWXyz  true     
aa                          false
puz                         true
puzz                        false
puzZ                        false
puZ                         true
PuZ                         true
pzu                         false
pzU                         false
abcdABCD                    false
dcba                        false

Si lo desea, ejecute su programa en todas las palabras de una lista de palabras como esta y publique algunas interesantes =).

Puntuación

El menor número de bytes gana.

CJam, 8 bytes

lel_$_&=

Aquí hay un arnés de prueba para todos los ejemplos en el desafío. Esto devuelve 0o 1(que son falso y verdadero, respectivamente, en CJam).

Y aquí hay un script para filtrar la lista de palabras en la pregunta (tarda unos segundos en ejecutarse). Tendrá que copiar la lista de palabras en el campo de entrada manualmente, porque es demasiado larga para un enlace permanente.

Explicación

l        "Read input.";
 el      "Convert to lower case.";
   _$    "Get a copy and sort it.";
     _&  "Remove duplicates (by computing the set intersection with itself).";
       = "Check for equality with original (lower case) word.";

Regex (cualquier sabor), 55 bytes

Algunas personas no consideran que la expresión regular sea un lenguaje de programación, pero se ha usado antes y no está cerca de ser el más corto.

^a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?$

Agregué un byte para la marca i(sin distinción entre mayúsculas y minúsculas). Esto es muy sencillo y puede ser más corto de generar sobre la marcha.

Si regex solo no está permitido, puede usar este programa Retina de 56 bytes sugerido por Martin Büttner:

i`^a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?$

Ejecutar esto en la lista de palabras vinculada anteriormente produjo 10 palabras de 6 letras en orden alfabético.

["aborrece", "casi", "comienza", "begirt", "bijoux", "biopsia", "chimpancés", "chinos", "chintz", "fantasma"]

Python 3, 44 bytes

*s,=input().lower()
print(sorted(set(s))==s)

Un enfoque simple: verificar la unicidad, verificar la clasificación.

> <> , 52 42 39 bytes

0>i:1+?v1n;
? )'`':/'@'v
0v?){:-<'`'/;n

Este tipo de pregunta es uno de los pocos tipos con los que> <> se siente bastante cómodo, ya que solo necesitamos tratar con un personaje a la vez.

Explicación

¡No te pierdas! Hay mucha envoltura aquí.

0            Push 0. We'll be mapping a-z to 1-26, so 0 will be smaller than everything

(loop)
i            Read a char of input
:1+? 1n;     If there's no more input, print 1
:'`')?       If the char is bigger than backtick...
  '`'          Push backtick  (which is one before 'a'), else...
  '@'          Push an @ sign (which is one before 'A')
-            Subtract, mapping a-z to 1-26
:{)?         If the new char is bigger than the previous char...
               Repeat from the beginning of the loop, else...
  0n;          Print 0

Solución anterior, 42 bytes

0i:1+?v1n;n0/\!
?)'`':/'@'v
? ){:-<'`'/ vv

Lo interesante es que, a pesar de parecer tener la misma funcionalidad, la alternativa

0i:1+?v1n;n0\/!
?)'`':/'@'v
? ){:-<'`'/ ^^

(El cambio está en las flechas y los espejos en el extremo derecho)

en realidad da resultados incorrectos , debido a que el intérprete de> <> usa un defaultdict de Python. Lo que sucede es que, al atravesar el espacio vacío al final de la segunda fila, los 0 se colocan implícitamente en los espacios en blanco cuando> <> intenta acceder a la celda. Esto luego se mete con el ?trampolín condicional al comienzo de la misma fila, ya que los 0 recién colocados se omiten en lugar de val final.

Haskell, 52 bytes

import Data.Char
and.(zipWith(>)=<<tail).map toLower

Uso: (and.(zipWith(>)=<<tail).map toLower) "abcd"que salidas True.

C, 67 65 57 54 (52) caracteres

f(char*s){int c,d=0;for(;(c=*s++)&&(c&~32)>(d&~32);d=c);return!c;}

un poco más corto

f(char*s){int c,d=0;for(;(c=*s++)&&(c&~32)>d;d=c&~32);return!c;}

e incluso más corto:

f(char*s){int d=32;for(;(*s|32)>d;d=*s++|32);return!*s;}

Aquí hay una pequeña prueba: http://ideone.com/ZHd0xl

Después de las últimas sugerencias, aquí hay dos versiones más cortas:

// 54 bytes
f(char*s){int d=1;for(;(*s&=95)>d;d=*s++);return!*s;}

// 52, though not sure if valid because of global variable
d;f(char*s){d=1;for(;(*s&=95)>d;d=*s++);return!*s;}

Además, este código se basa en el hecho de que, en ASCII, las minúsculas y mayúsculas solo difieren en el quinto bit (32) que filtro. Por lo tanto, esto podría no funcionar con otras codificaciones, obviamente.

EDITAR: la última versión siempre establece el quinto bit como |32más corto que &~32.

Rubí, 33

->s{c=s.upcase.chars
c==c.sort|c}

Comprueba si los caracteres únicos ordenados son los mismos que todos los caracteres.

Javascript (ES5), 101

function i(s){b=0;l=''.a
s.toUpperCase().split('').forEach(function(c){if(c<=l)b=1
l=c})
return!b}

Mejorado a 87 por edc95:

votó su comentario :)

function i(s){return!s.toUpperCase().split(l='').some(function(c){return(u=l,l=c)<=u})}

Por cierto, los casos de prueba actualmente en OP se cumplen si un programa solo está verificando la unicidad, sin tener en cuenta el orden.

Todavía no puedo escribir comentarios, así que responderé algunos comentarios aquí:

@ edc65: ¡Gracias! Traté de reescribirlo usando some(), pero no pude obtener una solución más corta, porque aunque parece que me permitiría deshacerme de la variable superflous b, debe escribir "return" dos veces (lo mismo con reduce()), y usted no puede devolver el resultado de la comparación directamente, porque el último carácter debe guardarse después de la comparación con él.

@ edc65: ¡ Es un buen uso del operador de coma para 87! Lo edité en mi respuesta para mayor visibilidad.

Haskell, 90 bytes

Suministra la función f :: String -> Bool

import Data.List
import Distribution.Simple.Utils
f l=g$lowercase l
g l=sort l==l&&l==nub l

Uso (suponiendo que se guarde como golf.hs). ...se usa para reemplazar ghcilos mensajes detallados de carga.

$ ghci golf.hs
...
*Main> f "as"
...
True
*Main> f "aa"
False

Si alguien tiene un lowercasemétodo más corto que import Distribution.Simple.Utilsentonces, por favor comente.

Wolfram Mathematica, 49 37 bytes

f[x_]:=(l=Characters[ToLowerCase[x]];Union[l]==l)

PS Solución más corta de Martin Büttner:

Union[l=Characters@ToLowerCase@#]==l&

J, 17 bytes

Comprueba si la /:~cadena ordenada en minúscula es igual a -:la ~.cadena de protuberancia en minúscula .

   (/:~-:~.)@tolower

   NB. testing with the example inputs
   ((/:~-:~.)@tolower) every (1$'a');'abcdefGHIjklmnopqrSTUVWXyz';'aa';'puz';'puzz';'puzZ';'puZ';'PuZ'
1 1 0 1 0 0 1 1

Al igual que en J, una "cadena" larga de 1 carácter representada como una cadena regular (con comillas) es solo un átomo de caracteres, no una cadena real. (En el ejemplo anterior que usé 1$'a').

MATLAB, 29 27 bytes

Ahora para una línea que incluso tiene sentido fuera del código de golf.

Como una función anónima (usar como o('yourstring'))

o=@(s)all(diff(lower(s))>0)

Supongo que esta función se explica por sí misma, ya que se lee como un anuncio de periódico.

Versión anterior (29 bytes):

all(diff(lower(input('')))>0)

La entrada debe presentarse entre 'marcas, p 'Potato'. Ej .

Brachylog , 3 bytes

ḷ⊆Ạ

Pruébalo en línea!

El predicado tiene éxito si la entrada cumple con los requisitos descritos y falla si no lo hace, imprimiendo true.o false.si se ejecuta como un programa.

       The input,
ḷ      lowercased,
 ⊆     is a not-necessarily-contiguous sub-list of
  Ạ    "abcdefghijklmnopqrstuvwxyz".

La primera versión que se me ocurrió, sin hacer referencia explícita al alfabeto:

Brachylog , 4 bytes

ḷ≠.o

Pruébalo en línea!

        The input,
ḷ       lowercased,
 ≠      in which every character is distinct,
  .     is the output variable,
   o    which sorted,
        is still the output variable.

J, 21 caracteres

Esto es demasiado largo. El argumento debe tener rango 1, es decir, debe ser una cadena o un vector.

*/@(<=~.;/:~)@tolower

• tolower y- yen minúsculas.
• /:~ y- yen orden léxico.
• ~. y- la protuberancia de y, es decir, ycon los duplicados eliminados.
• x ; y- xy yponer en cajas y luego concatenar.
• < y- yponer en una caja.
• x = y- x comparado en cuanto a elementos con y.
• (< y) = (~. y) ; (/:~ y)- un vector que indica si yes igual a su protuberancia y está ordenado.
• */ y- el producto de los elementos de y, o su lógica y si los elementos son booleanos.
• */ (< y) = (~. y) ; (/:~ y)- un booleano que indica la propiedad deseada para minúsculas y.

Julia, 44 bytes

s->(l=lowercase(s);l==join(sort(unique(l))))

Esto crea una función anónima que toma un único argumento s, lo convierte a minúsculas y lo compara con la versión única ordenada de la cadena. Devuelve un valor booleano, es decir, trueo false. Si desea probarlo, asígnelo como f=s->...y luego llame f("PuZ"), etc.

Pure Bash 4.x, 37

[[ ${1,,} =~ ^`printf %s? {a..z}`$ ]]

Entrada tomada como un parámetro de línea de comando. Según la semántica de shell estándar, el código de salida 0 significa verdadero (alfabético) y el código de salida! = 0 significa falso (no alfabético).

El printf crea la expresión regular como en la solución de @ hsl . La cadena de entrada se expande a minúsculas y se compara con la expresión regular.

Respuesta anterior:

Bash + coreutils, 52

Solución directa:

a=`fold -1<<<${1,,}`
cmp -s <(sort -u<<<"$a")<<<"$a"

C # 6, 18 + 82 76 = 94 bytes

Requiere (18 bytes):

using System.Linq;

Código (76 bytes):

bool a(string s)=>(s=s.ToLower()).Distinct().OrderBy(x=>x).SequenceEqual(s);

C # 6 admite lambdas para definir una función, que es útil para jugar al golf.

Versión no C # 6:

bool a(string s){return (s=s.ToLower()).Distinct().OrderBy(x=>x).SequenceEqual(s);}

Código sin golf:

bool IsInAlphabeticalOrder(string s)
{
    s = s.ToLower();
    return s.Distinct()
            .OrderBy(x => x)
            .SequenceEqual(s);
}

JavaScript (ES6) 54

Convierte a mayúsculas, luego a matriz y ordena. Si durante la ordenación dos elementos están en el orden incorrecto o igual, devuelve 0 (falso) más 1 (verdadero)

Editar acortado thx a @Optimizer (pero todavía 2 más de la solución @Tamas implementado en ES6: F=s=>[...s.toUpperCase()].every(c=>(u=l,l=c)>u,l=''))

F=s=>[...s.toUpperCase(x=1)].sort((a,b)=>a<b?1:x=0)&&x

Prueba en la consola Firefox / FireBug

;['a','abcdefGHIjklmnopqrSTUVWXyz','aa','puz','puzz','puzZ','puZ','PuZ']
.map(w=>w+' '+F(w))

["a 1", "abcdefGHIjklmnopqrSTUVWXyz 1", "aa 0", "puz 1", "puzz 0", "puzZ 0", "puZ 1", "PuZ 1"]

C (44 bytes)

f(char*s){return(*s&=95)?f(s+1)>*s?*s:0:96;}

Pruébalo aquí: http://ideone.com/q1LL3E

Publicar esto porque todavía no puedo comentar, de lo contrario sería una sugerencia para mejorar la respuesta C existente porque robé por completo la idea que no distingue entre mayúsculas y minúsculas de la respuesta C existente.

Devuelve 0 si la cadena no está ordenada y un valor distinto de cero si está ordenado.

Golang (65 bytes)

Ir no es un lenguaje amigable para el golf, también, soy un asco en el golf ...

func a(s[]byte)(bool){return len(s)<2||s[0]|32<s[1]|32&&a(s[1:])}

Ejecútelo aquí: http://play.golang.org/p/xXJX8GjDvr

editar 106-> 102

editar 102-> 96

editar 96-> 91

editar 91-> 87

editar 87-> 65

Batí la versión de Java, puedo parar por hoy

Java 8 - 90 89 87 85 caracteres

La idea aquí es utilizar una función 'reducir' que rastrea el último carácter y "se da por vencido" cuando detecta que la secuencia no es estrictamente ascendente.

golfizado:

int f(String s){return s.toLowerCase().chars().reduce(0,(v,c)->(v<0)?v:(c>v)?c:-1);}

sin golf:

int f(String s){
    return s.toLowerCase()
            .chars()
            .reduce(0, (v,c) -> (v<0)? v : (c>v)?c:-1);
}

ejemplo:

System.out.println(new Quick().f("abc"));
System.out.println(new Quick().f("aa"));
System.out.println(new Quick().f("abcdefGHIjklmnopqrSTUVWXyz"));
System.out.println(new Quick().f("puZ"));
System.out.println(new Quick().f("Puz"));
System.out.println(new Quick().f("cba"));

salida:

99
-1
122
122
122
-1

Perl 6, 35 bytes

{my@c=.uc.comb;@c eq@c.sort.unique}

Esto produce un bloque invocable; Si pudiera suponer que $_ya está configurado para la palabra deseada, podría eliminar las llaves y perder dos bytes más, pero probablemente la única forma razonable de hacer esa suposición sería ejecutarlo -ny alimentar la palabra como entrada estándar , que agregaría los dos bytes de vuelta.

R , 37 bytes

all(diff(utf8ToInt(scan(,''))%%32)>0)

Pruébalo en línea!

Publicar ya que esto es sustancialmente diferente y más corto que la respuesta R de Michal .

Convierte las letras en puntos de código ASCII con utf8ToInt, luego toma el módulo 32 para que las letras inferiores y superiores se conviertan en los mismos números 1 ... 26. Calcula las diferencias por pares y verifica que todas sean positivas.

Perl, 27

La expresión regular de @ hsl se construye dinámicamente.

#!perl -p
$"="?";@x=a..z;$_=/^@x?$/i

También podemos hacer una coincidencia inversa: convertir la entrada en una expresión regular: PuZ=> .*p.*u.*z.*y luego hacer coincidir esto con una cadena de letras en orden alfabético. Resultado: también 27 caracteres.

#!perl -lp
$_=join(s//.*/g,a..z)=~lc

k (6 bytes)

&/>':_

& devuelve verdadero si ambos argumentos son verdaderos

/ modifica & para aplicar "sobre" una lista, como un pliegue en lenguajes funcionales

> mas grande que

':modifica >para aplicar "each-before", por lo que devuelve un vector de booleanos que indica qué elementos son mayores que su predecesor

_ lo hace argumento en minúsculas

  _"puzZ"
"puzz"
  >':_"puzZ"
1110b
  &/>':_"puzZ"
0b

( 0bsignifica booleano falso)

q (13 bytes)

all(>':)lower

q es solo azúcar sintáctico en k. allse define como &/y menor es_

Python, 50 bytes

f=lambda x:sorted(set(x.lower()))==list(x.lower())

Pruebe en línea aquí: http://repl.it/c5Y/2

VBA (161 bytes)

Function t(s As String)
t = 0
For i = 2 To Len(s)
a = Left(LCase(s), i)
    If Asc(Right(a, 1)) <= Asc(Right(a, 2)) Then Exit Function
Next
t = 1
End Function  

Compara el valor ASCII con la letra anterior en minúscula, devuelve 0 (falso) cuando su valor es menor / igual y sale de la función

Python 2 , 43 bytes

lambda s:eval('"%s"'%'"<"'.join(s.lower()))

Pruébalo en línea!

Pone <símbolos entre todas las letras (convertidas a minúsculas), y luego lo evalmarca. Los operadores de comparación encadenados de Python están perfectamente felices de evaluar todo como una gran expresión booleana.

Erlang, 51

f(S)->G=string:to_lower(S),ordsets:from_list(G)==G.

Utiliza un conjunto ordenado (análogo a java.util.TreeSet) para ordenar los caracteres y descartar cualquier duplicado. La nueva lista se compara con la cadena de entrada.

Función de prueba:

test() ->
    [io:format("~p ~p~n", [S, f(S)]) || S <- ["a","abcdefGHIjklmnopqrSTUVWXyz","aa","puz","puzz","puzZ","puZ","PuZ"]].

Java, 96

boolean a(char[]a){int i=-1,l=0;for(;++i<a.length;l+=i>0&&a[i]<=a[i-1]?1:0)a[i]|=32;return l<1;}

Bastante sencillo aquí. Simplemente convierta todo a menor y compare cada uno con el personaje anterior.