Compito

• L'utente inserisce una frase - solo parole. Qualsiasi input diverso da lettere o spazi, inclusi numeri interi e punteggiatura, dovrebbe generare un'eccezione: "La frase deve usare solo lettere".
• L'output ha uno schema, in cui alcune parole sono invertite e altre parole sono normali.
• Lo schema inizia come una parola normale, le due parole successive vengono invertite, quindi le due parole successive sono normali e lo schema continua.
• Un esempio di dove le parole dovrebbero essere normali e dove le parole invertite è di seguito:

Normale - Invertito - Invertito - Normale - Normale - Invertito - Invertito - Normale ...

Esempio di input

Vende conchiglie sulla riva del mare

Esempio di output

Fa scivolare conchiglie sulla sua riva

Regole aggiuntive

• Se vengono utilizzate le lettere maiuscole, dovrebbero rimanere sulla lettera in cui erano state originariamente pubblicate.
• Eventuali spazi multipli inizialmente pubblicati sull'input devono essere ridotti a uno spazio. Ad esempio Programming Puzzles and Code GolfdiventaProgramming selzzuP dna Code Golf

Vince il codice più corto !!

Buona codifica ...

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

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

Questo è estremamente breve, ne sono molto contento.

Gli ultimi ~ 20 caratteri possono sembrare incomprensibili ma è codificato "La frase deve usare solo lettere". Tutti i caratteri hanno codici di caratteri inferiori a 256, quindi ognuno è un byte

Spiegazione

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

• Provalo online
• pastebin

Haskell, 141 byte

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"

Quasi i 2/3 del codice servono per il controllo degli errori. Sembra essere la prima sfida del mondo reale.

Il lavoro viene svolto per unwords$zipWith($)(cycle[id,reverse,reverse,id])$words xdividere l'input in un elenco di parole, comprimerlo con l'elenco ciclico di funzioni [id,reverse,reverse,id,id,reverse...]e unire il risultato con spazi di nuovo a una singola stringa.

Grazie a @Christian Irwan per 2 byte.

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 byte

\s+

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

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

Dovrebbe esserci un solo spazio sulla seconda riga, che SE sembra deglutire. Esegui il codice da un singolo file con il -sflag.

Retina non ha il concetto di eccezioni, quindi l'output viene semplicemente sostituito da Sentence must only use lettersse nell'input sono presenti caratteri non bianchi non di lettera.

Pyth, 61 byte

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

Provalo online.

Python, 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],

Rimossi 15 caratteri, grazie Mego !!

Bash + coreutils, 108

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

_{L'ultimo personaggio di questo programma è uno spazio.}

L'input viene prelevato dalla riga di 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

Non batte l'altra risposta di Pyth, ma ho già investito tempo nello scriverlo. Fondamentalmente è una traduzione della mia risposta Python .

Provalo online

Julia, 109 byte

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

i=0e (i+=1)%4>1sono usati per decidere se ogni parola diventa reverseo meno. isalphasi applica alle parole dopo essere state divise usando split(s)per determinare se ci sono caratteri che non sono lettere (gli spazi sono già stati rimossi da questo punto). joinripristina la stringa dopo la manipolazione, a meno che non errorvenga lanciata.

Julia, 150 134 byte

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)]," "))

Ungolfed:

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

Risparmiato 16 byte grazie a Glen O!

Pyth, 55 byte

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

%%k4 3Preso in prestito il pezzo da Pietu1998. Salvato un byte aggiuntivo.

Provalo online: dimostrazione o Test Suite

Spiegazione

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

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

Provalo online!

Java, 215 byte

Regex è divertente

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()?"":" "));}}

Provalo online!

Gelatina , 39 byte

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

Provalo online!

Grazie a Erik the Outgolfer. Mi ha salvato da qualche byte in più e da molte ore di frustrazione.

Ecco una soluzione a 46 byte

In realtà genera un errore di sintassi di Python quando l'input contiene caratteri non validi.

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

Provalo online!

Japt v2.0a0 -S, 41 byte

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

Provalo

¸¬è\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 byte

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

Provalo online.

Genera il seguente errore quando l'input non contiene solo [A-Za-z ]:

(RuntimeError) Impossibile convertire la frase deve usare solo lettere in numero intero.

Spiegazione:

ð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)

Vedere questo suggerimento 05AB1E mio (sezione Come utilizzare il dizionario? ) Per capire il motivo per cui “¸–ƒ—€É€Å™ê“è "sentence must only use letters".

PHP , 147 byte

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;

Provalo online!

O se die()è accettabile come "eccezione":

PHP , 131 byte

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

Provalo online!