Definición

Una palabra dólar es una palabra en la que cuando a cada una de sus letras se le asigna un valor en centavos, de a = 1 a z = 26, y las letras se suman, el resultado es 100. Aquí hay un ejemplo en CodeReview, y aquí hay una lista de palabras en dólares que encontré en línea.

Entrada

La entrada será alfabética desde az, en los tipos de datos de texto de su idioma (se permiten matrices). No necesita tener en cuenta ninguna otra entrada; no habrá espacios, apóstrofes ni guiones. Puede tomar en minúsculas, mayúsculas o una combinación. Se permiten nuevas líneas al final.

Salida

Genere un valor verdadero si la entrada es una palabra en dólares y un valor falso si no lo es.

Casos de prueba

Verdad:

buzzy
boycott
identifies
adiabatically
ttttt

Falsey

zzz
zzzzzzz
abcdefghiljjjzz
tttt
basic

Este es el código de golf, por lo que gana la respuesta más corta en bytes. Se aplican las lagunas y normas estándar. La corbata va al primer póster.

GS2 , 6 bytes

▲1Θd←q

La entrada debe estar en mayúscula.

Pruébalo en línea!

Cómo 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

Pruébalo en línea!

-1 byte gracias a @JonathanAllan

05AB1E , 8 bytes

Código:

Ç96-O4bQ

Utiliza la codificación CP-1252 . Pruébalo en línea!

Explicación:

Ç          # 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}

Intentalo

Alterno:

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

Intentalo

Tenga en cuenta que Ⅽes ROMAN NUMERAL ONE HUNDREDU + 216D con un unival de ... 100,
que toma 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=

Utiliza entrada en minúsculas.

Pruébalo en línea!

Explicación

El código es tan legible como se pone:

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

Devoluciones 0o 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

Pruébalo en línea!

La idea es hacer una lista de caracteres desde ael carácter dado para cada carácter en la lista, y verificar que la longitud total sea 100.

Otros intentos

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

Lástima que enumFromTosea ​​tan largo.

C, 45 43 bytes

¡Gracias a @Neil por guardar dos bytes y hacer que la solución no distinga entre mayúsculas y minúsculas!

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

Pruébalo en línea!

Haskell , 32 bytes

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

Esto funciona para la entrada en minúsculas. Para mayúscula, s/96/64/. La compatibilidad con mayúsculas y minúsculas agregaría un montón de bytes.

Mathematica, 23 bytes

100==Tr@LetterNumber@#&

Función pura que toma una cadena (o una matriz de letras) como entrada, no distingue entre mayúsculas y minúsculas y devuelve Trueo False. Aquí Trsolo agrega los números de letras juntos; todo lo demás se explica por sí mismo.

Jalea , 9 7? * 8 bytes

ɠO%32S⁼³

Programa completo, generando 1 si la entrada es una palabra en dólares, o 0 si no.

Pruébalo en línea!

¿Cómo?

ɠ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?

* ¿Podría ser de 7 bytes?

La única razón de que esto tomó de entrada con ɠera mantener ³como el literal 100 en lugar de la 3 ^ª entrada de línea de comandos (1 ^st entrada del programa).

Una manera de evitar eso sería, como lo señaló Dennis, crear 100 usando la forma literal sin procesar ȷ2que es 10 ² . Esto lleva a otra de 8 bytes O%32S=ȷ2, pero esto ahora es una función monádica sin nombre (así como de funcionamiento como un programa completo con 3 ^rd argumento).

Dado que, en el golf, uno puede crear variables o funciones auxiliares que restrinjan el programa en el que pueden residir (no se puede reutilizar el nombre dentro del alcance sin evitar que la función sea reutilizable), tal vez restringir el programa a solo recibir información de STDIN. también será aceptable, en cuyo caso el byte 7 O%32S=³sería aceptable aquí como una función sin nombre.

Alice , 23 bytes

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

Pruébalo en línea!

La entrada debe ser minúscula. Imprime 1palabras en dólares y de 0otra manera.

