'Even string', karakterlerin ASCII değerlerinin eşliğinin daima değişken olduğu herhangi bir dizedir . Örneğin EvenSt-ring$!, karakterlerin ASCII değerleri: çünkü dize çift bir dizedir:

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

Ve bu sayıların pariteleri:

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

Bu bütün yolu değiştiriyor. Ancak, böyle bir dize Hello world!olduğu değil ASCII değerleri çünkü daha dizesi:

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

Ve pariteler:

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

Hangi açıkça her zaman değişmez.

Meydan okuma

Tam bir program veya girişi için bir dize kabul eder ve bir çıkışı bir işlev ya yazmalısınız truthy dize bile eğer değerini ve aksi bir falsy değer. Girişinizi ve çıkışınızı herhangi bir makul formatta alabilir ve girişin yalnızca yazdırılabilir ASCII'ye sahip olacağını varsayabilirsiniz (32-127 aralığı). Sen do not boş girişi işlemek zorunda.

Örnekler

İşte bazı karakter dizeleri örnekleri:

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

Ve bu örneklerin tümü dizge bile değil:

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

Bu unungolfed çözümü , belirli bir test durumu hakkında merak ediyorsanız, herhangi bir dizgiyi test etmek için de kullanabilirsiniz .

MATL , 4 3 bayt

Bir byte tasarrufu için Emigna ve bazı hataları düzeltmek için Luis Mendo sayesinde . Kod:

doA

Açıklama:

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

Çevrimiçi deneyin!

05AB1E , 5 4 bayt

Adnan sayesinde 1 byte kurtarıldı .

Ç¥ÉP

Çevrimiçi deneyin!

açıklama

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

Jöle , 7 5 4 bayt

OIḂẠ

@ Steven H. kaynaklı deltas fikrini kullanarak 2 byte kurtarıldı

@ Lynn sayesinde 1 byte kaydedildi .

Çevrimiçi deneyin! veya Tüm test durumlarını doğrulayın.

açıklama

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

Python 2, 54 Bayt

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

Mathematica, 50 44 bayt

Mevcut sürüm temelde tüm Martin Ender'in ustalığıdır.

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

TrueVeya döndürür False. Çok akıllıca bir şey yok: her ardışık ASCII kod çiftinin mod-2 toplamını alır ve 0'ın asla elde edilemediğini kontrol eder.

Eski versiyon:

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

JavaScript (ES6), 60 50 46 bayt

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

Özyinelemeyi denedim, ancak 51 baytta, buna değmez gibi görünüyor:

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

Test pasajı

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>

Brain-Flak , 138 114 112 84 + 3 = 87 bayt

Yardım golfü için @Riley'e teşekkür ederiz .

Bu program boş girdiyi düzensiz bir dize olarak kabul eder.

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

Çevrimiçi deneyin!

Açıklama (eski)

Giriş modunu 2 ile mod değiştirirken soldaki yığından sağa kaydırır. Her biri bitişik olan her karakter arasındaki farkı bulur veya farklardan biri sıfıra eşittir (yalnızca düz olmayan bir dizgede gerçekleşir). Döngü düzgün olmayan bir dize nedeniyle sonlandırıldıysa, sol yığına geri dönün ve üzerinde kalan değeri girin. Aksi takdirde, sağ yığında durun ve sırayı yığında kalan 1'in üzerine getirin.

R, 41 35 bayt

EDIT: @JDL diffyerine birkaç bayt kullanılarak kaydedildi rle.

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

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

açıklama

1. readline() girişi oku.
2. utf8ToInt()%%2 ascii değerlerine ve mod 2'ye dönüştür (R-vektörü olarak sakla)
3. all(rle()==1)çalışma bulmak için çalışma uzunluğu kodlaması. Hiçbir işlem negatif olamaz veya 0 (bunun yerine bir bayt kaydeder) çünkü tüm işlemler bir veya ikiden küçük olmalıdır ==.

Pyth ( çatal ), 9 bayt

.A%R2.+CM

Hayır Çevrimiçi Deneyin bağlantısı çünkü çatalı çevrimiçi çevirmenlerde kendi sürümüne sahip değil.

Açıklama:

       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 bayt

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

Çevrimiçi deneyin!

açıklama

@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

Java 8, 77 76 72 57 bayt

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

@ Geobits sayesinde -4 bayt .

Açıklama:

Çevrimiçi deneyin.

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

Brain-Flak 155 151 141 121

-A için +3 içerir

1000000000 sayesinde 30 bayt kurtardı

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

Çıktı:
truthy : 1
falsy : 0 yığının üstüne

Çevrimiçi deneyin! (truthy)
Çevrimiçi deneyin! (falsy)

Daha sonra açıklanacak daha iyi açıklama (birkaç saat sonra nasıl çalıştığını hatırlayabilirsem ...)

#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
([]<(())>){((<{}{}>))}{}

Yıldızlı , 85 bayt

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

Çevrimiçi deneyin!

