No me pregunten cómo ni por qué, pero mientras codificaba un proyecto noté que los caracteres de un par de palabras tenían un patrón particular referido al alfabeto, conecté cada carácter de las palabras con el lápiz en el alfabeto y obtuve dos espirales, luego me di cuenta de que la primera espiral era en sentido horario y la otra era en sentido antihorario, y otras características ... ¡así que las llamé palabras remolino !

Una palabra arremolinada puede ser:

1. en sentido horario o antihorario
2. centrípeto o centrífugo

Aquí hay algunos ejemplos de palabras en remolino :

Tarea 1:

Escriba un programa o función completa que tomará una palabra de la entrada estándar y dará salida si es una Palabra Remolina y sus características, en un formato legible, texto extendido, 3 caracteres, banderas, etc.

Casos de prueba y ejemplos de resultados para diferentes palabras (pero puede decidir cómo representar los 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

Reglas:

1. La conexión entre los dos primeros caracteres debe estar activa (como en los gráficos), toda la conexión par debe estar desactivada , todas las conexiones impares deben estar activadas .
2. Puede ignorar mayúsculas / minúsculas o considerar / convertir todo a mayúsculas o todo a minúsculas.
3. Las palabras de entrada son solo caracteres en el rango alfabético de AZ, sin espacios, sin signos de puntuación, etc.
4. Si una palabra tiene caracteres dobles, como "GROOVE", debe contraer los dobles a un carácter: "GROOVE"> "GROVE".
5. Las palabras de entrada contendrán al menos 3 caracteres distintos. Palabras como "MOM", "DAD", "LOL" no son palabras válidas.
6. Es posible pasar varias veces en el mismo personaje, como "IRIS".
7. El código más corto gana.

Tarea 2:

Para obtener más reputación, encuentre las palabras de remolino más largas , y sus características, que puede encontrar en el diccionario de inglés, siguiendo las reglas anteriores. Puede tomar como referencia la lista completa de las palabras en inglés aquí .

¡Feliz codificación!

MATL , 33 31 30 bytes

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

La entrada está en letras mayúsculas (o en letras minúsculas, pero no mezcladas).

Salida es:

• Si la palabra no gira: no se produce salida
• Si está girando: se producen dos números en diferentes líneas:
  • Primer número 1/ -1 indica centrífugo / centrípeto.
  • El segundo número 1/ '-1' indica en sentido horario / antihorario.

Pruébalo en línea! O verifique todos los casos de prueba (código modificado para tomar todas las entradas y producir los dos números de salida en la misma línea)

Explicación

Tomemos la entrada 'OPERAA'como un ejemplo.

La primera parte del código elimina letras dobles:

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'

Ahora verificamos si las distancias entre las letras no disminuyen (condición necesaria para que la palabra se arremoline):

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]

Luego verificamos si las letras van y vienen (esta es la otra condición para que la palabra se arremoline):

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 último, verificamos si se cumplen las dos condiciones y, en ese caso, producimos la salida:

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

¡Gracias a JHM por guardar 6 bytes y hacer que no sea sensible a mayúsculas y minúsculas para arrancar!

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

Función sin nombre que toma una cadena y devuelve una lista anidada de booleanos en el formulario {{B1,B2},B3,B4}. B4 registra si la palabra está girando (y si no es así, el resto de la salida es basura). Si la palabra gira, entonces B1 registra si la palabra es centrífuga, B2 registra si la palabra es centrípeta y B3 registra si la palabra es en sentido horario (Verdadero) o en sentido antihorario (Falso).

Aquí hay una versión más larga que el post-procesos (primera línea) la función anterior (espaciados sobre las líneas 2 al 5) para que sea idéntica a la OP: NOSi la palabra no está girando, y la elección apropiada de {SW,CF,CW}, {SW,CF,CC}, {SW,CP,CW}, o {SW,CP,CC}si la palabra se arremolina:

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

