Ne me demandez pas comment ni pourquoi, mais en codant sur un projet, j'ai remarqué que les caractères de deux mots avaient un motif particulier faisant référence à l'alphabet, j'ai relié chaque caractère des mots au crayon de l'alphabet et j'ai obtenu deux spirales, puis j'ai remarqué que la première spirale était dans le sens des aiguilles d'une montre et l'autre dans le sens contraire des aiguilles d'une montre, ainsi que d'autres caractéristiques ... alors je les ai nommées Mots tourbillonnants !

Un mot tourbillonnant peut être:

1. dans le sens horaire ou antihoraire
2. centripète ou centrifuge

Voici quelques exemples de mots tourbillonnants :

Tache 1:

Ecrivez un programme complet ou une fonction qui prendra un mot de l’entrée standard et produira un mot tourbillonnant et ses caractéristiques, dans un format lisible, un texte étendu, 3 caractères, des drapeaux, etc.

Cas de test et exemples de sorties pour différents mots (mais vous pouvez décider comment représenter les résultats):

EARTH, GROUP            > NO        // NOT A SWIRLING WORD
OPERA, STAY, IRIS       > SW,CF,CW  // SWIRLING WORD, CENTRIFUGAL, CLOCKWISE
MINER, TAX, PLUG, META  > SW,CF,CC  // SWIRLING WORD, CENTRIFUGAL, COUNTERCLOCKWISE
AXIOM, AXIS, COOK       > SW,CP,CW  // SWIRLING WORD, CENTRIPETAL, CLOCKWISE
WATCH, YETI, PILL       > SW,CP,CC  // SWIRLING WORD, CENTRIPETAL, COUNTERCLOCKWISE

MORE EXAMPLES OF FALSE TEST CASES (NOT SWIRLING WORDS): 
EARTH, GROUP, OUTPUT, WORD, CONNECTION, ODD, MOM, DAD, 
CHARACTER, EXAMPLE, QUESTION, NEWSLETTER, OTHER

Règles:

1. La connexion entre les deux premiers caractères doit être active (comme dans les graphiques), toute la connexion paire doit être interrompue , toutes les connexions impaires doivent être actives .
2. Vous pouvez ignorer les majuscules / minuscules ou considérer / convertir tout en majuscule ou tout en minuscule.
3. Les mots d'entrée ne sont que des caractères dans la plage alphabétique de AZ, pas d'espaces, pas de ponctuation, etc.
4. Si un mot a des caractères doubles, comme "GROOVE", vous devez réduire les doubles à un seul caractère: "GROOVE"> "GROVE".
5. Les mots entrés contiendront au moins 3 caractères distincts. Des mots comme "MOM", "PAPA", "LOL" ne sont pas des mots valides.
6. Il est possible de passer plusieurs fois dans le même caractère, comme "IRIS".
7. Le code le plus court gagne.

Tâche 2:

Pour obtenir plus de réputation, recherchez les mots les plus longs qui tourbillonnent , ainsi que leurs caractéristiques, que vous trouverez dans le dictionnaire anglais en suivant les règles ci-dessus. Vous pouvez prendre par exemple comme référence la liste complète des mots anglais ici .

Bonne codage!

MATL , 33 31 30 octets

lydhg)dt|dZSXz&=wZSdh?4M1)3M1)

L'entrée est en majuscules (ou en minuscules, mais non mélangée).

La sortie est:

• Si le mot ne tourne pas: aucune sortie n'est produite
• Si elle tourbillonne: deux nombres sont produits dans des lignes différentes:
  • Premier chiffre 1/ -1 indique centrifuge / centripète.
  • Le deuxième nombre 1/ «-1» indique le sens horaire / antihoraire.

Essayez-le en ligne! Ou vérifiez tous les cas de test (code modifié pour prendre toutes les entrées et produire les deux numéros de sortie sur la même ligne)

Explication

Prenons l'entrée 'OPERAA'comme exemple.

La première partie du code supprime les doubles lettres:

l     % Push 1
      %   STACK: 1
y     % Take input implicitly from below, and duplicate
      %   STACK: 'OPERAA', 1, 'OPERAA'
d     % Convert to code points and compute differences
      %   STACK: 'OPERAA', 1, [1 -11  13 -17 0]
h     % Concatenate horizontally
      %   STACK: 'OPERAA', [1 1 -11  13 -17 0]
g     % Convert to logical
      %   STACK: 'OPERAA', [true true true true true false]
)     % Index
      %   STACK: 'OPERA'