Bir Yıldızlı programın isteğe bağlı uzunluktaki bir girişin ne zaman biteceğini söylemenin bir yolu olmadığından, bu program dizenin sonunu işaretlemek için girişte izleyen bir yeni satır kullanır. Bunun ordiçin ve tanımsız bir yöntem hakkında şifreli bir hata mesajı alırsanız nil:NilClass, girişin sonunda yeni bir satır yok.

açıklama

Programın uyguladığı temel strateji, karakterleri girişten birer birer okur ve eğer yeni bir satır değilse (karakter 10) karakterin ASCII değerini 2 ile değiştirir ve daha önce okunan karakter arasındaki farkı bulur. Fark sıfır ise, program sonlandırılır ve yazdırır 0(falsey). Aksi halde program geri döner ve işlemi tekrar yapar. Program yeni bir satır okursa, sonlandırır ve yazdırır 10(gerçek).

Açıklamalı Program

 ,               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

Perl, 24 + 1 ( -p) = 25 bayt

@Ton Hospel sayesinde -4 byte !

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

-pBayrağa ihtiyacı var . Çıkış 1, dizedir, aksi halde hiçbir şey değildir. Örneğin :

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

Açıklamalar : her karakteri mod 2 değeriyle değiştirir (bu nedenle dize yalnızca 0s ve 1s içerir). Sonra 1 veya 0 dan sonra iki tanesini arayın: eğer bazı bulursa, o zaman dize eşit değildir, aksi halde olur.

J, 15 bayt

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

kullanım

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

açıklama

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 bayt

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

Giriş dizesini tamponda ve boş olarak kabul eder "q. Doğru ise ikili saçma, çıktı ise yanlış.

• s<C-R>=char2nr(@")%2<CR>: Bir karakteri tek ise 1, çift ise 0 ile değiştirir. Bu içindeki makro bunu satırdaki her karaktere yapar (ne kadar olursa olsun).
• :g/00\|11/d<CR>: Eğer 2 ardışık "bit" aynı değere sahipse satırı siler. Geri referanstan daha hızlı.

Normalde, vimgolf'ta, bir makro içinde bir ifade işlevi kullandığınızda, makroyu ifade kaydında yapmanız ve sekmeyi tamamlamak için bazı hileler kullanmanız gerekir. Bu sefer daha zor. Bunu daha sonra kısaltmanın bir yolunu bulabilirim.

Retina , 39 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

Mm`.¶.|^¶$
^0

Çıkışlar 1truthy için ve 0falsy için.

Çevrimiçi deneyin! (İlk satır satır besleme ile ayrılmış bir test takımı sağlar.)

açıklama

Mbomb007'nin cevabından ilham aldım Son zamanlardaord() Retina'da oldukça kısa bir uygulama geliştirdim . Bu büyük ölçüde buna dayanıyor, ancak birkaç basitleştirme yapabildim, çünkü yalnızca yazdırılabilir ASCII'yi desteklemem gerektiğinden ondalık bir sonuca ihtiyacım yok (ve sadece sonucun paritesini önemsiyorum, keyfi bir denge de iyidir.

1. Aşama: Bölünmüş

S_`

Bu basitçe girişi boş karakterin etrafına bölerek ve boş sonuçları başlangıçta ve sonunda bırakarak ayrı karakterlerine ayırır _.

Aşama 2: Değiştir

%{2`
$`

%{Dize tam yineleme yoluyla değişen durana kadar bu aşamada ve sonraki bir döngü içinde çalıştırılması gerekir ve bu iki aşama ayrı ayrı her bir satırın girişin (yani her bir karakteri) uygulanması gerektiğini) Retina a söyler.

Aşama kendisi, girişin ilk karakterini çoğaltmak için standart tekniktir. Boş dizgiyle eşleşiriz (ancak yalnızca ilk iki eşleşmeye bakın) ve eşleşmenin önekini ekleriz. İlk eşleşmenin öneki (dizgenin başında) boştur, bu nedenle bu hiçbir şey yapmaz ve ikinci eşleşmenin öneki bu nedenle kopyalanan ilk karakterdir.

Aşama 3: Harf Çevirisi

}T01`p`_o

}döngünün sonunu gösterir. Sahnenin kendisi bir harf çevirisidir. 01bunun yalnızca dizenin ilk karakterine uygulanması gerektiğini belirtir. pyazdırılabilir tüm ASCII karakterleri için kısayoldur ve _"delete" anlamına gelir. Yani eğer bunu genişletirsek, harf çevirisi aşağıdaki dönüşümü yapar:

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

Böylece boşluklar silinir ve diğer tüm karakterler azalır. Bu, birlikte bu iki aşama birlikte uzaydan verilen karaktere kadar bir karakter aralığı oluşturacaktır (çünkü bunlar, çoğaltmanın ve silme işleminin iptal edildiği bir noktaya gelinceye kadar ilk karakteri tekrar tekrar çoğaltacak ve azaltacaktır).

