'String genap' adalah string mana pun dimana paritas nilai ASCII dari karakter selalu bergantian. Misalnya, string EvenSt-ring$!adalah string genap karena nilai ASCII dari karakter adalah:

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

Dan paritas dari angka-angka ini adalah:

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

Yang bergantian sepanjang jalan. Namun, string seperti Hello world!ini tidak string bahkan karena nilai-nilai ASCII adalah:

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

Dan paritasnya adalah:

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

Yang jelas tidak selalu berganti-ganti.

Tantangan

Anda harus menulis program lengkap atau fungsi yang menerima string untuk input dan menghasilkan nilai kebenaran jika string itu genap, dan nilai palsu sebaliknya. Anda dapat mengambil input dan output Anda dalam format apa pun yang masuk akal, dan Anda dapat mengasumsikan bahwa input tersebut hanya akan memiliki ASCII yang dapat dicetak (kisaran 32-127). Anda tidak harus menangani input kosong.

Contohnya

Berikut adalah beberapa contoh string genap:

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

Dan semua contoh ini bahkan bukan string:

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

Anda juga dapat menggunakan solusi tanpa kulit untuk menguji setiap string jika Anda ingin tahu tentang kasus uji tertentu.

MATL , 4 3 byte

Terima kasih kepada Emigna karena menyimpan byte dan terima kasih kepada Luis Mendo karena telah memperbaiki beberapa bug. Kode:

doA

Penjelasan:

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

Cobalah online!

05AB1E , 5 4 byte

Disimpan 1 byte berkat Adnan .

Ç¥ÉP

Cobalah online!

Penjelasan

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

Jelly , 7 5 4 byte

OIḂẠ

Disimpan 2 byte menggunakan ide delta dari @ Steven H.

Disimpan 1 byte berkat @ Lynn .

Cobalah online! atau Verifikasi semua kasus uji.

Penjelasan

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

Python 2, 54 Bytes

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

Mathematica, 50 44 byte

Versi saat ini pada dasarnya semua keahlian Martin Ender.

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

Kembali True atau False. Tidak ada yang terlalu pintar: mengambil jumlah mod-2 dari setiap pasangan kode ASCII berturut-turut, dan memeriksa 0 yang tidak pernah diperoleh.

Versi lama:

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

JavaScript (ES6), 60 50 46 byte

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

Saya mencoba rekursi, tetapi pada 51 byte, sepertinya tidak cukup layak:

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

Cuplikan tes

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 byte

Terima kasih kepada @Riley untuk bantuan bermain golf.

Program ini memperlakukan input kosong sebagai string tidak ada.

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

Cobalah online!

Penjelasan (kedaluwarsa)

Menggeser input dari tumpukan kiri ke kanan sementara modding oleh 2. Menemukan perbedaan antara masing-masing karakter yang berdekatan sampai semua telah diperiksa atau salah satu perbedaannya sama dengan nol (yang hanya akan terjadi dalam string yang tidak ada). Jika loop diakhiri karena string noneven kemudian beralih kembali ke tumpukan kiri dan pop nilai yang tersisa di sana. Kalau tidak, tetap di tumpukan kanan dan pop nol di atas 1 yang tersisa di tumpukan.

R, 41 35 byte

EDIT: Menyimpan beberapa byte berkat @JDL dengan menggunakan diffalih-alih rle.

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

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

Penjelasan

1. readline() baca input.
2. utf8ToInt()%%2 mengkonversi ke nilai ascii dan mod 2 (simpan sebagai R-vektor)
3. all(rle()==1)panjang pengkodean untuk menemukan menjalankan. Semua run harus sama dengan satu atau lebih kecil dari 2 karena tidak boleh berjalan negatif atau 0 (menyimpan satu byte, bukan ==).

Pyth ( fork ), 9 byte

.A%R2.+CM

Tidak ada tautan Try Try Online karena garpu tidak memiliki versinya sendiri di penerjemah online.

Penjelasan:

       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 byte

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

Cobalah online!

Penjelasan

@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 byte

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

-4 byte terima kasih kepada @Geobits .

Penjelasan:

Cobalah online.

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

Termasuk +3 untuk -a

Disimpan 30 byte berkat 1000000000

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

Output:
kebenaran : 1
falsy : 0 di atas tumpukan

Cobalah online! (jujur)
Cobalah online! (palsu)

Penjelasan yang lebih baik datang kemudian (jika saya dapat mengingat cara kerjanya setelah beberapa jam ...)

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

Starry , 85 byte

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

Cobalah online!

