Definizione

Una parola in dollari è una parola in cui quando a ciascuna delle sue lettere viene assegnato un valore in cent, da a = 1 a z = 26, e le lettere vengono sommate, il risultato è 100. Ecco un esempio su CodeReview, ed ecco un elenco di parole in dollari che ho trovato online.

Ingresso

L'input sarà in ordine alfabetico da az, nei tipi di dati di testo della tua lingua (sono consentite le matrici). Non è necessario tenere conto di altri input: non ci saranno spazi, apostrofi o trattini. Puoi prendere in minuscolo, maiuscolo o una combinazione. Sono consentite nuove righe finali.

Produzione

Emette un valore di verità se l'input è una parola in dollari e un valore di falsa in caso contrario.

Casi test

Truthy:

buzzy
boycott
identifies
adiabatically
ttttt

Falsey:

zzz
zzzzzzz
abcdefghiljjjzz
tttt
basic

Questo è code-golf, quindi vince la risposta più breve in byte! Si applicano scappatoie e regole standard. La cravatta va al primo poster.

GS2 , 6 byte

▲1Θd←q

L'input deve essere in maiuscolo.

Provalo online!

Come funziona

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

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

Provalo online!

-1 byte grazie a @JonathanAllan

05AB1E , 8 byte

Codice:

Ç96-O4bQ

Utilizza la codifica CP-1252 . Provalo online!

Spiegazione:

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

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

Provalo

Alternato:

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

Provalo

Si noti che Ⅽè ROMAN NUMERAL ONE HUNDREDU + 216D con univalente di ... 100
che richiede 3 byte per codificare.

Allargato:

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

96-s100=

Usa input in minuscolo.

Provalo online!

Spiegazione

Il codice è leggibile come ottiene:

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 byte

Restituisce 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 byte

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

Provalo online!

L'idea è di creare un elenco di caratteri dal acarattere specificato per ciascun personaggio nell'elenco e verificare che la lunghezza totale sia 100.

Altri tentativi:

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

Peccato enumFromToè così lungo.

C, 45 43 byte

Grazie a @Neil per il salvataggio di due byte e la distinzione tra maiuscole e minuscole!

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

Provalo online!

Haskell , 32 byte

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

Funziona con input in minuscolo. Per maiuscolo, s/96/64/. Il supporto per casi misti aggiungerebbe un mucchio di byte.

Mathematica, 23 byte

100==Tr@LetterNumber@#&

Funzione pura che accetta una stringa (o una matrice di lettere) come input, senza distinzione tra maiuscole e minuscole e ritorno Trueo False. Qui Traggiunge solo i numeri delle lettere insieme; tutto il resto è autoesplicativo.

Gelatina , 9 7? * 8 byte

ɠO%32S⁼³

Programma completo, in uscita 1 se l'input è una parola in dollari, o 0 in caso contrario.

Provalo online!

Come?

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

* Potrebbe essere 7 byte?

L'unica ragione per questo ha preso in ingresso con ɠera di mantenere ³come letterale 100 piuttosto che il 3 ^° ingresso di linea di comando (1 ^° ingresso di programma).

Un modo per evitarlo sarebbe, come sottolineato da Dennis, creare 100 usando la forma letterale grezza ȷ2che è 10 ² . Ciò porta a un altro 8 byte O%32S=ȷ2, ma ora è una funzione monadica senza nome (oltre a funzionare come un programma completo con un ^terzo argomento).

Dal momento che, nel golf, si possono creare variabili o funzioni di supporto che limitano il programma in cui possono risiedere (non è possibile riutilizzare il nome nell'ambito senza arrestare la funzione da riutilizzabile), forse limitando il programma a prendere solo input da STDIN potrebbe anche accettabile, nel qual caso il 7 byte O%32S=³sarebbe accettabile qui come una funzione senza nome.

Alice , 23 byte

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

Provalo online!

L'input deve essere minuscolo. Stampa 1per parole in dollari e 0altro.

Spiegazione

È ora di mostrare il nastro di Alice e alcuni flussi di controllo avanzati. Nonostante sia abbastanza bravo a lavorare con numeri interi e stringhe singolarmente, Alice non ha built-in per a) determinare la lunghezza di una stringa, b) convertire tra caratteri e i loro punti di codice. La ragione di ciò è che tutti i comandi di Alice mappano numeri interi a numeri interi o stringhe a stringhe. Ma entrambi richiederebbero di mappare le stringhe su numeri interi o viceversa, quindi non si adattano a nessuna delle modalità di Alice.

