Verifique si las letras de las palabras están en orden alfabético

37

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.

falla
fuente
3
Casos de prueba débiles. (Vea mi comentario sobre la respuesta PHP de Richard A ).
manatwork
¿El alfabeto se repite? ¿Debería zaser un valor verdadero?
MayorMonty
No, el alfabeto comienza con ay termina con z.
flawr
Debería tener algunos casos de prueba que no están en orden alfabético
Jo King
1
@JoKing agregué algunos.
falla

Respuestas:

28

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.";
Martin Ender
fuente
21

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"]

NinjaOsoMono
fuente
2
Puede usar Retina en lugar de ES6 si alguien se queja de que regex no es un idioma: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?$
Martin Ender
@ MartinBüttner Me había olvidado de Retina. ¡Gracias!
NinjaBearMonkey
@ MartinBüttner Según el META ( meta.codegolf.stackexchange.com/questions/2028/… ) Las expresiones regulares pueden ser 'vistas' de alguna manera como un lenguaje de programación.
Ismael Miguel
@IsmaelMiguel lo sé. Y, de hecho, esa definición fue elegida específicamente para asegurarse de que no descarta la expresión regular. Pero algunas personas todavía se quejan regularmente, porque no se puede usar la expresión regular como cualquier otro idioma.
Martin Ender
@ MartinBüttner Los que se quejan pueden ir a un lugar llamado META y buscarlo. ¿Por qué nadie visita un lugar tan hermoso lleno de preguntas que resuelven la mayoría de los problemas?
Ismael Miguel
19

Python 3, 44 bytes

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

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

Sp3000
fuente
¿Puedes explicar qué *s,=...hace?
flawr
@flawr Esto se llama 'asignación destacada'. En este código, simplemente convierte el lado derecho en una lista. Es lo mismo que s=list(input().lower()).
Jakube
1
@flawr Como dice Jakube, aquí solo se está convirtiendo la entrada en una lista de caracteres. En general, es una sintaxis de asignación especial que le permite hacer cosas como x,*y = [1, 2, 3, 4], que asigna 1 a xy [2, 3, 4]para y.
Sp3000
@ mbomb007 *s,= es list(s) ... enlace
Sp3000
Puede hacerlo en {*s}lugar de set(s)guardar 2 bytes.
mbomb007
12

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

Sp3000
fuente
Siento que podría guardar algunos bytes restando solo 32 de letras minúsculas en lugar de obtener un índice alfabético para todas las letras
Aaron
9

Haskell, 52 bytes

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

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

nimi
fuente
9

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.

Felix Bytow
fuente
Buen uso del conocimiento del dominio para manejar el problema de mayúsculas y minúsculas.
RomSteady
Ahorre 2 reemplazando el bucle for con for(;(*s&=95)>d;d=*s++);. Y se puede inicializar da 1sin cambiar el resultado, ahorrando 1 más. Ver.
AShelly
1
No estoy seguro de si esto se considera legal en el código de golf, pero d;f(char*s){d=32;for...}funciona, declarando dimplí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.
wchargin
AShelly hm, no consideró eso. Sin embargo, su sugerencia cambia la cadena original. Pero lo que sea, es código golf: D Además, no estoy seguro acerca de la sugerencia de WChargin ya que d como una variable global realmente no sería parte de la función.
Felix Bytow
1
¿Por qué no inicializar den el forciclo en lugar de su propia declaración? De esa manera salvas a ;.
Josh
6

Rubí, 33

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

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

britishtea
fuente
1
Piensa que puedes hacerlo un poco más corto conc==c.sort|c
histocrat
Ooh, eso me gusta, eso es inteligente. Gracias.
britishtea
5

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.

Tamas
fuente
Esa es una mejor idea que la mía. Usar .some podría ser aún mejor (52 con ES6)
edc65
Puede eliminar el espacio entre returny !bpara guardar un carácter.
ProgramFOX
Tal como está, solo cuidando el espacio en blanco, 96:function i(s){b=0;l='';s.toUpperCase().split('').forEach(function(c){if(c<=l)b=1;l=c});return!b}
edc65
Lo mismo, más golf, 92:function i(s){s.toUpperCase(b=0).split(l='').forEach(function(c){if(c<=l)b=1;l=c});return!b}
edc65
1
Usando algunos (o todos, el mismo puntaje), 87:function i(s){return!s.toUpperCase().split(l='').some(function(c){return(u=l,l=c)<=u})}
edc65
4

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.

HEGX64
fuente
1
Usar map toLoweren Data.Charlugar delowercase
nimi
1
Además: puede eliminar el parámetro len f, es decir f=g.lowercase(o f=g.map toLowersi cambia a toLower). Dentro de guna comparación es suficiente: g l=nub(sort l)==l.
nimi
4

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&
Savenkov Alexey
fuente
2
#⋃#==#&@*Characters@*ToLowerCase
alephalpha
1
@alephalpha ¡Eso es hermoso!
Martin Ender
4

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

randomra
fuente
4

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 .

Sanchises
fuente
4

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.
Cadena no relacionada
fuente
3

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.
FUZxxl
fuente
3

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.

Alex A.
fuente
Amén a eso, @flawr. Gracias por el apoyo.
Alex A.
3

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"
Trauma digital
fuente
Tenga en cuenta que esto requiere bash 4.x.
Mark Reed
@ MarkReed Sí. Célebre.
Digital Trauma
3

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);
}
ProgramFOX
fuente
3

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"]

edc65
fuente
1
s=no parece ser necesario ...
Optimizer
@Optimizer correcto, fue un primer intento cuando por fin
comparé
3

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.

erai
fuente
3

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

Kristoffer Sall-Storgaard
fuente
3

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
Michael Easter
fuente
3

Perl 6, 35 bytes

{my@c=.uc.comb;@c [email protected]}

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.

Mark Reed
fuente
Claro que si. .uc.combno 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.
Mark Reed
a la derecha, está comprobando el tamaño de la intersección, que ignora el orden. Ok, actualizado.
Mark Reed
3

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.

Robin Ryder
fuente
2

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
nutki
fuente
2

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_

mollmerx
fuente
44
¿Puedes explicar cómo funciona esto?
flawr
Esto casi se siente como hacer trampa en otros idiomas ... ¿Quién necesita nombres de funciones, paréntesis y punto y coma? :)
Sanchises
@sanchises k tiene todas esas cosas y funcionan de la misma manera que en los lenguajes de estilo C. Es solo que este problema se puede expresar como una sola declaración.
mollmerx
2

Python, 50 bytes

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

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

mbomb007
fuente
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

Alex
fuente
2

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.

ArBo
fuente
1

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"]].
cPu1
fuente
1

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.

Geobits
fuente