소문자 / 대문자 문자열 [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_$_&=

도전 과제의 모든 예제에 대한 테스트 장치 가 있습니다. 이것은 0또는 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 바이트를 추가했습니다 . 이것은 매우 간단하며 즉석에서 생성하는 것이 더 짧을 수 있습니다.

정규식 만 허용되지 않으면 Martin Bü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 자 단어가 나옵니다.

[ "abhors", "거의", "시작", "begirt", "bijoux", "biopsy", "chimps", "chinos", "chintz", "ghosty"]

파이썬 3, 44 바이트

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

간단한 접근 방식-고유성 검사, 정렬 검사.

> <> , 52 42 39 바이트

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

이 유형의 질문은 한 번에 하나의 문자 만 처리하면되기 때문에> <>가 꽤 편한 몇 가지 유형 중 하나입니다.

설명

길을 잃지 마십시오! 포장이 많이 있습니다.

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
? ){:-<'`'/ ^^

(가장 오른쪽에있는 화살표와 거울에 변화가 있습니다)

파이썬 defaultdict를 사용하는> <>의 인터프리터로 인해 실제로 잘못된 결과를 제공 합니다. 결과는 두 번째 행의 끝에서 빈 공간을 통과하여> <>가 셀에 액세스하려고 할 때 빈 공간에 0을 암시 적으로 배치한다는 것입니다. 그런 다음 ?동일한 행의 시작 부분에서 조건부 트램폴린 을 망칩니다 . 새로 배치 된 0은 v끝이 아니라 건너 뜁니다 .

하스켈, 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

최신 제안 후에도 두 가지 더 짧은 버전이 있습니다.

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

정렬 된 고유 문자가 모든 문자와 같은지 확인합니다.

자바 스크립트 (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})}

Btw, 프로그램이 순서를 무시하고 고유성을 검사하는 경우 현재 OP에있는 테스트 사례가 이행됩니다.

아직 의견을 쓸 수 없으므로 여기에 몇 가지 의견에 대답하겠습니다.

@ edc65 : 감사합니다! 나는 그것을 사용하여 다시 작성을 시도했지만 some()더 짧은 해결책을 얻을 수 없었습니다. 왜냐하면 그것이 superflous b 변수를 제거 할 수있는 것처럼 보이지만 "return"을 두 번 입력해야합니다 (와 동일 reduce()). 비교 후 마지막 문자를 저장해야하기 때문에 비교 결과를 직접 반환 할 수는 없습니다.

@ edc65 : 87에 쉼표 연산자를 사용하는 것이 좋습니다! 가시성을 높이기 위해 내 답변으로 편집했습니다.

하스켈, 90 바이트

기능을 제공합니다 f :: String -> Bool

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

사용법 (골프 .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)

Martin Bü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))))

이렇게하면 단일 인수 s를 사용하여 소문자로 변환하여 고유 한 정렬 된 버전의 문자열과 비교 하는 익명 함수가 생성 됩니다. 부울 즉, true또는을 반환합니다 false. 테스트하려면 원하는 방식으로 할당 f=s->...한 다음을 호출하십시오 f("PuZ").

퓨어 배쉬 4.x, 37

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

명령 줄 매개 변수로 입력됩니다. 표준 쉘 의미에 따라 종료 코드 0은 true (알파벳)를 의미하고 종료 코드! = 0은 false (알파벳 제외)를 의미합니다.

printf는 @ hsl 's solution 과 같이 정규식을 만듭니다 . 입력 문자열은 소문자로 확장되어 정규식과 비교됩니다.

이전 답변 :

배쉬 + 코어 유틸리티, 52

간단한 해결책 :

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

C # 6, 18 + 82 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);}

Ungolfed 코드 :

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

자바 스크립트 (ES6) 54

대문자로 변환 한 다음 배열 및 정렬로 변환하십시오. 정렬하는 동안 두 요소의 순서가 잘못되었거나 같으면 0 (거짓)을, 그렇지 않으면 1 (거짓)을 반환

단축 thx를 @Optimizer로 편집하십시오 (그러나 ES6에서 구현 된 @Tamas 솔루션보다 여전히 2 개 더 많음 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을, 정렬 된 경우 0이 아닌 값을 반환합니다.

골랑 (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

나는 자바 버전을 이겼다. 나는 오늘 멈출 수있다.

자바 (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

펄 6, 35 바이트

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

이것은 호출 가능한 블록을 생성합니다. 내가 $_이미 원하는 단어로 설정 되었다고 가정 할 수 있다면 주변의 중괄호를 삭제하고 2 바이트를 더 잃을 수는 있지만 아마도 그것을 가정 -n하고 표준 입력으로 단어를 공급하는 것이 합리적 인 유일한 방법 일 것입니다 두 바이트를 다시 추가합니다.

R , 37 바이트

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

온라인으로 사용해보십시오!

이것은 Michal의 R 답변 과 실질적으로 다르고 짧기 때문에 게시하는 것 입니다.

을 사용하여 문자를 ASCII 코드 포인트로 변환 한 utf8ToInt다음 모듈러스 32를 사용하여 소문자와 대문자를 동일한 숫자 1 ... 26으로 변환합니다. 쌍별 차이를 계산하고 모두 양수인지 확인합니다.

펄, 27

@ hsl의 정규 표현식은 동적으로 빌드됩니다.

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

또한 입력을 regexp : 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부울 거짓을 의미)

q (13 바이트)

all(>':)lower

q는 k의 구문 설탕입니다. all로 정의 &/되고 더 낮은_

파이썬, 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 (거짓)을 반환하고 종료 함수

파이썬 2 , 43 바이트

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

온라인으로 사용해보십시오!

박았의 <모든 문자와 기호 (소문자로 변환) 한 다음 eval그것을이야. 파이썬의 체인 비교 연산자는 모든 것을 하나의 큰 부울 식으로 평가하는 것에 매우 만족합니다.

에를 랑, 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"]].

자바, 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;}

여기에 매우 간단합니다. 모두를 더 낮은 것으로 변환하고 각각을 이전 문자와 비교하십시오.