Tuttavia, oltre allo stack, Alice ha anche un nastro e la modalità Cardinale e Ordinale interpretano i dati sul nastro in diversi modi

• In modalità Cardinale, è un normale nastro familiare da altre lingue come Brainfuck. È possibile memorizzare un numero intero in ogni cella e spostare una testina. Il nastro è infinitamente lungo e inizialmente contiene un -1 in ogni cella. Anche le celle sono indicizzate e la testina del nastro inizia all'indice 0 .
• La modalità ordinale ha una propria testina di nastro (anche a partire dall'indice 0 ) e interpreta il nastro come un elenco di stringhe. Le stringhe sono terminate da celle non di carattere (ovvero qualsiasi valore che non sia un punto di codice Unicode valido), in particolare -1 . Quindi, per la modalità Ordinale, il nastro è inizialmente riempito con stringhe vuote.

Questo nastro può essere utilizzato per entrambe le operazioni precedenti: per ottenere una lunghezza della stringa, lo scriviamo sul nastro in modalità Ordinale, cerchiamo il -1 finale in modalità Cardinale e recuperiamo la posizione della testina. Per convertire i caratteri nei loro punti di codice, li leggiamo semplicemente dal nastro in modalità Cardinale.

Le altre due importanti funzionalità utilizzate in questa soluzione sono lo stack di ritorno e un iteratore. Alice ha uno stack di ritorno che di solito viene riempito quando si utilizza il comando jump je con il quale è possibile far apparire un indirizzo per tornare indietro k. Tuttavia, è anche possibile spingere l'indirizzo corrente nello stack di ritorno senza saltare da nessuna parte w. Se ci combiniamo wcon il comando repeat& , possiamo inviare l'indirizzo corrente allo stack di ritorno n volte. Ora ogni volta che raggiungiamo k, una copia viene estratta dallo stack di ritorno ed eseguiamo un'altra iterazione da w(iniziando dalla cella dopo di essa, perché l'IP si sposta prima di eseguire un altro comando). Quando lo stack di ritorno diventa vuoto,knon fa nulla e l'IP passa semplicemente. Quindi &w...kapre un numero intero n e quindi esegue ... n + 1 volte, il che ci dà un modo molto conciso per esprimere un semplice forciclo.

Sul codice stesso ...

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

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

-1 byte grazie a BLT

• restituisce una funzione che esegue il calcolo richiesto, che ritorna TRUEe FALSEcome ci si aspetterebbe.

• accetta l'input in minuscolo; sarebbe solo un passaggio da lettersa LETTERSper tutte le maiuscole

Rubino, 25 byte

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

Funziona in maiuscolo.

Vedo un paio di voci Ruby più complesse, ma è davvero così semplice. s.sumaggiunge i codici ASCII della stringa di input e da questo sottraggiamo 64 volte la lunghezza della stringa.

Esempio di utilizzo

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

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

Java 8, 36 byte

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

Provalo online!

Nota: case indipendente.

05AB1E , 9 byte

5bIvAyk>-

Provalo online!

Spiegazione

Poiché 1 è l'unico valore di verità in 05AB1E, possiamo salvare un byte usando la sottrazione rispetto 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 byte

-1 byte grazie a @Neil ( 31&invece di -96+).

29 byte di codice + -pflag.

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

Provalo online!

PowerShell , 36 30 byte

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

Provalo online!

Input come array, ma mi chiedo se esiste un modo migliore per gestire i personaggi.

EDIT Mancava uno spazio facile ma @AdmBorkBork mi ha fatto gentilmente sapere: P, in effetti, c'era in effetti un modo migliore di gestire i personaggi!

Alice , 28 18 byte

Grazie a @MartinEnder per giocare a golf 10 byte

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

Provalo online!