Nous vérifions maintenant si les distances entre les lettres ne sont pas décroissantes (condition nécessaire pour que le mot tourbillonne):

d     % Convert to code points and compute differences
      %   STACK: [1 -11  13 -17]
t|    % Duplicate and take absolute value
      %   STACK: [1 -11  13 -17], [1 11  13 17]
d     % Differences
      %   STACK: [1 -11  13 -17], [10 2 4]
ZS    % Signum
      %   STACK: [1 -11  13 -17], [1 1 1]
Xz    % Remove zeros (gives a vertical vector). Needed for words like 'IRIS',
      % where some consecutive distances are equal
      %   STACK: [1 -11  13 -17], [1; 1; 1]
&=    % All pairwise equality comparisons. Gives a matrix. If all the signs 
      % were equal the matrix will contain all ones
      %   STACK: [1 -11  13 -17], [1 1 1; 1 1 1; 1 1 1]

Nous vérifions ensuite si les lettres vont et viennent (c’est l’autre condition pour que le mot tourbillonne):

w     % Swap
      %   STACK: [1 1 1; 1 1 1; 1 1 1], [1 -11  13 -17]
ZS    % Signum
      %   STACK: [1 1 1; 1 1 1; 1 1 1], [1 -1 1 -1]
d     % Differences
      %   STACK: [1 1 1; 1 1 1; 1 1 1], [-2 2 -2]

Enfin, nous vérifions si les deux conditions sont vérifiées et, dans ce cas, produisons la sortie:

h     % Concatenate horizontally
      %   STACK: [1 1 1 1 1 1 1 1 1 -2 2 -2]
?     % If all elements are nonzero
  4M  %   Push first signum array without zeros, from the automatic clipboard
      %     STACK: [1; 1; 1]
  1)  %   Get first element (tells if first difference was positive or negative)
      %     STACK: 1
  3M  %   Push second signum array, from the automatic clipboard
      %     STACK: 1, [1 -1 1 -1]
  1)  %   Get first element (tells if first movement was right or left)
      %     STACK: 1, 1
      %   Implicitly end if
      % Implicitly display

Mathematica, 117 111 octets

