Tarea

• El usuario ingresa una oración, solo palabras. Cualquier entrada que no sean letras o espacios, incluidos los enteros y la puntuación, debe arrojar una excepción: "La oración solo debe usar letras".
• La salida tiene un patrón, donde algunas palabras se invierten y otras palabras son normales.
• El patrón comienza como una palabra normal, las siguientes dos palabras se invierten, luego las siguientes dos palabras son normales y el patrón continúa.
• A continuación se muestra un ejemplo de dónde deberían ser normales las palabras y dónde se invierten las palabras:

Normal - Invertido - Invertido - Normal - Normal - Invertido - Invertido - Normal ...

Ejemplo de entrada

Ella vende conchas marinas en la orilla del mar

Ejemplo de salida

Ella arroja conchas en cada orilla

Reglas Adicionales

• Si se utilizan letras mayúsculas, deben permanecer en la letra en la que se publicaron originalmente.
• Cualquier espacio múltiple inicialmente publicado en la entrada debe reducirse a un espacio. Por ejemplo se Programming Puzzles and Code GolfconvierteProgramming selzzuP dna Code Golf

¡El código más corto gana!

Feliz codificación ...

TeaScript , 55 bytes 58 60 69 76 78 80 87 89

xO`a-z `?xl(#~-i&2?l:lv(),/ +/):Ld`SÀZn­ Û § «e Ò5s`

Esto es extremadamente corto, estoy muy feliz con eso.

Los últimos ~ 20 caracteres pueden parecer galimatías, pero eso es "La oración solo debe usar letras" codificada. Todos los caracteres tienen códigos de caracteres inferiores a 256, por lo que cada uno tiene un byte

Explicación

xO`a-z `?  // If input contains only a-z and space...

   xl(#       // Loop through input 
      ~-i&2?  // If (index - 1 "unary and"ed with 2) isn't 0...
          :l,     // Leave alone
          lv()    // Otherwise, reverse string
       / +/ // Loops on spaces
   )

:Ld`SÀZn­ Û § «e Ò5s` // Otherwise... decompress and print  the error string

• Pruébalo en línea
• Pastebin

Haskell, 141 bytes

r=reverse
f x|all(`elem`(' ':['a'..'z']++['A'..'Z']))x=unwords$zipWith($)(cycle[id,r,r,id])$words x|1<2=error"Sentence must only use letters"

Casi 2/3 del código es para verificación de errores. Parece ser el primer desafío del mundo real.

El trabajo se realiza mediante el unwords$zipWith($)(cycle[id,reverse,reverse,id])$words xcual divide la entrada en una lista de palabras, la comprime con la lista de funciones de ciclado [id,reverse,reverse,id,id,reverse...]y une el resultado con espacios de vuelta a una sola cadena.

Gracias a @Christian Irwan por 2 bytes.

JavaScript (ES6) 122

f=s=>/[^a-z ]/i.test(s)?"Sentence must only use letters":s.split(/ +/).map((w,i)=>~-i&2?w:[...w].reverse().join``).join` `

alert(f(prompt('?','She sells Sea shells on the Sea shore')))

Retina , 103 bytes

\s+

(?<=^\S+ (\S+ )?((\S+ ){4})*)
;
+`(;\S*)(\S)
$2$1
;

i`.*[^a-z ].*
Sentence must only use letters

Debería haber un solo espacio en la segunda línea, que SE parece estar tragando. Ejecute el código desde un único archivo con el-s bandera.

Retina no tiene el concepto de excepciones, por lo que la salida simplemente se reemplaza por Sentence must only use letterssi hay caracteres que no sean letras ni espacios en blanco en la entrada.

Pyth, 61 bytes

?.A}R+G\ rz0jd.e_W%%k4 3bfTczd"Sentence must only use letters

Pruébalo en línea.

Pitón, 163 160 157 145

k=raw_input()
k=["Sentence tsum ylno use letters",k][k.replace(' ','').isalpha()]
for i,x in enumerate(k.split()):print x[::-1if(i+1)/2%2else 1],

Se eliminaron 15 caracteres, ¡gracias Mego !

Bash + coreutils, 108

