小文字/大文字の文字列[A-Za-z]を入力として受け入れ、出現する文字が一意であり、アルファベット順（小文字と大文字を無視）であるかどうかをチェックする関数/プログラムを作成します。出力は、一意であり、アルファベット順である場合は真実であり、そうでない場合は偽である必要があります。

ここにいくつかのテストケース

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

必要に応じて、このような単語リストのすべての単語でプログラムを実行し、興味深いものを投稿してください=）。

スコア

最も少ないバイト数が優先されます。

CJam、8バイト

lel_$_&=

これが課題のすべての例のテストハーネスです。これは0orを返します1（CJamではそれぞれ偽りであり、真実です）。

そして、ここに質問の単語リストをフィルターするスクリプトがあります（実行に数秒かかります）。パーマリンクには長すぎるため、単語リストを入力フィールドに手動でコピーする必要があります。

説明

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

正規表現（任意のフレーバー）、55バイト

一部の人々は、正規表現をプログラミング言語とは見なしていませんが、以前に使用されたことがあり、最短になるとは限りません。

^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（大文字と小文字を区別しない）フラグに1バイトを追加しました。これは非常に簡単で、オンザフライで生成するのに短いかもしれません。

正規表現のみが許可されていない場合は、MartinBüttnerが推奨するこの56バイトのRetinaプログラムを使用できます。

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

上記のリンクされたワードリストでこれを実行すると、アルファベット順に10個の6文字の単語が生成されました。

[「嫌い」、「ほぼ」、「始まり」、「始まり」、「ビジュー」、「生検」、「チンパンジー」、「チノ」、「チンツ」、「ゴースト」

Python 3、44バイト

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

シンプルなアプローチ-一意性の確認、ソートの確認。

> <>、52 42 39バイト

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

このタイプの質問は、一度に1つの文字だけを処理する必要があるため、> <>が非常に使いやすい数少ないタイプの1つです。

説明

迷子にしないでください！ここにはたくさんのラッピングがあります。

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

以前のソリューション、42バイト

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

興味深いのは、同じ機能を持っているように見えても、代替手段が

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

（変更は右端の矢印とミラーにあります）

> <>のインタープリターがPython defaultdictを使用しているため、実際には誤った結果が返されます。何が起こるかというと、2番目の行の終わりにある空のスペースを走査することにより、> <>がセルにアクセスしようとすると、暗黙的に0が空白スペースに配置されます。これ?により、同じ行の先頭で条件付きトランポリンが乱れます。これは、新しく配置された0がv末尾ではなくスキップされるためです。

Haskell、52バイト

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

使用法：(and.(zipWith(>)=<<tail).map toLower) "abcd"を出力しますTrue。

C、67 65 57 54（52）文字

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

少し短い：

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

さらに短く：

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

ちょっとしたテスト：http : //ideone.com/ZHd0xl

ここでの最新の提案の後、まだ2つの短いバージョンがあります。

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

また、このコードは、ASCIIの小文字と大文字の違いが、5番目のビット（32）だけであるという事実に依存しています。したがって、これは明らかに他のエンコーディングでは機能しない可能性があります。

編集：として常に5ビット目をセットし、最新バージョン|32よりも短くなっています&~32。

ルビー、33

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

ソートされた一意の文字がすべての文字と同じかどうかを確認します。

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により87に改善：

彼のコメントに賛成:)

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

ところで、プログラムが順序を無視して一意性のみをチェックしている場合、現在OPにあるテストケースは満たされます。

私はまだコメントを書くことができないので、ここでいくつかのコメントに答えます：

@ edc65：ありがとう！私が使用してそれを書き換えてみましたsome()が、それは余分にB変数を取り除くために私を可能にするように見えるにもかかわらず、あなたが二回（同じで「リターン」を入力する必要がありますので、私は、短い解を得ることができませんでしたreduce()）、そしてあなた最後の文字を比較した後に保存する必要があるため、比較の結果を直接返すことはできません。

@ edc65： 87のコンマ演算子の素晴らしい使用法です！可視性を高めるために回答に編集しました。

Haskell、90バイト

機能を提供する f :: String -> Bool

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

使用法（golf.hsとして保存されていると仮定）。...交換に使用されますghciの詳細な読み込みメッセージます。

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

誰かがそれlowercaseより短い方法を持っている場合はimport Distribution.Simple.Utilsコメントしてください。

Wolfram Mathematica、49 37バイト

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

MartinBüttnerによるPS Shorterソリューション：

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

J、17バイト

小文字でソートされた/:~文字列が-:小文字のnub ~.文字列と等しいかどうかを確認します。

   (/:~-:~.)@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のように、通常の文字列（引用符付き）として表される1文字の長い「文字列」は、実際の文字列ではなく単なる文字アトムです。（上記の例ではを使用しました1$'a'。）

MATLAB、29 27バイト

さて、コードゴルフの外でさえ意味をなすワンライナーのために。

無名関数として（として使用o('yourstring')）

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

この関数は、新聞広告のように表示されるため、一目瞭然です。

以前のバージョン（29バイト）：

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

入力は、'マークの間で提示する必要があります'Potato'。

Brachylog、3バイト

ḷ⊆Ạ

オンラインでお試しください！

入力が概説された要件を満たしている場合、述部は成功し、満たさない場合、印刷true.またはfalse.プログラムとして実行される場合は失敗します。

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

私が思いついた最初のバージョンで、アルファベットを明示的に参照していません：

