Una 'cadena par' es cualquier cadena donde la paridad de los valores ASCII de los caracteres siempre se alterna. Por ejemplo, la cadena EvenSt-ring$!es una cadena par porque los valores ASCII de los caracteres son:

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

Y las paridades de estos números son:

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

Lo cual se alterna todo el camino. Sin embargo, una cadena como noHello world! es una cadena par porque los valores ASCII son:

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

Y las paridades son:

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

Lo cual claramente no siempre se alterna.

El reto

Debe escribir un programa completo o una función que acepte una cadena de entrada y genere un valor verdadero si la cadena es par, y un valor falso de lo contrario. Puede tomar su entrada y salida en cualquier formato razonable, y puede suponer que la entrada solo tendrá ASCII imprimible (el rango 32-127). Usted no tiene que manejar la entrada vacía.

Ejemplos

Aquí hay algunos ejemplos de cadenas pares:

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

Y todos estos ejemplos ni siquiera son cadenas:

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

También puede usar esta solución no protegida para probar cualquier cadena si tiene curiosidad sobre un determinado caso de prueba.

MATL , 4 3 bytes

Gracias a Emigna por guardar un byte y gracias a Luis Mendo por corregir algunos errores. Código:

doA

Explicación:

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

Pruébalo en línea!

05AB1E , 5 4 bytes

Guardado 1 byte gracias a Adnan .

Ç¥ÉP

Pruébalo en línea!

Explicación

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

Gelatina , 7 5 4 bytes

OIḂẠ

Guardado 2 bytes usando la idea deltas de @ Steven H.

Guardado 1 byte gracias a @ Lynn .

Pruébalo en línea! o Verificar todos los casos de prueba.

Explicación

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

La versión actual es básicamente todo el virtuosismo de Martin Ender.

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

Devoluciones TrueoFalse . Nada demasiado inteligente: toma la suma mod-2 de cada par de códigos ASCII consecutivos y verifica que 0 nunca se obtenga.

Versión antigua:

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)

Intenté la recursión, pero a 51 bytes, no parece valer la pena:

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

Fragmento de prueba

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 bytes

Gracias a @Riley por su ayuda en el golf.

Este programa trata la entrada vacía como una cadena no uniforme.

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

Pruébalo en línea!

Explicación (obsoleta)

Cambia la entrada de la pila izquierda a la derecha mientras modifica por 2. Encuentra la diferencia entre cada carácter adyacente hasta que todos hayan sido verificados o una de las diferencias sea igual a cero (lo que solo ocurriría en una cadena no uniforme). Si el bucle terminó debido a una cadena no uniforme, vuelva a la pila izquierda y muestre el valor restante. De lo contrario, quédese en la pila derecha y coloque el cero sobre el 1 restante en la pila.

R, 41 35 bytes

EDITAR: Guardado algunos bytes gracias a @JDL al usar en difflugar de rle.

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

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

Explicación

1. readline() leer entrada
2. utf8ToInt()%%2 convertir a valores ascii y mod 2 (almacenar como vector R)
3. all(rle()==1)codificación de longitud de ejecución de para encontrar ejecuciones. Todas las ejecuciones deben ser iguales o menores a 2 ya que ninguna ejecución puede ser negativa o 0 (guarda un byte en lugar de ==).

Pyth ( fork ), 9 bytes

.A%R2.+CM

No intente en línea porque la bifurcación no tiene su propia versión en los intérpretes en línea.

Explicación:

       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 bytes

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

Pruébalo en línea!

Explicación

@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 gracias a @Geobits .

Explicación:

Pruébalo en línea.

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 155151141 121

Incluye +3 para -a

Guardado 30 bytes gracias a 1000000000

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

Salida:
verdadero : 1
falso : 0 en la parte superior de la pila

Pruébalo en línea! (verdad)
Pruébalo en línea! (falso)