[ ${@//[a-zA-Z]/} ]&&echo Sentence must only use letters||for t;{
((++i/2%2))&&rev<<<$t||echo $t
}|tr \\n \ 

_{El último personaje de este programa es un espacio.}

La entrada se toma de la línea de comando:

$ ./norrevvevnor.sh Programming Puzzles and Code$'\n' Golf
Programming selzzuP dna Code Golf $ 
$ ./norrevvevnor.sh Programming Puzzles and Code$'\n' Golf1
Sentence must only use letters
$ 

Pyth, 72

=zflTc?:z"[^A-Za-z ]"0"Sentence tsum ylno use letters"zdjd.e?%/hk2 2_bbz

No supera la otra respuesta de Pyth, pero ya invertí tiempo en escribirla. Básicamente es una traducción de mi respuesta de Python .

Pruébalo en línea

Julia, 109 bytes

s->(i=0;join([isalpha(w)?(i+=1)%4>1?reverse(w):w:error("Sentence must only use letters")for w=split(s)]," "))

i=0y (i+=1)%4>1se usan para decidir si cada palabra recibe reversed o no. isalphase aplica a las palabras después de dividirse usando split(s)para determinar si hay caracteres que no son letras (los espacios ya se han eliminado en este punto). joinrestaura la cadena después de la manipulación, a menos que errorse lance.

Julia, 150 134 bytes

s->ismatch(r"[^a-z ]"i,s)?error("Sentence must only use letters"):(i=3;join([(i+=1;isodd((i+1)i÷2)?reverse(w):w)for w=split(s)]," "))

Sin golf:

function f(s::AbstractString)
    if ismatch(r"[^a-z ]"i, s)
        error("Sentence must only use letters")
    else
        i = 3
        a = [(i += 3; isodd((i + 1)i ÷ 2) ? reverse(w) : w) for w = split(s)]
        return join(a, " ")
    end
end

Guardado 16 bytes gracias a Glen O!

Pyth, 55 bytes

?--rz0Gd"Sentence must only use letters"jd.e_W%%k4 3bcz

Prestado el %%k4 3 pedazo de Pietu1998. Se guardó un byte adicional.

Pruébelo en línea: demostración o pruebas

Explicación

?--rz0Gd"..."jd.e_W%%k4 3bcz   implicit: z = input string
   rz0                         convert z to lower-case
  -   G                        remove all letters
 -     d                       remove all spaces
?                              if there is some chars left than
        "..."                    print the string "Sentence must only ..."
                               else:
                          cz     split z by spaces or multiple spaces
               .e                map each pair (k index, b string) of ^ to: 
                 _       b          b or reversed of b, depending on
                  W%%k4 3           (k mod 4) mod 3
             jd                  join the result by spaces

Perl 5 -ap , 80 bytes

map$_=++$i%4>1?reverse:$_,@F;$_=/[^a-z ]/i?"Sentence must use only letters":"@F"

Pruébalo en línea!

Java, 215 bytes

Regex es divertido

s->{if(s.split("[^a-zA-Z ]").length>1)throw new Error("Sentence must only contains letters");else{int i=1;for(String a:s.split(" "))System.out.print((i++%2<1?new StringBuffer(a).reverse():a)+(a.isEmpty()?"":" "));}}

Pruébalo en línea!

Jalea , 39 bytes

³Ḳ¹ƇUJ2&TƲ¦K
“*[,ṛDṾȧƤ°Ġṛ©¦»
ØẠ” ṭ³eƇ⁼£

Pruébalo en línea!

Gracias a Erik the Outgolfer. Me salvó de unos pocos bytes adicionales y de muchas horas de frustración.

Aquí hay una solución de 46 bytes

En realidad, arroja un error de sintaxis de Python cuando la entrada contiene caracteres no válidos.

³Ḳ¹ƇUJ2&TƲ¦K
“çỤḷṁŀDṀẠṠGmḟĖƲƑ⁽Ḳḟ»ŒV
ØẠ” ṭ³eƇ⁼£

Pruébalo en línea!

Japt v2.0a0-S , 41 bytes

¸¬è\L ?`SÀZn­ Û § «e Ò5s`:UeS²S ¸ËzEc2

Intentalo

¸¬è\L ?`...`:UeS²S ¸ËzEc2     :Implicit input of string U
¸                             :Split on spaces
 ¬                            :Join
  è                           :Count occurrences of
   \L                         :RegEx /[^A-Z]/gi
      ?`...`:                 :If truthy return the compressed string "Sentence must only use letters", else
             Ue               :Recursively replace in U
               S²S            :  Two spaces with one
                   ¸          :Split on spaces
                    Ë         :Map each element at 0-based index E
                     z        :  Rotate clockwise by 90 degrees multiplied by
                      Ec2     :    E rounded up to the nearest multiple of 2
                              :Implicit output, joined with spaces

05AB1E , 36 bytes

ðKDáÊi“¸–ƒ—€É€Å™ê“.ªFë#áεN4%>2÷iR]ðý

Pruébalo en línea.

Lanza el siguiente error cuando la entrada no solo contiene [A-Za-z ] :

(RuntimeError) No se pudo convertir La oración solo debe usar letras al número entero.

Explicación:

ðK                   # Remove all spaces from the (implicit) input-string
  Dá                 # Create a copy, and remove everything except for letters from this copy
    Êi               # If the copy with letters removed and the original are NOT equal:
      “¸–ƒ—€É€Å™ê“   #  Push dictionary string "sentence must only use letters"
                  .ª #  With sentence capitalization
      F              #  And try to loop that many times, causing the error above
     ë               # Else:
      #              #  Split the (implicit) input-string on spaces
       á             #  Only keep letters (which will remove empty items caused by multiple
                     #  adjacent spaces in the input, which is shorter than `õK`)
        ε            #  Map each word to:
         N4%>2÷      #   Calculate ((index modulo-4) + 1) integer-divided by 2
                     #   (results in 0,1,1,2,0,1,1,2,0,1 for indices 0,1,2,3,4,5,6,7,8,9)
               i     #   If this is exactly 1:
                R    #    Reverse the current word
     ]               # Close the if-statement, map, and if-else statement
      ðý             # Join the modified word-list by spaces
                     # (and then output it implicitly as result)

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué “¸–ƒ—€É€Å™ê“es "sentence must only use letters".

PHP , 147 bytes

foreach(explode(' ',$argn)as$a){if(!ctype_alpha($a))throw new Exception('Sentence must only use letters');$o.=(++$i%4>1?strrev($a):$a).' ';}echo$o;

Pruébalo en línea!

O si die()es aceptable como una "Excepción":

PHP , 131 bytes

foreach(explode(' ',$argn)as$a){if(!ctype_alpha($a))die('Sentence must only use letters');$o.=(++$i%4>1?strrev($a):$a).' ';}echo$o;

Pruébalo en línea!