Girdi olarak küçük / büyük harflerden oluşan bir dize [A-Za-z] dizisini kabul eden, ortaya çıkan harflerin benzersiz olup olmadığını ve alfabetik sırayla (küçük ve büyük harfleri yok sayarak) olup olmadığını denetleyen bir işlev / program yazın. Çıktı, eğer benzersiz ve alfabetik sıraya göre sıradışı ve eğer değilse sahte.

İşte bazı testcases

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

İsterseniz, böyle bir wordlist tüm kelimeleri programınızı çalıştırmak bu bir ) = ve ve bazı ilginç olanları yayınlamak.

Gol

En düşük bayt sayısı kazanır.

CJam, 8 bayt

lel_$_&=

İşte mücadeledeki tüm örnekler için bir test donanımı . Bu döner 0veya 1(sırasıyla, CJam'da sahte ve truthy olan).

Ve burada söz konusu kelime listesini filtrelemek için bir komut dosyası (çalıştırmak için birkaç saniye sürer). Sözcük listesini giriş alanına el ile kopyalamanız gerekecek, çünkü bir kalıcı bağlantı için çok uzun.

açıklama

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 (herhangi bir lezzet), 55 bayt

Bazı insanlar regex'i bir programlama dili olarak düşünmüyor, ancak daha önce kullanılmış ve en kısa olmaya yakın değil.

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

i(Büyük-küçük harf duyarlı) bayrağı için bir bayt ekledim . Bu çok basittir ve anında üretilmesi daha kısa olabilir.

Yalnız regex'e izin verilmiyorsa, Martin Büttner tarafından önerilen bu 56 baytlık Retina programını kullanabilirsiniz :

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

Bunu yukarıda bağlanan kelime listesi üzerinde çalıştırmak, alfabetik sırayla 10 harfli 10 kelime verdi.

["nefret", "neredeyse", "başlar", "yalvarıyor", "bijuteri", "biyopsi", "şempanze", "chinos", "chintz", "ghosty"]

Python 3, 44 bayt

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

Basit bir yaklaşım - benzersizliği, sıralama düzenini kontrol edin.

> <> , 52 42 39 bayt

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

Bu tür bir soru, bir kerede yalnızca bir karakterle başa çıkmamız gerektiğinden, oldukça rahat olan birkaç tipten biridir.

açıklama

Kaybolma! Burada çok fazla sarma var.

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

Önceki çözüm, 42 bayt

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

İlginç olan, aynı işlevselliğe sahip görünmesine rağmen alternatifin

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

(Değişiklik oklarda ve en sağdaki aynalarda)

aslında > <> bir Python defaultdict kullanan yorumlayıcısı nedeniyle yanlış sonuçlar veriyor . Olan şu ki, ikinci satırın sonundaki boş alan boyunca ilerleyerek, hücreye>>> erişmeye çalıştığında 0'ların boş alanlara örtük olarak yerleştirilmesi. Bu, daha sonra ?yerleştirilen 0'lar vsonunda değil atlandığından, aynı sıranın başında koşullu trambolinle karışır .

Haskell, 52 Bayt

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

Kullanımı: (and.(zipWith(>)=<<tail).map toLower) "abcd"Hangi çıktılar True.

C, 67 65 57 54 (52) karakter

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

biraz daha kısa:

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

ve hatta daha kısa:

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

İşte küçük bir test: http://ideone.com/ZHd0xl

Buradaki son önerilerden sonra hala iki kısa versiyon var:

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

Ayrıca, bu kod, ASCII'de küçük harf ve büyük harfin yalnızca filtreledim 5'inci bit (32) ile farklı olduğu gerçeğine dayanır. Yani bu açıkça diğer kodlamalar ile çalışmayabilir.

EDIT: En son sürüm her zaman 5. bit'i |32olduğundan daha kısa olarak ayarlar &~32.

Ruby, 33

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

Sıralanan benzersiz karakterlerin tüm karakterlerle aynı olup olmadığını kontrol eder.

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}

Edc95 tarafından 87'ye geliştirildi:

Yorumunu oyla :)

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

Ancak, OP’deki test durumları, bir program sadece benzersizliği kontrol edip sırasını dikkate almadığında yerine getirilir.

Henüz yorum yazamıyorum, bu yüzden bazı açıklamaları burada cevaplayacağım:

@ edc65: Teşekkürler! Kullanarak yeniden yazmaya çalıştım some(), ancak daha kısa bir çözüm bulamadım, çünkü yüzeysel b değişkeninden kurtulmamı sağlayacak gibi görünse de, iki kez "return" yazmanız gerekir (aynı reduce()) karşılaştırmanın sonucunu doğrudan döndüremezsiniz, çünkü son karakterin karşılaştırmadan sonra kaydedilmesi gerekiyor.

@ edc65: 87 için virgül operatörünün güzel bir kullanımı! Daha fazla görünürlük için cevabımı düzenledim.

Haskell, 90 bayt

Fonksiyonu sağlar f :: String -> Bool

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

Kullanımı (varsayarak golf.hs kaydedilir). 'in ayrıntılı yükleme mesajlarını ...değiştirmek için kullanılır ghci.

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

Birisinin lowercasedaha kısa bir yöntemi varsa, import Distribution.Simple.Utilslütfen yorum yapın.

Wolfram Mathematica, 49 37 bayt

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

Martin Büttner'den PS Shorter çözümü:

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

J, 17 bayt

Küçük harf sıralı /:~dizgenin -:küçük harf nub ~.dizeye eşit olup olmadığını kontrol eder .

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

J'de olduğu gibi normal bir dize (tırnak işaretli) olarak temsil edilen 1-karakter uzunluğundaki bir "string" sadece bir karakter atomudur, girişimi uygun şekilde formatladım, böylece tüm girişler gerçek stringler olacaktı. (Yukarıdaki örnekte kullandım 1$'a'.)

MATLAB, 29 27 bayt

Şimdi kod golf dışında bile mantıklı olan bir liner için.

İsimsiz bir işlev olarak (kullanın o('yourstring'))

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

Bir gazete ilanı gibi okuduğu için bu fonksiyonun oldukça açıklayıcı olduğunu düşünüyorum.

Önceki sürüm (29 bayt):

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

Girdi 'işaretler arasında sunulmalıdır , örn 'Potato'.

Brachylog , 3 bayt

ḷ⊆Ạ

Çevrimiçi deneyin!

Öngörülen girdi, belirtilen gereksinimleri karşılıyorsa başarılı olur ve yazmazsa, yazdırmazsa true.veya false.bir program olarak çalışıyorsa başarısız olur .

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

İlk kez buldum, alfabeye atıfta bulunmadan açıkça:

Brachylog , 4 bayt

ḷ≠.o

Çevrimiçi deneyin!

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

J, 21 karakter

Bu çok uzun. Argüman rütbeli olmalı 1, yani bir dize veya vektör olmalıdır.

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

• tolower y- yküçük harflerle.
• /:~ y- ysözlü olarak.
• ~. y- nub y, yani ykopyalar çıkarılmış olarak.
• x ; y- xve ykutulara koymak ve sonra birleştirilmiş.
• < y- ybir kutuya koyun.
• x = y- x element-bilge ile karşılaştırıldığında y.
• (< y) = (~. y) ; (/:~ y)- ynubuna eşit olup olmadığını ve sıralandığını gösteren bir vektör .
• */ y- Maddelerin ürünü yveya mantıksal ve eğer öğeler boolean ise.
• */ (< y) = (~. y) ; (/:~ y)- Küçük harf için istenen özelliği gösteren bir Boole y.

Julia, 44 bayt

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

Bu, tek bir argüman alan s, küçük harfe dönüştüren ve dizenin benzersiz sıralanmış sürümüyle karşılaştıran anonim bir işlev oluşturur . Bir boole döndürür, yani trueveya false. Test etmek istiyorsanız, gibi ata f=s->...ve sonra ara f("PuZ"), vb.

Saf Bash 4.x, 37

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

Komut satırı parametresi olarak alınan giriş. Standart kabuk anlambilimine göre, çıkış kodu 0, doğru (alfabetik) ve çıkış kodu! = 0, yanlış (alfabetik değil) anlamına gelir.

Printf, regex'i @ hsl'nin çözümünde olduğu gibi yaratır . Giriş dizesi küçük harfe genişletilir ve regex ile karşılaştırılır.

Önceki cevap:

Bash + coreutils, 52

Basit çözüm:

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

C # 6, 18 + 82 76 = 94 bayt

Gerektirir (18 bayt):

using System.Linq;

Kod (76 bayt):

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

C # 6, golf oynamak için yararlı olan bir işlevi tanımlamak için lambdaları destekler.

C # 6 olmayan sürüm:

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

Ungolfed kod:

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

JavaScript (ES6) 54