Bu aralığın uzunluğu, karakterin paritesini belirlemek için kullanılabilir.

Aşama 4: Değiştir

..

Sadece tüm karakter çiftlerini bırakırız. Bu, eşit uzunluktaki çizgileri temizler ve tek uzunluktaki çizgileri tek bir karaktere indirger (aslında giriş karakteri, ancak bu gerçekten önemli değil).

Aşama 5: Eşleşme

Mm`.¶.|^¶$

Düzgün olmayan girişleri bulmak daha kolaydır , bu nedenle art arda iki boş satırın veya art arda iki boş olmayan satırın eşleşme sayısını sayarız. 0Girdiler ve hatta sıfır olmayan bir şey için bile almalıyız .

Aşama 6: Eşleşme

^0

Geriye kalan tek şey, girişin a ile başladığını kontrol eden bu regex'in eşleşme sayısını sayarak yaptığımız sonucu tersine çevirmektir 0. Bu, yalnızca ilk aşamadaki sonucun gerçekleşmesi durumunda mümkündür 0.

Clojure, 59 bayt

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

Tüm sıralı çiftleri dizeden oluşturur nve her çift toplamının tek olup olmadığını kontrol eder. Bir dizi dizinin makul bir format olduğu düşünülürse, 50 bayttır.

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

Çevrimiçi görün: https://ideone.com/USeSnk

Julia, 55 53 Bayt

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

Açıklaması

Karakterleri 0 | 1 ile eşleştirin ve elde edilen dizginin "00" veya "11" içerip içermediğini kontrol edin;

Python, 52 bayt

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

Özyinelemeli bir işlev. Çiftler için 1 (veya Gerçek), tek olanlar için 0 üretir. İlk iki karakter arasındaki farkın paritesini, kalan kısımdaki özyinelemeli değer ile çarpar. Tek karakterli bir dize, ilk karakterine eşit olarak işaretlendiği şekilde True verir. Bu, girişin boş olmadığını varsayar; Aksi takdirde, s==s[:1]veya için bir bayt daha gerekir len(s)<2.

Python 2, 52 bayt

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

Alternatif olarak, yinelemeli bir çözüm. Geçerli ve önceki karakter değerlerini mod 2'ye kaydederek giriş karakterlerini tekrar eder. Çalışan ürünü aradaki farkla çarpar, çünkü 0 (Falsey) yalnızca iki ardışık parite eşit olduğunda.

"Önceki" değer 2'ye (veya 0 veya 1 olmayan herhangi bir değer) ilklendirilir, böylece ilk karakter hiçbir zaman kurgusal önceki karakterle eşleşmez.

Python, 42 bayt, çıkış kodu ile çıkışlar

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

Çıkış kodu ile çıkış yapar. Ardışık iki karakter aynı pariteye sahip olduğunda ZeroDivisionError ile sonlanır, aksi halde temiz bir şekilde sonlanır.

Haskell, 42 40 bayt

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

Kullanım örneği: all odd.(zipWith(-)=<<tail).map fromEnum $ "long"-> True.

Nasıl çalışır:

               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

Düzenleme: @xnor iki bayt kaydetti. Teşekkürler!

Mathematica, 41 40 Bayt

And@@OddQ@Differences@ToCharacterCode@#&

-1 karakter, Martin Ender sayesinde

C, 52 bayt

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

İlk 2 karakterin paritesini karşılaştırır, tekrar tekrar aynı karakterde 2 karakter bulana kadar veya 1 ( s[1] == 0) uzunluğunda bir dize içinde katar .

Bazı test durumlarını içeren kod

Pyke, 8 bayt

m.o$2m%B

Burada dene!

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

C #, 69 bayt

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

Test vakaları ile tam program:

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 Bayt

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

Regex 81 Bytes ile çözüm

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

PowerShell v2 +, 47 bayt

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

( PowerShell'in olağan rakiplerini tam olarak yakalayamıyorum ...)

Girişi alır $args[0], bir dizge olarak olarak atan char-array, bu döngüler |%{...}, (kapalı olan boru hattı üzerindeki modulo yerleştirilmesi her bir tekrar [char]için [int]dönüşüm). Bunlar parenler içinde kapsüllenir -joinve -notmatchoperatörün sol tarafına beslenen , yani 00veya s 11( s True, 0s ' 1nin alternatifi olarak geri döner)' e karşı kontrol edilen bir dizge haline getirilir . Bu Boolean sonucu boru hattında bırakılır ve çıktı kesindir.

Test Kılıfları

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 bayt

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

Sözcük düz ise 1, sözcük tek ise 0 olur.

Şunları yapabilirsiniz çevrimiçi denemek .

Düzenleme: Martin Ender sayesinde iki bayt kaydedildi

Perl 6 ,  47  26 bayt

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

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

Expanded:

# 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?
}

Scala, 54 bayt

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

Bunun geliştirilebileceğinden eminim.