Explicación

Es hora de mostrar la cinta de Alice y un flujo de control avanzado. A pesar de ser bastante bueno trabajando con enteros y cadenas individualmente, Alice no tiene funciones integradas para a) determinar la longitud de una cadena, b) convertir entre caracteres y sus puntos de código. La razón de esto es que todos los comandos de Alice asignan enteros a enteros o cadenas a cadenas. Pero ambos requerirían asignar cadenas a enteros o viceversa, por lo que no encajan en ninguno de los modos de Alice.

Sin embargo, además de su stack, Alice también tiene una cinta y los modos Cardinal y Ordinal interpretan los datos en la cinta de diferentes maneras.

• En el modo Cardinal, es una cinta normal conocida de otros idiomas como Brainfuck. Puede almacenar un número entero en cada celda y puede mover un cabezal de cinta. La cinta es infinitamente larga e inicialmente contiene un -1 en cada celda. Las celdas también están indexadas y el cabezal de la cinta comienza en el índice 0 .
• El modo ordinal tiene su propio cabezal de cinta (que también comienza en el índice 0 ) e interpreta la cinta como una lista de cadenas. Las cadenas están terminadas por celdas sin caracteres (es decir, cualquier valor que no sea un punto de código Unicode válido), en particular -1 . Entonces, para el modo Ordinal, la cinta se llena inicialmente con cadenas vacías.

Esta cinta se puede usar para las dos operaciones anteriores: para obtener una longitud de cadena, la escribimos en la cinta en modo Ordinal, buscamos la terminación -1 en modo Cardinal y recuperamos la posición del cabezal de la cinta. Para convertir caracteres a sus puntos de código, simplemente los leemos de la cinta en modo Cardinal.

Las otras dos características importantes utilizadas en esta solución son la pila de retorno y un iterador. Alice tiene una pila de retorno que generalmente se llena cuando se usa el comando de salto j, y desde la que puede hacer saltar una dirección para volver a saltar k. Sin embargo, también es posible enviar la dirección actual a la pila de retorno sin saltar a ningún lado w. Si combinamos wcon el comando de repetición& , podemos empujar la dirección actual a la pila de retorno n veces. Ahora, cada vez que llegamos k, se saca una copia de la pila de retorno y realizamos otra iteración desde w(comenzando en la celda después de ella, porque la IP se mueve antes de ejecutar otro comando). Cuando la pila de devolución se vacía,kno hace nada y la IP simplemente pasa. Por lo tanto, &w...kaparece un entero n y luego se ejecuta ... n + 1 veces, lo que nos da una forma muy concisa de expresar un forbucle simple .

En el código en sí ...

/     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 gracias a BLT

• devuelve una función que realiza el cálculo requerido, que devuelve TRUEy FALSEcomo cabría esperar.

• toma la entrada en minúsculas; solo sería un cambio de lettersa LETTERSpara todas las mayúsculas

Rubí, 25 bytes

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

Obras para mayúsculas.

Veo un par de entradas de Ruby más complejas, pero realmente es así de simple. s.sumagrega los códigos ASCII de la cadena de entrada, y de esto restamos 64 veces la longitud de la cadena.

Ejemplo 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

Pruébalo en línea!

Nota: caso independiente.

05AB1E , 9 bytes

5bIvAyk>-

Pruébalo en línea!

Explicación

Como 1 es el único valor verdadero en 05AB1E, podemos guardar un byte usando la resta en comparación con 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 gracias a @Neil (en 31&lugar de -96+).

29 bytes de código + -pbandera.

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

Pruébalo en línea!

PowerShell , 36 30 bytes

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

Pruébalo en línea!

Entradas como una matriz, pero me pregunto si hay una mejor manera de manejar los caracteres.

EDITAR Se perdió un espacio fácil, pero @AdmBorkBork amablemente me avisó: P también, de hecho, ¡había una mejor manera de manejar a los personajes!

Alicia , 28 18 bytes

