Definição

Uma palavra em dólar é uma palavra em que quando cada uma de suas letras recebe um valor em centavos, de a = 1 a z = 26, e as letras são somadas, o resultado é 100. Aqui está um exemplo no CodeReview e aqui está uma lista de palavras em dólar que encontrei online.

Entrada

A entrada será alfabética de az, nos tipos de dados de texto do seu idioma (matrizes são permitidas). Você não precisa dar conta de nenhuma outra entrada - não haverá espaços, apóstrofos ou hífens. Você pode usar como minúscula, maiúscula ou uma combinação. Novas linhas à direita são permitidas.

Resultado

Emita um valor verdadeiro se a entrada for uma palavra em dólar e um valor falsey se não for.

Casos de teste

Verdade:

buzzy
boycott
identifies
adiabatically
ttttt

Falsey:

zzz
zzzzzzz
abcdefghiljjjzz
tttt
basic

Isso é código-golfe, então a resposta mais curta em bytes vence! Aplicam-se brechas e regras padrão. O empate vai para o primeiro pôster.

GS2 , 6 bytes

▲1Θd←q

A entrada deve estar em maiúscula.

Experimente online!

Como funciona

  Θ       Combine the previous two tokens into a block and map it over the input.
▲             Push 64.
 1            Subtract 64 from the character on the stack.
   d      Take the sum of the resulting character array.
    ←     Push 100.
     q    Compare the two items on the stack for equality.

Python, 39 38 bytes

lambda s:sum(ord(i)-96for i in s)==100

Experimente online!

-1 byte graças a @JonathanAllan

05AB1E , 8 bytes

Código:

Ç96-O4bQ

Usa a codificação CP-1252 . Experimente online!

Explicação:

Ç          # Convert the string into a list of character codes
 96-       # Subtract 96 of each element
    O      # Take the sum
     4b    # Push 100 (4 in binary)
       Q   # Check if equal

Perl 6 , 21 bytes

{100==[+] .ords X%32}

Tente

Alternar:

{Ⅽ==[+] .ords X%32}

Tente

Observe que Ⅽé ROMAN NUMERAL ONE HUNDREDU + 216D com um unival de… 100 O
que leva 3 bytes para codificar.

Expandido:

{  # bare block lambda with implicit parameter $_

  100     # is 100
  ==      # equal to
  [+]     # the sum of the following

    .ords # the ordinals of the input (implicit method call on $_)
    X[%]  # crossed using the modulus operator
    32    # with 32 to get 65..90 or 97..122 to become 1..26
}

MATL , 8 bytes

96-s100=

Usa entrada em minúsculas.

Experimente online!

Explicação

O código é o mais legível possível:

96-   % Implicitly input string. Subtract 96 from each char interpreted as ASCII code
s     % Sum of array
100=  % Does it equal 100? Implicitly display

JavaScript (ES6), 46 bytes

Retorna 0ou 1.

let f =

w=>[...w].map(c=>p-=parseInt(c,36)-9,p=100)|!p

console.log(f('buzzy'))
console.log(f('qwerty'))

Haskell , 32 bytes

f s=sum[1|c<-s,_<-['a'..c]]==100

Experimente online!

A idéia é fazer uma lista de caracteres do caractere aespecificado para cada caractere da lista e verificar se o comprimento total é 100.

Outras tentativas:

f s=sum[1|c<-s,_<-['a'..c]]==100

f s=sum[fromEnum c-96|c<-s]==100
f s=100==length((\c->['a'..c])=<<s)
(==100).length.(>>= \c->['a'..c])
(==100).length.(=<<)(\c->['a'..c])
(==100).length.(enumFromTo 'a'=<<)
f s=100==length(do c<-s;['a'..c])

Pena que enumFromToé tão longa.

C, 45 43 bytes

Agradecemos ao @Neil por salvar dois bytes e tornar a solução sem distinção entre maiúsculas e minúsculas!

n;f(char*s){for(n=100;*s;)n-=*s++&31;n=!n;}

Experimente online!

Haskell , 32 bytes

f w=sum[fromEnum c-96|c<-w]==100

Isso funciona para entrada em minúsculas. Para maiúsculas s/96/64/,. O suporte a maiúsculas e minúsculas adicionaria vários bytes.

Mathematica, 23 bytes

100==Tr@LetterNumber@#&

