Non chiedermi come o perché, ma durante la programmazione di un progetto ho notato che i caratteri di un paio di parole avevano un modello particolare riferito all'alfabeto, ho collegato ogni carattere delle parole con la matita sull'alfabeto e ho ottenuto due spirali, poi ho notato che la prima spirale era in senso orario e l'altra in senso antiorario, e altre caratteristiche ... così le ho nominate Parole turbinanti !

Una parola vorticosa può essere:

1. in senso orario o antiorario
2. centripeto o centrifugo

Ecco alcuni esempi di Swirling Words :

Compito 1:

Scrivi un programma completo o una funzione che prenderà una parola dall'input standard e verrà emesso se è una parola vorticosa e le sue caratteristiche, in un formato leggibile, testo esteso, 3 caratteri, bandiere, ecc.

Casi di test ed esempi di output per parole diverse (ma puoi decidere come rappresentare i risultati):

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

Regole:

1. La connessione tra i primi due caratteri deve essere attiva (come nella grafica), tutta la connessione pari deve essere inattiva , tutte le connessioni dispari devono essere attive .
2. È possibile ignorare le maiuscole / minuscole o considerare / convertire tutto in maiuscolo o tutto in minuscolo.
3. Le parole di input sono solo caratteri nell'intervallo alfabetico di AZ, nessuno spazio, nessuna punteggiatura, ecc.
4. Se una parola ha caratteri doppi, come "GROOVE", devi comprimere i doppi in un carattere: "GROOVE"> "GROVE".
5. Le parole di input conterranno almeno 3 caratteri distinti. Parole come "MOM", "DAD", "LOL" non sono parole valide.
6. È possibile passare più volte nello stesso personaggio, come "IRIS".
7. Il codice più corto vince.

Compito 2:

Per ottenere più reputazione, trova le parole vorticose più lunghe e le sue caratteristiche che puoi trovare nel dizionario inglese, seguendo le regole di cui sopra. Puoi prendere ad esempio come riferimento l'elenco completo delle parole inglesi qui .

Buona programmazione!

MATL , 33 31 30 byte

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

L'input è in lettere maiuscole (o in lettere minuscole, ma non miste).

L'output è:

• Se la parola non è vorticosa: non viene prodotto alcun output
• Se vortica: vengono prodotti due numeri in righe diverse:
  • Primo numero 1/ -1 indica centrifugo / centripeto.
  • Il secondo numero 1/ `-1 'indica in senso orario / antiorario.

Provalo online! Oppure verifica tutti i casi di test (codice modificato per accettare tutti gli input e produrre i due numeri di output sulla stessa riga)

Spiegazione

Prendiamo l'input 'OPERAA'come esempio.

La prima parte del codice rimuove le doppie lettere:

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'

Ora controlliamo se le distanze tra le lettere non sono decrescenti (condizione necessaria affinché la parola sia vorticosa):

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]

Quindi controlliamo se le lettere vanno avanti e indietro (questa è l'altra condizione per la parola che vortica):

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]

Infine, controlliamo se le due condizioni sono valide e in tal caso producono l'output:

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 byte

Grazie a JHM per il salvataggio di 6 byte e per l'avvio senza distinzione tra maiuscole e minuscole!

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

Funzione senza nome che accetta una stringa e restituisce un elenco nidificato di booleani nel modulo {{B1,B2},B3,B4}. B4 registra se la parola è vorticosa (e in caso contrario, il resto dell'output è immondizia). Se la parola vortica, allora B1 registra se la parola è centrifuga, B2 registra se la parola è centripeta e B3 registra se la parola è in senso orario (Vero) o antiorario (Falso).

Ecco una versione più quello post-processi (prima riga) la funzione di cui sopra (distanziati sulle linee 2a-5a) per renderlo identico al OP: NOse la parola non è vorticoso, e la scelta appropriata di {SW,CF,CW}, {SW,CF,CC}, {SW,CP,CW}, o {SW,CP,CC}se la parola è vorticosa:

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 spiegazione è la stessa della risposta CJam di Martin Ender, con una nota aggiuntiva: l'elenco delle differenze consecutive deve alternarsi nel segno affinché la parola sia vorticosa, e ciò può essere rilevato assicurandosi che tutti i prodotti di coppie di differenze consecutive siano negativi (è quello che Max[Most[d]Rest@d]<0fa).

Eseguendo la funzione su tutte le oltre 40.000 parole di Mathematica WordList[], troviamo le seguenti parole vorticose di 8 lettere, che sono le più lunghe dei rispettivi tipi di vortice:

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 indica di positivenon avere doppie lettere e meno lettere ripetute di stowaway.)

Ma il campione assoluto è la parola centripeta vorticosa in senso antiorario di 9 lettere vassalage!

Scala, 110 byte

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

Restituisce una tupla (a,b)con

• a == 1 se s è centripeto
• a == 0 se s è centrifugo
• a == -1 se s non vortica

e

• b == true se s è in senso orario
• b == false se s è antiorario
• b può essere vero o falso se s non vortica

Spiegazione:

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 byte

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

TryItOnline
Oppure visualizza i casi di test (con una leggera modifica poiché l'ultimoÑindica un nuovo link principale)

(La mia mancanza di abilità di concatenamento probabilmente sta costando alcuni byte qui)
Tutti in alto o in basso.
Restituisce un elenco di flag [D, F, S]:
S: rotazione = 1 / non rotazione = 0
F: centrifuga = 1 (circolare = 0) centripeta = -1
D: senso orario = 1 / senso antiorario = -1
- se S = 0 gli altri flag vengono comunque valutati anche se non contengono informazioni utili.

Come?

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 byte

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

Provalo online!

L'input può essere maiuscolo o minuscolo, ma non misto.

Il programma indica inavvertitamente parole che non sono necessariamente centrifughe o centripete, ma che altrimenti soddisfano i requisiti della spirale. Questi sono descritti come "circolari" nella tabella seguente.

Per interpretare l'output utilizzare questo grafico:

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)

Spiegazione:

Il programma in realtà valuta se la sequenza di differenze diverse da zero tra i caratteri inizia positiva o negativa, se si alterna in segno, se le magnitudini iniziano ad aumentare o diminuire e se continua a farlo. Se le dimensioni non aumentano o diminuiscono, il programma si interrompe operando su un array vuoto. Di seguito sono mostrati i passaggi principali (questo codice mostra anche l'avanzamento dello stack):

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 byte

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;

per un output più carino echo["n","+P","-P","+F","-F"][$s];

Versione estesa

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

Valore dell'attività 2 secondi senza regola dei doppi brevi

Killingness 4 -F 11 byte positivizzano 10 byte

3 + F opposto 10 byte logogogo 9 byte

2 -P vassalage 9 Bytes sarcocol, sasarara 8 Bytes

1 + P assession 9 Byte apanage, aramaic, argonon, asta, avision, premiato, crenele, exesion, exition, eyewink 7 Bytes

Visualizza una parola

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

nello snippet è il risultato dell'SVG che ho creato

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

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

Provalo su Ideone.

L'ingresso deve essere sia maiuscolo che minuscolo.
L'uscita è una lista di cinque booleani: [SW?, CF?, CP?, CW?, CC?].

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

Ciò si è rivelato più lungo del previsto, in particolare passare il crollo di caratteri ripetuti richiede circa 40 byte.

All'inizio ho confrontato solo i primi due personaggi per cedere CWo CCprima di notare che anche i test sono simili bbao bbcvalidi e hanno sconfitto questo approccio.

Python, 152 byte:

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 funzione lambda anonima. Chiama come print(<Function Name>('<String>')).

Accetta l'input come tutto minuscolo o maiuscolo, ma non in maiuscolo / minuscolo .

Emette un array che non contiene nulla ( []) se la parola non è swirly, oppure un array nel seguente formato altrimenti:

• 1 ° elemento è True/Falseper Centrifugal/Centripetal.
• 2 ° elemento è True/Falseper Clockwise/Counterclockwise.

Provalo online! (Ideone)