Napisz funkcję / program, który przyjmuje jako ciąg ciąg małych / wielkich liter [A-Za-z], który sprawdza, czy występujące litery są unikalne i czy są uporządkowane alfabetycznie (ignorując małe i wielkie litery), czy nie. Dane wyjściowe muszą być zgodne z prawdą, jeśli są unikalne, w kolejności alfabetycznej, a fałsz, jeśli nie.

Oto kilka przypadków testowych

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

Jeśli chcesz, uruchom swój program na wszystkich słowach z listy słów takich jak ta i zamieść kilka interesujących =).

Wynik

Najniższa liczba bajtów wygrywa.

CJam, 8 bajtów

lel_$_&=

Oto uprząż testowa dla wszystkich przykładów w wyzwaniu. Zwraca 0lub 1(które są odpowiednio fałszem i prawdą w CJam).

A oto skrypt do filtrowania listy słów w pytaniu (uruchomienie zajmuje kilka sekund). Musisz ręcznie skopiować listę słów do pola wejściowego, ponieważ jest ona zbyt długa, aby można było skorzystać z bezpośredniego łącza.

Wyjaśnienie

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 (dowolny smak), 55 bajtów

Niektóre osoby nie uważają wyrażenia regularnego za język programowania, ale używano go już wcześniej i nie jest on zbyt krótki.

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

Dodałem jeden bajt dla iflagi (bez rozróżniania wielkości liter). Jest to bardzo proste i może być krótsze do wygenerowania w locie.

Jeśli sam regex nie jest dozwolony, możesz użyć tego 56-bajtowego programu Retina sugerowanego przez Martina Büttnera:

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

Uruchomienie tego na powyższej liście słów dało 10 6-literowych słów w kolejności alfabetycznej.

[„wstręt”, „prawie”, „zaczyna się”, „żebrać”, „bijoux”, „biopsja”, „szympansy”, „chinos”, „perkal”, „duchy”]

Python 3, 44 bajty

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

Proste podejście - sprawdź niepowtarzalność, sprawdź sortowanie.

> <> , 52 42 39 bajtów

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

Tego rodzaju pytanie jest jednym z niewielu rodzajów, z którymi> <> jest całkiem wygodne, ponieważ musimy radzić sobie tylko z jednym char na raz.

Wyjaśnienie

Nie zgub się! Tutaj jest dużo zawijania.

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

Poprzednie rozwiązanie, 42 bajty

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

Ciekawe jest to, że pomimo tego, że wydaje się mieć tę samą funkcjonalność, stanowi alternatywę

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

(Zmiana znajduje się w strzałkach i lusterkach po prawej stronie)

faktycznie daje niepoprawne wyniki, ponieważ interpreter> <> używa domyślnego słownika Pythona. To, co się dzieje, polega na tym, że przechodząc przez pustą przestrzeń na końcu drugiego rzędu, zero jest domyślnie umieszczane w pustych przestrzeniach, gdy> <> próbuje uzyskać dostęp do komórki. To wtedy miesza się z ?warunkową trampoliną na początku tego samego rzędu, ponieważ nowo umieszczone 0 są pomijane, a nie vna końcu.

Haskell, 52 bajty

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

Zastosowanie: (and.(zipWith(>)=<<tail).map toLower) "abcd"które wyjścia True.

C, 67 65 57 54 (52) znaków

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

trochę krótszy:

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

a nawet krótszy:

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

Oto mały test: http://ideone.com/ZHd0xl

Po najnowszych sugestiach nadal są dwie krótsze wersje:

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

Również ten kod opiera się na fakcie, że małe i wielkie litery ASCII różnią się tylko 5-tym bitem (32), który odfiltrowuję. Może to oczywiście nie działać z innymi kodowaniami.

EDYCJA: Najnowsza wersja zawsze ustawia 5. bit, ponieważ |32jest krótszy niż &~32.

Ruby, 33

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

Sprawdza, czy posortowane unikalne znaki są takie same jak wszystkie znaki.

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}

Poprawiono do 87 przez edc95:

głosujcie na jego komentarz :)

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

Przy okazji, przypadki testowe obecnie w OP są spełnione, jeśli program sprawdza tylko unikalność, nie uwzględniając kolejności.

Nie mogę jeszcze pisać komentarzy, więc odpowiem na kilka uwag tutaj:

@ edc65: Dzięki! Próbowałem przepisać go za pomocą some(), ale nie mogłem znaleźć krótszego rozwiązania, ponieważ chociaż wygląda na to, że pozwoliłoby mi to pozbyć się zbędnej zmiennej b, musisz wpisać „return” dwa razy (to samo z reduce()), a ty nie można po prostu zwrócić wyniku porównania bezpośrednio, ponieważ ostatnia postać musi zostać zapisana po porównaniu z nią.

@ edc65: To miłe użycie operatora przecinka dla 87! Zredagowałem to w mojej odpowiedzi dla większej widoczności.

Haskell, 90 bajtów

Dostarcza funkcję f :: String -> Bool

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

Użycie (przy założeniu, że jest zapisane jako golf.hs). ...służy do zastąpienia ghcipełnych komunikatów ładujących.

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

Jeśli ktoś ma lowercasemetodę krótszą niż import Distribution.Simple.Utilswtedy, prosimy o komentarz.

Wolfram Mathematica, 49 37 bajtów

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

PS Krótsze rozwiązanie Martina Büttnera:

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

J, 17 bajtów

Sprawdza, czy posortowany /:~ciąg -:małych liter jest równy ~.ciągowi nub małymi literami .

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

Tak jak w J 1-znakowy długi „ciąg” reprezentowany jako zwykły ciąg (z cudzysłowami) jest tylko atomem znaków, a nie prawdziwym ciągiem, odpowiednio sformatowałem dane wejściowe, aby wszystkie dane wejściowe były prawdziwymi łańcuchami. (W powyższym przykładzie użyłem 1$'a'.)

MATLAB, 29 27 bajtów

Teraz dla jednej linii, która ma sens nawet poza golfem.

Jako funkcja anonimowa (użyj jako o('yourstring'))

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

Myślę, że ta funkcja jest dość oczywista, ponieważ brzmi jak reklama w gazecie.

Poprzednia wersja (29 bajtów):

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

Dane wejściowe muszą być prezentowane między 'znakami, np 'Potato'.

Brachylog , 3 bajty

ḷ⊆Ạ

Wypróbuj online!

Predykat kończy się powodzeniem, jeśli dane wejściowe spełniają określone wymagania, a jeśli nie, drukowanie true.lub false.uruchamianie jako program kończy się niepowodzeniem .

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

Pierwsza wersja, którą wymyśliłem, nie odnosząc się wprost do alfabetu:

Brachylog , 4 bajty

ḷ≠.o

Wypróbuj online!

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

J, 21 znaków

To za długo Argument musi mieć rangę 1, tzn. Musi być łańcuchem lub wektorem.

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

• tolower y- ymałymi literami.
• /:~ y- yw porządku leksykalnym.
• ~. y- nub y, czyli yz usuniętymi duplikatami.
• x ; y- xi ywkładany do pudełek, a następnie łączony.
• < y- ywłożyć do pudełka.
• x = y- w x porównaniu z elementem y.
• (< y) = (~. y) ; (/:~ y)- wektor wskazujący, czy yjest równy nub i sam posortowany.
• */ y- iloczyn pozycji ylub jego logika oraz jeśli pozycje są wartościami logicznymi.
• */ (< y) = (~. y) ; (/:~ y)- wartość logiczna wskazująca pożądaną właściwość małych liter y.

Julia, 44 bajty

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

Tworzy to anonimową funkcję, która pobiera pojedynczy argument s, konwertuje go na małe litery i porównuje z unikalną posortowaną wersją łańcucha. Zwraca wartość logiczną, tj . trueLub false. Jeśli chcesz to przetestować, przypisz to, f=s->...a następnie zadzwoń f("PuZ")itp.

Pure Bash 4.x, 37

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

Dane wejściowe są brane jako parametr wiersza polecenia. Zgodnie ze standardową semantyką powłoki, kod wyjścia 0 oznacza prawda (alfabetycznie), a kod wyjścia! = 0 oznacza fałsz (nie alfabetycznie).

Printf tworzy regex jak w rozwiązaniu @ hsl . Łańcuch wejściowy jest rozwijany do małych liter i porównywany z wyrażeniem regularnym.

Poprzednia odpowiedź:

Bash + coreutils, 52

Proste rozwiązanie:

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

C # 6, 18 + 82 76 = 94 bajtów

Wymaga (18 bajtów):

using System.Linq;

Kod (76 bajtów):

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

C # 6 obsługuje lambdy do zdefiniowania funkcji, która jest przydatna podczas gry w golfa.

Wersja inna niż C # 6:

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

Nieskluczony kod:

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

JavaScript (ES6) 54

