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.
za
ser un valor verdadero?a
y termina conz
.Respuestas:
CJam, 8 bytes
Aquí hay un arnés de prueba para todos los ejemplos en el desafío. Esto devuelve
0
o1
(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
fuente
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.
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:
Ejecutar esto en la lista de palabras vinculada anteriormente produjo 10 palabras de 6 letras en orden alfabético.
fuente
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?$
Python 3, 44 bytes
Un enfoque simple: verificar la unicidad, verificar la clasificación.
fuente
*s,=...
hace?s=list(input().lower())
.x,*y = [1, 2, 3, 4]
, que asigna 1 ax
y[2, 3, 4]
paray
.*s,=
eslist(s)
... enlace{*s}
lugar deset(s)
guardar 2 bytes.> <> ,
524239 bytesEste 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í.
Solución anterior, 42 bytes
Lo interesante es que, a pesar de parecer tener la misma funcionalidad, la alternativa
(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 dev
al final.fuente
Haskell, 52 bytes
Uso:
(and.(zipWith(>)=<<tail).map toLower) "abcd"
que salidasTrue
.fuente
C,
67 65 5754 (52) caracteresun poco más corto
e incluso más corto:
Aquí hay una pequeña prueba: http://ideone.com/ZHd0xl
Después de las últimas sugerencias, aquí hay dos versiones más cortas:
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
|32
más corto que&~32
.fuente
for(;(*s&=95)>d;d=*s++);
. Y se puede inicializard
a1
sin cambiar el resultado, ahorrando 1 más. Ver.d;f(char*s){d=32;for...}
funciona, declarandod
implícitamente como un int global (que, en GCC, es una advertencia: "la definición de datos no tiene tipo ni clase de almacenamiento", pero no es un error). Esto ahorra dos bytes.d
en elfor
ciclo en lugar de su propia declaración? De esa manera salvas a;
.Rubí, 33
Comprueba si los caracteres únicos ordenados son los mismos que todos los caracteres.
fuente
c==c.sort|c
Javascript (ES5), 101
Mejorado a 87 por edc95:
votó su comentario :)
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 conreduce()
), 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.
fuente
return
y!b
para guardar un carácter.function i(s){b=0;l='';s.toUpperCase().split('').forEach(function(c){if(c<=l)b=1;l=c});return!b}
function i(s){s.toUpperCase(b=0).split(l='').forEach(function(c){if(c<=l)b=1;l=c});return!b}
function i(s){return!s.toUpperCase().split(l='').some(function(c){return(u=l,l=c)<=u})}
Haskell, 90 bytes
Suministra la función
f :: String -> Bool
Uso (suponiendo que se guarde como golf.hs).
...
se usa para reemplazarghci
los mensajes detallados de carga.Si alguien tiene un
lowercase
método más corto queimport Distribution.Simple.Utils
entonces, por favor comente.fuente
map toLower
enData.Char
lugar delowercase
l
enf
, es decirf=g.lowercase
(of=g.map toLower
si cambia atoLower
). Dentro deg
una comparación es suficiente:g l=nub(sort l)==l
.Wolfram Mathematica,
4937 bytesPS Solución más corta de Martin Büttner:
fuente
#⋃#==#&@*Characters@*ToLowerCase
J, 17 bytes
Comprueba si la
/:~
cadena ordenada en minúscula es igual a-:
la~.
cadena de protuberancia en minúscula .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'
).fuente
MATLAB,
2927 bytesAhora para una línea que incluso tiene sentido fuera del código de golf.
Como una función anónima (usar como
o('yourstring')
)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):
La entrada debe presentarse entre'
marcas, p'Potato'
. Ej .fuente
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.
ofalse.
si se ejecuta como un programa.La primera versión que se me ocurrió, sin hacer referencia explícita al alfabeto:
Brachylog , 4 bytes
Pruébalo en línea!
fuente
J, 21 caracteres
Esto es demasiado largo. El argumento debe tener rango
1
, es decir, debe ser una cadena o un vector.tolower y
-y
en minúsculas./:~ y
-y
en orden léxico.~. y
- la protuberancia dey
, es decir,y
con los duplicados eliminados.x ; y
-x
yy
poner en cajas y luego concatenar.< y
-y
poner en una caja.x = y
-x
comparado en cuanto a elementos cony
.(< y) = (~. y) ; (/:~ y)
- un vector que indica siy
es igual a su protuberancia y está ordenado.*/ y
- el producto de los elementos dey
, o su lógica y si los elementos son booleanos.*/ (< y) = (~. y) ; (/:~ y)
- un booleano que indica la propiedad deseada para minúsculasy
.fuente
Julia, 44 bytes
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,true
ofalse
. Si desea probarlo, asígnelo comof=s->...
y luego llamef("PuZ")
, etc.fuente
Pure Bash 4.x, 37
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:
fuente
C # 6, 18 +
8276 = 94 bytesRequiere (18 bytes):
Código (76 bytes):
C # 6 admite lambdas para definir una función, que es útil para jugar al golf.
Versión no C # 6:
Código sin golf:
fuente
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='')
)Prueba en la consola Firefox / FireBug
fuente
s=
no parece ser necesario ...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.
fuente
Golang (65 bytes)
Ir no es un lenguaje amigable para el golf, también, soy un asco en el golf ...
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
fuente
Java 8 -
90898785 caracteresLa 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:
sin golf:
ejemplo:
salida:
fuente
Perl 6, 35 bytes
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-n
y alimentar la palabra como entrada estándar , que agregaría los dos bytes de vuelta.fuente
.uc.comb
no reorganiza nada, por lo que si la matriz mayúscula y peinada es igual a la matriz mayúscula y peinada ordenada , eso significa que comenzó en orden ordenado.R , 37 bytes
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.fuente
Perl, 27
La expresión regular de @ hsl se construye dinámicamente.
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.fuente
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(
0b
significa booleano falso)q (13 bytes)
q es solo azúcar sintáctico en k.
all
se define como&/
y menor es_
fuente
Python, 50 bytes
Pruebe en línea aquí: http://repl.it/c5Y/2
fuente
VBA (161 bytes)
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
fuente
Python 2 , 43 bytes
Pruébalo en línea!
Pone
<
símbolos entre todas las letras (convertidas a minúsculas), y luego loeval
marca. Los operadores de comparación encadenados de Python están perfectamente felices de evaluar todo como una gran expresión booleana.fuente
Erlang, 51
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:
fuente
Java, 96
Bastante sencillo aquí. Simplemente convierta todo a menor y compare cada uno con el personaje anterior.
fuente