Perhatikan bahwa karena program Starry tidak memiliki cara untuk mengetahui kapan input dengan panjang arbitrer berakhir, program ini menggunakan baris tambahan di input untuk menandai akhir string. Jika Anda mendapatkan pesan kesalahan samar tentang dan metode tidak terdefinisi orduntuknil:NilClass kemudian input tersebut hilang baris baru yang tertinggal.

Penjelasan

Strategi dasar yang digunakan oleh program adalah membaca karakter satu per satu dari input dan jika mereka bukan baris baru (karakter 10), mod mereka nilai ASCII dari karakter sebesar 2 dan menemukan perbedaan antara itu dan karakter yang sebelumnya dibaca. Jika perbedaannya nol, program akan berhenti dan mencetak 0(falsey). Kalau tidak, program akan kembali dan melakukan proses lagi. Jika program membaca baris baru, program akan berakhir dan dicetak 10(benar).

Program Beranotasi

 ,               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 byte

-4 byte terima kasih kepada @Ton Hospel !

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

Membutuhkan -pbendera. Output 1 adalah string genap, tidak ada yang sebaliknya. Contohnya :

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

Penjelasan : mengganti setiap karakter dengan nilainya mod 2 (jadi string hanya berisi 0s dan 1s setelah itu). Kemudian cari dua berikut 1 atau 0: jika menemukan beberapa, maka string tidak genap, jika tidak.

J, 15 byte

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

Pemakaian

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

Penjelasan

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 byte

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

Mengasumsikan string input dalam buffer, dan kosongkan "q. Output binary nonsense jika benar, tidak ada jika false.

• s<C-R>=char2nr(@")%2<CR>: Mengganti karakter dengan 1 jika aneh, 0 jika genap. Makro ini hanya melakukan ini untuk setiap karakter di baris (tidak peduli berapa lama itu).
• :g/00\|11/d<CR>: Menghapus baris jika 2 "bit" berturut-turut memiliki nilai yang sama. Lebih cepat dari referensi kembali.

Biasanya, di vimgolf, ketika Anda menggunakan fungsi ekspresi di dalam makro, Anda seharusnya melakukan makro itu sendiri pada register ekspresi dan menggunakan beberapa tipu daya untuk melengkapi tab. Itu lebih sulit kali ini. Saya mungkin menemukan cara untuk mempersingkat itu nanti.

Retina , 39 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

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

Mm`.¶.|^¶$
^0

Keluaran 1untuk kebenaran dan 0kepalsuan.

Cobalah online! (Baris pertama memungkinkan suite tes yang dipisahkan dengan linefeed.)

Penjelasan

Terinspirasi oleh jawaban mbomb007, saya baru-baru ini mengembangkan ord()implementasi yang cukup singkat di Retina. Ini sebagian besar didasarkan pada hal itu, meskipun saya dapat membuat beberapa penyederhanaan karena saya tidak memerlukan hasil desimal karena saya hanya perlu mendukung ASCII yang dapat dicetak (dan saya hanya peduli dengan paritas hasil, jadi berakhir dengan offset sewenang-wenang juga baik-baik saja).

Tahap 1: Berpisah

S_`

Ini hanya membagi input menjadi karakter individu dengan membaginya di sekitar pertandingan kosong dan menjatuhkan hasil kosong di awal dan akhir dengan _ .

Tahap 2: Ganti

%{2`
$`

Itu %{ memberitahu Retina a) bahwa tahap ini dan berikutnya harus dijalankan dalam satu lingkaran sampai string berhenti berubah melalui iterasi penuh, dan bahwa dua tahap ini harus diterapkan untuk setiap baris (yaitu masing-masing karakter) dari input secara terpisah.

Panggung itu sendiri adalah teknik standar untuk menduplikasi karakter pertama dari input. Kami mencocokkan string kosong (tetapi hanya melihat dua kecocokan pertama) dan menyisipkan awalan yang cocok. Awalan pertandingan pertama (di awal string) kosong, jadi ini tidak melakukan apa-apa, dan awalan pertandingan kedua adalah karakter pertama, yang karenanya digandakan.

Tahap 3: Transliterasi

}T01`p`_o

}menunjukkan akhir dari loop. Panggung itu sendiri adalah transliterasi. 01menunjukkan bahwa itu hanya boleh diterapkan pada karakter pertama dari string. padalah singkatan untuk semua karakter ASCII yang dapat dicetak dan _berarti "hapus". Jadi jika kita memperluas ini, transliterasi melakukan transformasi berikut:

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

Jadi spasi dihapus dan semua karakter lainnya dikurangi. Itu berarti, dua tahap ini bersama-sama akan membuat rentang karakter dari ruang ke karakter yang diberikan (karena mereka akan berulang kali menduplikasi dan mengurangi karakter pertama sampai menjadi ruang di mana titik duplikasi dan penghapusan dibatalkan).