Konwertuj na wielkie litery, a następnie na tablicę i sortuj. Jeśli podczas sortowania dwa elementy są w niewłaściwej kolejności lub równe, zwróć 0 (fałsz) w przeciwnym razie 1 (prawda)

Edycja skróconego thx do @Optimizer (ale nadal 2 więcej niż roztwór @Tamas realizowanego w 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 w konsoli 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 bajty)

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

Przetestuj tutaj: http://ideone.com/q1LL3E

Publikowanie tego, ponieważ nie mogę jeszcze komentować, w przeciwnym razie byłaby sugestia, aby poprawić istniejącą odpowiedź C, ponieważ całkowicie ukradłem pomysł bez rozróżniania wielkości liter z istniejącej odpowiedzi C.

Zwraca 0, jeśli ciąg nie jest uporządkowany, a wartość niezerowa, jeśli jest uporządkowana.

Golang (65 bajtów)

Go nie jest językiem przyjaznym golfowi, a także, ssę golfa ...

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

Uruchom tutaj: http://play.golang.org/p/xXJX8GjDvr

edycja 106-> 102

edycja 102-> 96

edycja 96-> 91

edycja 91-> 87

edycja 87-> 65

Pokonałem wersję Java, mogę zatrzymać się na dziś

Java 8 - 90 89 87 85 znaków

Chodzi tutaj o użycie funkcji „zmniejszania”, która śledzi ostatni znak i „poddaje się”, gdy wykryje, że sekwencja nie jest ściśle rosnąca.

grał w golfa:

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

bez golfa:

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

przykład:

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

wydajność:

99
-1
122
122
122
-1

Perl 6, 35 bajtów

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

Powoduje to wywołanie bloku; jeśli mógłbym tylko założyć, że $_jest już ustawione pożądane słowo, mógłbym usunąć otaczające nawiasy klamrowe i stracić dwa dodatkowe bajty, ale prawdopodobnie jedynym rozsądnym sposobem na przyjęcie takiego założenia byłoby uruchomienie go -ni przekazanie słowa jako standardowego wejścia , który dodałby dwa bajty od razu.

R , 37 bajtów

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

Wypróbuj online!

Delegowanie ponieważ jest znacznie krótsza niż inne i Michała R odpowiedź .

Konwertuje litery na znaki kodowe ASCII za pomocą utf8ToInt, a następnie bierze modulo 32, dzięki czemu dolne i górne litery są konwertowane na te same cyfry 1 ... 26. Oblicza różnice par i sprawdza, czy wszystkie są dodatnie.

Perl, 27

Wyrażenie regularne @ hsl buduje się dynamicznie.

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

Możemy również wykonać odwrotne dopasowanie: przekonwertować dane wejściowe na wyrażenie regularne: PuZ=>, .*p.*u.*z.*a następnie dopasować to do ciągu liter w kolejności alfabetycznej. Wynik - także 27 znaków.

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

k (6 bajtów)

&/>':_

& zwraca true, jeśli oba argumenty są prawdziwe

/modyfikuje, &aby zastosować „nad” listą, podobnie jak fold w językach funkcjonalnych

> Lepszy niż

':modyfikuje, >aby zastosować „przed każdym”, więc zwraca wektor wartości logicznych określający, które elementy są większe niż ich poprzednik

_ czyni to argument małą literą

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

( 0boznacza boolean false)

q (13 bajtów)

all(>':)lower

q jest po prostu cukrem syntaktycznym na k. alljest zdefiniowany jako &/, a niższy to_

Python, 50 bajtów

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

Spróbuj online tutaj: http://repl.it/c5Y/2

VBA (161 bajtów)

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  

Porównuje wartość ascii z poprzednią literą małymi literami, zwraca 0 (fałsz), gdy jej wartość jest mniejsza / równa, i wychodzi z funkcji

Python 2 , 43 bajty

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

Wypróbuj online!

Umieszcza <symbole między wszystkimi literami (konwertowane na małe litery), a następnie evals to. Łańcuchowe operatory porównania w Pythonie z wielką przyjemnością oceniają całość jako jedno duże wyrażenie logiczne.

Erlang, 51

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

Używa uporządkowanego zestawu (analogicznie do java.util.TreeSet) do sortowania znaków i odrzucania duplikatów. Nowa lista jest następnie porównywana z ciągiem wejściowym.

Funkcja testowa:

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

Całkiem proste. Wystarczy przekonwertować wszystkie na niższe i porównać każdą z poprzednimi postaciami.