Palavras amadeiradas, pequenas palavras


35

Nota: Existem algumas palavras rudes nesta pergunta.

Há um quebra-cabeça implícito nesse esboço clássico do Monty Python (você também pode preparar o script online).

Várias frases são descritas como 'woody' ou 'tinny', e uma é descrita como sendo 'PVC'.

Dada uma frase, responda com seu tipo de acordo com as seguintes listas:

woody:

gone
sausage
seemly
prodding
vacuum
bound
vole
caribou
intercourse
pert
thighs
botty
erogenous zone
ocelot
wasp
yowling

tinny:

litter bin
newspaper
antelope
recidivist
tit
simpkins

PVC:

leap

Regras

  • Se a entrada pertencente a uma das listas acima, a saída deve ser woody, tinnyou PVC, em conformidade.
  • Toda entrada é minúscula.
  • Qualquer comportamento é aceitável para frases que não estão listadas acima.
  • O menor número de bytes na resposta vence.

@AJFaraday Eu recomendo passar algum tempo no site e responder a algumas perguntas antes de iniciar a difícil tarefa de escrever desafios. Quando você se sentir pronto, use a caixa de areia , pelo menos nos seus primeiros desafios e também em desafios não triviais.
Adám 5/0318

27
Eu não gosto dessa recomendação! Continue postando desafios, mesmo que você não goste de responder. É claro que é bom olhar para outros desafios para ter uma ideia do site, e eu recomendo o Sandbox também, mas continue escrevendo desafios! :)
Stewie Griffin

5
Então, devemos aplicar a lógica a um esboço de Monty Python? ...excelente!
precisa saber é o seguinte

@BruceWayne é exatamente isso que estamos fazendo.
precisa saber é o seguinte

You may choose how to deal (or ignore) with casing in input and output.Para esclarecer, isso significa que podemos esperar que a entrada esteja em maiúsculas?
Οurous

Respostas:


4

Stax , 30 25 bytes

ï═H♣║GÇX→ΩM+@╢^j╬♪►╨╝ô╤c\

Execute e depure

A representação ascii comentada é essa. Eu não inventei esse algoritmo. É descaradamente arrancado da solução python de Jonathan Allen .

