Tulis fungsi / program yang menerima string huruf kecil / besar [A-Za-z] sebagai input, yang memeriksa apakah huruf yang muncul adalah unik dan dalam urutan abjad (mengabaikan huruf kecil dan besar) atau tidak. Outputnya harus benar jika mereka unik dan dalam urutan abjad dan palsu jika tidak.

Ini beberapa 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

Jika Anda mau, jalankan program Anda pada semua kata dari daftar kata seperti ini dan posting beberapa yang menarik =).

Skor

Jumlah byte terendah menang.

CJam, 8 byte

lel_$_&=

Berikut ini adalah test harness untuk semua contoh dalam tantangan. Ini mengembalikan 0atau 1(yang masing-masing palsu dan jujur, dalam CJam).

Dan inilah skrip untuk memfilter daftar kata dalam pertanyaan (perlu beberapa detik untuk dijalankan). Anda harus menyalin daftar kata ke dalam kolom input secara manual, karena terlalu panjang untuk permalink.

Penjelasan

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 (rasa apa saja), 55 byte

Beberapa orang tidak menganggap regex sebagai bahasa pemrograman, tetapi sudah pernah digunakan sebelumnya, dan itu tidak dekat dengan yang terpendek.

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

Saya telah menambahkan satu byte untuk iflag (case-insensitive). Ini sangat mudah dan mungkin lebih pendek untuk dihasilkan dengan cepat.

Jika regex saja tidak diperbolehkan, Anda dapat menggunakan program Retina 56-byte yang disarankan oleh 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?$

Menjalankan ini pada daftar kata yang ditautkan di atas menghasilkan 10 kata 6 huruf dalam urutan abjad.

["membenci", "hampir", "dimulai", "begirt", "bijoux", "biopsi", "simpanse", "chino", "chintz", "ghosty"]

Python 3, 44 byte

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

Pendekatan sederhana - periksa keunikan, periksa penyortiran.

> <> , 52 42 39 byte

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

Jenis pertanyaan ini adalah salah satu dari beberapa jenis yang> <> cukup nyaman digunakan, karena kita hanya perlu berurusan dengan satu karakter pada satu waktu.

Penjelasan

Jangan sampai tersesat! Ada banyak pembungkus di sini.

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

Solusi sebelumnya, 42 byte

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

Yang menarik adalah bahwa, meskipun tampaknya memiliki fungsi yang sama, alternatifnya

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

(Perubahan ada di panah dan cermin di paling kanan)

sebenarnya memberikan hasil yang salah , karena interpreter> <> menggunakan Python defaultdict. Apa yang terjadi adalah, dengan menelusuri ruang kosong di akhir baris kedua, 0s secara implisit ditempatkan ke dalam ruang kosong ketika> <> mencoba mengakses sel. Ini kemudian mengacaukan ?trampolin kondisional pada awal baris yang sama, karena 0s yang baru ditempatkan dilewati daripada vdi akhir.

Haskell, 52 Bytes

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

Penggunaan: (and.(zipWith(>)=<<tail).map toLower) "abcd"output mana 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;}

sedikit lebih pendek:

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

dan bahkan lebih pendek:

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

Inilah sedikit tes: http://ideone.com/ZHd0xl

Setelah saran terbaru di sini masih ada dua versi yang lebih pendek:

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

Kode ini juga bergantung pada fakta, bahwa dalam ASCII huruf kecil dan besar hanya berbeda dengan bit ke-5 (32) yang saya filter. Jadi ini mungkin tidak bekerja dengan pengkodean lainnya.

EDIT: Versi terbaru selalu menetapkan bit ke-5 |32lebih pendek dari &~32.

Ruby, 33

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

Cek untuk melihat apakah karakter unik yang diurutkan sama dengan semua karakter.

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}

Ditingkatkan menjadi 87 oleh edc95:

komentarnya :)

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

Btw, kasus uji saat ini di OP terpenuhi jika program hanya memeriksa keunikan, mengabaikan pesanan.

Saya belum bisa menulis komentar, jadi saya akan menjawab beberapa komentar di sini:

@ edc65: Terima kasih! Saya mencoba menulis ulang menggunakansome() , tetapi saya tidak bisa mendapatkan solusi yang lebih pendek, karena meskipun sepertinya itu akan memungkinkan saya untuk menyingkirkan variabel b superflous, Anda perlu mengetik "kembali" dua kali (sama dengan reduce()), dan Anda tidak bisa hanya mengembalikan hasil perbandingan secara langsung, karena karakter terakhir harus disimpan setelah perbandingan dengannya.