Mejor explicación más adelante (si puedo recordar cómo funciona después de unas 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
([]<(())>){((<{}{}>))}{}

Estrellado , 85 bytes

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

Pruébalo en línea!

Tenga en cuenta que, dado que un programa Starry no tiene forma de saber cuándo termina una entrada de longitud arbitraria, este programa utiliza una nueva línea final en la entrada para marcar el final de la cadena. Si recibe un mensaje de error críptico y un método indefinido ordparanil:NilClass la entrada, falta una nueva línea final.

Explicación

La estrategia básica que emplea el programa es leer los caracteres uno por uno desde la entrada y si no son una nueva línea (carácter 10) modifica el valor ASCII del carácter en 2 y encuentra la diferencia entre él y el carácter leído previamente. Si la diferencia es cero, el programa finaliza e imprime 0(falsey). De lo contrario, el programa se repite y vuelve a realizar el proceso. Si el programa lee una nueva línea, finaliza e imprime10 (verdad).

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 gracias a @Ton Hospel !

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

Necesita -pbandera. Salidas 1 es la cadena es par, nada de lo contrario. Por ejemplo :

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

Explicaciones : reemplaza cada carácter por su valor mod 2 (por lo que la cadena contiene solo 0s y 1s después de eso). Luego busque dos siguientes 1 o 0: si encuentra alguno, entonces la cadena no es par, de lo contrario lo es.

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

Explicación

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>

Asume una cadena de entrada en el búfer y vacía "q. Emite tonterías binarias si es verdadero, nada si es falso.

• s<C-R>=char2nr(@")%2<CR>: Reemplaza un personaje con 1 si es impar, 0 si es par. La macro en la que se encuentra solo hace esto a todos los caracteres de la línea (no importa cuánto tiempo sea)
• :g/00\|11/d<CR>: Elimina la línea si 2 "bits" consecutivos tienen el mismo valor. Más rápido que una referencia de referencia.

Normalmente, en vimgolf, cuando usa una función de expresión dentro de una macro, se supone que debe hacer la macro en el registro de expresión y usar algunos trucos para completar la pestaña. Eso es más difícil esta vez. Puedo encontrar una manera de acortar eso más tarde.

Retina , 39 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Mm`.¶.|^¶$
^0

Salidas 1para la verdad y 0para la falsedad.

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

Explicación

Inspirado por una respuesta de mbomb007 recientemente desarrollé una ord()implementación razonablemente corta en Retina. Esto se basa en gran medida en eso, aunque pude hacer algunas simplificaciones ya que no necesito un resultado decimal ya que solo necesito admitir ASCII imprimible (y solo me importa la paridad del resultado, por lo que terminé con un desplazamiento arbitrario también está bien).

Etapa 1: Split

S_`

Esto simplemente divide la entrada en sus caracteres individuales dividiéndolos alrededor de la coincidencia vacía y soltando los resultados vacíos al principio y al final con _.

Etapa 2: reemplazar

%{2`
$`

los %{ le dice a Retina a) que esta etapa y la siguiente deben ejecutarse en un bucle hasta que la cadena deje de cambiar a través de una iteración completa, y que estas dos etapas deben aplicarse a cada línea (es decir, cada carácter) de la entrada por separado.

La etapa en sí es la técnica estándar para duplicar el primer carácter de la entrada. Emparejamos la cadena vacía (pero solo miramos las dos primeras coincidencias) e insertamos el prefijo de esa coincidencia. El prefijo de la primera coincidencia (al comienzo de la cadena) está vacío, por lo que esto no hace nada, y el prefijo de la segunda coincidencia es el primer carácter, que por lo tanto está duplicado.

Etapa 3: transliterar

}T01`p`_o

}indica el final del ciclo. El escenario en sí mismo es una transliteración. 01indica que solo debe aplicarse al primer carácter de la cadena. pes una forma abreviada de todos los caracteres ASCII imprimibles y _significa "eliminar". Entonces, si expandimos esto, la transliteración realiza la siguiente transformación:

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

Entonces, los espacios se eliminan y todos los demás caracteres se reducen. Eso significa que estas dos etapas juntas crearán un rango de caracteres desde el espacio hasta el carácter dado (porque repetidamente duplicarán y disminuirán el primer carácter hasta que se convierta en un espacio en el que se cancele la duplicación y eliminación).

La longitud de este rango se puede usar para determinar la paridad del personaje.

Etapa 4: reemplazar

..

Simplemente dejamos caer todos los pares de caracteres. Esto borra las líneas de longitud par y reduce las líneas de longitud impar a un solo carácter (el carácter de entrada, de hecho, pero eso realmente no importa).

Etapa 5: partido

Mm`.¶.|^¶$

Es más fácil encontrar entradas que no sean pares, por lo que contamos el número de coincidencias de dos líneas vacías sucesivas o dos líneas sucesivas no vacías. Deberíamos conseguir0 contrario, entradas pares y algo distinto de cero.

Etapa 6: partido

^0

Todo lo que queda es invertir el resultado, lo que hacemos contando el número de coincidencias de esta expresión regular, que comprueba que la entrada comienza con a 0. Esto solo es posible si el resultado de la primera etapa fue 0.

Clojure, 59 bytes

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

Genera todos los pares secuenciales a partir de una cadena ny comprueba si la suma de cada par es impar. Si una secuencia de entradas se considera un formato razonable, entonces son 50 bytes.

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

Véalo en línea: https://ideone.com/USeSnk

Julia, 55 53 bytes

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

Explicado

Asigne caracteres a 0 | 1 y compruebe si la cadena resultante contiene "00" u "11", lo que hace que la cadena no se alterne.

Python, 52 bytes

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

Una función recursiva. Produce 1 (o True) para cadenas pares, 0 para las impares. Multiplica la paridad de la diferencia de los dos primeros caracteres por el valor recursivo del resto. Una cadena de un solo carácter da Verdadero, como lo verifica igualando su primer carácter. Esto supone que la entrada no está vacía; de lo contrario, se necesita un byte más para s==s[:1]o 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, una solución iterativa. Itera sobre los caracteres de entrada, almacenando los valores de caracteres actuales y anteriores mod 2. Multiplica el producto en ejecución por la diferencia, lo cual se debe a 0 (Falsey) solo cuando dos paridades consecutivas son iguales.

El valor "anterior" se inicializa a 2 (o cualquier valor que no sea 0 o 1) para que el primer personaje nunca coincida con la paridad con el personaje anterior ficticio.

Python, 42 bytes, salidas a través del código de salida

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

Salidas a través del código de salida. Termina con un ZeroDivisionError cuando dos caracteres consecutivos tienen las mismas paridades, de lo contrario termina limpiamente.

Haskell, 42 40 bytes

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

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

Cómo 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

Editar: @xnor guardó dos bytes. ¡Gracias!

Mathematica, 41 40 Bytes

And@@OddQ@Differences@ToCharacterCode@#&

-1 personaje, gracias a Martin Ender

C, 52 bytes

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

Compara la paridad de los primeros 2 caracteres, moviéndose recursivamente a través de la cadena hasta encontrar 2 caracteres con la misma paridad o la cadena con la longitud de 1 ( s[1] == 0).

Codifique con algunos de los casos de prueba

Pyke, 8 bytes

m.o$2m%B

Pruébalo aquí!

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 con casos de prueba:

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;

solución con 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'

(No se puede bastante coger competidores habituales de PowerShell ...)

Toma la entrada $args[0]como una cadena, la charconvierte como una matriz, la recorre |%{...}, cada iteración coloca el módulo en la tubería (con implícito [char]a la [int]conversión). Éstos se encapsulan en parens y se editan -joinen una cadena, que se introduce en la mano izquierda del -notmatchoperador, verificando 00o 11(es decir, devuelve Truesi 0s y1 s alternativo). Ese resultado booleano se deja en la tubería y la salida es implícita.

Casos de prueba

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^?(

Emite 1 si la palabra es par, 0 si la palabra es impar.

Puedes probarlo en línea.

Editar: guardado dos bytes gracias a Martin Ender

Perl 6,  47  26 bytes

{?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 bytes

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

I'm sure this can be improved.