Büyük harfe dönüştürün, ardından sıralamak ve sıralamak için. Sıralama sırasında iki eleman yanlış sırada veya eşitse, 0 (falsy) else 1 (truthy) döndürün

Düzenleme Kısaltılmış @Optimizer thx (ama yine de daha ES6 uygulanan @Tamas çözümü 2'den: 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

Firefox / FireBug konsolunda test edin

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

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

C (44 bayt)

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

Burada test edin: http://ideone.com/q1LL3E

Bunu gönderdiğim için henüz yorum yapamıyorum, aksi halde mevcut C cevabını iyileştirmek için bir öneri olurdu çünkü mevcut C cevabından büyük / küçük harf duyarlı fikri tamamen çaldım.

Dize sipariş edilmediyse 0, sipariş edilirse sıfır olmayan bir değer döndürür.

Golang (65 bayt)

Git golf dostu bir dil değil, aynı zamanda golf de emmek ...

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

Burada çalıştırın: http://play.golang.org/p/xXJX8GjDvr

Düzenle 106-> 102

düzenle 102-> 96

Düzenle 96-> 91

düzenle 91-> 87

düzenle 87-> 65

Java sürümünü yendim, bugün için durabilirim

Java 8 - 90 89 87 85 karakter

Buradaki fikir, son karakteri izleyen ve dizinin kesin olarak yükselmediğini tespit ettiğinde "pes eden" bir "azaltma" işlevi kullanmaktır.

golfed:

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

örnek:

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

çıktı:

99
-1
122
122
122
-1

Perl 6, 35 bayt

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

Bu, çağrılabilir bir blok üretir; $_önceden istenen kelimeye ayarlanmış olduğunu varsayabilirsem , çevreleyen kıvrımlı parantezleri silebilir ve iki bayt daha kaybedebilirim, ancak muhtemelen bu varsayımı yapmanın tek makul yolu onu çalıştırmak -nve sözcüğü standart girdi olarak beslemektir. , bu iki byte'ı hemen geri ekler.

R , 37 bayt

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

Çevrimiçi deneyin!

Bu, Michal'ın R cevabından önemli ölçüde farklı ve daha kısa olduğu için gönderiliyor .

Harfleri ASCII kod noktalarına dönüştürür utf8ToInt, daha sonra alt ve üst harflerin aynı sayılara 1 ... 26 çevrilmesi için modulo 32 alır. İkili farkları hesaplar ve hepsinin pozitif olduğunu kontrol eder.

Perl, 27

@ hsl'nin düzenli ifadesi dinamik olarak oluşturulur.

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

Ayrıca ters bir eşleşme de yapabiliriz: girişi bir regexp: PuZ=> 'ye dönüştürün .*p.*u.*z.*ve sonra bunu alfabetik sırayla bir harf dizisi ile eşleştirin. Sonuç - ayrıca 27 karakter.

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

k (6 bayt)

&/>':_

& Her iki argüman da doğruysa true döndürür

/değiştirir &fonksiyonel dilde bir kat gibi bir liste "üzerinde" uygulamak

> daha büyük

':>"her-önceki" uygulanacak şekilde modifiye edildiğinden, hangi elementlerin öncekinden daha büyük olduğunu belirten bir boolel vektörü döndürür

_ argümanı küçük harf yapar

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

( 0bboolean false anlamına gelir)

q (13 bayt)

all(>':)lower

q, sadece k üzerindeki sözdizimsel şekerdir. allolarak tanımlanır &/ve düşük_

Python, 50 bayt

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

Burada çevrimiçi deneyin: http://repl.it/c5Y/2

VBA (161 bayt)

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  

Ascii değerini önceki harf ile küçük harflerle karşılaştırır, değeri daha küçük / eşit olduğunda ve işlevinden çıkınca 0 (false) döndürür

Python 2 , 43 bayt

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

Çevrimiçi deneyin!

Koyar <bütün harfler arasında semboller (küçük harfe dönüştürülür) ve sonra evalböyle. Python'un zincirleme karşılaştırma operatörleri, her şeyi büyük bir boole ifadesi olarak değerlendirmekten çok mutlular.

Erlang, 51

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

java.util.TreeSetKarakterleri sıralamak ve kopyaları atmak için sıralı bir küme kullanır (buna benzer ). Yeni liste daha sonra giriş dizesiyle karşılaştırılır.

Test İşlevi:

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

Burada oldukça basit. Sadece hepsini aşağıya dönüştürün ve her birini önceki karakterle karşılaştırın.