@ edc65: Itu penggunaan yang bagus dari operator koma untuk 87! Saya mengeditnya di jawaban saya untuk visibilitas lebih.

Haskell, 90 byte

Persediaan fungsi f :: String -> Bool

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

Penggunaan (dengan asumsi itu disimpan sebagai golf.hs). ...digunakan untuk mengganti ghcipesan pemuatan verbose.

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

Jika seseorang memiliki lowercasemetode yang lebih pendek daripada import Distribution.Simple.Utilsitu, silakan berkomentar.

Wolfram Mathematica, 49 37 byte

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

Solusi PS Shorter oleh Martin Büttner:

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

J, 17 byte

Periksa apakah /:~string yang diurutkan huruf kecil sama -:dengan ~.string nub kecil .

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

Seperti pada J, panjang 1-karakter "string" yang direpresentasikan sebagai string biasa (dengan tanda kutip) hanyalah atom karakter, bukan string nyata. Saya memformat input dengan tepat sehingga semua input akan menjadi string nyata. (Dalam contoh di atas saya gunakan 1$'a'.)

MATLAB, 29 27 byte

Sekarang untuk satu-liner yang bahkan masuk akal di luar kode-golf.

Sebagai fungsi anonim (gunakan sebagai o('yourstring'))

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

Saya kira fungsi ini cukup jelas karena berbunyi seperti iklan surat kabar.

Versi sebelumnya (29 byte):

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

Input harus disajikan di antara 'tanda, mis 'Potato'.

Brachylog , 3 byte

ḷ⊆Ạ

Cobalah online!

Predikat berhasil jika input memenuhi persyaratan yang diuraikan dan gagal jika tidak, pencetakan true.atau false.jika dijalankan sebagai suatu program.

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

Versi pertama yang saya buat, tidak secara eksplisit merujuk alfabet:

Brachylog , 4 byte

ḷ≠.o

Cobalah online!

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

J, 21 karakter

Ini terlalu lama. Argumen harus memiliki peringkat 1, yaitu harus berupa string atau vektor.

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

• tolower y- ydalam huruf kecil.
• /:~ y- ydalam urutan leksikal.
• ~. y- inti y, yaitu, ydengan duplikat dihapus.
• x ; y- xdan ydimasukkan ke dalam kotak dan kemudian digabungkan.
• < y- ydimasukkan ke dalam kotak.
• x = y- x Dibandingkan dengan elemen-bijaksana y.
• (< y) = (~. y) ; (/:~ y)- vektor yang menunjukkan apakah ysama dengan nubnya dan diurutkan sendiri.
• */ y- produk dari item y, atau logis dan jika item tersebut adalah boolean.
• */ (< y) = (~. y) ; (/:~ y)- boolean yang menunjukkan properti yang diinginkan untuk huruf kecil y.

Julia, 44 byte

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

Ini menciptakan fungsi anonim yang mengambil argumen tunggal s, mengubahnya menjadi huruf kecil, dan membandingkannya dengan versi unik dari string. Ia mengembalikan boolean, yaitu trueatau false. Jika Anda ingin mengujinya, tetapkan seperti f=s->...lalu panggil f("PuZ"), dll.

Pure Bash 4.x, 37

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

Input diambil sebagai parameter baris perintah. Sesuai standar semantik shell, kode keluar 0 berarti benar (alfabet) dan kode keluar! = 0 berarti salah (bukan alfabet).

Printf menciptakan regex seperti pada solusi @ hsl . String input diperluas ke huruf kecil dan dibandingkan dengan regex.

Jawaban sebelumnya:

Bash + coreutils, 52

Solusi mudah:

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

C # 6, 18 + 82 76 = 94 byte

Membutuhkan (18 byte):

using System.Linq;

Kode (76 byte):

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

C # 6 mendukung lambdas untuk mendefinisikan suatu fungsi, yang berguna untuk bermain golf.

Versi Non-C # 6:

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

Kode tidak dikunci:

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

JavaScript (ES6) 54

Konversikan ke huruf besar, lalu ke array dan urutkan. Jika selama mengurutkan dua elemen berada dalam urutan yang salah atau sama, mengembalikan 0 (salah) yang lain 1 (benar)

