Le défi

Eh bien, je pense que c'est assez clair, n'est-ce pas? Vous devez créer une fonction ou un programme qui prend une chaîne en tant qu'argument et génère le correspondant correspondant, Yoda.

C'est le code-golf , donc le moins d'octets gagne.

L'entrée

L'entrée peut être n'importe quelle chaîne sans saut de ligne. Vous pouvez traduire une chaîne si elle est composée comme ceci:

Sujet + Verbe + Quelque chose d'autre.

Où Subject est un pronom personnel (moi, vous, il, elle, elle, nous, eux). Vous n'êtes pas obligé de reconnaître que le deuxième mot est un verbe.

Si le premier mot n'est pas un pronom, l'entrée est valide mais la sortie sera Too difficult, this sentence is.

You have to win this code challenge -> Translatable
Luke has to win this code challenge -> Untranslatable

La saisie peut se terminer par une lettre, a. ou un!, pas avec un?.

De plus, les chaînes peuvent contenir des caractères non-ASCII, des parenthèses, des virgules, des deux-points, etc.

Le résultat

Dans le cas d'une phrase traduisible, le résultat est la même phrase, avec le sujet et le verbe à la fin de la phrase.

You have to win this code challenge -> To win this code challenge, you have.

Les virgules, les points et les minuscules du pronom sont obligatoires. (Sauf, bien sûr, si le pronom est I).

Comme indiqué précédemment, s'il est intraduisible, vous devez générer la chaîne Too difficult, this sentence is.

Exemples

You have to win this code challenge -> To win this code challenge, you have.
He won this code challenge -> This code challenge, he won.  (I know this is not yoda-speaking, but I don’t want to overcomplicate this challenge)
I ate an ice cream earlier! -> An ice cream earlier, I ate.
I liked the Star Wars original trilogy more than the prequel’s one. -> The Star Wars original trilogy more than the prequel’s one, I liked.
I find your lack of faith disturbing -> Your lack of faith disturbing, I find.
I think we are done with the examples -> We are done with examples, I think.
He is your son, Vader -> Your son, Vader, he is.
I think they’ll add new features -> They’ll add new features, I think.
I made a fantastic code challenge (I hope) -> A fantastic code challenge (I hope), I made.
I love constants like π -> Constants like π, I love.

I’ll be the next President, I swear! -> Too difficult, this sentence is.
This challenge is great! -> Too difficult, this sentence is.
Is this challenge great? -> Too difficult, this sentence is.
Luke is not ready for this task -> Too difficult, this sentence is.
Somebody loves constants like π -> Too difficult, this sentence is.
[Empty string] -> Too difficult, this sentence is.

Retina, 162 137 145 134 131 129

La ponctuation multiple est maintenant gérée correctement. Cas de test:You will not win this challenge...! -> Not win this challenge..., you will.

Essayez-le en ligne!

[.!]$

T`A-Z`a-z`^\w\w
G`^(I|we|you|s?he|it|they) \S+ \S
(\S+ \S+) (.*)
$2, $1.
T`a-z`A-Z`^.
^$
Too difficult, this sentence is.

La description:

S'il y a ponctuation à la fin, supprimez-le.

[.!]$

^empty line

Transforme le pronom en minuscule, sauf que c'est I.

T`A-Z`a-z`^\w\w

Filtrer toute ligne qui ne correspond pas <Pronoun><space><word><space><word>...

G`^(I|we|you|s?he|it|they) \S+ \S

Divisé en pronoun + verb, remainder. Puis réorganiser.

(\S+ \S+) (.*)
$2, $1.

Transforme le premier caractère en majuscule.

T`a-z`A-Z`^.

Si le résultat est vide, le filtre ci-dessus n'est pas passé. Imprimer un message d'erreur.

^$
Too difficult, this sentence is.

ES6, 212

Cela peut probablement être un peu plus compliqué:

i=>(r=/(you|s?he|it?|we|they)( \S+) ([^\.!?]+)/i.exec(i))?(c=(a,b)=>a[`to${['Low','Upp'][b]}erCase`]())(r[3].slice(0,1),1)+r[3].slice(1)+", "+c(r[1],+(/i/i.test(r[1])))+r[2]+".":"Too difficult, this sentence is."

JSFiddle (nécessite un navigateur à jour tel que Chrome) ou l'exécuter via node.js

Ungolfed:

i=>{
    r=/(you|s?he|it?|we|they)( \S+) ([^\.!?]+)/i.exec(i); //Main RegExp
    c=(a,b)=>a[`to${['Low','Upp'][b]}erCase`](); //shortcut for toUpperCase/toLowerCase
    if (r)
        return c(r[3].slice(0,1),1)+r[3].slice(1) + ", " //the "something else", properly formated
             + c(r[1], +(/i/i.test(r[1]))) //The subject lowercased except for "i" or "I"
             + r[2] + "."; //The End
    else //no match, no sentence to translate
        return "Too difficult, this sentence is.";
}

JavaScript (ES6), 164 octets

s=>([,p,,i,r]=s.match`^(((I)|You|He|She|It|We|They) \\S+) (.*?)[.!]?$`)?r[0].toUpperCase()+r.slice(1)+`, ${i?p:p.toLowerCase()}.`:"Too difficult, this sentence is."

Explication

C'est presque douloureux combien d'octets en majuscule la première lettre d'une chaîne prend en JavaScript ...

s=>

  // Match and get specific parts of the input string
  ([,p,,i,r]=s.match`^(((I)|You|He|She|It|We|They) \\S+) (.*?)[.!]?$`)?

    r[0].toUpperCase()+r.slice(1)     // capitalise first letter
      +`, ${i?p:p.toLowerCase()}.`    // lower-case the pronoun (unless it is I)
  :"Too difficult, this sentence is."

Tester

Test n'utilise pas d'attribution de déstructuration pour le rendre plus compatible avec tous les navigateurs.

var solution = s=>(p=s.match`^(((I)|You|He|She|It|We|They) \\S+) (.*?)[.!]?$`)?p[4][0].toUpperCase()+p[4].slice(1)+`, ${p[3]?p[1]:p[1].toLowerCase()}.`:"Too difficult, this sentence is."

<input type="text" id="input" value="I love constants like π...!" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Python, 261 octets

import re
def a(b):
 if b[-1:]in".!":
  b=b[:-1]
 if re.match('(I|YOU|S?HE|IT|WE|THEY) \w+ \S+',b.upper()):
  b=(b+',').split()
  if b[0]!="I":
   b[0]=b[0].lower()
  b=" ".join(b[2:]+b[:2])
  return b[0].upper()+b[1:]
 return "Too difficult, this sentence is."

Il s'avère que Python ne s'inquiète pas de choses comme b[-1]in".!"Next, je vais jouer plus souvent avec l'objet match, si personne ne me bat dessus :)

Python, 218 217 204 octets

Je ne sais pas si cela peut encore être joué.

def f(s):t=s.split();u=' '.join(t[2:]).rstrip('!.');return['Too difficult, this sentence is.','%s, %s %s.'%(u[0].upper()+u[1:],['I',t[0].lower()][t[0]!='I'],t[1])][t[0]in'I We You He She It They'.split()]

Ungolfed:

def f(s):
    t = s.split()
    u = ' '.join(t[2:]).rstrip('!.')
    return [
        'Too difficult, this sentence is.',
        '%s, %s %s.' % (u[0].upper() + u[1:],
                        ['I', t[0].lower()][t[0] != 'I'],
                        t[1])
    ][t[0] in 'I We You He She It They'.split()]

GNU sed, 129 octets

J'inclus +1 octet pour le -rdrapeau.

#!/bin/sed -rf

/^I /b
s/^(You|[HW]e|She|It|They) /\L&/
t
s/.*/Too difficult, this sentence is./p
d
:
s/[.!]$//
s/^([^ ]+ [^ ]+) (.*)/\u\2, \1./

Explication

Si nous correspondons à un leader, Inous sautons au label:

/^I /b

Si nous correspondons à l'un des autres pronoms, nous le minimisons, puis passons à l'étiquette:

s/^(You|[HW]e|She|It|They) /\L&/
t

Sinon, nous imprimons le message d'échec et passons à la ligne de saisie suivante:

s/.*/Too difficult, this sentence is./p
d

Si nous sautons à l'étiquette, nous supprimons toute ponctuation finale:

:
s/[.!]$//

et permutez les deux premiers mots avec le reste de la phrase, en capitalisant le nouveau premier mot et en ajoutant la ponctuation requise en procédant ainsi:

s/^([^ ]+ [^ ]+) (.*)/\u\2, \1./