Uma 'Sequência Par' é qualquer sequência em que a paridade dos valores ASCII dos caracteres esteja sempre alternada. Por exemplo, a sequência EvenSt-ring$!é uma sequência par porque os valores ASCII dos caracteres são:

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

E as paridades desses números são:

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

O que está alternando o caminho todo. No entanto, uma sequência como nãoHello world! é uma sequência par porque os valores ASCII são:

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

E as paridades são:

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

O que nem sempre é sempre alternado.

O desafio

Você deve escrever ou um programa completo ou uma função que aceita uma seqüência para entrada e gera um truthy valor se a string é ainda, e um valor Falsas contrário. Você pode levar sua entrada e saída em qualquer formato razoável e pode assumir que a entrada terá apenas ASCII imprimível (o intervalo 32-127). Você não precisa lidar com entrada vazia.

Exemplos

Aqui estão alguns exemplos de seqüências pares:

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

E todos esses exemplos nem são strings:

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

Você também pode usar esta solução não-gasta para testar qualquer string, se estiver curioso sobre um determinado caso de teste.

MATL , 4 3 bytes

Agradecemos a Emigna por salvar um byte e a Luis Mendo por corrigir alguns bugs. Código:

doA

Explicação:

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

Experimente online!

05AB1E , 5 4 bytes

Guardado 1 byte graças a Adnan .

Ç¥ÉP

Experimente online!

Explicação

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

Geléia , 7 5 4 bytes

OIḂẠ

Salvou 2 bytes usando a ideia deltas de @ Steven H.

Guardou 1 byte graças a @ Lynn .

Experimente online! ou Verifique todos os casos de teste.

Explicação

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 bytes

A versão atual é basicamente todo virtuosismo de Martin Ender.

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

Devoluções True ou False. Nada muito inteligente: pega a soma mod-2 de cada par de códigos ASCII consecutivos e verifica se 0 nunca é obtido.

Versão antiga:

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

JavaScript (ES6), 60 50 46 bytes

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

Tentei recursão, mas com 51 bytes, não parece valer a pena:

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

Snippet de teste

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>

Explosão Cerebral , 138 114 112 84 + 3 = 87 bytes

Graças a @Riley pela ajuda no golfe.

Este programa trata a entrada vazia como uma sequência não uniforme.

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

Experimente online!

Explicação (desatualizada)

Desloca a entrada da pilha esquerda para a direita enquanto modifica por 2. Encontra a diferença entre cada caractere adjacente até que todos tenham sido verificados ou uma das diferenças seja igual a zero (o que ocorreria apenas em uma sequência não-igual). Se o loop for encerrado devido a uma sequência não uniforme, volte para a pilha esquerda e insira o valor restante nela. Caso contrário, permaneça na pilha direita e coloque o zero acima do 1 restante na pilha.

R, 41 35 bytes

EDIT: salvou alguns bytes graças a @JDL usando em diffvez de rle.

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

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

Explicação

1. readline() leia a entrada.
2. utf8ToInt()%%2 converter para valores ascii e mod 2 (armazenar como vetor R)
3. all(rle()==1)codificação de comprimento de execução de para encontrar execuções. Todas as execuções devem ser iguais a um ou menores que 2, pois nenhuma execução pode ser negativa ou 0 (salva um byte em vez de ==).

Pitão ( bifurcação ), 9 bytes

.A%R2.+CM

Link No Try It Online, porque o fork não possui sua própria versão nos intérpretes online.

Explicação:

       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)

Braquilog , 17 bytes

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

Experimente online!

Explicação

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

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

-4 bytes graças a @Geobits .

Explicação:

Experimente 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

Inclui +3 para -a

Economizou 30 bytes graças a 1000000000

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

Saída:
truthy : 1
falsy : 0 no topo da pilha

Experimente online! (verdade)
Experimente online! (falso)

Melhor explicação depois (se me lembro como funciona depois de algumas horas ...)

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

Estrelado , 85 bytes

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

Experimente online!