Mengedit disingkat thx untuk @Optimizer (tapi masih 2 lebih dari solusi @Tamas diterapkan di 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

Uji di Firefox / konsol 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", "puZZ", "puZ 1", "PuZ 1"]

C (44 byte)

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

Uji di sini: http://ideone.com/q1LL3E

Posting ini karena saya belum bisa berkomentar, kalau tidak itu akan menjadi saran untuk meningkatkan jawaban C yang ada karena saya benar-benar mencuri ide case-sensitive dari jawaban C yang ada.

Mengembalikan 0 jika string tidak dipesan, dan nilai bukan nol jika dipesan.

Golang (65 byte)

Go bukan bahasa yang ramah golf, juga, saya payah di golf ...

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

Jalankan di sini: http://play.golang.org/p/xXJX8GjDvr

sunting 106-> 102

sunting 102-> 96

sunting 96-> 91

sunting 91-> 87

sunting 87-> 65

Saya mengalahkan versi java, saya bisa berhenti untuk hari ini

Java 8 - 90 89 87 85 karakter

Idenya di sini adalah untuk menggunakan fungsi 'mengurangi' yang melacak karakter terakhir dan "menyerah" ketika mendeteksi urutan tidak naik secara ketat.

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

contoh:

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

keluaran:

99
-1
122
122
122
-1

Perl 6, 35 byte

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

Ini menghasilkan blok yang bisa dipanggil; jika saya hanya bisa berasumsi bahwa $_sudah diatur ke kata yang diinginkan, saya bisa menghapus kurung kurawal sekitarnya dan kehilangan dua byte lagi, tetapi mungkin satu-satunya cara yang masuk akal untuk membuat asumsi itu adalah dengan menjalankannya -ndan memberi makan kata sebagai input standar , yang akan menambahkan dua byte segera kembali.

R , 37 byte

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

Cobalah online!

Posting karena ini sangat berbeda dan lebih pendek dari jawaban R Michal .

Ubah huruf menjadi ASCII dengan codepoint utf8ToInt, lalu ambil modulo 32 sehingga huruf bawah dan atas dikonversi ke angka yang sama 1 ... 26. Hitung perbedaan berpasangan, dan periksa apakah semuanya positif.

Perl, 27

@ hsl's regexp membangun secara dinamis.

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

Kita juga dapat melakukan pencocokan terbalik: mengonversi input menjadi regexp: PuZ=> .*p.*u.*z.*dan kemudian mencocokkan ini dengan serangkaian huruf dalam urutan abjad. Hasil - juga 27 karakter.

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

k (6 byte)

&/>':_

& mengembalikan true jika kedua args benar

/memodifikasi &untuk menerapkan "lebih dari" daftar, seperti lipatan dalam bahasa fungsional

> lebih besar dari

':memodifikasi >untuk menerapkan "setiap-sebelumnya", jadi mengembalikan vektor boolean yang menyatakan elemen mana yang lebih besar dari pendahulunya

_ menjadikannya argumen huruf kecil

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

( 0bberarti boolean false)

q (13 byte)

all(>':)lower

q hanya gula sintaksis pada k. alldidefinisikan sebagai &/, dan lebih rendah adalah_

Python, 50 byte

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

Coba online di sini: http://repl.it/c5Y/2

VBA (161 byte)

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  

Membandingkan nilai ascii dengan huruf sebelumnya dalam huruf kecil, menghasilkan 0 (salah) ketika nilainya lebih kecil / sama dan keluar dari fungsi

Python 2 , 43 byte

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

Cobalah online!

Letakkan <simbol di antara semua huruf (dikonversi ke huruf kecil), lalu evals. Operator perbandingan dirantai Python sangat senang mengevaluasi semuanya sebagai satu ekspresi boolean besar.

Erlang, 51

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

Menggunakan set yang dipesan (analog dengan java.util.TreeSet) untuk mengurutkan karakter dan membuang duplikat. Daftar baru kemudian dibandingkan dengan string input.

Fungsi tes:

test() ->
    [io:format("~p ~p~n", [S, f(S)]) || S <- ["a","abcdefGHIjklmnopqrSTUVWXyz","aa","puz","puzz","puzZ","puZ","PuZ"]].

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

Cukup mudah di sini. Konversikan semua menjadi lebih rendah dan bandingkan masing-masing dengan karakter sebelumnya.