'짝수 문자열'은 문자의 ASCII 값의 패리티 가 항상 번갈아 나타나는 문자열입니다. 예를 들어, EvenSt-ring$!문자의 ASCII 값은 다음과 같으므로 문자열 은 짝수 문자열 입니다.

69 118 101 110 83 116 45 114 105 110 103 36 33

이 숫자의 패리티는 다음과 같습니다.

Odd Even Odd Even Odd Even Odd Even Odd Even Odd Even Odd

어느 쪽이든 번갈아 가며 그러나 ASCII 값은 다음 과 같으 므로 같은 문자열 은 짝수 문자열 Hello world!이 아닙니다 .

72 101 108 108 111 32 87 111 114 108 100 33

그리고 패리티는 다음과 같습니다.

Even Odd Even Even Odd Even Odd Odd Even Even Even Odd

항상 교대하지는 않습니다.

도전

전체 프로그램 또는 입력을 위해 문자열을 허용 하고 문자열이 짝수이면 정확한 값을 출력하고 그렇지 않으면 거짓 값을 출력하는 함수를 작성해야합니다 . 적절한 형식으로 입력 및 출력을 취할 수 있으며 입력에 인쇄 가능한 ASCII (32-127 범위) 만 있다고 가정 할 수 있습니다 . 빈 입력을 처리 할 필요가 없습니다 .

예

짝수 문자열의 예는 다음과 같습니다.

#define
EvenSt-ring$!
long
abcdABCD
3.141
~
0123456789
C ode - g ol!f
HatchingLobstersVexinglyPopulateJuvenileFoxglove

그리고이 모든 예제는 문자열조차도 아닙니다.

Hello World
PPCG
3.1415
babbage
Code-golf
Standard loopholes apply
Shortest answer in bytes wins
Happy golfing!

이 테스트되지 않은 솔루션 을 사용 하여 특정 테스트 사례에 대해 궁금한 경우 문자열을 테스트 할 수도 있습니다 .

MATL , 4 3 바이트

바이트를 절약 해 준 Emigna 와 일부 버그를 수정 한 Luis Mendo 에게 감사드립니다 . 암호:

doA

설명:

d     # Difference between the characters
 o    # Mod 2
  A   # Matlab style all

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

05AB1E , 5 4 바이트

Adnan 덕분에 1 바이트가 절약되었습니다 .

Ç¥ÉP

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

설명

Ç       # convert to ascii values 
 ¥      # compute delta's
  É     # mod by 2
   P    # product

젤리 , 7 5 4 바이트

OIḂẠ

@ Steven H 의 델타 아이디어를 사용하여 2 바이트를 절약했습니다 .

@ Lynn 덕분에 1 바이트를 절약했습니다 .

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

설명

OIḂẠ  Input: string S
O     Ordinal
 I    Increments
  Ḃ   Mod 2
   Ạ  All, 0 if it contains a falsey value, else 1

파이썬 2, 54 바이트

lambda s:all((ord(x)-ord(y))%2for x,y in zip(s,s[1:]))

매스 매 티카, 50 44 바이트

현재 버전은 기본적으로 모든 Martin Ender의 미덕입니다.

Differences@ToCharacterCode@#~Mod~2~FreeQ~0&

반환 True또는 False. 너무 영리한 것은 아닙니다 : 연속 ASCII 코드의 각 쌍의 mod-2 합을 취하고 0이 절대로 얻지 않는지 확인합니다.

구 버전:

Union@Mod[Most[a=ToCharacterCode@#]+Rest@a,2]=={1}&

자바 스크립트 (ES6), 60 50 46 바이트

s=>[...s].every(c=>p-(p=c.charCodeAt()%2),p=2)

재귀를 시도했지만 51 바이트에서 그만한 가치가없는 것 같습니다.

f=([c,...s],p=2)=>c?p-(p=c.charCodeAt()%2)&f(s,p):1

테스트 스 니펫

f=s=>[...s].every(c=>p-(p=c.charCodeAt()%2),p=2)

<input id=I value="Evenst-ring"><button onclick="console.log(f(I.value))">Run</button>

뇌 플랙 , 138 (114) 112 84 + 3 = 87 바이트

골프를 도와 주신 @Riley 에게 감사드립니다 .

이 프로그램은 빈 입력을 고르지 않은 문자열로 취급합니다.

{({}(())){({}[()]<(()[{}])>)}{}(({})<>[[]{}]()){{}(<>)}{}({}<>)<>}<>(([])[()]){<>}{}

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

설명 (오래됨)

2로 모딩하는 동안 왼쪽 스택에서 오른쪽으로 입력을 이동합니다. 모든 항목을 확인할 때까지 또는 차이 중 하나가 0이 될 때까지 (각각 고르지 않은 문자열에서만 발생) 각 인접 문자 간의 차이를 찾습니다. 고르지 않은 문자열로 인해 루프가 종료 된 경우 왼쪽 스택으로 다시 전환하고 나머지 값을 팝하십시오. 그렇지 않으면 오른쪽 스택을 유지하고 스택에 남아있는 1보다 0을 팝니다.

R, 41 35 바이트

편집 : diff대신 @JDL 덕분에 몇 바이트를 절약했습니다 rle.

all(diff(utf8ToInt(readline())%%2))

all(rle(utf8ToInt(readline())%%2)[[1]]<2)

설명

1. readline() 입력을 읽습니다.
2. utf8ToInt()%%2 ASCII 값과 모드 2로 변환 (R- 벡터로 저장)
3. all(rle()==1)실행을 찾기위한 실행 길이 인코딩 음수 또는 0이 될 수없는 런이 없기 때문에 모든 런은 1보다 작거나 같아야합니다 (대신에 1 바이트를 절약 함 ==).

Pyth ( 포크 ), 9 바이트

.A%R2.+CM

온라인 인터프리터에 포크 자체 버전이 없으므로 온라인 사용해보기 링크가 없습니다.

설명:

       CM       Map characters to their ASCII codes.
     .+         Get deltas (differences between consecutive character codes)
  %R2           Take the modulo of each base 2
.A              all are truthy (all deltas are odd)

Brachylog , 17 바이트

@c:{:2%}a@b:{l1}a

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

설명

@c                   Input to a list of char codes
  :{:2%}a            Apply X mod 2 for each X in the list of char codes
         @b          Split the list into a list of lists where each sublist elements are the
                       same, e.g. turn [1,0,1,1,0,0] into [[1],[0],[1,1],[0,0]]
           :{l1}a    The length of each sublist must be 1

자바 8, 77 76 72 57 바이트

a->{int i=2,b=1;for(int c:a)b=i==(i=c%2)?0:b;return b>0;}

@Geobits 덕분에 -4 바이트 .

설명:

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

a->{               // Method with character-array parameter and boolean return-type
  int i=2,         //  Integer `i`, starting at any integer not 0 or 1
      b=1;         //  Flag-integer `b`, starting at 1
  for(int c:a)     //  Loop over the input-array
    b=i==(i=c%2)?  //   If two adjacent characters were both odd or even:
       0           //    Set the flag-integer `b` to 0
      :            //   Else:
       b;          //    The flag-integer `b` remains the same
  return b>0;}     //  Return if the flag-integer `b` is still 1

뇌 플랙 155 151 141 121

-a에 +3 포함

1000000000 덕분에 30 바이트 절약

{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>{({}[({})]<(())>){((<{}{}>))}{}({}[()]<>)<>}<>{{}}([]<(())>){((<{}{}>))}{}

출력 :
진실 : 1
거짓 : 스택 상단에 0

온라인으로 사용해보십시오! (truthy)
온라인으로보십시오! (가짜)

나중에 더 나은 설명 (몇 시간 후에 어떻게 작동하는지 기억할 수 있다면 ...)

#compute ((mod 2) + 1) and put on other stack
{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>

#compare top two (remove top 1) push on other stack (-1 for different 0 for same)
{({}[({})]<(())>){((<{}{}>))}{}({}[()]<>)<>}<>

#remove all of the top -1s
{{}}

#take the logical not of the stack height
([]<(())>){((<{}{}>))}{}

별이 빛나는 , 85 바이트

 ,       +    *   ` , +               + * ' +  ' `       +    * +   + *   '     +  `.

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

Starry 프로그램은 임의의 길이의 입력이 끝나는 시점을 알려주는 방법이 없으므로이 프로그램은 입력에서 후행 줄 바꿈을 사용하여 문자열의 끝을 표시합니다. 암호 오류 메시지와 정의되지 않은 메소드가 표시되는 경우ord 에 대해 nil:NilClass다음 입력이 뒤에 줄 바꿈이 없습니다.

설명

프로그램이 사용하는 기본 전략은 입력에서 문자를 하나씩 읽고 문자가 개행 (문자 10)이 아닌 경우 문자의 ASCII 값을 2 씩 수정하고 이전에 읽은 문자 사이의 차이점을 찾는 것입니다. 차이가 0이면 프로그램이 종료되고 인쇄됩니다 0(거짓). 그렇지 않으면 프로그램이 루프백하고 프로세스를 다시 수행합니다. 프로그램이 개행을 읽으면 종료되고 인쇄됩니다.10 .

주석이 달린 프로그램

 ,               Push the first character
       +         Push 2
    *            Replace the first character and 2 with the first character mod 2
   `             Label 3 <--------------------------------------------------------\
 ,               Push the next the character                                      |
 +               Push a duplicate of it                                           |
               + Push 10                                                          |
 *               Replace the 10 and the duplicate with their difference           |
 '               Pop and if not zero (the read char is not 10) goto label 1 >-\   |
 +               Push a duplicate of the character which must be newline (10) |   |
  '              Pop and goto label 2 >---------------------------------------+-\ |
 `               Label 1 <----------------------------------------------------/ | |
       +         Push 2                                                         | |
    *            Replace the character and 2 with the character mod 2           | |
 +               Duplicate it ^                                                 | |
   +             Roll the top three items on the stack. The top goes to         | |
                   the bottom. The top three items are now                      | |
                   (from top to bottom) the current character, the previous     | |
                   character, the current character (all modded by 2).          | |
 *               Replace the current character and previous character           | |
                   with their difference                                        | |
   '             Pop if nonzero goto label 3 >----------------------------------+-/
     +           Push zero                                                      |
  `              Label 2 <------------------------------------------------------/
.                Print out the number on top of the stack
                    0 if we came by not following the goto label 3
                   10 if we came by going to label 2

펄, 24 + 1 ( -p) = 25 바이트

@Ton Hospel 덕분에 -4 바이트 !

s/./$&&v1/eg;$_=!/(.)\1/

-p깃발이 필요 합니다. 출력 1은 문자열이 짝수이며 다른 것은 없습니다. 예를 들면 :

perl -pe 's/./$&&v1/eg;$_=!/(.)\1/' <<< "#define
Hello World"

설명 : 각 문자를 값 mod 2로 바꿉니다 (따라서 문자열에는 0과 1 만 포함됨). 그런 다음 1 또는 0을 따르는 두 가지를 검색하십시오. 일부를 찾으면 문자열이 고르지 않으며 그렇지 않으면 그렇지 않습니다.

J, 15 바이트

0=1#.2=/\2|3&u:

용법

   f =: 0=1#.2=/\2|3&u:
   f 'C ode - g ol!f'
1
   f 'Code-golf'
0

설명

0=1#.2=/\2|3&u:  Input: string S
           3&u:  Get ordinals of each char
         2|      Take each modulo 2
     2  \        For each pair of values
      =/           Test if they are equal, 1 if true else 0
  1#.            Treat the list of integers as base 1 digits and convert to decimal
                 This is equivalent to taking the sum
0=               Is it equal to 0, 1 if true else 0, and return

Vim, 38 바이트

qqs<C-R>=char2nr(@")%2<CR><Esc>l@qq@q:g/00\|11/d<CR>

입력 문자열을 버퍼로 가정하고 비어 있다고 가정합니다 "q. true이면 이진 넌센스를 출력하고 false이면 아무것도 출력하지 않습니다.

• s<C-R>=char2nr(@")%2<CR>: 문자가 홀수이면 1로, 짝수이면 0으로 바꿉니다. 이 매크로는 행의 모든 ​​문자에 관계없이 (길이에 관계없이) 수행합니다.
• :g/00\|11/d<CR>: 2 개의 연속 "비트"가 동일한 값을 갖는 경우 라인을 삭제합니다. 역 참조보다 빠릅니다.

일반적으로 vimgolf에서는 매크로 내에서 표현식 함수를 사용할 때 표현식 레지스터에서 매크로 자체를 수행하고 탭을 완성하기 위해 약간의 속임수를 사용해야합니다. 이번에는 더 어렵다. 나중에 줄일 수있는 방법을 찾을 수 있습니다.

망막 , 39 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

S_`
%{2`
$`
}T01`p`_p
..

Mm`.¶.|^¶$
^0

출력 1truthy 및 0falsy합니다.

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

설명

mbomb007의 답변에 영감을 받아 최근ord() Retina에서 상당히 짧은 구현 을 개발했습니다 . 이것은 인쇄 가능한 ASCII 만 지원해야하기 때문에 소수 결과가 필요하지 않기 때문에 약간 단순화 할 수 있었지만 (결과의 패리티 만 신경 쓰므로 결과는 다음과 같습니다. 임의의 오프셋도 좋습니다).

1 단계 : 스플릿

S_`

이렇게하면 입력 내용을 빈 일치 항목으로 분할하고 빈 결과를 시작과 끝 부분에서로 삭제하여 입력을 개별 문자로 분리합니다 _.

2 단계 : 교체

%{2`
$`

는 %{문자열 전체 반복을 통해 변경 멈출 때까지이 단계와 다음 루프에서 실행해야합니다, 그리고이 두 단계는 개별적으로 각 라인 입력의 (즉, 각 문자를) 적용되어야 함) 망막 a를 알려줍니다.

스테이지 자체는 입력의 첫 문자를 복제하는 표준 기술입니다. 빈 문자열과 일치하지만 처음 두 개의 일치 항목 만보고 일치하는 접두사를 삽입합니다. 첫 번째 일치의 접두어 (문자열의 시작 부분)는 비어 있으므로 아무 것도하지 않으며 두 번째 일치의 접두사는 첫 번째 문자이므로 중복됩니다.

3 단계 : 음역

}T01`p`_o

}루프의 끝을 나타냅니다. 무대 자체는 음역입니다. 01문자열의 첫 번째 문자에만 적용되어야 함을 나타냅니다. p인쇄 가능한 모든 ASCII 문자의 약어이며 _"삭제"를 의미합니다. 따라서 이것을 확장하면 음역은 다음과 같은 변환을 수행합니다.

from:   !"#$%...
to:    _ !"#$...

따라서 공백이 삭제되고 다른 모든 문자가 줄어 듭니다. 즉,이 두 단계는 함께 공간에서 주어진 문자까지의 문자 범위를 만듭니다 (첫 번째 문자가 복제 및 삭제가 취소되는 공간이 될 때까지 첫 번째 문자를 반복적으로 복제하고 감소시키기 때문에).

이 범위의 길이는 캐릭터의 패리티를 결정하는 데 사용될 수 있습니다.

4 단계 : 교체

..

우리는 단순히 모든 문자 쌍을 버립니다. 이렇게하면 짝수 길이 줄이 지워지고 홀수 길이 줄이 단일 문자 (사실 입력 문자이지만 실제로는 중요하지 않음)로 줄어 듭니다.

5 단계 : 경기

Mm`.¶.|^¶$

짝수 가 아닌 입력을 찾기가 더 쉽기 때문에 두 개의 연속적인 빈 줄이나 두 개의 연속되는 비어 있지 않은 줄의 일치 수를 계산합니다. 0입력이 고르지 않으면 0이 아닌 것을 얻 습니다.

6 단계 : 경기

^0

남은 것은 결과를 뒤집는 것입니다.이 정규 표현식의 일치 횟수를 세어 입력이 a로 시작하는지 확인합니다 0. 이것은 첫 번째 단계의 결과가이면 가능합니다 0.

클로저, 59 바이트

#(every?(fn[p](odd?(apply + p)))(partition 2 1(map int %)))

문자열에서 모든 순차 쌍을 생성하고 n모든 쌍 합계가 홀수인지 확인합니다. int 시퀀스가 ​​합리적인 형식으로 간주되면 50 바이트입니다.

#(every?(fn[p](odd?(apply + p)))(partition 2 1 %))

온라인 참조 : https://ideone.com/USeSnk

줄리아, 55 53 바이트

f(s)=!ismatch(r"00|11",join(map(x->Int(x)%2,[s...])))

설명

문자를 0 | 1에 매핑하고 결과 문자열에 "00"또는 "11"이 포함되어 있는지 확인하여 문자열이 번갈아 나타나지 않도록합니다.

파이썬, 52 바이트

f=lambda s:s==s[0]or(ord(s[0])-ord(s[1]))%2*f(s[1:])

재귀 함수 짝수 문자열의 경우 1 (또는 True)을 생성하고 홀수 문자열의 경우 0을 생성합니다. 처음 두 문자의 차이에 대한 패리티에 나머지의 재귀 값을 곱합니다. 단일 문자 문자열은 첫 번째 문자와 동일하게 확인하여 True를 제공합니다. 이것은 입력이 비어 있지 않은 것으로 가정합니다. 그렇지 않으면 s==s[:1]or에 하나 이상의 바이트가 필요합니다 len(s)<2.

파이썬 2, 52 바이트

p=r=2
for c in input():x=ord(c)%2;r*=p-x;p=x
print r

대안 적으로, 반복적 인 솔루션. 입력 문자를 반복하여 현재 및 이전 문자 값을 mod 2로 저장합니다. 실행중인 제품에 차이를 곱합니다. 두 개의 연속 패리티가 동일한 경우에만 0 (Falsey)이기 때문입니다.

"이전"값은 2 (또는 0 또는 1이 아닌 값)로 초기화되므로 첫 번째 문자는 가상의 이전 문자와 패리티와 절대 일치하지 않습니다.

종료 코드를 통한 Python, 42 바이트 출력

p=2
for c in input():x=ord(c)%2;p=x/(p!=x)

종료 코드를 통해 출력합니다. 연속 된 두 문자가 동일한 패리티를 갖는 경우 ZeroDivisionError로 종료됩니다. 그렇지 않으면 깨끗하게 종료됩니다.

하스켈, 42 40 바이트

all odd.(zipWith(-)=<<tail).map fromEnum

사용 예 : all odd.(zipWith(-)=<<tail).map fromEnum $ "long"-> True.

작동 방식 :

               map fromEnum         -- turn into a list of ascii values
    (zipWith(/=)=<<tail)            -- build a list of neighbor differences
all odd                             -- check if all differences are odd

편집 : @xnor은 2 바이트를 저장했습니다. 감사!

매스 매 티카, 41 40 바이트

And@@OddQ@Differences@ToCharacterCode@#&

Martin Ender 덕분에 -1 문자

C, 52 바이트

int f(char*s){return s[1]?(s[0]-s[1])%2?f(s+1):0:1;}

처음 2 자의 패리티를 비교하여 동일한 패리티를 가진 2 개의 문자 또는 길이가 1 ( s[1] == 0) 인 문자열을 찾을 때까지 문자열을 반복적으로 이동합니다 .

일부 테스트 사례가 포함 된 코드

파이크, 8 바이트

m.o$2m%B

여기 사용해보십시오!

m.o      -    map(ord, input)
   $     -   delta(^)
    2m%  -  map(> % 2, ^) 
       B - product(^)

C #, 69 바이트

s=>{int i=1,e=0;for(;i<s.Length;)e+=(s[i-1]+s[i++]+1)%2;return e<1;};

테스트 케이스가 포함 된 전체 프로그램 :

using System;

namespace EvenStrings
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,bool>f= s=>{int i=1,e=0;for(;i<s.Length;)e+=(s[i-1]+s[i++]+1)%2;return e<1;};

            Console.WriteLine(f("lno")); //false

            //true:
            Console.WriteLine(f("#define"));
            Console.WriteLine(f("EvenSt-ring$!"));
            Console.WriteLine(f("long"));
            Console.WriteLine(f("abcdABCD"));
            Console.WriteLine(f("3.141"));
            Console.WriteLine(f("~"));
            Console.WriteLine(f("0123456789"));
            Console.WriteLine(f("C ode - g ol!f"));
            Console.WriteLine(f("HatchingLobstersVexinglyPopulateJuvenileFoxglove"));

            //false:
            Console.WriteLine(f("Hello World"));
            Console.WriteLine(f("PPCG"));
            Console.WriteLine(f("3.1415"));
            Console.WriteLine(f("babbage"));
            Console.WriteLine(f("Code-golf"));
            Console.WriteLine(f("Standard loopholes apply"));
            Console.WriteLine(f("Shortest answer in bytes wins"));
            Console.WriteLine(f("Happy golfing!"));
        }
    }
}

PHP, 69 바이트

for(;$i<strlen($s=$argv[1])-1;)$d+=1-ord($s[$i++]^$s[$i])%2;echo$d<1;

Regex 81 바이트를 사용한 솔루션

for(;$i<strlen($s=$argv[1]);)$t.=ord($s[$i++])%2;echo 1-preg_match("#00|11#",$t);

PowerShell v2 +, 47 바이트

-join([char[]]$args[0]|%{$_%2})-notmatch'00|11'

(할 수 없습니다 꽤 ... PowerShell에서의 일반적인 경쟁을 잡기)

입력을 받아 $args[0], 문자열로로 캐스트 char-array, 그것을 통해 루프 |%{...}(암시 적으로 파이프 라인에 모듈을 배치 각각의 반복 [char]으로 [int]변환). 그것들은 parens로 캡슐화되고 -join문자열로 묶여지며 , -notmatch연산자 의 왼쪽에 공급되어 00or를 검사합니다 11(즉, s와 s가 다른 True경우 반환 ). 해당 부울 결과는 파이프 라인에 남아 있으며 출력은 암시 적입니다.01

테스트 사례

PS C:\Tools\Scripts\golfing> '#define','EvenSt-ring$!','long','abcdABCD','3.141','~','0123456789','C ode - g ol!f','HatchingLobstersVexinglyPopulateJuvenileFoxglove'|%{"$_ --> "+(.\evenst-ring-c-ode-g-olf.ps1 $_)}
#define --> True
EvenSt-ring$! --> True
long --> True
abcdABCD --> True
3.141 --> True
~ --> True
0123456789 --> True
C ode - g ol!f --> True
HatchingLobstersVexinglyPopulateJuvenileFoxglove --> True

PS C:\Tools\Scripts\golfing> 'Hello World','PPCG','3.1415','babbage','Code-golf','Standard loopholes apply','Shortest answer in bytes wins','Happy golfing!'|%{"$_ --> "+(.\evenst-ring-c-ode-g-olf.ps1 $_)}
Hello World --> False
PPCG --> False
3.1415 --> False
babbage --> False
Code-golf --> False
Standard loopholes apply --> False
Shortest answer in bytes wins --> False
Happy golfing! --> False

> <> , 29 27 바이트

i2%\0 n;n 1<
0:i/!?-}:%2^?(

단어가 짝수이면 1을 출력하고 단어가 홀수이면 0을 출력합니다.

당신은 할 수 있습니다 온라인으로보십시오 .

편집 : Martin Ender 덕분에 2 바이트를 절약했습니다.

펄 6 ,  47  26 바이트

{?all .ords.rotor(2=>-1).map({(.[0]+^.[1])%2})}

{[~](.ords X%2)!~~/(.)$0/}

넓히는:

# bare block lambda with implicit parameter $_
{
  [~](             # reduce using concatenation operator ( no space chars )
    .ords X[%] 2   # the ordinals cross modulus with 2 ( 1 or 0 )
  # ^-- implicit method call on $_
  )

  ![~~]            # negating meta operator combined with smartmatch operator

  / ( . ) $0 /     # is there a character followed by itself?
}

스칼라, 54 바이트

(_:String)sliding 2 map(t=>t(0)%2!=t(1)%2)reduce(_&&_)

이것이 향상 될 수 있다고 확신합니다.