La explicación es la misma que en la respuesta CJam de Martin Ender, con una nota adicional: la lista de diferencias consecutivas debe alternar en el signo de que la palabra se arremolina, y eso se puede detectar asegurándose de que todos los productos de pares de diferencias consecutivas sean negativos (eso es lo que Max[Most[d]Rest@d]<0hace).

Al ejecutar la función en todas las más de 40,000 palabras de Mathematica WordList[], encontramos las siguientes palabras de remolino de 8 letras, que son las más largas de sus respectivos tipos de remolino:

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 señala que positiveno tiene letras dobles y menos letras repetidas que stowaway).

¡Pero el campeón absoluto es la palabra centrípeta de 9 letras que gira en sentido antihorario 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))}

Devuelve una tupla (a,b)con

• a == 1 si s es centrípeto
• a == 0 si s es centrífugo
• a == -1 si s no está girando

y

• b == true si s es en sentido horario
• b == false si s es en sentido antihorario
• b puede ser verdadero o falso si s no gira

Explicación:

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

Jalea , 30 bytes

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

TryItOnline
O vea los casos de prueba (con un ligero cambio ya que el últimoÑapuntaría al nuevo enlace principal)

(Mi falta de habilidad para encadenar probablemente esté costando unos pocos bytes aquí)
Todos los superiores o todos los inferiores.
Devuelve una lista de banderas [D, F, S]:
S: girando = 1 / no girando = 0
F: centrífuga = 1 (circular = 0) centrípeta = -1
D: en sentido horario = 1 / en sentido antihorario = -1
- si S = 0 las otras banderas aún se evalúan a pesar de que no contienen información útil.

¿Cómo?

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=\(-!

Pruébalo en línea!

La entrada puede ser mayúscula o minúscula, pero no mixta.

El programa señala inadvertidamente palabras que no son necesariamente centrífugas o centrípetas, pero que cumplen con los requisitos de ser espirales. Estos se describen como "circulares" en el cuadro a continuación.

Para interpretar el resultado, 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)

Explicación:

El programa realmente evalúa si la secuencia de diferencias distintas de cero entre caracteres comienza positiva o negativa, si alterna en signo, si las magnitudes comienzan aumentando o disminuyendo, y si continúa haciéndolo. Si las magnitudes no aumentan o disminuyen, el programa se interrumpe al operar en una matriz vacía. Los pasos principales se muestran a continuación (este código también mostrará el progreso de la pila):

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 una salida más bonita echo["n","+P","-P","+F","-F"][$s];

Versión ampliada

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

Tarea 2 segundo valor sin regla de dobles cortos

4 -F matanza 11 Bytes positivizar 10 Bytes

3 + F opuesto 10 Bytes logogogue 9 Bytes

Vasallaje 2 -P 9 Bytes sarcocol, sasarara 8 Bytes

Evaluación 1 + P 9 bytes apanage, arameo, argón, subasta, avision, premiado, crenele, exesion, exition, eyewink 7 bytes

Visualiza una palabra

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

en el fragmento es el resultado del SVG que he creado

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

Pruébalo en Ideone.

La entrada debe ser mayúscula o minúscula.
La salida es una lista de cinco booleanos: [SW?, CF?, CP?, CW?, CC?].

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

Esto resultó más de lo esperado, especialmente la entrega del colapso de caracteres repetidos toma alrededor de 40 bytes.

Al principio comparé solo los dos primeros caracteres para producir CWo CCantes de notar que los casos de pruebabba o bbcson válidas también y derrotar a este enfoque.

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

Una función lambda anónima. Llamar como print(<Function Name>('<String>')).

Toma la entrada en minúsculas o mayúsculas, pero no en minúsculas.

Emite una matriz que no contiene nada ([] ) si la palabra no es swirly, o una matriz en el siguiente formato de lo contrario:

• 1er elemento es True/False para Centrifugal/Centripetal.
• El segundo elemento es True/Falsepara Clockwise/Counterclockwise.

¡Pruébelo en línea! (Ideona)