Merci à JHM d’avoir économisé 6 octets et de le rendre insensible à la casse!

 {o=OrderedQ/@{a=Abs[d=Differences[#&@@@Split@LetterNumber@#]],Reverse@a},d[[1]]>0,Or@@o&&Max[Most[d]Rest@d]<0}&

Fonction sans nom qui prend une chaîne et retourne une liste imbriquée de booléens dans le formulaire {{B1,B2},B3,B4}. B4 enregistre si le mot tourbillonne (et si ce n'est pas le cas, le reste de la sortie est illisible). Si le mot tourne, B1 indique si le mot est centrifuge, B2 si le mot est centripète et B3 si le mot est dans le sens des aiguilles d'une montre (Vrai) ou dans le sens inverse des aiguilles d'une montre (Faux).

Voici une version plus longue que les processus de post-(première ligne) la fonction ci - dessus (espacées sur les 2e-5e lignes) pour la rendre identique à l'OP: NOsi le mot est tourbillonnant, et le choix approprié de {SW,CF,CW}, {SW,CF,CC}, {SW,CP,CW}ou {SW,CP,CC}si le mot tourbillonne:

If[#3, {SW, If[#[[1]], CF, CP], If[#2, CW, CC]}, NO] & @@
  {o = OrderedQ /@
    {a = Abs[d = Differences[# & @@@ Split@LetterNumber@#]], Reverse@a},
  d[[1]] > 0,
  Or @@ o && Max[Most[d] Rest@d] < 0} &

L'explication est la même que dans la réponse de Martin Ender dans CJam, avec une remarque supplémentaire: la liste des différences consécutives doit alterner dans le signe pour que le mot tourbillonne, et cela peut être détecté en s'assurant que tous les produits de paires de différences consécutives sont négatifs. (c'est ce que Max[Most[d]Rest@d]<0fait).

En exécutant la fonction sur plus de 40 000 mots de Mathematica WordList[], nous trouvons les mots tourbillonnants de 8 lettres suivants, qui sont les plus longs de leurs types tourbillonnants respectifs:

operetta    {SW, CF, CW}
opposite    {SW, CF, CW}
stowaway    {SW, CF, CW}
assassin    {SW, CP, CW}
assessor    {SW, CP, CW}
baccarat    {SW, CF, CC}
keenness    {SW, CF, CC}
positive    {SW, CF, CC}

(Brownie fait référence à positivene pas avoir de lettres doubles et moins de lettres répétées que stowaway.)

Mais le champion absolu est le mot centripète tourbillonnant dans le sens antihoraire vassalage!

Scala, 110 octets

def/(s:String)={val ? =s.sliding(2).map(t=>(t(0)-t(1)).abs).toSeq
(Seq(?,?reverse)indexOf(?sorted),s(0)<s(1))}

Retourne un tuple (a,b)avec

• a == 1 si s est centripète
• a == 0 si s est centrifuge
• a == -1 si s ne tourne pas

et

• b == true si s est dans le sens des aiguilles d'une montre
• b == false si s est dans le sens antihoraire
• b peut être vrai ou faux si s ne tourne pas

Explication:

def/(s:String)={      //define a method called / with a String argument
  val ? =s            //define ? as...
    .sliding(2)       //an iterator for each two consecutive elements
    .map(t=>          //foreach 2 chars
      (t(0)-t(1)).abs //get the absolute value of their difference
    ) 
    .toSeq            //and convert the iterator to a Seq, because iterator doesn't have reverse and sorted methods
  (                   //return a tuple of
    Seq(?,?reverse)     //a Seq of ? and reversed ?
    .indexOf(?sorted)   //and check which of them is sorted ?
  ,                   //and
   s(0)< s(1)          //the difference bewteen the first two elements of the string.
  )
}

Gelée , 30 octets

3Ŀḟ0ṠE
ÑṠḟ0Ṃ
ÑAI
OIḟ0
ÇṠḢ;2Ŀ;Ñ

TryItOnline
Ou voir les cas de test (avec un léger changement car le dernierÑpoint indiquerait le nouveau lien principal)

(Mon manque de compétences d'enchaînement coûte probablement quelques octets ici)
Tout en haut ou tout en bas.
Renvoie une liste de drapeaux [D, F, S]:
S: rotation = 1 / pas de rotation = 0
F: centrifuge = 1 (circulaire = 0) centripète = -1
D: dans le sens des aiguilles d'une montre = 1 / dans le sens inverse des aiguilles d'une montre =
S - 0 les autres indicateurs sont toujours évalués même s'ils ne contiennent aucune information utile.

Comment?

3Ŀḟ0ṠE      - Link 1, isSpinning: s
3Ŀ          - call link 3 as a monad with s
  ḟ0        - filter out zeros
    Ṡ       - sign
     E      - all equal?

ÑṠḟ0Ṃ       - Link 2, centrifugal(-1), circular(0) or centripetal(1): s
Ñ           - call next link (3) as a monad with s
 Ṡ          - sign (+1 for positive changes, -1 for negative changes, 0 for no change)
  ḟ0        - filter out zeros (ignore these for cases like "IRIS")
    Ṃ       - minimum (will be the only value for spinning words)
            -    (circular words like "DAD", now excluded, yield min([])=0)

ÑAI         - Link 3, absolute change of moves over alphabet: s
Ñ           - call next link (4) as a monad with s
 A          - absolute
  I         - differences

OIḟ0        - Link 4, non-zero moves over alphabet: s
O           - ordinal cast
 I          - differences
  ḟ0        - filter out zeros

ÇṠḢ;2Ŀ;Ñ    - Main link: s
Ç           - call last link (4) as a monad with s
 Ṡ          - sign
  Ḣ         - head (clockwise / anticlockwise: 1 / -1)
   ;  ;     - concatenate
    2Ŀ      - call link (2) as a monad with s
       Ñ    - call next link (1) as a monad with s

CJam , 39 octets

r{2ew::-V}:D~-_:g_0=\D#)!@:zD-:g_0=\(-!

Essayez-le en ligne!

L'entrée peut être en majuscule ou en minuscule, mais pas mélangée.

Le programme signale par inadvertance des mots qui ne sont pas nécessairement centrifuges ou centripètes, mais qui répondent aux exigences de spirale. Celles-ci sont décrites comme "circulaires" dans le tableau ci-dessous.

Pour interpréter la sortie, utilisez ce tableau:

SPIRAL (output contains four 1s)
-11-11 : Clockwise Centrifugal
-1111  : Clockwise Centripetal
11-11  : Counter-clockwise Centrifugal
1111   : Counter-clockwise Centripetal

CIRCULAR (output contains two 1s)
-11    : Clockwise Circular
11     : Counter-clockwise Circular

NONSPIRAL (output contains a 0)

Explication:

Le programme évalue en fait si la séquence de différences non nulles entre les caractères commence positivement ou négativement, si elle alterne en signe, si les magnitudes commencent à augmenter ou à diminuer et si elle continue à le faire. Si les magnitudes n'augmentent ni ne diminuent, le programme s'interrompt en opérant sur un tableau vide. Les principales étapes sont indiquées ci-dessous (ce code indiquera également la progression de la pile):

r{2ew::-V}:D~-   e# take difference of overlapping pairs, removing 0s handles duplicates
               ede# store difference function plus 0 as D, it's multipurpose
_:g_0=\          e# compute signs differences, keep first to show starting direction
               ede# -1 = CLOCKWISE, 1 = COUNTERCLOCKWISE
D#)!@            e# difference of signs includes 0 if not alternating, keep in stack
               ede# 1 = ALTERNATING, 0 = NOT ALTERNATING
:zD-:g           e# signs of difference of absolute values, ignoring 0s (fixed magnitude)
_0=\             e# keep first sign in stack to indicate how the sequence starts
               ede# -1 = INCREASING, 1 = DECREASING
(-!              e# remove first item from entire list and see if nothing remains
               ede# 1 = EMPTY(MONOTONE), 0 = NONEMPTY

PHP, 322 octets

for(;++$i<strlen($z=preg_replace("#(.)\\1#","$1",$argv[1]));){$t[]=$z[$i-1]<=>$z[$i]?:0;$o[]=$z[0]<=>$z[$i];$i<2?:$k[]=$z[$i-2]<=>$z[$i];}$s=preg_match("#^1?(-11)*(-1)?$#",join($t))?($t[0]!=1?1:2):0;$s+=2*preg_match($r="#^(-1|0)?([01](-1|0))*[01]?$#",join($o));$s*=preg_match($r,join($k));count_chars($z,3)[2]?:$s=0;echo$s;

pour une sortie plus jolie echo["n","+P","-P","+F","-F"][$s];

Version élargie

for(;++$i<strlen($z=preg_replace("#(.)\\1#","$1",$argv[1]));){
    $t[]=$z[$i-1]<=>$z[$i]?:0;
    $o[]=$z[0]<=>$z[$i];
    $i<2?:$k[]=$z[$i-2]<=>$z[$i];
    }
$s=preg_match("#^1?(-11)*(-1)?$#",join($t))?($t[0]!=1?1:2):0; #Clockwise direction or not
$s+=2*preg_match($r="#^(-1|0)?([01](-1|0))*[01]?$#",join($o)); # True centrifugal
$s*=preg_match($r,join($k)); #true or false second test for not
count_chars($z,3)[2]?:$s=0; # word must have >2 different characters
echo$s;# short output
echo["n","+P","-P","+F","-F"][$s]; #long output alternative

Tâche 2 seconde valeur sans la règle des doubles courts

4 -F killness 11 Bytes positivize 10 Bytes

Logogue 3 + F 10 octets opposés 9 octets

2-P vassalage 9 Bytes sarcocol, sasarara 8 Bytes

1 + P assession 9 Bytes apanage, araméen, argonon, vente aux enchères, avision, récompensé, créneau, exesion, exition, paupière 7 Bytes

Visualiser un mot

header('Content-Type: image/svg+xml; charset=UTF-8');
$w=$_GET["w"]??"OOPERRA";
$w=strtoupper($w);
echo '<?xml version="1.0" encoding="UTF-8"?>'
.'<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'

.'<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 -100 420 400">'
.'<title>Swirl Word</title><desc>Viualize a Word</desc>';
echo '<text x="210" y="-50" text-anchor="middle" font-family="arial">'.$w.'</text>';

foreach(range("A","Z")as $x=>$c){
    echo '<text x="'.(15+$x*15).'" y="110" text-anchor="middle" font-family="arial">'.$c.'</text>';
    $r[$c]=15+$x*15;
}
for($i=0;++$i<strlen($w);){
    echo '<path d="M '.($r[$w[$i-1]]).',105 A '.($radius=abs($r[$w[$i]]-$r[$w[$i-1]])/2).' '.($radius).' 0 0 0 '.($r[$w[$i]]).',105" style="stroke:gold; stroke-width:1px;fill:none;" />';
}
echo '</svg>';  

dans l'extrait est le résultat du SVG que j'ai créer

<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 -100 420 400"><title>Swirl Word</title><desc>Viualize a Word</desc><text x="210" y="-50"  text-anchor="middle" font-family="arial">KILLINGNESS</text><text x="15" y="110" text-anchor="middle" font-family="arial">A</text><text x="30" y="110" text-anchor="middle" font-family="arial">B</text><text x="45" y="110" text-anchor="middle" font-family="arial">C</text><text x="60" y="110" text-anchor="middle" font-family="arial">D</text><text x="75" y="110" text-anchor="middle" font-family="arial">E</text><text x="90" y="110" text-anchor="middle" font-family="arial">F</text><text x="105" y="110" text-anchor="middle" font-family="arial">G</text><text x="120" y="110" text-anchor="middle" font-family="arial">H</text><text x="135" y="110" text-anchor="middle" font-family="arial">I</text><text x="150" y="110" text-anchor="middle" font-family="arial">J</text><text x="165" y="110" text-anchor="middle" font-family="arial">K</text><text x="180" y="110" text-anchor="middle" font-family="arial">L</text><text x="195" y="110" text-anchor="middle" font-family="arial">M</text><text x="210" y="110" text-anchor="middle" font-family="arial">N</text><text x="225" y="110" text-anchor="middle" font-family="arial">O</text><text x="240" y="110" text-anchor="middle" font-family="arial">P</text><text x="255" y="110" text-anchor="middle" font-family="arial">Q</text><text x="270" y="110" text-anchor="middle" font-family="arial">R</text><text x="285" y="110" text-anchor="middle" font-family="arial">S</text><text x="300" y="110" text-anchor="middle" font-family="arial">T</text><text x="315" y="110" text-anchor="middle" font-family="arial">U</text><text x="330" y="110" text-anchor="middle" font-family="arial">V</text><text x="345" y="110" text-anchor="middle" font-family="arial">W</text><text x="360" y="110" text-anchor="middle" font-family="arial">X</text><text x="375" y="110" text-anchor="middle" font-family="arial">Y</text><text x="390" y="110" text-anchor="middle" font-family="arial">Z</text><path d="M 165,105 A 15 15 0 0 0 135,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 135,105 A 22.5 22.5 0 0 0 180,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 180,105 A 0 0 0 0 0 180,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 180,105 A 22.5 22.5 0 0 0 135,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 135,105 A 37.5 37.5 0 0 0 210,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 210,105 A 52.5 52.5 0 0 0 105,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 105,105 A 52.5 52.5 0 0 0 210,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 210,105 A 67.5 67.5 0 0 0 75,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 75,105 A 105 105 0 0 0 285,105" style="stroke:gold; stroke-width:1px;fill:none;" /><path d="M 285,105 A 0 0 0 0 0 285,105" style="stroke:gold; stroke-width:1px;fill:none;" /></svg>

Haskell, 148 octets

z f=tail>>=zipWith f
g c=and.z c.filter(/=0).map abs.z(-).map fromEnum
(a:b:r)%c|a==b=(b:r)%c|1<3=c a b
f s|a<-[g(>=)s,g(<=)s]=or a:a++[s%(<),s%(>)]

Essayez-le sur Ideone.

Les entrées doivent être toutes les lettres majuscules ou minuscules.
La sortie est une liste de cinq booléens: [SW?, CF?, CP?, CW?, CC?].

f "positive" -> [True,True,False,False,True]

Cela s'est avéré plus long que prévu, en particulier le traitement de la réduction des caractères répétés prend environ 40 octets.

Au début, je n'ai comparé que les deux premiers caractères pour céder CWou CCavant de remarquer que les cas de test sont valables bbaou bbcvalables aussi et que cette approche est vaincue .

Python, 152 octets:

lambda C:[C[-1]in max(C)+min(C),C[1]>C[0]]*all([[i>g,i<g][[h%2>0,h%2<1][C[1]>C[0]]]for i,g,h in filter(lambda i:i[0]!=i[1],zip(C,C[1:],range(len(C))))])

Une fonction lambda anonyme. Appeler comme print(<Function Name>('<String>')).

Prend les entrées en minuscules ou majuscules, mais pas en majuscules.

Génère un tableau ne contenant rien ( []) si le mot n'est pas swirly, ou un tableau au format suivant:

• 1er élément est True/Falsepour Centrifugal/Centripetal.
• 2ème élément est True/Falsepour Clockwise/Counterclockwise.

Essayez-le en ligne! (Idéone)