คำนิยาม

คำดอลล่าร์เป็นคำที่เมื่อตัวอักษรแต่ละตัวได้รับค่าเซ็นต์จาก a = 1 ถึง z = 26 และตัวอักษรถูกรวมผลที่ได้คือ 100 นี่คือตัวอย่างบน CodeReview และนี่คือรายการ ของคำเงินดอลลาร์ที่ฉันพบออนไลน์

อินพุต

การป้อนข้อมูลจะเป็นตัวอักษรจาก az ในประเภทข้อมูลข้อความภาษาเดียวของคุณ (อนุญาตให้ใช้อาร์เรย์) คุณไม่จำเป็นต้องคำนึงถึงอินพุตอื่น ๆ - จะไม่มีช่องว่างเครื่องหมายวรรคตอนหรือเครื่องหมายยัติภังค์ คุณสามารถใช้ตัวพิมพ์เล็กตัวพิมพ์ใหญ่หรือชุดค่าผสม ขึ้นบรรทัดใหม่ที่ได้รับอนุญาต

เอาท์พุต

เอาท์พุทค่าความจริงหากการป้อนข้อมูลเป็นคำดอลลาร์และค่าความเท็จถ้ามันไม่ได้

กรณีทดสอบ

Truthy:

buzzy
boycott
identifies
adiabatically
ttttt

Falsey:

zzz
zzzzzzz
abcdefghiljjjzz
tttt
basic

นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ! มีช่องโหว่และกฎมาตรฐานที่บังคับใช้ ผูกไปที่โปสเตอร์แรก

GS2 , 6 ไบต์

▲1Θd←q

ข้อมูลที่ป้อนต้องเป็นตัวพิมพ์ใหญ่

ลองออนไลน์!

มันทำงานอย่างไร

  Θ       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 ไบต์

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

ลองออนไลน์!

-1 ไบต์ขอบคุณ @JonathanAllan

05AB1E , 8 ไบต์

รหัส:

Ç96-O4bQ

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!

คำอธิบาย:

Ç          # 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 ไบต์

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

ลองมัน

สำรอง:

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

ลองมัน

โปรดทราบว่าⅭเป็นROMAN NUMERAL ONE HUNDREDU + 216D ด้วยความไม่สมดุลของ ... 100
ซึ่งใช้เวลา 3 ไบต์ในการเข้ารหัส

ขยาย:

{  # 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 ไบต์

96-s100=

ใช้อินพุตตัวพิมพ์เล็ก

ลองออนไลน์!

คำอธิบาย

รหัสสามารถอ่านได้ตามที่ได้รับ:

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 ไบต์

ผลตอบแทนหรือ01

let f =

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

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

Haskell , 32 ไบต์

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

ลองออนไลน์!

แนวคิดคือการสร้างรายการของตัวละครจากaไปยังตัวละครที่กำหนดสำหรับตัวละครแต่ละตัวในรายการและตรวจสอบว่าความยาวทั้งหมดคือ 100

ความพยายามอื่น ๆ :

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

เลวร้ายเกินไปenumFromToนานมาก

C, 45 43 ไบต์

ขอบคุณ @Neil สำหรับการบันทึกสองไบต์และทำให้การแก้ปัญหาเล็ก ๆ

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

ลองออนไลน์!

Haskell , 32 ไบต์

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

มันใช้งานได้กับอินพุตตัวพิมพ์เล็ก สำหรับตัวพิมพ์ใหญ่, s/96/64/. การสนับสนุนตัวพิมพ์ใหญ่จะเพิ่มจำนวนไบต์

Mathematica ขนาด 23 ไบต์

100==Tr@LetterNumber@#&

ฟังก์ชั่นการถ่ายเพียวสตริง (หรืออาร์เรย์ของตัวอักษร) ที่เป็น input กรณีตายและกลับมาหรือTrue Falseที่นี่Trเพียงเพิ่มตัวเลขตัวอักษรเข้าด้วยกัน ทุกสิ่งทุกอย่างสามารถอธิบายตนเองได้

เยลลี่ , 9 7? * 8 ไบต์

ɠO%32S⁼³

โปรแกรมเต็มเอาต์พุต 1 หากอินพุตเป็นคำดอลล่าร์หรือ 0 ถ้าไม่ใช่

ลองออนไลน์!

อย่างไร?

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

* สามารถเป็น 7 ไบต์ได้หรือไม่

เหตุผลเดียวที่นี้เอาการป้อนข้อมูลด้วยɠก็เพื่อให้³เป็นตัวอักษร 100 มากกว่า 3 ^ถอินพุตบรรทัดคำสั่ง (1 ^{เซนต์}โปรแกรมการป้อนข้อมูล)

วิธีที่จะหลีกเลี่ยงที่จะเป็นออกแหลมโดยเดนนิสเพื่อสร้าง 100 โดยใช้รูปแบบตัวอักษรดิบȷ2ซึ่งเป็น 10 2 สิ่งนี้นำไปสู่อีก 8 ไบต์O%32S=ȷ2แต่ตอนนี้เป็นฟังก์ชัน monadic ที่ไม่มีชื่อ (เช่นเดียวกับการทำงานเป็นโปรแกรมเต็มรูปแบบที่มีอาร์กิวเมนต์3 ^rd )

เนื่องจากในวงการกอล์ฟหนึ่งอาจสร้างตัวแปรหรือฟังก์ชั่นตัวช่วยที่ จำกัด โปรแกรมที่พวกเขาอาจอาศัยอยู่ (หนึ่งไม่สามารถใช้ชื่อในขอบเขตโดยไม่หยุดฟังก์ชั่นจากการถูกนำมาใช้ซ้ำ) อาจ จำกัด โปรแกรมเพื่อรับอินพุตจาก STDIN เท่านั้น ก็สามารถยอมรับได้ซึ่งในกรณีนี้ 7 ไบต์O%32S=³จะยอมรับได้ในที่นี้ว่าเป็นฟังก์ชั่นที่ไม่มีชื่อ

อลิซ 23 ไบต์

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

ลองออนไลน์!

อินพุตควรเป็นตัวพิมพ์เล็ก พิมพ์1คำดอลล่าร์และ0อื่น ๆ

คำอธิบาย

ถึงเวลาอวดเทปของอลิซและการควบคุมขั้นสูงบางส่วน แม้จะมีความสามารถในการทำงานกับจำนวนเต็มและสตริงได้ค่อนข้างดี แต่อลิซยังไม่มีตัวใน a) กำหนดความยาวของสตริง b) แปลงระหว่างอักขระและจุดโค้ด เหตุผลนี้เป็นเพราะคำสั่งทั้งหมดของอลิสแมปจำนวนเต็มเป็นจำนวนเต็มหรือสตริงกับสตริง แต่ทั้งคู่จะต้องใช้สตริงการจับคู่เป็นจำนวนเต็มหรือในทางกลับกันดังนั้นพวกเขาจึงไม่เข้ากับโหมดของอลิซอย่างใดอย่างหนึ่ง

อย่างไรก็ตามนอกเหนือจากสแต็กแล้ว Alice ยังมีเทปและโหมด Cardinal และ Ordinal ตีความข้อมูลบนเทปในรูปแบบต่างๆ

• ในโหมด Cardinal มันเป็นเทปปกติที่คุ้นเคยจากภาษาอื่นเช่น Brainfuck คุณสามารถเก็บจำนวนเต็มหนึ่งจำนวนในแต่ละเซลล์และคุณสามารถย้ายหัวเทปได้ เทปมีความยาวไม่สิ้นสุดและเริ่มแรกถือ-1ในทุกเซลล์ เซลล์ที่มีการจัดทำดัชนีและยังหัวเทปเริ่มต้นที่ดัชนี0
• โหมด Ordinal มีหัวเทปของตัวเอง (เริ่มจากดัชนี0 ) และตีความเทปเป็นรายการสตริง สตริงจะสิ้นสุดโดยเซลล์ที่ไม่ใช่ตัวอักษร (ค่าเช่นใด ๆ ที่ไม่ได้จุดรหัส Unicode ที่ถูกต้อง) โดยเฉพาะอย่างยิ่ง-1 ดังนั้นสำหรับโหมด Ordinal เทปจะเต็มไปด้วยสตริงว่างเปล่าในตอนแรก

เทปนี้สามารถใช้สำหรับการดำเนินการทั้งสองข้างต้น: เพื่อให้ได้ความยาวสตริงเราเขียนมันลงในเทปในโหมด Ordinal, ค้นหาการยุติ-1ในโหมด Cardinal และดึงตำแหน่งของหัวเทป ในการแปลงตัวอักษรเป็นจุดรหัสเราเพียงแค่อ่านมันออกจากเทปในโหมด Cardinal