Função pura pegando uma string (ou uma matriz de letras) como entrada, sem distinção entre maiúsculas e minúsculas e retornando Trueou False. Aqui Trapenas adicionamos os números das letras; tudo o resto é auto-explicativo.

Geléia , 9 7? * 8 bytes

ɠO%32S⁼³

Programa completo, emitindo 1 se a entrada for uma palavra em dólar ou 0 se não.

Experimente online!

Quão?

ɠO%32S⁼³ - Main link
ɠ        - read a line of input from STDIN
 O       - cast to ordinals
  %32    - mod 32 (vectorises) (-3*32=96 from lowercase; -2*32=64 from uppercase)
     S   - sum
       ³ - literal: 100
      ⁼  - equal?

* Poderia ser 7 bytes?

A única razão pela qual este tomou entrada com ɠera manter ³como o literal 100 em vez do 3 ^rd entrada de linha de comando (1 ^st entrada de programa).

Uma maneira de evitar isso seria, como apontado por Dennis, criar 100 usando a forma literal bruta ȷ2que é 10 ² . Isso leva a outro byte de 8 bytes O%32S=ȷ2, mas agora é uma função monádica sem nome (além de operar como um programa completo com um ^terceiro argumento).

Como no golfe, é possível criar variáveis ​​ou funções auxiliares que restringem o programa em que residem (não é possível reutilizar o nome no escopo sem impedir que a função seja reutilizável), talvez restringindo o programa a receber apenas informações do STDIN. também será aceitável; nesse caso, o byte de 7 bytes O%32S=³seria aceitável aqui como uma função sem nome.

Alice , 23 bytes

/o!
\i@/e)q&w[?'`-+k3-n

Experimente online!

A entrada deve estar em minúscula. Imprime 1para palavras em dólar e 0outros.

Explicação

Hora de mostrar a fita de Alice e algum fluxo de controle avançado. Apesar de ser bastante bom em trabalhar com números inteiros e seqüências de caracteres individualmente, Alice não possui built-ins para: a) determinar o comprimento de uma string; b) converter entre caracteres e seus pontos de código. A razão para isso é que todos os comandos de Alice mapeiam números inteiros para números inteiros ou cadeias para cadeias. Mas os dois exigiriam mapear seqüências de caracteres para números inteiros ou vice-versa, para que não se encaixem nos modos de Alice.

No entanto, além de sua pilha, Alice também possui uma fita e os modos Cardinal e Ordinal interpretam os dados na fita de diferentes maneiras.

• No modo Cardinal, é uma fita comum familiar de outras línguas, como Brainfuck. Você pode armazenar um número inteiro em cada célula e mover uma cabeça de fita. A fita é infinitamente longa e inicialmente contém um -1 em cada célula. As células também são indexadas e a cabeça da fita começa no índice 0 .
• O modo ordinal tem sua própria cabeça de fita (também iniciando no índice 0 ) e interpreta a fita como uma lista de seqüências de caracteres. As strings são finalizadas por células sem caracteres (ou seja, quaisquer valores que não sejam um ponto de código Unicode válido), em particular -1 . Portanto, no modo Ordinal, a fita é inicialmente preenchida com cadeias vazias.

Essa fita pode ser usada para as duas operações acima: para obter um comprimento de string, escrevemos na fita no modo Ordinal, procuramos o -1 no modo Cardinal e recuperamos a posição da cabeça da fita. Para converter caracteres em seus pontos de código, simplesmente os lemos da fita no modo Cardinal.

Os outros dois recursos importantes usados ​​nesta solução são a pilha de retorno e um iterador. Alice tem uma pilha de retorno que geralmente é preenchida ao usar o comando jump je da qual você pode inserir um endereço para retornar k. No entanto, também é possível enviar o endereço atual para a pilha de retorno sem precisar ir a lugar nenhum w. Se combinarmos wcom o comando repeat& , podemos enviar o endereço atual para a pilha de retorno n vezes. Agora, cada vez que chegamos k, uma cópia é retirada da pilha de retorno e executamos outra iteração w(iniciando na célula depois dela, porque o IP se move antes de executar outro comando). Quando a pilha de retorno fica vazia,knão faz nada e o IP simplesmente passa. Portanto, &w...kaparece um número inteiro n e, em seguida, executa ... n + 1 vezes, o que nos dá uma maneira muito concisa de expressar um forloop simples .

Para o próprio código ...

/     Reflect to SE. Switch to Ordinal.
i     Read the input word as a string.
      Bounce off bottom boundary, move NE.