Brachylog、4バイト

ḷ≠.o

オンラインでお試しください！

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

J、21文字

これは長すぎです。引数にはrankが1必要です。つまり、文字列またはベクトルでなければなりません。

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

• tolower y– y小文字で。
• /:~ y– y字句順。
• ~. y–のナブy、つまりy重複が削除された。
• x ; y- xとy箱に入れ、その後、連結。
• < y– y箱に入れます。
• x = y– x 要素ごとにと比較y。
• (< y) = (~. y) ; (/:~ y)– yナブと等しいかどうかを示すベクトルとそれ自体がソートされます。
• */ y–のアイテムの積y、またはその論理的アイテム、およびアイテムがブール値の場合。
• */ (< y) = (~. y) ; (/:~ y)–小文字に必要なプロパティを示すブール値y。

ジュリア、44バイト

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

これにより、1つの引数を取り、sそれを小文字に変換し、文字列の一意のソートされたバージョンと比較する匿名関数が作成されます。ブール値、つまりtrueまたはを返しますfalse。テストする場合は、同様に割り当ててから、などをf=s->...呼び出しますf("PuZ")。

Pure Bash 4.x、37

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

コマンドラインパラメータとして取得される入力。標準シェルのセマンティクスにより、終了コード0はtrue（アルファベット）を意味し、終了コード！= 0はfalse（アルファベットではない）を意味します。

printfは、@ hslのソリューションのように正規表現を作成します。入力文字列は小文字に展開され、正規表現と比較されます。

前の答え：

Bash + coreutils、52

簡単なソリューション：

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

C＃6、18 + 82 6、18 76 = 94バイト

必要（18バイト）：

using System.Linq;

コード（76バイト）：

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

C＃6は、関数を定義するためにラムダをサポートしています。これは、ゴルフに役立ちます。

非C＃6バージョン：

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

未ゴルフコード：

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

JavaScript（ES6）54

大文字に変換してから、配列とソートに変換します。ソート中に2つの要素の順序が間違っているか等しい場合、0（偽）または1（真）を返します

編集短縮の@OptimizerにTHX（まだ2以上ES6で実装@Tamasソリューションより：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コンソールでテストする

;['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バイト）

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

ここでテストしてください：http : //ideone.com/q1LL3E

まだコメントできないため、これを投稿します。そうしないと、既存のCの回答から大文字と小文字を区別しないアイデアを完全に盗んだため、既存のCの回答を改善することをお勧めします。

文字列が順序付けられていない場合は0を返し、順序付けされている場合はゼロ以外の値を返します。

Golang（65バイト）

Goはゴルフにやさしい言語ではありません。また、私はゴルフを嫌いです...

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

ここで実行：http : //play.golang.org/p/xXJX8GjDvr

編集106-> 102

編集102-> 96

編集96-> 91

編集91-> 87

編集87-> 65

私はJavaバージョンに勝ちました、今日はやめられます

Javaの8 - 90の 89 87 85文字

ここでの考え方は、最後の文字を追跡し、シーケンスが厳密に昇順ではないことを検出すると「あきらめる」「縮小」機能を使用することです。

ゴルフ：

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

なし：

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

例：

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

出力：

99
-1
122
122
122
-1

Perl 6、35バイト

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

これにより、呼び出し可能ブロックが生成されます。$_既に目的の単語に設定されていると仮定できる場合、周囲の中括弧を削除してさらに2バイトを失う可能性がありますが、おそらくその仮定を立てる唯一の合理的な方法は、それを実行して-n単語を標準入力としてフィードすることです、これは2バイトをすぐに追加します。

R、37バイト

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

オンラインでお試しください！

これは、MichalのR回答とは大幅に異なり、短いため投稿。

を使用して文字をASCIIコードポイントに変換し、utf8ToIntモジュロ32を使用して、小文字と大文字を同じ数字1 ... 26に変換します。ペアごとの差を計算し、それらがすべて正であることを確認します。

Perl、27

@hslの正規表現は動的に構築されます。

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

また、逆の照合を行うこともできます。入力を正規表現に変換します：PuZ=> .*p.*u.*z.*そして、これをアルファベット順の文字列に照合します。結果-27文字。

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

k（6バイト）

&/>':_

& 両方の引数がtrueの場合、trueを返します

/&関数型言語の折り畳みのように、リストに「重ねて」適用するように変更します

> より大きい

': 変更する >"each-prior"を適用ようにし、先行要素よりも大きい要素を示すブール値のベクトルを返します

_ 引数を小文字にします

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

（0bブール値falseを意味します）

q（13バイト）

all(>':)lower

qはk上の単なる構文糖です。allはとして定義され&/、下限は_

Python、50バイト

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

ここでオンラインで試してください：http : //repl.it/c5Y/2

VBA（161バイト）

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値を小文字の前の文字と比較し、値が小さい/等しい場合は0（false）を返し、関数を終了します

Python 2、43バイト

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

オンラインでお試しください！

プット<（小文字に変換）すべての文字間のシンボルを、その後、evalそれをです。Pythonの連鎖比較演算子は、1つの大きなブール式として全体を評価できて非常に満足しています。

アーラン、51

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

順序付きセットを使用します（に類似 java.util.TreeSet）を、文字をソートし、重複を破棄します。次に、新しいリストが入力文字列と比較されます。

テスト機能：

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

ここではかなり簡単です。すべてを下位に変換し、それぞれを前の文字と比較します。