Não me pergunte como ou por que, mas enquanto codificava em um projeto, notei que os caracteres de algumas palavras tinham um padrão específico referente ao alfabeto, liguei cada caractere das palavras com o lápis no alfabeto e obtive dois espirais, então notei que a primeira espiral era no sentido horário e a outra no sentido anti-horário, e outras características ... então eu as nomeei Swirling Words !

Uma palavra em redemoinho pode ser:

1. no sentido horário ou anti-horário
2. centrípeto ou centrífugo

Aqui estão alguns exemplos de Swirling Words :

Tarefa 1:

Escreva um programa ou função completa que retire uma palavra da entrada padrão e faça a saída se for uma palavra em redemoinho e suas características, em um formato legível, texto estendido, 3 caracteres, sinalizadores, etc.

Casos de teste e saídas de exemplo para palavras diferentes (mas você pode decidir como representar os resultados):

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

Regras:

1. A conexão entre os dois primeiros caracteres deve estar ativa (como nos gráficos), toda a conexão uniforme deve estar desativada , todas as conexões ímpares devem estar ativadas .
2. Você pode ignorar maiúsculas / minúsculas ou considerar / converter tudo em maiúsculas ou tudo em minúsculas.
3. As palavras de entrada são apenas caracteres no intervalo do alfabeto de AZ, sem espaços, sem pontuação, etc.
4. Se uma palavra tiver caracteres duplos, como "GROOVE", você deverá recolher as dobras para um caractere: "GROOVE"> "GROVE".
5. As palavras de entrada conterão pelo menos 3 caracteres distintos. Palavras como "MOM", "DAD", "LOL" não são válidas.
6. É possível passar várias vezes no mesmo personagem, como "IRIS".
7. O menor código vence.

Tarefa 2:

Para obter mais reputação, encontre as palavras Swirling mais longas e suas características que você pode encontrar no dicionário de inglês, seguindo as regras acima. Você pode tomar, por exemplo, como referência a lista completa das palavras em inglês aqui .

Feliz codificação!

MATL , 33 31 30 bytes

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

A entrada está em letras maiúsculas (ou em letras minúsculas, mas não mista).

A saída é:

• Se a palavra não estiver girando: nenhuma saída será produzida
• Se estiver girando: dois números são produzidos em linhas diferentes:
  • O primeiro número 1/ -1 indica centrífugo / centrípeto.
  • O segundo número 1/ `-1 'indica no sentido horário / anti-horário.

Experimente online! Ou verifique todos os casos de teste (código modificado para receber todas as entradas e produzir os dois números de saída na mesma linha)

Explicação

Vamos dar 'OPERAA'um exemplo como exemplo.

A primeira parte do código remove letras duplas:

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'

Agora, verificamos se as distâncias entre as letras não são decrescentes (condição necessária para a palavra girar):

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]

Em seguida, verificamos se as letras vão e voltam (essa é a outra condição para a palavra estar girando):

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]

Por fim, verificamos se as duas condições se mantêm e, nesse caso, produzimos a saída:

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 bytes

Agradecemos ao JHM por salvar 6 bytes e torná-lo sem distinção entre maiúsculas e minúsculas!

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

Função sem nome que pega uma string e retorna uma lista aninhada de booleanos no formulário {{B1,B2},B3,B4}. B4 registra se a palavra está girando (e, se não estiver, o restante da saída será lixo). Se a palavra estiver girando, B1 registra se a palavra é centrífuga, B2 registra se a palavra é centrípeta e B3 registra se a palavra é no sentido horário (True) ou no sentido anti-horário (False).

Aqui está uma versão mais longa que o pós-processos (de primeira linha) A função acima (espaçados ao longo das linhas 2 a 5 de) para torná-lo idêntico ao OP: NOse a palavra não está rodando, e a escolha adequada de {SW,CF,CW}, {SW,CF,CC}, {SW,CP,CW}ou {SW,CP,CC}se a palavra está girando:

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} &

A explicação é a mesma da resposta CJam de Martin Ender, com uma nota adicional: a lista de diferenças consecutivas deve alternar em sinal para que a palavra esteja girando, e isso pode ser detectado ao garantir que todos os produtos de pares de diferenças consecutivas sejam negativos (é isso que Max[Most[d]Rest@d]<0faz).

Executando a função em todas as mais de 40.000 palavras do Mathematica WordList[], encontramos as seguintes palavras de turbilhão de 8 letras, que são as mais longas de seus respectivos tipos de turbilhão:

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 aponta positivepara não ter letras duplas e menos letras repetidas que stowaway.)

Mas o campeão absoluto é a palavra centrípeta de 9 letras que gira no sentido anti-horário vassalage!

Scala, 110 bytes

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

Retorna uma tupla (a,b)com

• a == 1 se s é centrípeto
• a == 0 se s é centrífugo
• a == -1 se s não está rodando

e

• b == true se s é no sentido horário
• b == false se s estiver no sentido anti-horário
• b pode ser verdadeiro ou falso se s não estiver girando

Explicação:

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.
  )
}

Gelatina , 30 bytes

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

TryItOnline
Ou veja os casos de teste (com uma pequena alteração, pois o últimoÑapontaria para o novo link principal)

(Minha falta de habilidade em encadeamento provavelmente está custando alguns bytes aqui)
Tudo em cima ou em baixo.
Retorna uma lista de sinalizadores [D, F, S]:
S: girando = 1 / não girando = 0
F: centrífugo = 1 (circular = 0) centrípeto = -1
D: no sentido horário = 1 / no sentido anti-horário = -1
- se S = 0 os outros sinalizadores ainda são avaliados, apesar de não conterem informações úteis.

Quão?

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 bytes

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

Experimente online!

A entrada pode ser maiúscula ou minúscula, mas não mista.

O programa indica inadvertidamente palavras que não são necessariamente centrífugas ou centrípetas, mas que atendem aos requisitos de espiral. Eles são descritos como "circulares" no gráfico abaixo.

Para interpretar a saída, use este gráfico:

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)

Explicação:

O programa realmente avalia se a sequência de diferenças diferentes de zero entre os caracteres inicia positiva ou negativa, se alterna no sinal, se as magnitudes começam a aumentar ou diminuir, e se continua a fazê-lo. Se as magnitudes não aumentarem ou diminuírem, o programa será interrompido operando em uma matriz vazia. As principais etapas são mostradas abaixo (este código também mostrará o progresso da pilha):

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 bytes

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;

para uma saída mais bonita echo["n","+P","-P","+F","-F"][$s];

Versão expandida

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

Valor da tarefa 2 segundo sem regra de dobra curta

4 -F killness 11 Bytes positivize 10 Bytes

3 + F opositivo log de 10 bytes 9 bytes

Vassalagem 2-P 9 bytes sarcocol, sasarara 8 bytes

Avaliação 1 + P 9 bytes Captage, aramaic, argonon, auction, avision, concedido, crenele, exesion, exition, eyewink 7 bytes

Visualize uma palavra

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>';  

no snippet é o resultado do SVG que eu criei

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

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%(>)]

Experimente em Ideone.

A entrada deve estar em letras minúsculas ou todas em maiúsculas.
A saída é uma lista de cinco booleans: [SW?, CF?, CP?, CW?, CC?].

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

Isso ficou mais do que o esperado, especialmente entregar o recolhimento de caracteres repetidos leva cerca de 40 bytes.

No começo eu comparados apenas os primeiros dois caracteres para produzir CWou CCantes de notar que os casos de teste como bbaou bbcsão válidos também e derrotar esta abordagem.

Python, 152 bytes:

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

Uma função lambda anônima. Ligar como print(<Function Name>('<String>')).

Recebe a entrada como todas minúsculas ou maiúsculas, mas não com maiúsculas e minúsculas.

Gera uma matriz que não contém nada ( []) se a palavra não for swirly ou uma matriz no seguinte formato:

• O primeiro elemento é True/Falsepara Centrifugal/Centripetal.
• O segundo elemento é True/Falsepara Clockwise/Counterclockwise.

Experimente Online! (Ideona)