Observe que, como um programa Starry não tem como saber quando uma entrada de comprimento arbitrário termina, esse programa usa uma nova linha à direita na entrada para marcar o final da string. Se você receber uma mensagem de erro enigmática sobre um método indefinido ordparanil:NilClass a entrada, falta uma nova linha à direita.

Explicação

A estratégia básica que o programa emprega é ler os caracteres um a um a partir da entrada e, se não forem uma nova linha (caractere 10), modifica o valor ASCII do caractere por 2 e encontra a diferença entre ele e o caractere lido anteriormente. Se a diferença for zero, o programa termina e imprime 0(falsey). Caso contrário, o programa volta e faz o processo novamente. Se o programa lê uma nova linha, ele termina e imprime10 (na verdade).

Programa anotado

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

-4 bytes graças a @Ton Hospel !

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

Precisa de -pbandeira. As saídas 1 são a sequência é par, nada diferente. Por exemplo :

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

Explicações : substitui cada caractere pelo seu valor mod 2 (para que a sequência contenha apenas 0s e 1s depois disso). Em seguida, procure dois seguintes 1 ou 0: se encontrar algum, a sequência não será par; caso contrário, será.

J, 15 bytes

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

Uso

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

Explicação

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 bytes

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

Assume a string de entrada no buffer e vazia "q. Produz absurdo binário se verdadeiro, nada se falso.

• s<C-R>=char2nr(@")%2<CR>: Substitui um caractere por 1 se ímpar, 0 se for par. A macro em que se encontra faz isso com todos os caracteres da linha (não importa quanto tempo seja).
• :g/00\|11/d<CR>: Exclui a linha se 2 "bits" consecutivos tiverem o mesmo valor. Mais rápido que uma referência posterior.

Normalmente, no vimgolf, quando você usa uma função de expressão dentro de uma macro, você deve fazer a própria macro no registro de expressões e usar alguns truques para concluir a tabulação. Desta vez é mais difícil. Eu posso encontrar uma maneira de encurtar isso mais tarde.

Retina , 39 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Mm`.¶.|^¶$
^0

Saídas 1para verdade e0 falsidade.

Experimente online!(A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Explicação

Inspirado por uma resposta de mbomb007, desenvolvi recentemente uma ord()implementação razoavelmente curta na Retina. Isso é amplamente baseado nisso, embora eu tenha sido capaz de fazer algumas simplificações, já que não preciso de um resultado decimal, pois só preciso oferecer suporte a ASCII imprimível (e só me preocupo com a paridade do resultado, terminando com um deslocamento arbitrário também é bom).

Etapa 1: Divisão

S_`

Isso simplesmente divide a entrada em seus caracteres individuais, dividindo-a em torno da correspondência vazia e eliminando os resultados vazios no início e no final _.

Etapa 2: substituir

%{2`
$`

o %{ diz à Retina a) que esse estágio e o próximo devem ser executados em um loop até que a string pare de mudar por uma iteração completa e que esses dois estágios sejam aplicados a cada linha (ou seja, cada caractere) da entrada separadamente.

O próprio palco é a técnica padrão para duplicar o primeiro caractere da entrada. Combinamos a string vazia (mas apenas observamos as duas primeiras correspondências) e inserimos o prefixo dessa correspondência. O prefixo da primeira correspondência (no início da string) está vazio, portanto, isso não faz nada, e o prefixo da segunda correspondência é o primeiro caractere, portanto, é duplicado.

Etapa 3: Transliterar

}T01`p`_o

}indica o fim do loop. O palco em si é uma transliteração. 01indica que ele deve ser aplicado apenas ao primeiro caractere da sequência. pé uma abreviação de todos os caracteres ASCII imprimíveis e _significa "excluir". Portanto, se expandirmos isso, a transliteração fará a seguinte transformação:

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

Portanto, os espaços são excluídos e todos os outros caracteres são diminuídos. Isso significa que esses dois estágios juntos criarão um intervalo de caracteres do espaço ao caractere especificado (porque eles duplicam e decrementam repetidamente o primeiro caractere até que se torne um espaço no qual a duplicação e a exclusão são canceladas).

O comprimento desse intervalo pode ser usado para determinar a paridade do personagem.

Etapa 4: substituir

..