Gracias a @MartinEnder por jugar al golf 10 bytes

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

Pruébalo en línea!

Este envío utiliza un método diferente al de la respuesta de @ MartinEnder.

Esta sumisión da como resultado la 0x00falsedad y la 0x01verdad.

Así que aquí hay una versión que sale 0o, en 1cambio, ¡ pruébalo!

Explicación

La explicación a continuación es para la versión "visible". Ambos son muy similares, excepto en el primer programa, el último ono convierte el 0o 1en una cadena (porque estamos en modo cardinal), sino que toma el número y muestra el carácter en ese punto del 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

Después de esto, la IP se ajusta al borde izquierdo en el =. Si el valor superior de la pila es 0, la IP continúa con su ruta, aumentando la suma total de todos los caracteres, una vez que se hace con la entrada (la parte superior de la pila será 1), entonces la IP gira a la derecha (90 grados en sentido horario).

Una cosa es importante tener en cuenta, el bucle en la primera línea iterará una vez que la entrada haya finalizado. Esto restará 97( 96del '`y -1de la falta de entrada) del 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

Taxi , 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.

Con saltos de línea, se ve así:

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.

Acepta mayúsculas o minúsculas porque las Auctioneer Schoolconvierte a mayúsculas.
Chop Sueylo divide en caracteres individuales.
Charboil Grillconvierte caracteres a su código ASCII.
Recogemos un carácter a la vez, lo convertimos a ASCII, restamos 65 y lo sumamos al total acumulado.
Una vez que no haya más personajes, compara el total con 100.

Devoluciones TRUEpara palabras en dólares y FALSEpara todo lo demás.

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 montaje:

    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

Cuenta de 100 a 0. Si llega a 0, devuelve verdadero (0xff); de lo contrario falso (0x00).

Dyalog APL, 17 15 bytes

100=+/17-⍨⎕AV⍳⍞

Utiliza el 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)

Pruébalo en línea!

Misma longitud que la solución de ovs . En lugar de restar 96 de cada ordvalor, esto verifica si el ordtotal es igual 100+96*len(s). Esto se expresa un byte más corto como 4-96*~len(s), que es igual 4-96*(-len(s)-1).

Ruby , 35 30 bytes

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

Pruébalo en línea!

Retina , 47 23 bytes

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

Pruébalo en línea! Nota: El encabezado ingresa en minúsculas y lo divide en palabras; Los resultados aparecen en líneas separadas. Editar: se guardaron demasiados bytes gracias a @MartinEnder.

Octava, 18 bytes

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

Resta 96de la cadena de entrada x(minúscula), para obtener los valores numéricos de las letras. Toma el sumy lo compara con 100. Devuelve una lógica 1para casos verdaderos y una lógica 0para casos falsos.

Podría guardar un byte si estuviera bien dar falso para "palabras en dólares" y verdadero para "palabras en dólares".

Japt , 13 12 10 bytes

L¥U¬x_c %H

Explicación:

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

¡Pruébelo en línea!

12 bytes:

L¥U¬mc m%H x

Pruébalo en línea!

Otra solución de 12 bytes que utiliza una técnica diferente.

L¥U¬x@;CaX Ä

Pruébalo en línea!

Ruby (2.4+), 38 bytes

Toma entrada en minúsculas. Requiere Ruby 2.4 Array#sumpara que no se ejecute en 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

Pruébalo en línea!

Imprime un 1 si es una "palabra dólar", de lo contrario imprime un "0"

La entrada es la siguiente: (Desplácese hacia la derecha)

/~/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 reemplazando cada letra con su valor en unario, luego reemplazando un 100 unario con un 0. Luego sustituye cualquier valor de la palabra con un 1. Si el valor de la palabra es 0, imprimirá un 1 porque al final de el código, está reemplazando un 0. Si el valor de la palabra es otra cosa, simplemente imprimirá ese 0.

El golf funciona mediante el uso de ocurrencias comunes en el código como reemplazos.

Bash + GNU utils, 47

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

Pruébalo en línea .