คุณสมบัติที่สำคัญอีกสองประการที่ใช้ในการแก้ปัญหานี้คือสแต็กคืนและตัววนซ้ำ อลิซมีกองผลตอบแทนซึ่งมักจะเต็มไปเมื่อใช้คำสั่งกระโดดjและที่คุณสามารถ pop kที่อยู่จากการกระโดดกลับมาพร้อมกับ อย่างไรก็ตามมันเป็นไปได้ที่จะผลักดันที่อยู่ปัจจุบันไปยังกองซ้อนกลับโดยไม่ต้องกระโดดไปไหนwเลย หากเรารวมwกับคำสั่งซ้ำ&เราสามารถส่งที่อยู่ปัจจุบันไปยังสแต็กส่งคืนnครั้ง ตอนนี้ทุกครั้งที่เราไปถึงkสำเนาหนึ่งชุดจะถูกดึงออกจาก stack stack และเราทำการวนซ้ำอีกครั้งw(เริ่มที่เซลล์หลังจากนั้นเพราะ IP เคลื่อนที่ก่อนดำเนินการคำสั่งอื่น) เมื่อสแต็กคืนว่างเปล่าkไม่ทำอะไรเลยและ IP ก็แค่ผ่านไป ดังนั้น&w...kจะปรากฏจำนวนเต็มnและจากนั้นดำเนินการ... n + 1ครั้งซึ่งทำให้เรามีวิธีรัดกุมมากในการแสดงการforวนรอบง่าย

เพื่อรหัสตัวเอง ...

/     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 ไบต์

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

-1 ไบต์ต้องขอบคุณ BLT

• ส่งคืนฟังก์ชันที่ใช้ในการคำนวณที่ต้องการซึ่งส่งคืนTRUEและFALSEตามที่ต้องการ

• ใช้อินพุตเป็นตัวพิมพ์เล็ก จะเปลี่ยนจากlettersเป็นเป็นLETTERSสำหรับตัวพิมพ์ใหญ่ทั้งหมด

ทับทิมขนาด 25 ไบต์

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

ใช้งานได้กับตัวพิมพ์ใหญ่

ฉันเห็นรายการ Ruby ที่ซับซ้อนกว่านี้สองสามอัน แต่มันก็ง่ายมาก s.sumเพิ่มรหัส ASCII ของสายป้อนและจากนี้เราลบ 64 เท่าของความยาวของสตริง

ตัวอย่างการใช้งาน

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

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

Java 8, 36 ไบต์

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

ลองออนไลน์!

หมายเหตุ: กรณีที่เป็นอิสระ

05AB1E , 9 ไบต์

5bIvAyk>-

ลองออนไลน์!

คำอธิบาย

ในฐานะที่เป็น1เป็นค่าเพียง truthy ใน 05AB1E เราสามารถบันทึกไบต์โดยใช้การลบมากกว่าเมื่อเทียบกับ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 ไบต์

-1 ไบต์ขอบคุณ @Neil ( 31&แทน-96+)

29 ไบต์ของรหัส + -pธง

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

ลองออนไลน์!

PowerShell , 36 30 ไบต์

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

ลองออนไลน์!

ใส่เป็นอาร์เรย์ แต่ฉันสงสัยว่าถ้ามีวิธีที่ดีกว่าในการจัดการกับตัวละคร

แก้ไขพลาดช่องว่างง่ายๆ แต่ @AdmBorkBork กรุณาแจ้งให้เราทราบ: P ด้วยจริง ๆ แล้วเป็นวิธีที่ดีกว่าในการจัดการกับตัวละคร!

อลิซ , 28 18 ไบต์

ขอบคุณ @MartinEnder สำหรับการเล่นกอล์ฟขนาด 10 ไบต์

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

ลองออนไลน์!

การส่งนี้ใช้วิธีอื่นที่ไม่ใช่คำตอบของ @ MartinEnder

การส่งนี้ส่งออก0x00สำหรับเท็จและ0x01เพื่อความจริง

ดังนั้นนี่คือรุ่นที่มีเอาต์พุต0หรือ1แทนที่: ลอง!

คำอธิบาย

คำอธิบายด้านล่างนี้สำหรับรุ่น "มองเห็นได้" ทั้งคู่มีลักษณะคล้ายกันมากยกเว้นในโปรแกรมแรกตัวสุดท้ายoไม่แปลง0หรือ1เป็นสตริง (เพราะเราอยู่ในโหมดที่สำคัญ) แต่ใช้ตัวเลขและเอาท์พุทอักขระที่จุดโค้ดนั้นแทน

=                 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

หลังจากนี้ IP =ล้อมรอบไปที่ขอบด้านซ้ายที่ หากค่าสูงสุดของสแต็คคือ0IP ยังคงดำเนินต่อไปพร้อมกับพา ธ ของมันเพิ่มผลรวมทั้งหมดของอักขระทั้งหมดเมื่อเสร็จสิ้นด้วยอินพุต (ด้านบนของสแต็กจะเป็น1) IP จะเลี้ยวขวา (90 องศาตามเข็มนาฬิกา)