Simplesmente descartamos todos os pares de caracteres. Isso limpa as linhas de comprimento par e reduz as linhas de comprimento ímpar a um único caractere (o caractere de entrada, de fato, mas isso realmente não importa).

Etapa 5: partida

Mm`.¶.|^¶$

É mais fácil encontrar entradas que não são uniformes, por isso contamos o número de correspondências de duas linhas vazias sucessivas ou duas linhas não vazias sucessivas. Deveríamos obter 0entradas pares e algo diferente de zero, caso contrário.

Etapa 6: partida

^0

Tudo o que resta é inverter o resultado, o que fazemos contando o número de correspondências desse regex, que verifica se a entrada começa com a 0. Isso só é possível se o resultado da primeira etapa foi 0.

Clojure, 59 bytes

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

Gera todos os pares seqüenciais da string ne verifica se a soma de cada par é ímpar. Se uma sequência de entradas é considerada um formato razoável, são 50 bytes.

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

Veja on-line: https://ideone.com/USeSnk

Julia, 55 53 Bytes

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

Explicado

Mapeie caracteres para 0 | 1 e verifique se a sequência resultante contém "00" ou "11", o que torna a sequência não alternada.

Python, 52 bytes

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

Uma função recursiva. Produz 1 (ou Verdadeiro) para seqüências pares, 0 para ímpares. Multiplica a paridade da diferença dos dois primeiros caracteres pelo valor recursivo no restante. Uma cadeia de caracteres únicos fornece True, conforme verificado, igualando seu primeiro caractere. Isso pressupõe que a entrada não esteja vazia; caso contrário, é necessário mais um byte paras==s[:1] ou len(s)<2.

Python 2, 52 bytes

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

Alternativamente, uma solução iterativa. Repete os caracteres de entrada, armazenando os valores de caracteres atuais e anteriores mod 2. Multiplica o produto em execução pela diferença, que causa 0 (Falsey) somente quando duas paridades consecutivas são iguais.

O valor "anterior" é inicializado para 2 (ou qualquer valor que não seja 0 ou 1) para que o primeiro caractere nunca corresponda à paridade com o caractere anterior fictício.

Python, 42 bytes, saídas via código de saída

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

Saídas via código de saída. Termina com um ZeroDivisionError quando dois caracteres consecutivos têm as mesmas paridades, caso contrário, termina de maneira limpa.

Haskell, 42 40 bytes

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

Exemplo de uso: all odd.(zipWith(-)=<<tail).map fromEnum $ "long"-> True.

Como funciona:

               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: @xnor salvou dois bytes. Obrigado!

Mathematica, 41 40 bytes

And@@OddQ@Differences@ToCharacterCode@#&

-1 caracteres, graças a Martin Ender

C, 52 bytes

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

Compara a paridade dos 2 primeiros caracteres, movendo-se recursivamente pela sequência até encontrar 2 caracteres com a mesma paridade ou a sequência com o comprimento de 1 ( s[1] == 0).

Código com alguns dos casos de teste

Pyke, 8 bytes

m.o$2m%B

Experimente aqui!

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

C #, 69 bytes

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

Programa completo com casos de teste:

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;

solução com Regex 81 bytes

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

PowerShell v2 +, 47 bytes

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

(Não pode bastante pegar concorrentes habituais do PowerShell ...)

Pega a entrada $args[0]como uma cadeia de caracteres, lança-a como uma charmatriz e circula através dela |%{...}, cada iteração colocando o módulo no pipeline (com implícita [char]à [int]conversão). Aqueles são encapsulados em parênteses e editados -joinem uma string, que é alimentada no lado esquerdo do -notmatchoperador, verificando 00ou 11( ou seja, retorna Truese o0 s e 1s alternativo). Esse resultado booleano é deixado no pipeline e a saída é implícita.

Casos de teste

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 bytes

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

Produz 1 se a palavra for par, 0 se a palavra for ímpar.

Você pode experimentá-lo online .

Edit: salvou dois bytes graças a Martin Ender

Perl 6 ,  47  26 bytes

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

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

Expandido:

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

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

Tenho certeza que isso pode ser melhorado.