Questo invio utilizza un metodo diverso rispetto alla risposta di @ MartinEnder.

Questa presentazione produce 0x00falsità e 0x01verità.

Quindi ecco una versione che emette 0o 1invece: provalo!

Spiegazione

La spiegazione seguente è per la versione "visibile". Entrambi sono molto simili, tranne nel primo programma, l'ultimo onon converte 0né 1una stringa (perché siamo in modalità cardinale), ma invece prende il numero e genera il carattere in quel punto di codice.

=                 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

Successivamente, l'IP si sposta sul bordo sinistro del =. Se il valore massimo dello stack è 0, l'IP continua con il suo percorso, aumentando la somma totale di tutti i caratteri, una volta fatto con l'input (la parte superiore dello stack sarà 1), quindi l'IP gira a destra (90 gradi in senso orario).

Una cosa è importante notare, il loop sulla prima riga ripeterà una volta dopo che l'input è terminato. Questo sottrarrà 97( 96dalla '`e -1dalla mancanza di input) dal totale.

>                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 byte

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 le interruzioni di riga, si presenta così:

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.

Accetta maiuscole o minuscole perché Auctioneer Schoolconverte tutto in maiuscolo.
Chop Sueylo divide in singoli personaggi.
Charboil Grillconverte i caratteri nel loro codice ASCII.
Raccogliamo un carattere alla volta, lo convertiamo in ASCII, sottraggiamo 65 e lo aggiungiamo al totale parziale.
Quando non ci sono più personaggi, confronta il totale con 100.

Restituisce TRUEper parole in dollari e FALSEper tutto il resto.

Codice macchina IA-32, 21 byte

hexdump:

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

Codice dell'Assemblea:

    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 da 100 a 0. Se arrivato a 0, restituisce true (0xff); altrimenti falso (0x00).

Dyalog APL, 17 15 byte

100=+/17-⍨⎕AV⍳⍞

Utilizza il set di caratteri Dyalog Classic.

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

Python , 38 byte

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

Provalo online!

Stessa lunghezza della soluzione di ovs . Invece di sottrarre 96 da ciascun ordvalore, questo controlla se il ordtotale è uguale 100+96*len(s). Questo è espresso con un byte più breve di 4-96*~len(s), che equivale 4-96*(-len(s)-1).

Rubino , 35 30 byte

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

Provalo online!

Retina , 47 23 byte

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

Provalo online! Nota: l'intestazione mette in minuscolo l'input e lo divide in parole; i risultati vengono visualizzati su righe separate. Modifica: salvato troppi byte grazie a @MartinEnder.

Ottava, 18 byte

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

Sottrae 96dalla stringa di input x( lettere minuscole) per ottenere i valori numerici delle lettere. Prende il sume lo confronta con 100. Restituisce un logico 1per casi veritieri e un logico 0per casi falsi.

Potrei salvare un byte se fosse OK dare false per "parole in dollari" e true per "parole non in dollari".

Japt , 13 12 10 byte

L¥U¬x_c %H

Spiegazione:

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

Provalo online!

12-byte:

L¥U¬mc m%H x

Provalo online!

Un'altra soluzione a 12 byte che utilizza una tecnica diversa

L¥U¬x@;CaX Ä

Provalo online!

Rubino (2.4+), 38 byte

Riceve input in minuscolo. Richiede Ruby 2.4, Array#sumquindi non funzionerà su TIO.

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

/// , 564 210 189 185 byte

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

Provalo online!

Stampa un 1 se è una "parola del dollaro", altrimenti stampa uno "0"

L'input è il seguente: (Scorri completamente verso destra)

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

Funziona sostituendo ogni lettera con il suo valore in unario, quindi sostituendo un unario 100 con uno 0. Quindi sostituisce qualunque sia il valore della parola con un 1. Se il valore della parola è 0, quindi stamperà un 1 perché alla fine di il codice, sta sostituendo uno 0. Se il valore della parola è qualcos'altro, stamperà semplicemente quello 0.

Il golf funziona usando le ricorrenze comuni nel codice come rimpiazzi.

Utilità Bash + GNU, 47

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

Provalo online .