สิ่งหนึ่งที่สำคัญคือต้องทราบการวนรอบบนบรรทัดแรกจะวนซ้ำหลังจากอินพุตสิ้นสุดลง วิธีนี้จะลบ97( 96จาก'`และ-1จากการขาดอินพุต) จากผลรวม

>                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

แท็กซี่ 1259 ไบต์

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.

ด้วยการขึ้นบรรทัดใหม่ดูเหมือนว่า:

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.

มันยอมรับบนหรือล่างเพราะAuctioneer Schoolแปลงมันทั้งหมดเพื่อตัวพิมพ์ใหญ่
Chop Sueyแบ่งเป็นอักขระแต่ละตัว
Charboil Grillแปลงอักขระเป็นรหัส ASCII
เรารับหนึ่งตัวอักษรต่อครั้งแปลงเป็น ASCII ลบ 65 และเพิ่มเป็นผลรวมสะสม
เมื่อไม่มีตัวละครเพิ่มให้เปรียบเทียบกับทั้งหมด 100

ส่งคืนTRUEสำหรับคำดอลลาร์และFALSEทุกอย่างอื่น

รหัสเครื่อง IA-32 ขนาด 21 ไบต์

hexdump:

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

รหัสการประกอบ:

    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

นับจาก 100 ถึง 0 หากมาถึง 0 จะส่งกลับค่าจริง (0xff) มิฉะนั้นเป็นเท็จ (0x00)

Dyalog APL, 17 15 ไบต์

100=+/17-⍨⎕AV⍳⍞

ใช้ชุดอักขระ Dyalog Classic

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

Pythonขนาด 38 ไบต์

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

ลองออนไลน์!

ยาวเช่นเดียวกับวิธีการแก้ปัญหาของ OVS แทนที่จะลบ 96 จากแต่ละordค่าการตรวจสอบนี้จะordเท่ากับทั้งหมด100+96*len(s)หรือไม่ นี้จะแสดงหนึ่งไบต์สั้นลงซึ่งเท่ากับ4-96*~len(s)4-96*(-len(s)-1)

Ruby , 35 30 ไบต์

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

ลองออนไลน์!

เรติน่า47 47ไบต์

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

ลองออนไลน์! หมายเหตุ: ส่วนหัวลดขนาดอินพุตและแยกเป็นคำ ผลลัพธ์จะปรากฏในบรรทัดแยกกัน แก้ไข: บันทึกจำนวนมากเกินไปต้องขอบคุณ @MartinEnder

อ็อกเทฟ, 18 ไบต์

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

ลบ96ออกจากสตริงอินพุตx(ตัวพิมพ์เล็ก) เพื่อรับค่าตัวเลขของตัวอักษร เตะและเปรียบเทียบกับsum 100ส่งคืนตรรกะ1สำหรับคดีจริงและตรรกะ0สำหรับคดีเท็จ

ฉันสามารถบันทึกหนึ่งไบต์ได้ถ้าตกลงที่จะให้เท็จสำหรับ "คำดอลลาร์" และจริงสำหรับ "คำที่ไม่ใช่ดอลลาร์"

Japt , 13 12 10 ไบต์

L¥U¬x_c %H

คำอธิบาย:

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

ทดสอบออนไลน์!

12 ไบต์:

L¥U¬mc m%H x

ลองออนไลน์!

โซลูชัน 12 ไบต์อื่นโดยใช้เทคนิคที่แตกต่าง

L¥U¬x@;CaX Ä

ลองออนไลน์!

ทับทิม (2.4+), 38 ไบต์

ใช้อินพุตเป็นตัวพิมพ์เล็ก ต้องการ Ruby 2.4 Array#sumเพื่อไม่ให้ทำงานบน TIO

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

/// , 564 210 189 185 ไบต์

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

ลองออนไลน์!

พิมพ์ 1 หากเป็น "ดอลล่าร์คำ" มิฉะนั้นจะพิมพ์ "0"

อินพุตมีดังต่อไปนี้: (เลื่อนไปจนสุดทางขวา)

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

ทำงานโดยแทนที่ตัวอักษรแต่ละตัวด้วยค่าเป็น unary จากนั้นแทนที่ unary 100 ด้วย 0 จากนั้นจะแทนที่สิ่งใดก็ตามที่ค่าของคำนั้นมีค่าเป็น 1 หากค่าของคำเป็น 0 แล้วมันจะพิมพ์ 1 เพราะเมื่อสิ้นสุด รหัสมันจะถูกแทนที่ 0 ถ้าค่าของคำเป็นสิ่งอื่นมันก็จะพิมพ์ว่า 0

กอล์ฟทำงานโดยใช้สิ่งที่เกิดขึ้นทั่วไปในรหัสเป็นสิ่งทดแทน

Bash + GNU utils, 47

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

ลองมันออนไลน์