!     Store the input word on the tape.
      Bounce off top boundary, move SE.
/     Reflect to E. Switch to Cardinal.
e     Push -1.
)     Seek right on the tape for a -1, which finds the -1 terminating
      the input word.
q     Push the tape head's position, which gives us the string length N.
&w    Repeat this loop n+1 times (see above for an explanation)...
  [     Move the tape head left by one cell.
  ?     Retrieve the code point of the character in that cell.
  '`    Push 96.
  -     Subtract it from the code point to convert the letters to 1...26.
  +     Add the result to a running total. This total is initialised to 
        zero, because in Cardinal mode, the stack is implicitly filled with
        an infinite amount of zeros at the bottom.
k    End of loop.
     Note that the above loop ran once more than we have characters in the
     string. This is actually really convenient, because it means that we've
     added a "-1 character" to the running total. After subtracting 96 to
     convert it to its "letter value" this gives 97. So dollar words will
     actually result in 100 - 97 = 3, which we can check against for one
     byte less than for equality with 100.
3-   Subtract 3 to give 0 for dollar words.
n    Logical NOT. Turns 0 (dollar words) into 1 and everything else into 0.
     The IP wraps around to the beginning of the first line.
\    Reflect to NE. Switch to Ordinal.
o    Implicitly convert the result to a string and print it.
     Bounce off top boundary, move SE.
@    Terminate the program.

R, 55 54 bytes

function(x)sum(match(el(strsplit(x,"")),letters))==100

-1 byte graças ao BLT

• retorna uma função que faz o cálculo necessário, que retorna TRUEe FALSEcomo seria de esperar.

• recebe entrada como minúscula; seria apenas uma mudança de letterspara LETTERSpara todas as maiúsculas

Ruby, 25 bytes

->s{s.sum-s.size*64==100}

Funciona para maiúsculas.

Eu vejo algumas entradas Ruby mais complexas, mas é realmente simples assim. s.sumadiciona os códigos ASCII da string de entrada e, a partir disso, subtraímos 64 vezes o comprimento da string.

Exemplo de uso

f=->s{s.sum-s.size*64==100}

puts f["ADIABATICALLY"]
puts f["ZZZ"]

Java 8, 36 bytes

s->s.chars().map(c->c%32).sum()==100

Experimente online!

Nota: independente do caso.

05AB1E , 9 bytes

5bIvAyk>-

Experimente online!

Explicação

Como 1 é o único valor verdadeiro em 05AB1E, podemos salvar um byte usando subtração em comparação a 100 .

5b         # convert 5 to binary (results in 101)
  Iv       # for each letter in input word
    Ayk    # get the index of the letter in the alphabet
       >   # increment
        -  # subtract from total

Perl 5 , 30 bytes

-1 byte graças a @ Neil (em 31&vez de -96+).

29 bytes de código + -psinalizador.

$@+=31&ord for/./g;$_=$@==100

Experimente online!

PowerShell , 36 30 bytes

$args|%{$s+=$_[0]-96};$s-eq100

Experimente online!

Entradas como uma matriz, mas eu estou querendo saber se existe uma maneira melhor de lidar com caracteres.

EDIT Perdeu um espaço fácil, mas @AdmBorkBork gentilmente me avise: P também, de fato, havia uma maneira melhor de lidar com os personagens!

Alice , 28 18 bytes

Graças a @MartinEnder por jogar 10 bytes

=I.!'`-+?hn
>3-nO@

Experimente online!

Este envio usa um método diferente da resposta do @ MartinEnder.

Essa submissão gera 0x00falsas e verdadeiras 0x01.

Então, aqui está uma versão que emite 0ou 1não: Experimente!

Explicação

A explicação abaixo é para a versão "visível". Ambos são muito parecidos, exceto no primeiro programa, o último onão converte a 0ou 1em uma string (porque estamos no modo cardinal), mas pega o número e gera o caractere nesse ponto de código.

=                 Does nothing, but will be useful later on
I                 Read a character and push its code point onto the stack
                  If there is no more input, -1 is pushed instead
.                 Duplicate it
!                 Store it on the tape
#                 Skip the next command
o                 Gets skipped
'`                Push 96
-                 Subtract it from the character
+                 And add it to the total
?                 Load the number on the tape
h                 Increment it
n                 And negate it
                  For all characters that are read, ?hn results in 0,
                  but if -1 is pushed, then the result becomes 1

Depois disso, o IP envolve a borda esquerda no =. Se o valor superior da pilha for 0, o IP continuará com seu caminho, aumentando a soma total de todos os caracteres, assim que for feito com a entrada (a parte superior da pilha será 1), e o IP girará para a direita (90 graus no sentido horário).

Uma coisa é importante notar, o loop na primeira linha irá repetir uma vez após o término da entrada. Isso subtrairá 97( 96da '`e -1da falta de entrada) do total.

>                Set the direction of the IP to East
3-               Subtract 3 from it (yields 0 if sum is 100, something else otherwise)
n                Negate it; Zero becomes 1, non-zero numbers become 0
/                Mirror; the IP gets redirected South-East
                 The IP reflects off the bottom and goes North-East
                 Now the program is in Ordinal mode, where numbers are automatically converted into strings when being used
o                Output the top of the stack as a string
                 IP reflects off the top and heads South-East
@                End the program

Táxi , 1259 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Auctioneer School.Go to Auctioneer School:s 1 r 1 l 1 l.Pickup a passenger going to Chop Suey.0 is waiting at Starchild Numerology.Go to Starchild Numerology:s 1 l.Pickup a passenger going to Addition Alley.Go to Chop Suey:e 1 l 2 r 3 r 3 r.[a]Switch to plan "b" if no one is waiting.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:n 1 l 3 l 3 l.Pickup a passenger going to What's The Difference.Go to Go More:e.64 is waiting at Starchild Numerology.Go to Starchild Numerology:e 2 r.Pickup a passenger going to What's The Difference.Go to What's The Difference:e 1 l 2 r 1 l.Pickup a passenger going to Addition Alley.Go to Addition Alley:e 2 r.Pickup a passenger going to Addition Alley.Go to Chop Suey:n 1 r 2 r.Switch to plan "a".[b]Go to Addition Alley:n 1 l 2 l.Pickup a passenger going to Equal's Corner.100 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 3 l 2 r.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:w 1 l.Switch to plan "c" if no one is waiting."TRUE" is waiting at Writer's Depot.[c]"FALSE" is waiting at Writer's Depot.Go to Writer's Depot:n 1 l 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.

Com quebras de linha, fica assim:

Go to Post Office:w 1 l 1 r 1 l.
Pickup a passenger going to Auctioneer School.
Go to Auctioneer School:s 1 r 1 l 1 l.
Pickup a passenger going to Chop Suey.
0 is waiting at Starchild Numerology.
Go to Starchild Numerology:s 1 l.
Pickup a passenger going to Addition Alley.
Go to Chop Suey:e 1 l 2 r 3 r 3 r.
[a]
Switch to plan "b" if no one is waiting.
Pickup a passenger going to Charboil Grill.
Go to Charboil Grill:n 1 l 3 l 3 l.
Pickup a passenger going to What's The Difference.
Go to Go More:e.
64 is waiting at Starchild Numerology.
Go to Starchild Numerology:e 2 r.
Pickup a passenger going to What's The Difference.
Go to What's The Difference:e 1 l 2 r 1 l.
Pickup a passenger going to Addition Alley.
Go to Addition Alley:e 2 r.
Pickup a passenger going to Addition Alley.
Go to Chop Suey:n 1 r 2 r.
Switch to plan "a".
[b]
Go to Addition Alley:n 1 l 2 l.
Pickup a passenger going to Equal's Corner.
100 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 1 l 3 l 2 r.
Pickup a passenger going to Equal's Corner.
Go to Equal's Corner:w 1 l.
Switch to plan "c" if no one is waiting.
TRUE is waiting at Writer's Depot.
[c]
FALSE is waiting at Writer's Depot.
Go to Writer's Depot:n 1 l 1 r.
Pickup a passenger going to Post Office.
Go to Post Office:n 1 r 2 r 1 l.

Ele aceita maiúsculas ou minúsculas porque Auctioneer Schoolconverte tudo em maiúsculas.
Chop Sueydivide em caracteres individuais.
Charboil Grillconverte caracteres em seu código ASCII.
Pegamos um caractere por vez, convertemos para ASCII, subtraímos 65 e o adicionamos ao total em execução.
Quando não houver mais caracteres, compare o total com 100.

Retorna TRUEpara palavras em dólar e FALSEpara todo o resto.

Código de máquina IA-32, 21 bytes

Hexdump:

33 c0 6a 64 5a 8a 01 41 24 1f 75 05 83 ea 01 d6
c3 2b d0 eb f0

Código de montagem:

    xor eax, eax;   initialize eax to 0
    push 100;       initialize edx
    pop edx;            to 100
myloop:
    mov al, [ecx];  load a byte
    inc ecx;        go to next byte
    and al, 31;     convert from letter to number
    jnz cont;       not done? continue

    ;               done:
    sub edx, 1;     check whether edx got to 0; result is in CF
    __emit(0xd6);   aka SALC - set al to CF
    ret
cont:
    sub edx, eax
    jmp myloop

Conta de 100 a 0. Se chegou a 0, retorna verdadeiro (0xff); caso contrário, false (0x00).

Dyalog APL, 17 15 bytes

100=+/17-⍨⎕AV⍳⍞

Usa o conjunto de caracteres Dyalog Classic.

              ⍞  ⍝ string input
          ⎕AV⍳   ⍝ index in the character map
      17-⍨       ⍝ subtract 17 from each ('a' = 18)
    +/           ⍝ sum
100=             ⍝ equal to 100?

Python , 38 bytes

lambda s:sum(map(ord,s))==4-96*~len(s)

Experimente online!

O mesmo comprimento da solução ovs . Em vez de subtrair 96 de cada ordvalor, isso verifica se o ordtotal é igual 100+96*len(s). Isso é expresso em um byte menor que 4-96*~len(s), igual a 4-96*(-len(s)-1).

Ruby , 35 30 bytes

->w{196==eval(w.bytes*'-96+')}

Experimente online!

Retina , 47 23 bytes

\w
!$&
}T`l`_l
^!{100}$

Experimente online! Nota: O cabeçalho minúscula entrada e divide em palavras; os resultados aparecem em linhas separadas. Editar: salvou muitos bytes graças a @MartinEnder.

Oitava, 18 bytes

@(x)sum(x-96)==100

Subtrai 96da string de entrada x(minúscula), para obter os valores numéricos das letras. Pega sume compara 100. Retorna uma lógica 1para casos reais e uma lógica 0para casos falsos.

Eu poderia economizar um byte se não fosse correto fornecer falso para "palavras em dólar" e verdadeiro para "palavras que não sejam em dólar".

Japonês , 13 12 10 bytes

L¥U¬x_c %H

Explicação:

L¥ U¬x _c %H
L¥(U¬x(_c %H))
L¥(          )   // 100==
   U¬            //   Input split into a char array
     x(     )    //   The sum of:
       _         //     At each char:
        c        //       Get the char-code and
          %H     //       Mod 32

Teste online!

12 bytes:

L¥U¬mc m%H x

Experimente online!

Outra solução de 12 bytes usando uma técnica diferente

L¥U¬x@;CaX Ä

Experimente online!

Ruby (2.4+), 38 bytes

Recebe entrada em minúsculas. Requer Ruby 2.4's Array#sumpara que não funcione no TIO.

->a{a.chars.map{|c|c.ord-96}.sum==100}

/// , 564 210 189 185 bytes

/~/1\/\///4/11~3/41//6/33//2/66//5/22~a/~b/1~c/4~d/3~e/31~f/34~g/6~h/16~i/46~j/36~k/316~l/346~m/2~n/12~o/42~p/32~q/312~r/342~s/62~t/162~u/462~v/362~w/3162~x/3462~y/22~z/122~5555/0///1/0

Experimente online!

Imprime um 1 se for uma "palavra do dólar", caso contrário, imprime um "0"

A entrada é a seguinte: (Role todo o caminho para a direita)

/~/1\/\///4/11~3/41//6/33//2/66//5/22~a/~b/1~c/4~d/3~e/31~f/34~g/6~h/16~i/46~j/36~k/316~l/346~m/2~n/12~o/42~p/32~q/312~r/342~s/62~t/162~u/462~v/362~w/3162~x/3462~y/22~z/122~5555/0//INPUT WORD HERE/1/0

Funciona substituindo cada letra pelo seu valor em unário e, em seguida, substituindo um 100 unário por um 0. Ele substitui o valor da palavra por 1. Se o valor da palavra for 0, será impresso 1 porque no final de o código está substituindo um 0. Se o valor da palavra for qualquer outra coisa, ele imprimirá apenas 0.

O golfe funciona usando ocorrências comuns no código como substitutos.

Utilitários Bash + GNU, 47

od -An -td1 -vw1|sed 's/^/a+=-96+/;$a!a-100'|bc

Experimente online .