Ecrivez une fonction / programme qui accepte une chaîne de lettres minuscules / majuscules [A-Za-z], qui vérifie si les lettres en surbrillance sont uniques et dans l’ordre alphabétique (en ignorant les majuscules et les minuscules). La sortie doit être véridique si elles sont uniques et dans l’ordre alphabétique et faussée sinon.

Voici quelques cas de test

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 vous le souhaitez, lancez votre programme sur tous les mots d’une liste de mots comme celle-ci et publiez-en d’intéressants =).

But

Le plus petit nombre d'octets gagne.

CJam, 8 octets

lel_$_&=

Voici un test harnais pour tous les exemples du défi. Ceci retourne 0ou 1((qui sont la fausseté et la vérité, respectivement, dans CJam).

Et voici un script pour filtrer la liste de mots dans la question (cela prend quelques secondes). Vous devrez copier manuellement la liste de mots dans le champ de saisie, car elle est trop longue pour un lien permanent.

Explication

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 (toute saveur), 55 octets

Certaines personnes ne considèrent pas regex comme un langage de programmation, mais il a déjà été utilisé auparavant et n'est pas près d'être le plus court.

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

J'ai ajouté un octet pour l'indicateur i(insensible à la casse). Ceci est très simple et peut être plus court à générer à la volée.

Si les expressions rationnelles seules ne sont pas autorisées, vous pouvez utiliser ce programme Retina de 56 octets suggéré par 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?$

L'exécution de ceci sur la liste de mots liée ci-dessus a donné 10 mots de 6 lettres dans l'ordre alphabétique.

["abhors", "presque", "commence", "bégir", "bijoux", "biopsie", "chimpanzés", "chinos", "chintz", "fantomatique"]

Python 3, 44 octets

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

Une approche simple - vérifier l'unicité, vérifier le tri.

> <> , 52 42 39 octets

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

Ce type de question est l’un des rares types avec lequel <>> est assez à l’aise, car nous n’avons besoin que de traiter un seul caractère à la fois.

Explication

Ne te perds pas! Il y a beaucoup d'emballer ici.

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

Solution précédente, 42 octets

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

La chose intéressante est que, même si elle semble avoir la même fonctionnalité, l’alternative

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

(Le changement est dans les flèches et les miroirs à l'extrême droite)

donne en fait des résultats incorrects , à cause de l'interpréteur de> <> utilisant un defaultdict Python. En réalité, en parcourant l'espace vide à la fin de la deuxième ligne, les 0 sont placés implicitement dans les espaces vides lorsque> <> tente d'accéder à la cellule. Cela perturbe ensuite le ?trampoline conditionnel au début de la même ligne, car les 0 nouvellement placés sont ignorés plutôt que le dernier v.

Haskell, 52 octets

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

Utilisation: (and.(zipWith(>)=<<tail).map toLower) "abcd"quelles sorties True.

C, 67 65 57 54 (52) caractères

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

un peu plus court:

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

et même plus court:

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

Voici un petit test: http://ideone.com/ZHd0xl

Après les dernières suggestions, il reste encore deux versions plus courtes:

// 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;}

De plus, ce code repose sur le fait que, en ASCII, les minuscules et les majuscules ne diffèrent que par le cinquième bit (32) que je filtre. Donc, cela pourrait ne pas fonctionner avec d'autres encodages évidemment.

EDIT: La dernière version définit toujours le 5ème bit comme |32étant plus court que &~32.

Ruby, 33 ans

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

Vérifie si les caractères uniques triés sont les mêmes que tous les caractères.

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}

Amélioré à 87 par edc95:

upvote son commentaire :)

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

Btw, les tests élémentaires actuellement dans OP sont remplis si un programme ne fait que vérifier l'unicité, sans tenir compte de l'ordre.

Je ne peux pas encore écrire de commentaires, je vais donc répondre ici:

@ edc65: Merci! J'ai essayé de le réécrire en utilisant some(), mais je ne pouvais pas obtenir une solution plus courte, car même si cela semble me permettre de me débarrasser de la variable superflous b, vous devez taper "return" deux fois (comme avec reduce()), et vous ne peut pas simplement renvoyer le résultat de la comparaison directement, car le dernier caractère doit être sauvegardé après la comparaison.

@ edc65: C'est une bonne utilisation de l'opérateur virgule pour 87! Je l'ai modifié dans ma réponse pour plus de visibilité.

Haskell, 90 octets

Fournit la fonction f :: String -> Bool

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

Utilisation (en supposant qu'il soit enregistré en tant que golf.hs). ...est utilisé pour remplacer ghciles messages de chargement détaillés.

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

Si quelqu'un a une lowercaseméthode plus courte qu'alors, import Distribution.Simple.Utilsveuillez commenter.

Wolfram Mathematica, 49 37 octets

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

PS Solution plus courte de Martin Büttner:

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

J, 17 octets

Vérifie si la /:~chaîne triée en minuscules est égale à -:la ~.chaîne nub en minuscule .

   (/:~-:~.)@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

Comme dans J, une "chaîne" de 1 caractère représenté par une chaîne normale (avec des guillemets) est juste un atome de caractère et non une chaîne réelle. (Dans l'exemple ci-dessus, j'ai utilisé 1$'a'.)

MATLAB, 29 à 27 octets

Passons maintenant à un one-line qui fait sens en dehors du code-golf.

En tant que fonction anonyme (utiliser comme o('yourstring'))

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

Je suppose que cette fonction est assez explicite, car elle se lit comme une publicité dans un journal.

Version précédente (29 octets):

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

Les entrées doivent être présentées entre les 'marques, par exemple 'Potato'.

Brachylog , 3 octets

ḷ⊆Ạ

Essayez-le en ligne!

Le prédicat réussit si l'entrée répond aux exigences décrites et échoue s'il ne le fait pas, qu'il soit imprimé true.ou false.exécuté en tant que programme.

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

La première version que j'ai créée ne fait pas explicitement référence à l'alphabet:

Brachylog , 4 octets

ḷ≠.o

Essayez-le en ligne!

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

J, 21 caractères

C'est trop long. L'argument doit avoir un rang 1, c'est-à-dire qu'il doit s'agir d'une chaîne ou d'un vecteur.

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

• tolower y- yen minuscule.
• /:~ y- ydans l'ordre lexical.
• ~. y- le nœud de y, c'est-à-dire ysans les doublons.
• x ; y- xet ymis dans des boîtes puis concaténés.
• < y- ymettre dans une boîte.
• x = y- x comparé élément par s avec y.
• (< y) = (~. y) ; (/:~ y)- un vecteur indiquant si yest égal à son numéro et trié lui-même.
• */ y- le produit des éléments de y, ou sa logique et si les éléments sont des booléens.
• */ (< y) = (~. y) ; (/:~ y)- un booléen indiquant la propriété souhaitée pour les minuscules y.

Julia, 44 octets

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

Cela crée une fonction anonyme qui prend un seul argument s, le convertit en minuscule et le compare à la version unique triée de la chaîne. Il retourne un booléen, ie trueou false. Si vous voulez le tester, attribuez-le comme f=s->...et ensuite appelez f("PuZ"), etc.

Pure Bash 4.x, 37

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

Entrée prise en paramètre de ligne de commande. Selon la sémantique standard du shell, le code de sortie 0 signifie vrai (alphabétique) et le code de sortie! = 0 signifie faux (pas alphabétique).

Le printf crée le regex comme dans la solution de @ hsl . La chaîne d'entrée est développée en minuscule et comparée à l'expression régulière.

Réponse précédente:

Bash + coreutils, 52

Solution simple:

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

C # 6, 18 + 82 76 = 94 octets

Requiert (18 octets):

using System.Linq;

Code (76 octets):

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

C # 6 aide les lambdas à définir une fonction utile pour le golf.

Version non C # 6:

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

Code non golfé:

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

JavaScript (ES6) 54

Convertir en majuscule, puis en tableau et trier. Si pendant le tri deux éléments sont dans le mauvais ordre ou égaux, retourne 0 (falsy) sinon 1 (vérité)

Modifier Raccourcissement thx à @Optimizer (mais encore 2 de plus que la solution mise en œuvre dans @Tamas 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

Test dans la console 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 octets)

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

Testez-le ici: http://ideone.com/q1LL3E

Afficher ceci parce que je ne peux pas encore commenter, sinon ce serait une suggestion pour améliorer la réponse C existante car je vole complètement l’idée insensible à la casse de la réponse C existante.

Renvoie 0 si la chaîne n'est pas commandée et une valeur différente de zéro si commandé.

Golang (65 bytes)

Go n’est pas une langue favorable au golf, en plus, je suis nul au golf ...

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

Exécutez-le ici: http://play.golang.org/p/xXJX8GjDvr

modifier 106-> 102

modifier 102-> 96

modifier 96-> 91

modifier 91-> 87

modifier 87-> 65

J'ai battu la version java, je peux m'arrêter pour aujourd'hui

Java 8 - 90 89 87 85 caractères

L'idée ici est d'utiliser une fonction "réduire" qui suit le dernier caractère et "abandonne" lorsqu'elle détecte que la séquence n'est pas strictement ascendante.

joué au golf:

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

ungolfed:

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

Exemple:

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"));

sortie:

99
-1
122
122
122
-1

Perl 6, 35 octets

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

Ceci produit un bloc appelable. si je pouvais simplement supposer que $_le mot souhaité est déjà défini, je pourrais supprimer les accolades qui l'entourent et perdre deux octets supplémentaires, mais le seul moyen raisonnable de faire cette hypothèse serait de l'exécuter avec -nle mot et de le nourrir comme entrée standard. , ce qui ajouterait les deux octets immédiatement.

R , 37 octets

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

Essayez-le en ligne!

En raison de la différence importante et de la longueur de la réponse R de Michal, cette publication est très différente .

Convertit les lettres en points de code ASCII avec utf8ToInt, puis prend le modulo 32 afin que les lettres inférieures et supérieures soient converties en mêmes nombres 1 ... 26. Calcule les différences par paires et vérifie qu'elles sont toutes positives.

Perl, 27

La regexp de @ hsl est construite dynamiquement.

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

Nous pouvons également faire une correspondance inverse: convertir l’entrée en une expression rationnelle: PuZ=> .*p.*u.*z.*puis la faire correspondre à une chaîne de lettres dans l’ordre alphabétique. Résultat - également 27 caractères.

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

k (6 octets)

&/>':_

& renvoie vrai si les deux arguments sont vrais

/modifie &pour appliquer "sur" une liste, comme un pli dans les langages fonctionnels

> plus grand que

':modifie >pour appliquer "each-prior", donc retourne un vecteur de booléens indiquant quels éléments sont plus grands que leurs prédécesseurs

_ le rend argument minuscule

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

( 0bsignifie booléen faux)

q (13 octets)

all(>':)lower

q est juste un sucre syntaxique sur k. allest défini comme &/, et inférieur est_

Python, 50 octets

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

Essayez en ligne ici: http://repl.it/c5Y/2

VBA (161 octets)

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  

Compare la valeur ascii avec la lettre précédente en minuscule, renvoie 0 (faux) lorsque sa valeur est inférieure / égale et quitte la fonction

Python 2 , 43 octets

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

Essayez-le en ligne!

Place les <symboles entre toutes les lettres (converties en minuscules), puis evalc’est le cas. Les opérateurs de comparaison chaînés de Python sont parfaitement heureux d’évaluer le tout dans une seule et même expression booléenne.

Erlang, 51 ans

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

Utilise un ensemble ordonné (analogue à java.util.TreeSet) pour trier les caractères et éliminer les doublons. La nouvelle liste est ensuite comparée à la chaîne d'entrée.

Fonction de test:

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

Assez simple ici. Il suffit de convertir tous les éléments pour qu’ils abaissent et comparent chacun d’entre eux au personnage précédent.