9@                  10th character, modularly indexed
`#!z"pi0$L+%v9`X    store "tinny pvc woody" in the x register
3(                  keep only the first 3 characters ("tin")
#                   how many times the 10th char occurs in tin? (a)
y.eaI               index of "ea" in the input or -1 (b)
+                   a + b (one of -1, 0, or 1)
xj@                 modularly indexed word in x

Execute este


Esta resposta é boa, mas o compressor literal de strings é incorreto, às vezes produz resultados com 5 caracteres (se você incluir o `, 7) para strings de 4 caracteres.
Weijun Zhou

Nem sempre é garantido que a compressão produz um resultado menor. Geralmente apenas para strings em inglês. Isso não é um bug. Se você tiver um caso em que uma string com aspas duplas é menor, use-a.
recursivo

Eu pensei que era como da geléia que encontra sempre a representação mais curto (talvez a descrição deve ser reformulado, então?)
Weijun Zhou

Deixa pra lá. Eu acho que dizer can help youé um pouco confuso, mas tudo bem logicamente.
Weijun Zhou

Hum, sim, as palavras são meio enganosas.
recursivo

35

Python 2 , 99 73 65 64 63 bytes

lambda s:'PVC'*('ea'in s)or'wtoiondnyy'[s[-2:]in'instperit'::2]

Experimente online!

Alternativas também com 63 bytes:

lambda s:'PVC'*('ea'in s)or'wtoiondnyy'[s[-6::5]in'dtenmsr'::2]
lambda s:'PVC'*('ea'in s)or'wtoiondnyy'[s[::5]in'lrinaosit'::2]

23
Promovido pelo uso de python para resolver um desafio de monty python.
Brain Guider

10
@AnderBiguri, dê seu voto com base na solução em si e não no idioma usado.
Shaggy

24
@Shaggy AFAIK, a escolha do idioma é uma das partes divertidas do PPCG! Eu gosto da solução, porque é em python . Nós já temos os bytes para ver qual deles "ganha"
Cérebro Guider

2
Sim, os votos no codegolf devem ser apenas para a abordagem considerada melhor ou mais criativa, pois o vencedor é determinado de outra forma. Também seria chato se todos apenas utilizado linguagens especiais codegolf em vez de ficar criativo com mais comuns
Gimli

5
Concordo, pode haver muitas razões para gostar de uma resposta específica. Mas mesmo que as pessoas estejam tão empolgadas com o trocadilho do "Python para Monty Python", ainda é triste ver que os promotores não se incomodam em rolar um pouco para baixo e mostram alguma apreciação por outra resposta do Python que é realmente menos convencional e até pouco mais curto ...
Kirill L.

15

Python 2 , 62 bytes

lambda n:'wtPoiVonCdn yy'[hash(n)%97%78%28%15%2+('ea'in n)::3]

Experimente online!

Quão?

Esse envio usa o fato de que a hashfunção é estável para seqüências de caracteres no Python 2. Cada entrada válida possui uma saída válida. O módulo repetido de força bruta %97%78%28%15%2retorna 1para todas as palavras minúsculas e PVC e 0para palavras amadeiradas . Ao adicionar o valor ('ea' in n)a ele, temos 2em vez de 1para a entrada de 'salto'. Aqui está uma tabela de todos os valores:

+----------------+----------------------+----------------+-------------+-------+
| word           | hash                 | %97%78%28%15%2 | +('ea'in n) | type  |
+----------------+----------------------+----------------+-------------+-------+
| leap           | 5971033325577305778  | 1              | 2           | PVC   |
+----------------+----------------------+----------------+-------------+-------+
| litter bin     | 2393495108601941061  | 1              | 1           | tinny |
| newspaper      | 1961680444266253688  | 1              | 1           | tinny |
| antelope       | -2930683648135325182 | 1              | 1           | tinny |
| recidivist     | -1480015990384891890 | 1              | 1           | tinny |
| tit            | -1495230934635649112 | 1              | 1           | tinny |
| simpkins       | 672871834662484926   | 1              | 1           | tinny |
+----------------+----------------------+----------------+-------------+-------+
| gone           | 3644900746337488769  | 0              | 0           | woody |
| sausage        | 4880706293475915938  | 0              | 0           | woody |
| seemly         | -8112698809316686755 | 0              | 0           | woody |
| prodding       | 7325980211772477495  | 0              | 0           | woody |
| vacuum         | -5283515051184812457 | 0              | 0           | woody |
| bound          | -6522768127315073267 | 0              | 0           | woody |
| vole           | -7823607590901614336 | 0              | 0           | woody |
| caribou        | -3644594841083815940 | 0              | 0           | woody |
| intercourse    | 2499732157679168166  | 0              | 0           | woody |
| pert           | 4142553773863848247  | 0              | 0           | woody |
| thighs         | -3490317966011085195 | 0              | 0           | woody |
| botty          | -6522767127163072681 | 0              | 0           | woody |
| erogenous zone | 7046120593231489339  | 0              | 0           | woody |
| ocelot         | -6961879712146820842 | 0              | 0           | woody |
| wasp           | -3668927459619339511 | 0              | 0           | woody |
| yowling        | 6823632481520320220  | 0              | 0           | woody |
+----------------+----------------------+----------------+-------------+-------+

O tipo a ser retornado agora é extraído da sequência 'wtPoiVonCdn yy', pegando cada terceiro caractere, começando no índice calculado.


10

JavaScript (ES6), Chrome / Edge, 54 bytes

Como o comportamento de parseInt()entradas grandes com um raio de 36 é dependente da implementação , este não funciona com o SpiderMonkey (Firefox).

s=>[,'PVC',,'Tinny'][parseInt(s+383,36)%69%7]||'Woody'

Experimente online!

Quão?

A função hash retorna 3 para palavras Tinny, 1 para PVC e 0 , 4 , 5 ou 6 para palavras Woody. As palavras marcadas com um asterisco são implicitamente truncadas porque o espaço é considerado como um caractere inválido por parseInt () .

word           | +383           | base 36 -> decimal    | mod 69 | mod 7
---------------+----------------+-----------------------+--------+------
gone           | gone383        |           36318994131 |   54   |   5
sausage        | sausage383     |      2874302392811475 |   42   |   0
seemly         | seemly383      |        80120017777107 |    6   |   6
prodding       | prodding383    |     94214834629477200 |   12   |   5
vacuum         | vacuum383      |        88266035564499 |   60   |   4
bound          | bound383       |          916101808275 |    6   |   6
vole           | vole383        |           68967369939 |   39   |   4
caribou        | caribou383     |      1249086300450771 |   63   |   0
intercourse    | intercourse383 | 3.183324871563264e+21 |   11   |   4
pert           | pert383        |           55312791699 |   21   |   0
thighs         | thighs383      |        83184557510739 |    6   |   6
botty          | botty383       |          916052399571 |   63   |   0
erogenous zone | erogenous (*)  |        41664605989780 |    7   |   0
ocelot         | ocelot383      |        68678794158483 |   39   |   4
wasp           | wasp383        |           70309896339 |   63   |   0
yowling        | yowling383     |      3523299657958227 |   39   |   4
---------------+----------------+-----------------------+--------+------
litter bin     | litter (*)     |            1301413923 |   24   |   3
newspaper      | newspaper383   |   3081816298632183000 |    3   |   3
antelope       | antelope383    |     38980419895881940 |   24   |   3
recidivist     | recidivist383  | 129824740122576960000 |    3   |   3
tit            | tit383         |            1785109395 |   45   |   3
simpkins       | simpkins383    |    104264583727840850 |   24   |   3
---------------+----------------+-----------------------+--------+------
leap           | leap383        |           46576922259 |   57   |   1

Versão anterior, 59 57 bytes

s=>['Woody','Tinny','PVC'][82178>>parseInt(s,35)%50%26&3]

Experimente online!

Quão?

Abaixo estão as diferentes etapas da função para cada entrada. O resultado do primeiro módulo é uma aproximação dentro da precisão dos números JS e é matematicamente inválido para a relação sexual .

input          | base-35 -> dec.   | %50 | %26 | 00000000010100000100000010
---------------+-------------------+-----+-----+---------------------------
gone           |            716219 |  19 |  19 |      00------------------>
sausage        |       52042888324 |  24 |  24 | 00----------------------->
seemly         |        1492249219 |  19 |  19 |      00------------------>
prodding       |     1659396207121 |  21 |  21 |    00-------------------->
vacuum         |        1643736697 |  47 |  21 |    00-------------------->
bound          |          17573443 |  43 |  17 |        00---------------->
vole           |           1359274 |  24 |  24 | 00----------------------->
caribou        |       22625709220 |  20 |  20 |     00------------------->
intercourse    | 51532867489988450 |  48 |  22 |   00--------------------->
pert           |           1089999 |  49 |  23 |  00---------------------->
thighs         |        1549436973 |  23 |  23 |  00---------------------->
botty          |          17572449 |  49 |  23 |  00---------------------->
erogenous zone |    33308397234728 |  28 |   2 |                       00->
ocelot         |        1279159344 |  44 |  18 |       00----------------->
wasp           |           1385255 |   5 |   5 |                    00---->
yowling        |       63810499496 |  46 |  20 |     00------------------->
litter bin     |        1131250042 |  42 |  16 |         01--------------->
newspaper      |    52754217228642 |  42 |  16 |         01--------------->
antelope       |      687218151914 |  14 |  14 |           01------------->
recidivist     |  2160354371100934 |  34 |   8 |                 01------->
tit            |             36184 |  34 |   8 |                 01------->
simpkins       |     1835782971008 |   8 |   8 |                 01------->
leap           |            917900 |   0 |   0 |                         10


9

Java 8, 81 80 67 bytes

s->s.charAt(2)<98?"PVC":s.matches(".*(.p.|is?t).*")?"tinny":"woody"

Regex da resposta Retina de @MatrinEnder .

Experimente online.

Resposta original: 81 80 bytes

s->"anetisilire".contains(s.substring(0,2))?"tinny":s.charAt(2)<98?"PVC":"woody"

Experimente online.

Explicação:

s->                  // Method with String as both parameter and return-type
  "anetisilire".contains(s.substring(0,2))?
                     //  If the first two letters of the input are present in "anetisilire"
    "tinny"          //   Output "tinny"
   :s.charAt(2)<98?  //  Else-if the third character of the input is an 'a'
    "PVC"            //   Output "PVC"
   :                 //  Else:
    "woody"          //   Output "woody"

Explicação adicional:

litter bin:  anetisi(li)re
newspaper:   a(ne)tisilire
antelope:    (an)etisilire
recidivist:  anetisili(re)
tit:         ane(ti)silire
simpkins:    aneti(si)lire
  1. Nenhuma das duas primeiras letras das woodypalavras está presente nesta String acima, nem é lede leap.
  2. Nenhuma das woodypalavras tem um acomo terceira letra, de modo que é usado para obter leapa PVCse não é uma tinnypalavra.
  3. Tudo o resto é uma palavra da woodylista.

2
É muito legal ser capaz de ler através deste tipo de solução de problemas de pensar :)
AJFaraday

6

Haskell , 61 bytes

f(a:b:_)|b=='i'||elem a"ran"="tinny"|a=='l'="PVC"|1>0="woody"

Experimente online!

Usa essa lógica encontrada à mão:

  • Palavras com segunda carta iou primeira letra r, aoun sãotinny
  • Qualquer outra palavra que comece com l( leap) éPVC
  • Qualquer outra coisa é woody

Lynn salvou um byte verificando leapsua primeira letra.


11
Agradável! Você pode salvar um byte, detectando "leap"com |a=='l'="PVC".
Lynn

5

QuadS , 34 32 bytes

Desavergonhadamente usa o sistema de Martin Ender , incluindo o regex do regex golfista de Peter Norvig .

⊃⍵
ea
.p.|is?t
$
PVC
tinny
woody

Experimente online!

⊃⍵ escolha a primeira ocorrência de

ea "ea"
.p.|is?t  "p" cercado por letras OR "i" e "t" com um "s" opcional entre elas
$ final da entrada

… Mas substituindo as correspondências pela seguinte:

PVC
tinny
woody


O equivalente a 43 bytes função Dyalog APL de equivalente é:

'ea' '.p.|is?t' '$'S'PVC' 'tinny' 'woody'

Experimente todos os casos online!


5

C (gcc) , 81 bytes

h;f(char*s){puts(strchr("HzYfPW",h=*s^s[1]<<2&127)?"Tinny":h<120?"Woody":"PVC");}

Experimente online!

A primeira ordem do dia era encontrar alguma função de hash que separasse as palavras em suas categorias. Depois de algumas discussões, eu tropecei (s[0] ^ (s[1] << 2)) & 0x7f, onde o 0x7f está lá para reduzi-lo aos níveis ASCII imprimíveis. Isso produziu as seguintes informações (as tabelas são classificadas, mas não as seqüências resultantes):

Woody:
----
erogenous zone  - 45
prodding        8 56
yowling         E 69
vole            J 74
intercourse     Q 81
thighs          T 84
gone            [ 91
botty           ^ 94
bound           ^ 94
ocelot          c 99
pert            d 100
caribou         g 103
seemly          g 103
vacuum          r 114
wasp            s 115
sausage         w 119

[wg8r^JgQdT^-csE

Tinny:
----
litter bin      H 72
tit             P 80
simpkins        W 87
antelope        Y 89
recidivist      f 102
newspaper       z 122

HzYfPW

PVC:
----
leap            x 120

x

As colisões de hash não importam, pois são confiadas à mesma categoria. Só precisamos verificar se o hash resultante está na cadeia de hashes Tinny ("HzYfPW"), pois os hashes Woody estão todos abaixo do hash PVC (120). Se 120 ou superior, e não uma palavra Tinny, deve ser PVC. Se não for uma palavra Tinny, e o hash estiver abaixo de 120, deve ser uma palavra boa e amadeirada.


4

código de máquina x86 de 32 bits, 39 bytes

Hexdump:

69 01 47 6f 61 2c c7 02 50 56 43 00 3a c4 74 16
c7 02 77 6f 6f 64 85 c0 78 06 c7 02 74 69 6e 6e
66 c7 42 04 79 00 c3

A função hash é multiplicação por um número "mágico" 0x2c616f47. Existem apenas 6 números que podem ser usados ​​com este código.

Primeiro de tudo, ele grava PVCna saída. Isso será substituído, se necessário.

Após o hash, ele verifica a palavra PVC; a verificação é al = ah- eu a escolhi porque é uma pequena instrução de 2 bytes. Em seguida, ele grava um woodou tinn, dependendo do sinal do resultado do hash. Então, ele escreve y.

Código de montagem:

    imul eax, [ecx], 0x2c616f47;
    mov dword ptr [edx], 'CVP';
    cmp al, ah;
    je done;
    mov dword ptr [edx], 'doow';
    test eax, eax;
    js skip;
    mov dword ptr [edx], 'nnit';
skip:
    mov word ptr [edx + 4], 'y';
done:
    ret;

4

Geléia ,  27  26 bytes

⁵ịe“Ṗµ»_⁼“ḣG»$ị“©LẈḊ¶$Ḍ»Ḳ¤

Um link monádico que aceita e retorna listas de caracteres.

Experimente online!

Quão?

⁵ịe“Ṗµ»_⁼“ḣG»$ị“©LẈḊ¶$Ḍ»Ḳ¤ - Link: list of characters, W   e.g. "gone"  "leap"  "newspaper"
⁵                          - literal ten                  10
 ị                         - index into (1-based & modular)     'o'     'e'     'n'
   “Ṗµ»                    - compression of characters    "int"
  e                        - exists in?                          0       0       1
              $            - last two links as a monad
          “ḣG»             -   compression of characters  "leap"
         ⁼                 -   equal?                            0       1       0
        _                  - subtract                            0      -1       1
                         ¤ - nilad followed by link(s) as a nilad:
                “©LẈḊ¶$Ḍ»  -   compression of characters  "tinny PVC woody"
                         Ḳ -   split at spaces            ["tinny","PVC","woody"]
               ị           - index into (1-based & modular)     "woody" "PVC"   "tinny"


3

Sujo , 73 57 54 bytes

⇖'le'⇗≐∀⭦)Ẃ'nar'⇗{=]}⭨'i'=]'woody'‼␛['tinny'‼␛('PVC'‼␛

Experimente online!

Explicado:

Para uma versão mais antiga semelhante (atualizo-a quando parar de jogar)

␛‼'CVP'⇨⇖'leap'⇗≡⊭◌⬅Ẃ'nar'⇗{=]}1ẁ'i'=]'woody'‼␛['tinny'‼␛

O corpo disso é composto de:

⇖            put the input into the left stack
 'leap'      push the string "leap"
       ⇗     put that string into the right stack
        ≡    are the left and right stacks equal
         ⊭   logically negate
          ◌  skip next instruction if true
           ⬅ change direction to leftwards

Se acabarmos indo para a esquerda, temos:

       ⇨⇖'leap'⇗≡⊭◌ does stuff to the stacks, but isn't relevant
  'CVP'              push the string "PVC" (reversed, because we're going left)
 ‼                   print the string on the main stack
␛                    exit the program (this should wrap into the other exit, but that isn't working yet)

Caso contrário, isso verifica se a sequência começa com qualquer um dos "nar":

Ẃ           wipe the right stack
 'nar'      push the string "nar"
       ⇗    move string to right stack
        {
         =  compare the top of the left and right stacks
          ] goto matching bracket if true
        }   consuming loop while the right stack is true

Em seguida, verificamos se a segunda letra é "i":

1        push the number 1
 ẁ       drop ^ number of elements off of the left stack
  'i'    push "i"
     =   are the top of the left and middle stacks equal
       ] goto matching bracket if true

Se todos eles caírem, encontramos

'woody'   push the string "woody"
       ‼  print the string on the main stack
        ␛ exit the program

Se acabarmos pulando, enrolamos para

[          matching bracket for the goto
 'tinny'   push the string "tinny"
        ‼  print the string on the main stack
         ␛ exit the program

3

C # 97 bytes

string t(string w)=>w[0]!='p'&new[]{10,9,8,3}.Contains(w.Length)?"tinny":w[0]=='l'?"pvc":"woody";

Eu procurei um padrão no comprimento das strings e descobri que elas são únicas, exceto nos comprimentos 4 e 8. Portanto, eu caso especialmente as que estão observando os primeiros caracteres. Bem, ainda é mais curto que algumas respostas. :)


11
Você sabe, quando Martin Ender encontrou uma regra simples para essas listas, quase todas as respostas implementaram a mesma solução, de uma maneira ou de outra. É legal ver uma abordagem original. :)
AJFaraday

Obrigado pelo feedback. :) Eu não li outras soluções antes de tentar a minha .. talvez ainda exista uma solução mais elegante a ser descoberta .. Eu gostaria que todas tivessem comprimentos únicos, então essa seria a solução.
Lee #

2
string t(string w)=>pode ser justo w=>. Você pode converter 'p'e outros caracteres em suas representações int, eu acho. É possível remover o cólon semi fuga
TheLethalCoder

3

Python , 59 bytes

lambda w:"wtPoiVonCdn yy"[(w*4)[9]in"tin"or(w[2]<"b")*2::3]

Experimente online!

Usa a indexação da resposta Python do ovs mas uma função de escolha mais simples e mais curta:

Se a décima letra da palavra, wcom quebra automática ( (w*4)[9]- onde se w*4repete wquatro vezes) for uma letra na palavra tin ( in"tin"), a palavra será tinny ; caso contrário, se a terceira letra ( w[2]) for a ( <'b'), a palavra será PVC. caso contrário, a palavra é amadeirada .

... este 59 faz o mesmo trabalho:

lambda w:"wtPoiVonCdn yy"[[(w*4)[9]in"tin",2][w[2]<"b"]::3]


2

Lote, 145 bytes

@set/ps=
@if %s%==leap echo PVC&exit/b
@for %%s in (a n r)do @if %s:~,1%==%%s echo tinny&exit/b
@if %s:~1,1%==i echo tinny&exit/b
@echo woody

Recebe entrada em STDIN. Explicação: Depois de verificar para leap, palavras tinny quer começar com uma das cartas a, nou rou a sua segunda carta é i.


2

CJam , 35 bytes

1b_856%338<\418=-"woodytinnyPVC"5/=

Experimente online!

Esqueci completamente que havia iniciado uma busca de força bruta por expressões curtas para misturar as cordas amadeirada e fina em duas classes. Acabei de encontrar a janela do console onde a pesquisa foi executada e, na verdade, ele encontrou algo ...

Explicação

1b     e# Sum the code points of the input string.
       e# The result is unique for each input, except "pert" and "wasp" which
       e# both sum to 443. But they're both woody, so that's fine.
_      e# Duplicate.
856%   e# Take the sum modulo 856.
338<   e# Check whether the result is less than 338. That's true for all
       e# tinny words.
\      e# Swap with the other copy of the sum.
418=   e# Check whether the sum is equal to 418, which identifies "leap".
-      e# Subtract. Gives -1 for "leap", 1 for tinny words and 0 for woody words.
"woodytinnyPVC"5/
       e# Create the list ["woody" "tinny" "PVC"].
       e# Select the correct string.

1

Excel, 81 bytes

=IF(ISNUMBER(FIND(LEFT(A1,2),"anetisilire")),"tinny",IF(A1="leap","PVC","woody"))

Usando o método 'anetisilire'.



1

JavaScript, 60 , 50

EDIT Vi todas as outras respostas regex. Acho que sou apenas cego. Enfim, aqui está um usando o mesmo regex

i=="leap"?"PVC":/.p.|is*t/.test(i)?"tinny":"woody"

Além disso, agora, supera a outra resposta JS

Snippet:

let test = i => i=="leap"?"PVC":/.p.|is*t/.test(i)?"tinny":"woody"

let woody = `gone
sausage
seemly
prodding
vacuum
bound
vole
caribou
intercourse
pert
thighs
botty
erogenous zone
ocelot
wasp
yowling`;
console.log("THESE SHOULD BE woody");
woody.split("\n").forEach(el => console.log(test(el)));
let tinny = `litter bin
newspaper
antelope
recidivist
tit
simpkins`;
console.log("THESE SHOULD BE tinny");
tinny.split("\n").forEach(el => console.log(test(el)));
console.log("THIS SHOULD BE PVC");
console.log(test("leap"));

Resposta antiga

Ainda não vi nenhum com regex, então pensei em tentar

i=="leap"?"PVC":/[gyuz]|[or][tl]|as/.test(i)?"woody":"tinny"

Não tenho certeza se isso conta como 60 ou mais porque eu não incluí uma declaração de retorno. Adicionarei um trecho quando eu chegar no meu computador

Editar: Snippet

let test = i => i=="leap"?"PVC":/[gyuz]|[or][tl]|as/.test(i)?"woody":"tinny"

let woody = `gone
sausage
seemly
prodding
vacuum
bound
vole
caribou
intercourse
pert
thighs
botty
erogenous zone
ocelot
wasp
yowling`;
console.log("THESE SHOULD BE woody");
woody.split("\n").forEach(el => console.log(test(el)));
let tinny = `litter bin
newspaper
antelope
recidivist
tit
simpkins`;
console.log("THESE SHOULD BE tinny");
tinny.split("\n").forEach(el => console.log(test(el)));
console.log("THIS SHOULD BE PVC");
console.log(test("leap"));

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.