Panjang rentang ini dapat digunakan untuk menentukan paritas karakter.

Tahap 4: Ganti

..

Kami cukup menjatuhkan semua pasangan karakter. Ini menghapus garis panjang genap dan mengurangi garis panjang ganjil ke satu karakter (karakter input, pada kenyataannya, tapi itu tidak terlalu penting).

Tahap 5: Cocokkan

Mm`.¶.|^¶$

Lebih mudah untuk menemukan input yang tidak genap, jadi kami menghitung jumlah kecocokan dari dua baris kosong berturut-turut atau dua baris non-kosong berturut-turut. Kita harus mendapatkan 0input genap dan sesuatu yang bukan nol.

Tahap 6: Cocokkan

^0

Semua yang tersisa adalah untuk membalikkan hasil, yang kita lakukan dengan menghitung jumlah pertandingan regex ini, yang cek yang input dimulai dengan 0. Ini hanya mungkin jika hasil dari tahap pertama adalah 0.

Clojure, 59 byte

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

Menghasilkan semua pasangan berurutan dari string ndan memeriksa apakah setiap jumlah pasangan aneh. Jika urutan int dianggap sebagai format yang masuk akal maka 50 byte.

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

Lihat online: https://ideone.com/USeSnk

Julia, 55 53 Bytes

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

Dijelaskan

Peta karakter ke 0 | 1 dan periksa apakah string yang dihasilkan berisi "00" atau "11", yang membuat string tidak berganti-ganti.

Python, 52 byte

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

Fungsi rekursif. Menghasilkan 1 (atau True) untuk string genap, 0 untuk yang aneh. Mengalikan paritas perbedaan dari dua karakter pertama dengan nilai rekursif pada sisanya. String karakter tunggal memberikan True, seperti dicentang olehnya yang setara dengan karakter pertamanya. Ini mengasumsikan input tidak kosong; lain, satu byte lagi diperlukan untuk s==s[:1]atau len(s)<2.

Python 2, 52 byte

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

Atau, solusi berulang. Iterasi atas karakter input, menyimpan nilai karakter saat ini dan sebelumnya mod 2. Mengalikan produk yang berjalan dengan perbedaan, yang karena 0 (Falsey) hanya ketika dua paritas berturut-turut sama.

Nilai "sebelumnya" diinisialisasi ke 2 (atau nilai apa pun bukan 0 atau 1) sehingga karakter pertama tidak pernah cocok dengan paritas dengan karakter sebelumnya fiksi.

Python, 42 byte, keluaran melalui kode keluar

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

Keluaran melalui kode keluar. Berakhir dengan ZeroDivisionError ketika dua karakter berturut-turut memiliki paritas yang sama, jika tidak berakhir dengan rapi.

Haskell, 42 40 byte

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

Contoh penggunaan: all odd.(zipWith(-)=<<tail).map fromEnum $ "long"->True .

Bagaimana itu bekerja:

               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

Edit: @xnatau disimpan dua byte. Terima kasih!

Mathematica, 41 40 Bytes

And@@OddQ@Differences@ToCharacterCode@#&

-1 character, thanks to Martin Ender

C, 52 bytes

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

Compares the parity of first 2 characters, recursively moving through the string until it finds 2 characters with the same parity or the string with the length of 1 (s[1] == 0).

Code with some of the test cases

Pyke, 8 bytes

m.o$2m%B

Try it here!

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

C #, 69 byte

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

Program lengkap dengan kasus uji:

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 Bytes

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

solusi dengan Regex 81 Bytes

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

PowerShell v2 +, 47 byte

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

(Tidak bisa cukup menangkap pesaing PowerShell yang biasa ...)

Mengambil input $args[0]sebagai string, melemparkan sebagai char-array, loop melalui itu |%{...}, setiap iterasi menempatkan modulo pada pipa (dengan implisit [char]untuk [int]konversi). Itu diringkas dalam parens dan -joined menjadi string, yang diumpankan ke sebelah kiri -notmatchoperator, memeriksa terhadap 00atau 11(yaitu, mengembalikan Trueiff 0s dan 1s alternatif). Hasil Boolean ditinggalkan di jalur pipa dan hasilnya tersirat.

Uji Kasus

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 byte

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

Output 1 jika kata tersebut genap, 0 jika kata itu ganjil.

Anda dapat mencobanya secara online .

Sunting: disimpan dua byte berkat Martin Ender

Perl 6 ,  47  26 byte

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

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

Diperluas:

# 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 byte

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

Saya yakin ini bisa diperbaiki.