Définition

Un mot de dollar est un mot , où , quand chacune de ses lettres est donné une valeur de cent, de a = 1 à z = 26, et les lettres sont sommés, le résultat est 100. Voici un exemple sur CodeReview, et voici une liste des mots dollar que j'ai trouvé en ligne.

Contribution

La saisie sera alphabétique de az, dans les types de données texte de votre langue (les tableaux sont autorisés). Vous n'avez pas besoin de rendre compte de toute autre entrée - il n'y aura pas d'espaces, d'apostrophes ni de traits d'union. Vous pouvez prendre en minuscule, majuscule ou une combinaison. Les retours à la ligne sont autorisés.

Sortie

Indiquez une valeur de vérité si l'entrée est un mot dollar et une valeur de falsey si ce n'est pas le cas.

Cas de test

Vérité

buzzy
boycott
identifies
adiabatically
ttttt

Falsey:

zzz
zzzzzzz
abcdefghiljjjzz
tttt
basic

C'est du code-golf, donc la réponse la plus courte en octets gagne! Les lacunes et les règles standard s'appliquent. La cravate va à la première affiche.

GS2 , 6 octets

▲1Θd←q

L'entrée doit être en majuscule.

Essayez-le en ligne!

Comment ça fonctionne

  Θ       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 octets

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

Essayez-le en ligne!

-1 octet grâce à @JonathanAllan

05AB1E , 8 octets

Code:

Ç96-O4bQ

Utilise le codage CP-1252 . Essayez-le en ligne!

Explication:

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

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

L'essayer

Alterner:

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

L'essayer

Notez que Ⅽest ROMAN NUMERAL ONE HUNDREDU + 216D avec un unival de… 100,
ce qui prend 3 octets à encoder.

Étendu:

{  # 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 octets

96-s100=

Utilise une entrée en minuscule.

Essayez-le en ligne!

Explication

Le code est aussi lisible que possible:

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 octets

Retours 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 octets

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

Essayez-le en ligne!

L'idée est de faire une liste de caractères adans le caractère donné pour chaque caractère de la liste et de vérifier que la longueur totale est de 100.

Autres tentatives:

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

Dommage, enumFromToc'est si long.

C, 45 43 octets

Merci à @Neil d'avoir économisé deux octets et d'avoir rendu la solution insensible à la casse!

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

Essayez-le en ligne!

Haskell , 32 octets

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

Cela fonctionne pour les entrées en minuscules. Pour les majuscules, s/96/64/. La prise en charge de cas mixtes ajouterait un tas d'octets.

Mathematica, 23 octets

100==Tr@LetterNumber@#&

Fonction pure prenant une chaîne (ou un tableau de lettres) en entrée, insensible à la casse, et retournant Trueou False. Ici, Trajoute simplement les lettres-nombres ensemble; tout le reste est explicite.

Jelly , 9 7? * 8 octets

ɠO%32S⁼³

Programme complet, en indiquant 1 si l'entrée est un mot dollar ou 0 sinon.

Essayez-le en ligne!

Comment?

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

* Pourrait-il s'agir de 7 octets?

La seule raison pour laquelle cela a pris avec entrée ɠétait de garder ³comme 100 littéral plutôt que le 3 ^ème entrée de ligne de commande (1 ^er d'entrée du programme).

Un moyen d'éviter cela serait, comme l'a souligné Dennis, de créer 100 en utilisant la forme littérale brute ȷ2qui est 10 ² . Cela conduit à un autre octet de 8 O%32S=ȷ2, mais c'est maintenant une fonction monadique non nommée (ainsi que fonctionnant comme un programme complet avec un ^troisième argument).

Étant donné que, dans le golf, on peut créer des variables ou des fonctions auxiliaires qui restreignent le programme dans lequel ils peuvent résider (on ne peut pas réutiliser le nom dans le champ sans arrêter la fonction d'être réutilisable); également acceptable, auquel cas l'octet 7 O%32S=³serait acceptable ici en tant que fonction non nommée.

Alice , 23 octets

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

Essayez-le en ligne!

Les entrées doivent être en minuscules. Imprime 1pour les mots d'un dollar et 0autrement.

Explication

Il est temps de montrer la bande d'Alice et un flux de contrôle avancé. Bien qu'elle travaille assez bien avec les entiers et les chaînes individuellement, Alice ne dispose pas de fonctions intégrées pour a) déterminer la longueur d'une chaîne, b) convertir entre les caractères et leurs points de code. La raison en est que toutes les commandes d'Alice mappent des entiers en entiers ou des chaînes en chaînes. Mais les deux nécessiteraient de mapper des chaînes sur des nombres entiers ou vice versa, de sorte qu'elles ne s'intègrent dans aucun des modes d'Alice.

Cependant, en plus de sa pile, Alice dispose également d'une bande et les modes Cardinal et Ordinal interprètent les données de la bande de différentes manières.

• En mode Cardinal, il s’agit d’une cassette classique familière dans d’autres langues telles que Brainfuck. Vous pouvez stocker un entier dans chaque cellule et déplacer une tête de bande. La bande est infiniment longue et contient initialement un -1 dans chaque cellule. Les cellules sont également indexées et la tête de bande commence à l'indice 0 .
• Le mode ordinal a sa propre tête de bande (commençant également à l'indice 0 ) et interprète la bande comme une liste de chaînes. Les chaînes sont terminées par des cellules sans caractère (c'est-à-dire toute valeur qui n'est pas un point de code Unicode valide), en particulier -1 . Ainsi, en mode ordinal, la bande est initialement remplie avec des chaînes vides.

Cette bande peut être utilisée pour les deux opérations ci-dessus: pour obtenir une longueur de chaîne, nous l'écrivons sur la bande en mode Ordinal, cherchons la terminaison -1 en mode Cardinal et récupérons la position de la tête de la bande. Pour convertir les caractères en leurs points de code, nous les lisons simplement sur la bande en mode Cardinal.

Les deux autres fonctionnalités importantes utilisées dans cette solution sont la pile de retour et un itérateur. Alice a une pile de retour qui est généralement remplie lorsque vous utilisez la commande jump jet sur laquelle vous pouvez extraire une adresse k. Cependant, il est également possible de placer l'adresse actuelle dans la pile de retour sans sauter n'importe où avec w. Si nous combinons wavec la commande repeat& , nous pouvons pousser l'adresse actuelle n fois. Maintenant, chaque fois que nous atteignons k, une copie est extraite de la pile de retour et nous effectuons une autre itération à partir de w(en partant de la cellule suivante, car l’IP se déplace avant d’exécuter une autre commande). Quand la pile de retour devient vide,kne fait rien du tout et l'IP passe simplement à travers. D'où &w...kapparaît un entier n puis s'exécute ... n + 1 fois, ce qui nous donne un moyen très concis d'exprimer une forboucle simple .

Sur le code lui-même ...

/     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 octets

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

-1 octet grâce à BLT

• renvoie une fonction qui effectue le calcul requis, qui retourne TRUEet FALSEcomme on pourrait s'y attendre.

• prend les entrées en minuscules; serait seulement un passage de lettersà LETTERSpour toutes les majuscules

Ruby, 25 octets

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

Fonctionne en majuscule.

Je vois quelques entrées Ruby plus complexes, mais c'est aussi simple que cela. s.sumajoute les codes ASCII de la chaîne d'entrée et en soustrait 64 fois la longueur de la chaîne.

Exemple d'utilisation

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

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

Java 8, 36 octets

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

Essayez-le en ligne!

Remarque: indépendant du cas.

05AB1E , 9 octets

5bIvAyk>-

Essayez-le en ligne!

Explication

Comme 1 est la seule valeur de vérité dans 05AB1E, nous pouvons enregistrer un octet en utilisant la soustraction par rapport à 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 octets

-1 octet grâce à @Neil ( 31&au lieu de -96+).

29 octets de code + -pdrapeau.

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

Essayez-le en ligne!

PowerShell , 36 à 30 octets

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

Essayez-le en ligne!

Les entrées sont un tableau, mais je me demande s’il existe une meilleure façon de gérer les caractères.

EDIT Vous avez manqué un espace facile mais @AdmBorkBork a bien voulu me le faire savoir: P aussi, il y avait en fait un meilleur moyen de gérer les personnages!

Alice , 28 18 octets

Merci à @MartinEnder pour avoir joué au golf 10 octets

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

Essayez-le en ligne!

Cette soumission utilise une méthode différente de celle de @ MartinEnder.

Cette soumission 0x00renvoie à la fausseté et 0x01à la vérité.

Donc, voici une version qui sort 0ou à la 1place: Essayez-le!

Explication

L'explication ci-dessous concerne la version "visible". Les deux sont très similaires, sauf dans le premier programme, le dernier one convertit pas le 0ou 1en une chaîne (parce que nous sommes en mode cardinal), mais prend le nombre et affiche le caractère à ce point de code.

=                 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

Après cela, l’IP se termine sur le bord gauche =. Si la valeur supérieure de la pile est 0, l’IP continue avec son chemin, augmentant la somme totale de tous les caractères, une fois que cela est fait avec l’entrée (le haut de la pile sera 1), puis l’IP se tournera à droite (90 degrés dans le sens des aiguilles d'une montre).

Une chose est importante à noter, la boucle sur la première ligne itérera une fois après la fin de la saisie. Ceci soustraira 97( 96du '`et -1du manque d'entrée) du 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 octets

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.

Avec les sauts de ligne, cela ressemble à ceci:

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.

Il accepte les majuscules ou les minuscules, car Auctioneer Schoolil convertit le tout en majuscules.
Chop Sueyle divise en caractères individuels.
Charboil Grillconvertit les caractères en code ASCII.
Nous ramassons un caractère à la fois, le convertissons en ASCII, soustrayons 65 et nous l’ajoutons au total cumulé.
Une fois qu'il n'y a plus de caractères, comparez le total à 100.

Retours TRUEpour les mots d'un dollar et FALSEpour tout le reste.

IA-32 code machine, 21 octets

Hexdump:

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

Code d'assemblage:

    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

Compte de 100 à 0. Si arrivé à 0, renvoie vrai (0xff); sinon faux (0x00).

Dyalog APL, 17 à 15 octets

100=+/17-⍨⎕AV⍳⍞

Utilise le jeu de caractères Dyalog Classic.

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

Python , 38 octets

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

Essayez-le en ligne!

Même longueur que la solution de ovs . Plutôt que de soustraire 96 à chaque ordvaleur, cela vérifie si le ordtotal est égal 100+96*len(s). Ceci est exprimé un octet plus court que 4-96*~len(s), ce qui est égal 4-96*(-len(s)-1).

Ruby , 35 à 30 octets

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

Essayez-le en ligne!

Retina , 47 23 octets

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

Essayez-le en ligne! Remarque: Les en-têtes en-tête sont entrés et divisés en mots; les résultats apparaissent sur des lignes séparées. Edit: sauvé beaucoup trop d'octets grâce à @MartinEnder.

Octave, 18 octets

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

Soustrait 96de la chaîne d'entrée x(minuscule) pour obtenir les valeurs numériques des lettres. Prend le sumet le compare à 100. Renvoie une logique 1pour les cas véridiques et une logique 0pour les faux cas.

Je pourrais économiser un octet s'il était correct de donner false pour "mots en dollars" et vrai pour "mots non en dollars".

Japt , 13 12 10 octets

L¥U¬x_c %H

Explication:

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

Testez-le en ligne!

12 octets:

L¥U¬mc m%H x

Essayez-le en ligne!

Une autre solution de 12 octets utilisant une technique différente

L¥U¬x@;CaX Ä

Essayez-le en ligne!

Ruby (2.4+), 38 octets

Prend la saisie en minuscule. Nécessite Ruby 2.4 Array#sumpour qu'il ne fonctionne pas sur TIO.

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

/// , 564 210 189 185 octets

/~/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

Essayez-le en ligne!

Imprime un 1 s'il s'agit d'un "mot dollar", sinon un "0"

La saisie est la suivante: (Faites défiler tout le chemin à droite)

/~/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

Fonctionne en remplaçant chaque lettre par sa valeur en unaire, puis en remplaçant un unaire 100 par un 0. Il remplace alors quelle que soit la valeur du mot par un 1. Si la valeur du mot est 0, elle imprimera un 1 car à la fin de le code, il remplace un 0. Si la valeur du mot est autre chose, il imprimera simplement ce 0.

Le golf fonctionne en utilisant des occurrences communes dans le code en remplacement.

Bash + utilitaires GNU, 47

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

Essayez-le en ligne .