Bernardino identifie des mots dollar non modifiés

47

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.

Stephen
la source
20
Le titre contient des mots en dollars, désolé si cela vous a jeté.
Stephen

Réponses:

7

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.
Dennis
la source
13

Python, 39 38 octets

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

Essayez-le en ligne!


-1 octet grâce à @JonathanAllan

ovs
la source
12

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
Adnan
la source
2
Tnfonctionne aussi: P
Urne Octopus Magique
Ç4+OTn%0QC’était une autre idée que j’avais, mais c’est pire.
Urne Magic Octopus
11

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
}
Brad Gilbert b2gills
la source
11

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
Luis Mendo
la source
7

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

Arnauld
la source
Fait intéressant, quand j'ai essayé reduceet récursivité, ils sont sortis tous les deux de 2 octets de plus.
Neil
@Neil En fait, il était utilisé reduce()pendant les premières minutes de la période de grâce lorsque je l'ai posté pour la première fois.
Arnauld
7

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.

Xnor
la source
1
Vous avez raison de dire que la longueur est une honte - (100==).length.(enumFromTo 'a' =<<)est une utilisation si propre du sans-point
Julian Wolf
7

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!

Steadybox
la source
On dirait que vous pouvez sauvegarder un octet en définissant n=0globalement, puis en sautant la première clause de la spécification de boucle, non? edit: ça ne fait rien - je suppose que cela ne fonctionnerait que pour le tout premier appel.
Julian Wolf
3
Compte à rebours de 100 octets de sauvegarde? Cela &31pourrait également rendre votre code insensible à la casse.
Neil
Par curiosité, comment ça n=!nmarche? Je comprends qu’il vérifie si nest égal à zéro, car sur la base de certains tests, je vois des !0retours 1; !15retourne 0; et !-15revient 0aussi bien. Mais pourquoi? Quel opérande est !en C quand on l'utilise en tant que !integer?
Kevin Cruijssen le
@KevinCruijssen !est juste la logique not. En C, 0signifie false, et toute autre valeur entière signifie true. Alors !0 == 1et !n == 0pour tous n != 0.
Steadybox
@Steadybox Ah, je ne connaissais pas cette partie: " et toute autre valeur entière signifie true ", mais cela a du sens. J'ai toujours (à tort) pensé à cela comme à la 0=false; 1=trueplace, d'où ma confusion. Merci d'avoir répondu.
Kevin Cruijssen le
6

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.

Julian Wolf
la source
6

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.

Greg Martin
la source
6

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 2 . 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.

Jonathan Allan
la source
1
Vous pouvez également O%32S=ȷ2. Fonctionne pour les majuscules et les minuscules.
Dennis
@Dennis Cela peut être limite mais ne constituerait pas O%32S⁼³une entrée valide car il définit une fonction réutilisable non nommée, tant que le reste du programme dans lequel il se trouve n'utilise pas d'argument de ligne de commande pour la saisie?
Jonathan Allan
Hm, je suppose que cela pourrait être fait. Ce n’est pas si différent de l’utilisation d’une variable globale en C, par exemple.
Dennis
6

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.
Martin Ender
la source
Agréable! J'ai eu 41 avec mon premier essai
Kritixi Lithos le
6

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

Giuseppe
la source
1
function(x)sum(match(el(strsplit(x,"")),letters))==100enregistre un octet.
BLT
6

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"]
Level River St
la source
Cela ne fonctionne que sur Ruby 2.4 et ne fonctionne pas actuellement sur TIO
GB
1
@GB merci pour le commentaire mais je tourne sous 2.2.6 et ça marche très bien pour moi. Cette fonctionnalité est documentée depuis la 1.9.3. Cela fonctionne aussi pour TIO.run et Ideone.com.
Level River St
Vous avez raison, je pensais que c'était identique à Array # sum, qui est une nouveauté de la version 2.4
GB
En réalité, ce n'est pas la somme des valeurs ASCII, la définition est "Retourne une somme de contrôle de base à n bits des caractères dans str". Cela fonctionne dans ce cas, bien sûr.
GB
5

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
Emigna
la source
5

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!

Dada
la source
Pouvez-vous utiliser à la 31&ordplace?
Neil
@Neil Hum ... J'ai toujours utilisé -96+de telles choses .. Merci beaucoup pour ça! (mais je sens maintenant que je devrais revenir en arrière dans mes anciens messages et les remplacer tous les -96+: x)
Dada
La question spécifie que les tableaux sont autorisés en tant qu'entrée. Cela peut donc être plus bref comme sous-programme: {$@+=31&ord for@_;$@==100}(non testé)
msh210
Je suppose que cela dépend du contexte - ici, vous l’utilisez dans un +=, mais dans d’autres cas, vous pourriez gaspiller les économies réalisées entre parenthèses.
Neil
@ msh210 Le défi dit your one language's text datatypes. Les tableaux sont à peine du type de données texte de Perl ... (sinon, cela aurait économisé 1 octet)
Dada
5

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!

Sinusoïde
la source
Hiya - quelques golfs rapides. Vous n'avez pas besoin de pars autour [char]$_-96, et vous n'avez pas besoin d'espace entre -eqet et 100de vous abaisser à 33. Vous pouvez également le faire "$_"[0]au lieu de [char]$_, de vous abaisser à 32. Essayez-le en ligne!
AdmBorkBork
Les "autour sont-ils $_nécessaires? Il semble fonctionner sans le casting. Cela pourrait-il être dû au fait que l'entrée est déjà un tableau de chaînes?
Sinusoid
Ah, en effet, vous avez raison. Les "ne sont pas nécessaires dans ce cas particulier.
AdmBorkBork
5

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
Kritixi Lithos
la source
5

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.

Rôti d'ingénieur
la source
1
Dans un monde de "ennuyeux" langages de code-golf illisibles <20 octets de réponses, j'apprécie ton entrée, gentil inconnu.
Olivier Dulac le
5

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

anatolyg
la source
5

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?
Uriel
la source
Par défaut, toutes les soumissions doivent être des programmes ou des fonctions complets. Les programmes REPL sont autorisés tant qu'ils sont identifiés comme tels. Cependant, vous devez toujours demander la saisie de l'utilisateur.
Dennis
4

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

Xnor
la source
En Python 3, lambda s:sum(s.encode(),96*~len(s))==4fonctionnerait également.
Dennis
4

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.

Neil
la source
Il est beaucoup plus court de calculer les valeurs des lettres en les abaissant progressivement tout en insérant des caractères: tio.run/nexus/…
Martin Ender
4

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".

Stewie Griffin
la source
4

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!

Oliver
la source
Bon travail! Je pense que vous pouvez économiser un octet sur le premier avec m%Hau lieu de m-96(cela fonctionnera maintenant dans les deux cas, bonus!), Et un sur le second avecL¥U¬x@;CaX Ä
ETHproductions
@ETHproductions Merci! m%HC'était une bonne trouvaille. x@C'était une bonne idée aussi!
Oliver
@ETHproductions Je l'ai réduit à 10 octets;)
Oliver
3

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}
escargot_
la source
2
Utilisez String#bytesplutôt que de String#charsne pas avoir à appeler c.ord.
Value Ink
Et utiliser sumsur le tableau au lieu demap
GB
3

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

Camarade SparklePony
la source