พวกเขาเรียกฉันว่าสารวัตรมอร์ส


20

ภารกิจของคุณคุณควรเลือกที่จะยอมรับหรือไม่คือการตัดสินใจว่าสตริงอินพุตที่กำหนดเป็น Dot-heavy หรือ Dash-heavy

สตริงเป็นจุดหนักเมื่อการแสดงมอร์สของมันมีจุดมากกว่าขีดกลาง ตัวอย่างเช่นตัวอักษร E เป็นจุดเดียวซึ่งหมายความว่ามันเป็นจุดหนา

อินพุต

  • สตริงอินพุตจะมีอักขระอยู่ในช่วง[a-z]หรือ[A-Z]เท่านั้น คุณสามารถตัดสินใจว่าพวกเขาควรจะทั้งหมดเป็นกรณีบนหรือกรณีที่ต่ำกว่า AAAจะปรับaaaจะปรับaAaไม่ได้
  • สตริงอินพุตจะมีความยาวอย่างน้อย 1 อักขระเสมอ
  • คุณอาจคิดว่าสตริงอินพุตจะไม่มีจุดและขีดคั่นเท่ากัน

เอาท์พุต

คุณควรกลับTruthyสำหรับอินพุตที่มีอักขระจุดมากขึ้น
คุณควรกลับ Falsy สำหรับอินพุตที่มีอักขระขีดกลางมากกว่า
แก้ไข: ฉันจะอนุญาตค่าบวกสำหรับจุดและค่าลบสำหรับเส้นประเช่นกัน

กรณีทดสอบ

| input | morse representation | result          |
|------------------------------------------------|
| S     | ...                  | Truthy          |
| k     | -.-                  | Falsy           |
| HELLO | .... . .-.. .-.. --- | Truthy          |
| code  | -.-. --- -.. .       | Falsy           |

การอ้างอิง

รหัสมอร์สสากล

นี่คือรหัสกอล์ฟรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ



4
เราสามารถคืนค่าที่สูงกว่า 0 สำหรับ dotheavy และค่าลบสำหรับเส้นประหนักได้หรือไม่?
ศูนย์รวมแห่งความไม่รู้

@EmbodimentofIgnorance ที่เหมาะกับฉันตราบใดที่คุณระบุไว้ในโพสต์ของคุณ ฉันไม่คิดว่ามันมักจะผ่านการทดสอบเท็จจริง แต่มันให้ความรู้สึกเหมือนเป็นทางออกที่ดีในกรณีนี้ดังนั้นฉันจะอนุญาต
Bassdrop Cumberwubwubwub

คำตอบ:


5

APL (Dyalog Extended) , 24  15 ไบต์SBCS

-9 ขอบคุณ Ven

ฟังก์ชั่นคำนำหน้าเงียบโดยไม่ระบุชื่อโดยใช้ตัวพิมพ์ใหญ่เป็นอาร์กิวเมนต์

>/'.-'⍧∊∘⌂morse

ลองออนไลน์!

⌂morse แปลงรายการของสตริงมอร์ส
 แล้ว
ε nlist (แบน)
'.-'⍧ นับจำนวนจุดและขีดกลางในการที่
>/ จุดมากกว่าขีดกลาง? (ลดความสว่างมากกว่าการจุด)


ทำไมไม่มี Extended preload dfns เป็นค่าเริ่มต้น
ngn

@ngn มันถูกสร้างขึ้นในขณะนี้
อดัม

7

IBM PC DOS, ชุดประกอบ 8088, 54 35 ไบต์

-19 ไบต์โดยใช้วิธีการต่างกัน

ac2c 41d0 d8d7 7206 51b1 04d2 e859 240f 2c03 02e0 e2ea 3534 4527 4125 1303 1462 4523 13

แต่อย่างใด:

; compare dashes and dots in a morse code string
; input:
;   I: pointer to input string (default SI)
;   IL: length of input string (default CX)
;   TBL: pointer to data table (default BX)
; output:
;   Sign/OF flags: Dot-heavy: SF == OF (JGE), Dash-heavy: SF != OF (JL)
MORSE_DD    MACRO   I, IL, TBL
            LOCAL   LOOP_LETTER, ODD
        IFDIFI <I>,<SI>     ; skip if S is already SI
    MOV  SI, I              ; load string into SI 
        ENDIF
        IFDIFI <IL>,<CX>    ; skip if IL is already CX
    MOV  CX, IL             ; set up loop counter
        ENDIF
        IFDIFI <TBL>,<BX>   ; skip if TBL is already BX
    MOV  BX, OFFSET TBL     ; load letter table into BX
        ENDIF
LOOP_LETTER:
    LODSB                   ; load next char from DS:SI into AL, advance SI
    ;AND  AL, 0DFH           ; uppercase the input letter (+2 bytes)
    SUB  AL, 'A'            ; convert letter to zero-based index
    RCR  AL, 1              ; divide index by 2, set CF if odd index
    XLAT                    ; lookup letter in table
    JC   ODD                ; if odd index use low nibble; if even use high nibble
    PUSH CX                 ; save loop counter (since SHR can only take CL on 8088)
    MOV  CL, 4              ; set up right shift for 4 bits
    SHR  AL, CL             ; shift right
    POP  CX                 ; restore loop counter
ODD:
    AND  AL, 0FH            ; mask low nibble
    SUB  AL, 3              ; unbias dash/dot difference +3 positive
    ADD  AH, AL             ; add letter difference to sum (set result flags)
    LOOP LOOP_LETTER
        ENDM

TBL DB 035H, 034H, 045H, 027H, 041H, 025H, 013H, 003H, 014H, 062H, 045H, 023H, 013H

คำอธิบาย

มีการใช้งานในไวยากรณ์ Intel / MASM เป็น MACRO (โดยทั่วไปเป็นฟังก์ชั่น) โดยใช้เพียงคำสั่งที่เข้ากันได้ 8088 เท่านั้น อินพุตเป็นสตริงตัวพิมพ์ใหญ่ (หรือ +2 ไบต์เพื่ออนุญาตให้ใช้ตัวพิมพ์เล็ก) เอาต์พุตผลลัพธ์ Truthy / Falsy คือSF == OF(ใช้JGหรือJLเพื่อทดสอบ)

ค่าตารางความแตกต่างของตัวอักษรจะถูกเก็บไว้ในรูปแบบไบนารีดังนั้นจะใช้เวลาเพียง 13 ไบต์เท่านั้น

ดั้งเดิม (54 ไบต์):

; compare dashes and dots in a Morse code string
; input:
;   I: pointer to input string (default SI)
;   IL: length of input string (default CX)
;   TBL: pointer to data table
; output:
;   Carry Flag: CF=1 (CY) if dot-heavy, CF=0 (NC) if dash-heavy
MORSE_DD    MACRO   I, IL, TBL
            LOCAL   LOOP_LETTER
        IFDIFI <I>,<SI>     ; skip if S is already SI
    MOV  SI, I              ; load string into SI 
        ENDIF
        IFDIFI <IL>,<CX>    ; skip if IL is already CX
    MOV  CX, IL             ; set up loop counter
        ENDIF
    MOV  BX, OFFSET TBL     ; load score table into BX
    XOR  DX, DX             ; clear DX to hold total score
LOOP_LETTER:
    LODSB                   ; load next char from DS:SI into AL, advance SI
    ;AND  AL, 0DFH           ; uppercase the input letter (+2 bytes)
    SUB  AL, 'A'            ; convert letter to zero-based index
    XLAT                    ; lookup letter in table
    MOV  AH, AL             ; examine dot nibble
    AND  AH, 0FH            ; mask off dash nibble
    ADD  DH, AH             ; add letter dot count to total
    PUSH CX                 ; save loop counter (since SHR can only take CL)
    MOV  CL, 4              ; set up right shift for 4 bits
    SHR  AL, CL             ; shift right
    POP  CX                 ; restore loop counter
    ADD  DL, AL             ; add letter dash count to total
    LOOP LOOP_LETTER
    CMP  DL, DH             ; if dot-heavy CF=1, if dash-heavy CF=0
        ENDM

; data table A-Z: MSN = count of dash, LSN = count of dot
TBL DB 011H, 013H, 022H, 012H, 001H, 013H, 021H, 004H, 002H 
    DB 031H, 021H, 013H, 020H, 011H, 030H, 022H, 031H, 012H
    DB 003H, 010H, 012H, 013H, 021H, 022H, 031H, 022H

คำอธิบาย

มีการใช้งานในไวยากรณ์ Intel / MASM เป็น MACRO (โดยทั่วไปเป็นฟังก์ชั่น) โดยใช้เพียงคำสั่งที่เข้ากันได้ 8088 เท่านั้น อินพุตเป็นสตริงเอาต์พุตผลลัพธ์ Truthy / Falsy ใน Carry Flag ตารางคะแนนประกอบด้วยจำนวนขีดกลางและจุดต่อตัวอักษร

อินพุตเป็นตัวพิมพ์ใหญ่ เพิ่ม 2 ไบต์เพื่อลดขนาดตัวพิมพ์เล็กหรือใหญ่

ตัวอย่างโปรแกรมทดสอบ (เป็นปฏิบัติการ COM แบบสแตนด์อโลนของ IBM PC DOS)

    SHR  SI, 1              ; point SI to DOS PSP
    LODSW                   ; load arg length into AL, advance SI to 82H
    MOV  CL, AL             ; set up loop counter in CH
    DEC  CX                 ; remove leading space from letter count

    MORSE_DD SI, CX, TBL    ; execute above function, result is in CF

    MOV  DX, OFFSET F       ; default output to "Falsy" string
    JA   DISP_OUT           ; if CF=0, result is falsy, skip to output
    MOV  DX, OFFSET T       ; otherwise CF=1, set output to "Truthy" string
DISP_OUT:
    MOV  AH, 09H            ; DOS API display string function
    INT  21H
    RET

T   DB "Truthy$"
F   DB "Falsy$"

ตัวอย่างผลลัพธ์:

ป้อนคำอธิบายรูปภาพที่นี่

ดาวน์โหลดโปรแกรมทดสอบ DD.COM

หรือลองออนไลน์! ฉันไม่ทราบว่า TIO ออนไลน์จะเชื่อมโยงโดยตรงไปยังปฏิบัติการ DOS แต่คุณสามารถใช้สิ่งนี้ได้ในไม่กี่ขั้นตอน:

  1. ดาวน์โหลดDD.COM เป็นไฟล์ ZIP
  2. ไปที่https://virtualconsoles.com/online-emulators/DOS/
  3. อัปโหลดไฟล์ ZIP ที่คุณเพิ่งดาวน์โหลดคลิกเริ่ม
  4. พิมพ์DD HelloหรือDD codeเนื้อหาหัวใจของคุณ

ฉันอาจจะหายไปบางอย่าง แต่แมโครนั้นไม่ถือว่า AH = 0 เมื่อเข้าหรือไม่ ได้รับข้อสันนิษฐานนั้นใช้ได้เมื่อใช้โปรแกรมทดสอบ
Gastropner

1
ตาดี! ข้อสันนิษฐานนั้นขึ้นอยู่กับค่าเริ่มต้นของการลงทะเบียนเริ่มต้นการทำงานของ DOS ซึ่งเกือบทุกรุ่นของ DOS ใช้0000hสำหรับแหล่ง AX: fysnet.net/yourhelp.htm
640KB

จากนักกอล์ฟหนึ่งคนสู่อีกคนหนึ่ง: ดีมาก ! คะแนนสไตล์พิเศษสำหรับการใช้คำแนะนำที่เข้ากันได้กับ 8088 เท่านั้น นั่นเป็นแพลตฟอร์มที่การตีกอล์ฟเป็นส่วนใหญ่เทียบเท่ากับการเพิ่มประสิทธิภาพและเป็นศิลปะที่สูญหายไปอย่างแท้จริง ใช้ดีXLATเพื่อทำสิ่งที่ตั้งใจจะทำ หากคุณเพิ่มประสิทธิภาพความเร็วเกินขนาดจริง ๆ แล้วคุณต้องการทำการค้นหาขนาด WORD นี่ยังคงเป็นความเร็วที่ชนะได้แม้ใน 8088 ด้วยบัสภายนอกแบบ 8 บิตเนื่องจากคุณกำลังเพิ่มปริมาณงานเป็นสองเท่าโดยไม่เพิ่มขนาดรหัสประหยัดสำหรับการXCHGเรียนการสอนหรือสอง
โคดี้เกรย์

@CodyGray ขอบคุณ! มันสนุกอยู่เสมอเมื่อความท้าทายเข้าคู่กับแพลตฟอร์มและชุดคำสั่ง นอกจากนี้ยังเป็นระเบียบเมื่อคุณสามารถทำบางสิ่งบางอย่างบนพีซีดั้งเดิมของ 8088 ใน 1 ไบต์ (เช่นXLAT) แม้ว่าจะใช้เวลา 6 ไบต์ในการเปลี่ยนบิตบิตขวา 4 ตำแหน่ง (ภายใน a LOOP)
640KB

ได้. สำหรับประสิทธิภาพคุณต้องแยกกะ 4 ครั้งโดย 1 อย่างแน่นอนเพื่อขจัดแรงผลักดันและแรงกระแทก มันไม่ได้เป็นจำนวนไบต์ที่มากกว่า (+2) ดังนั้นโดยรวมแล้วจึงเป็นชัยชนะสุทธิ แต่ก็ไม่ดีสำหรับการเล่นกอล์ฟ ความสนุกที่แท้จริงเกิดขึ้นเมื่อความท้าทายไม่สอดคล้องกับ ISA และคุณต้องยืดความคิดของคุณเพื่อหาวิธีการใหม่ ๆ คำแนะนำเกี่ยวกับสตริงขนาด 1 ไบต์นั้นดีมากใน 8088 สำหรับประสิทธิภาพและการเล่นกอล์ฟ ฉันใช้พวกเขาในรหัสจริง XLAT เป็นสิ่งที่ฉันไม่ได้ใช้บ่อยนักฉันเดาว่าเพราะสถาปัตยกรรมสมัยใหม่ทำให้ฉันมีปัญหากับ LUT
โคดี้เกรย์

7

Java (JDK) , 131 124 110 84 64 ไบต์

ที่น่าสนใจคือ "จุด" นั้นหนักมากและ "เส้นประ" นั้นหนักหน่วง

ใช้อินพุตในตัวพิมพ์ใหญ่ทั้งหมดIntStream(เลื่อนลงสำหรับเวอร์ชันที่มีขนาดจริงStringเป็น 8 ไบต์พิเศษ) ฉันมีความช่วยเหลือค่อนข้างมากในการเล่นกอล์ฟนี้: ขอบคุณข้อมูลที่หมดอายุสำหรับการเล่นกอล์ฟ 20 ไบต์ไปยังNeilสำหรับการเล่นกอล์ฟ 26 ไบต์ไปยังOlivier Grégoireสำหรับการเล่นกอล์ฟ 18 ไบต์และKevin Cruijssenสำหรับการเล่นกอล์ฟ 2 ไบต์

มี 26 อักขระที่ไม่สามารถพิมพ์ได้ภายในเครื่องหมายคำพูดคู่

c->c.map(a->"".charAt(a-65)-4).sum()>0

ลองออนไลน์!

Ungolfed:

c -> // lambda taking input as an IntStream in upper case and returning a boolean
  c.map(a -> "" // map each character's ASCII value to its net dot impact (unprintable characters here)
    .charAt(a - 65) // translate the ASCII code into a zero-based index into the above string (65 is 'A')
    - 4) // unprintables are > 0, this restores the proper values
  .sum() > 0 // add up all the values, positive sum indicates a dot-heavy input string

Java (JDK) , 131 124 110 84 72 ไบต์

สำหรับคนพิถีพิถัน Stringจะเข้าเป็น ขอบคุณข้อมูลที่หมดอายุสำหรับการเล่นกอล์ฟ 20 ไบต์ไปยังNeilสำหรับการเล่นกอล์ฟ 26 ไบต์และOlivier Grégoireสำหรับการเล่นกอล์ฟ 10 ไบต์

s->s.chars().map(a->"".charAt(a-65)-4).sum()>0

ลองออนไลน์

Ungolfed:

s -> // lambda taking input as a String in upper case and returning a boolean
  s.chars() // convert to a stream of characters
  .map(a -> "" // map each character's ASCII value to its net dot impact (unprintable characters here)
    .charAt(a - 65) // translate the ASCII code into a zero-based index into the above string (65 is 'A')
    - 4) // unprintables are > 0, this restores the proper values
  .sum() > 0 // add up all the values, positive sum indicates a dot-heavy input string



2
ทำไมไม่ใช้"35344527512513031462452313".charAt(a-65)-51?
Neil


1
@ OlivierGrégoire 66 ไบต์ของคุณคือ 65 จริง ๆ แล้วเนื่องจากคุณลืมลบเซมิโคลอนที่ต่อท้าย สามารถบันทึกได้อีก 1 ไบต์โดยใช้อักขระที่ไม่สามารถพิมพ์ได้: 64 ไบต์
Kevin Cruijssen

4

เยลลี่ 21 ไบต์

Oị“ÆġwıMƥ)ɠịṙ{’D¤Æm>4

ลองออนไลน์!

อย่างไร?

Oị“ÆġwıMƥ)ɠịṙ{’D¤Æm>4 - Link: list of characters ([A-Z]), S
                ¤     - nilad followed by link(s) as a nilad:
  “ÆġwıMƥ)ɠịṙ{’       -   base 250 integer = 14257356342446455638623624
               D      -   to decimal digits
                      -   -- that is the number of dots less the number of dashes plus 4
                      -      ... for each of OPQRSTUVWXYZABCDEFGHIJKLMN
O                     - ordinals of S   e.g. "ATHROUGHZ" -> [65,84,72,82,79,85,71,72,90]
 ị                    - index into (1-indexed & modular, so O gets the 79%26 = 1st item
                      -                                  or A gets the 65%26 = 13th item
                 Æm   - arithmetic mean
                   >4 - greater than 4?

4

05AB1E , 22 21 ไบต์

บันทึกเป็นไบต์ด้วยKevin Cruijssen

SA•U(Õþć6Δ
»›I•‡3-O.±

ลองออนไลน์!

คำอธิบาย

•U(Õþć6Δ
»›I•

คือ35344527512513031462452313 ที่บีบอัดไปยังฐาน 255

S              # split input into list of chars
       ‡       # transliterate
 A             # the lowercase alphabet
  •...•        # with the digits from the compressed string
        3-     # subtract 3 from each              
          O    # then sum the result
           .±  # and take the sign

Sคุณสามารถบันทึกไบต์โดยการเปลี่ยนแผนที่ด้วย
Kevin Cruijssen

@KevinCruijssen: ขอบคุณ! ฉันแน่ใจว่าฉันได้ลองแล้ว แต่ดูเหมือนจะไม่ :)
Emigna

3
usdgpsahsoaboutlopezgbidolcv = ord(c)*3%83%8

@Arnauld: น่าสนใจ! คุณค้นพบได้อย่างไร? ไม่ใช่ด้วยมือฉันหวังว่า: P
Emigna

1
aboutlopezฉันเดรัจฉานบังคับคำคู่และการแข่งขันที่ยาวที่สุดคือ จากนั้นฉันก็มองหาแมตช์อื่นที่มีตัวคูณและโมดูโลเดียวกัน (ดังนั้นจึงไม่รับประกันว่าจะเหมาะสมที่สุด)
Arnauld

4

C # (Visual C # Interactive Compiler) , 47 ไบต์

n=>n.Sum(i=>("[E[LduRgmQSMK"[i%13]>>i%2*3)%8-3)

ใช้'สายเวท' ของ Level River St อย่าลืมโหวตโซลูชันของพวกเขาด้วยเช่นกัน!

มันไม่ใช่ C # ทุกวันที่จะเต้น Ruby, Python, Javascript, C, Retina และ Perl!

ลองออนไลน์!






2

Stax , 20 ไบต์

ÉBÜ◙ƒ╣<Hf6─òɼsäS╗◄↔

เรียกใช้และแก้ไขข้อบกพร่อง

คลายกล่อง ungolfed และแสดงความคิดเห็นมันมีลักษณะเช่นนี้

"45D.J57KBJa`"I"    string literal with code points [52 53 68 46 74 53 55 75 66 74 97 34 73]
$                   flatten to string "52536846745355756674973473"
;                   push input
@                   get string characters at indices 
                    (using input codepoints as indices; lookups wrap around)
:V                  arithmetic mean
53>                 is greater than 53

เรียกใช้อันนี้


2

Ruby , 64 ไบต์

->s{n=0;s.bytes{|i|n+=("[E[LduRgmQSMK"[i%13].ord>>i%2*3)%8-3};n}

ลองออนไลน์!

ใช้สตริงมายากลขนาด 13 ไบต์จำนวน 2 ตัว0..7เข้ารหัสในแต่ละไบต์ ลบ 3 -3..4ช่วง

รหัส ASCII สำหรับA(และยังN) ได้รับ modulo 13 โดยบังเอิญศูนย์


1

เรติน่า 0.8.2 , 51 ไบต์

T`L`35344527412513031462452313
.
$*<>>>
+`<>|><

^<

ลองออนไลน์! ลิงค์มีกรณีทดสอบ ยอมรับตัวพิมพ์ใหญ่เท่านั้น (+6 ไบต์สำหรับกรณีแบบผสม) การขโมยสตริงของ @ Arnauld อย่างไร้ยางอาย แต่ฉันจะใช้อัลกอริธึมแบบเดียวกันอยู่ดี คำอธิบาย:

T`L`35344527412513031462452313
.

เปลี่ยนตัวอักษรแต่ละตัวเข้าไปในความแตกต่างในตัวเลขของจุดและขีดกลางบวกสามดังนั้นและO=0H=7

$*<>>>

แสดงความแตกต่างเป็นจำนวน<s และสาม>s (น่าเสียดายที่ฉันไม่สามารถใช้จุดเพราะพวกเขาพิเศษใน regex.)

+`<>|><

ลบคู่ที่ตรงกันของ<s และ>s

^<

ตรวจสอบว่ายังมีจุดใดเหลืออยู่หรือไม่


1

Bash + coreutils,  64  60 ไบต์

tr a-z 35344526512513031462452313|sed s/./\&z-+/g|dc -eIK?^p

ลองออนไลน์!

รับค่าสตริงเป็นตัวพิมพ์เล็กเอาต์พุตเป็นศูนย์สำหรับค่าเท็จไม่เป็นศูนย์สำหรับความจริง

คำอธิบาย

ใช้ tr และ sed เพื่อสร้างโปรแกรม dc ที่ดูเหมือน (สำหรับอินพุตตัวอย่าง 'hello'):

IK6z-+4z-+5z-+5z-+0z-+^p

IK     Push 10, then 0 to the stack
6z-+  Push 6 (three more than the dots minus dashes in 'h'), subtract 3, and accumulate
...    Do the same for all other letters, so the stack now has the total dots minus dashes
^      Raise 10 to this power - precision is zero so this turns negative/positive to falsy/truthy
p      Print result

Golfed สองไบต์โดยเพียงแค่ใส่ dc ในไปป์ไลน์แทนที่จะใช้การทดแทนคำสั่งจากนั้นแทนที่<space>3ด้วยการแทนที่ด้วยz(สะดวกฉันมี 3 รายการบนสแต็ก ณ จุดนั้น!) และอีกหนึ่งไบต์โดยแทนที่เครื่องหมายคำพูดรอบโปรแกรม sed ของฉันด้วย แบ็กสแลชเดี่ยวเพื่อหลบหนี&
โซเฟียเลชเชอ


1

TI-BASIC (TI-84), 111 ไบต์

:Ans→Str1:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str2:"35344527512513031462452312→Str3:0<sum(seq(expr(sub(Str3,inString(Str2,sub(Str1,X,1)),1)),X,1,length(Str1))-3

ฉันใช้สตริงเดียวกันเพื่อหาจุดที่หนักหน่วงเหมือนคำตอบอื่น ๆ
โปรแกรมส่งคืนความจริง ( 1) หากสตริงอินพุตเป็น dot-heavy, falsy ( 0) ถ้าไม่ใช่
สตริงอินพุตต้องอยู่ในตัวพิมพ์ใหญ่ทั้งหมด การป้อนข้อมูลจะถูกเก็บไว้ใน
Ansเอาต์พุตถูกเก็บไว้ในAnsและพิมพ์ออกมาโดยอัตโนมัติเมื่อโปรแกรมเสร็จสิ้น

Ungolfed:

:Ans→Str1
:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str2 
:"35344527512513031462452312→Str3
:0<sum(seq(expr(sub(Str3,inString(Str2,sub(Str1,X,1)),1)),X,1,length(Str1))-3

ตัวอย่าง:

"HELLO
HELLO
prgmCDGF3
           1
"CODE
CODE
prgmCDGF3
           0

คำอธิบาย:
(TI-BASIC ไม่มีความคิดเห็นสมมติว่า;เป็นการบ่งบอกความมุ่งมั่น)

:Ans→Str1                          ;store the input into Str1
:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str2  ;store the uppercase alphabet into Str2
:"35344527512513031462452312→Str3  ;store dot-dash+3 for each letter into Str3

:0<sum(seq(expr(sub(Str3,inString(Str2,sub(Str1,X,1)),1)),X,1,length(Str1))-3 ;full logic

   sum(                                                                       ;sum the elements of
       seq(                                                               )    ;the list evaluated by
                sub(                                    )                       ;the substring of
                    Str3,                                                        ;Str3
                         inString(                  ),                           ;at the index of
                                       sub(        )                              ;the substring of
                                           Str1,                                   ;Str1
                                                X,                                 ;starting at X
                                                  1                                ;of length 1
                                  Str2,                                           ;in Str2
                                                      1                          ;of length 1
           expr(                                        ),                       ;converted to an integer
                                                          X,                    ;using X as the increment variable
                                                            1,                  ;starting at 1
                                                              length(Str1)      ;ending at the length of Str1
                                                                           -3   ;then subtract 3 from all elements in the list
  0<                                                                           ;then check if the sum is greater than 0
                                                                               ;implicitly output the result

หมายเหตุ: จำนวนไบต์ของโปรแกรมถูกประเมินโดยใช้ค่าใน[MEM] > [2] > [7] (124 ไบต์) จากนั้นลบความยาวของชื่อโปรแกรมCDGF3(5 ไบต์) และ 8 ไบต์พิเศษสำหรับใช้ จัดเก็บโปรแกรม:

124 - 5 - 8 = 111 ไบต์




0

C ++ (คอมไพล์ด้วย Visual Studio 2017) 171bytes

int f(string i){const char*c="1322131421130102123023121211210120032121323101112232";int j=0,h[2]={0};while(j<sizeof(i)/28)*h+=c[i[j]-97],h[1]+=c[i[j++]-71];return*h>h[1];}

ถ้าเราใช้โปรแกรมหลักที่มีอยู่เพื่อจุดประสงค์ในการทดสอบ

นี่เป็นตัวแปรที่ "ไม่เป็นระเบียบ"

#include "stdafx.h"
int main()
{
    const int dotCount[] = {1,3,2,2,1,3,1,4,2,1,1,3,0,1,0,2,1,2,3,0,2,3,1,2,1,2};
    const int dashCount[] = {1,1,2,1,0,1,2,0,0,3,2,1,2,1,3,2,3,1,0,1,1,1,2,2,3,2};
    std::cout << "Enter String:\n";
    std::string input;
    std::cin >> input;
    int inputsHeavyness[2] = { 0 };
    for(int i = 0;i < sizeof(input)/sizeof(std::string);i++)
    {
        inputsHeavyness[0] += dotCount[input[i] - 'a'];
        inputsHeavyness[1] += dashCount[input[i] - 'a'];
    }
    if (inputsHeavyness[0] > inputsHeavyness[1])
    {
        std::cout << "Dot Heavy\n";
    }
    else
    {
        std::cout << "Dash Heavy or Neutral\n";
    }
    return 0;
}

ถือว่าตัวพิมพ์เล็กทั้งหมด


1
คุณอาจต้องการที่จะเพิ่มการเชื่อมโยง TIO (นอกจากนี้ฉันคิดว่าคุณมีการพิมพ์ผิดในรหัส ungolfed: 22ควรเป็น2)
Arnauld

ใช่นี่อาจเป็นตัวพิมพ์ผิด ฉันคิดว่าฉันคงที่ในเวอร์ชัน golfed แม้ว่า tio ดีฉันไม่มีเงื่อนงำของสิ่งที่ (ฉันคิดว่าฉันดูมันครั้งเดียวและมันไม่ได้มีคุณลักษณะคอมไพเลอร์ฉันใช้ดังนั้นผลลัพธ์ระหว่าง vs2017 และ tio มีแนวโน้มที่จะแตกต่างกันไปหรือไม่ไม่ดีเลย)
der bender

1
145 ไบต์ ผลลัพธ์อาจแตกต่างกันระหว่าง VS และ TIO บางครั้งก็แตกต่างกันไปสำหรับฉันเช่นกันและจริง ๆ แล้วฉันใช้ GCC (แม้ว่า MinGW)
Gastropner

1
ปรับแต่ง @ceilingcat ขนาด 131 ไบต์
Gastropner

1
การสร้าง @gastropner 111 ไบต์รวมทั้งสองอาร์เรย์ไว้ในที่เดียว "132...และ"112...กลายเป็น"353...และ51เป็นค่า ASCII ของ3
ceilingcat

0

c (118 ตัวอักษร) ส่งคืนค่าบวกสำหรับ over-dot-ness และค่าลบสำหรับ over-dash-ness

int n(char* c){int v=25124858,d=3541434,i=0,o=0;for(;c[i]!=0;i++)o=(1&(v>(c[i]-65)))>0?(1&(d>>(c[i]-65)))>0?o+1:o-1:o;return o;}

ยกเลิกแข็งแรงเล่นกอล์ฟ

int n(char* c)
{
  // Bitwise alpha map: 
  // more dots = 1
  // more dashes or equal = 0
  int d=3541434;  
  // validation bit map.
  // dot/dash heavy = 1
  // even = 0
  int v=25124858;
  int i=0,o=0;
  for(;c[i]!=0;i++)   // iterate through all values
  {
    // There is no way to make this pretty
    // I did my best.
    // If the little endian validation bit corresponding
    // to the capitol letter ascii value - 65 = 0,
    // the output does not increment or decrement.
    // If the value is one it increases or decreases based
    // on the value of the d bitmap.
    o=(1& ( v > (c[I] - 65))) > 0 ?
      (1 & (d >> (c[I] - 65))) > 0 ?
        o + 1 :
        o - 1 :
      o;
  }
  return o;
}


ฉันต้องยอมรับว่าฉันไม่เข้าใจการเปรียบเทียบอย่างสมบูรณ์1& ( v > (c[I] - 65))ซึ่งเหมือนกันv > c[I] - 65ซึ่งฉันไม่สามารถจินตนาการได้ว่าเคยเป็นเท็จดังนั้นเราสามารถลบสิ่งนั้นทั้งหมดในขณะที่ riffing บน @ceilingcat 56 ไบต์
Gastropner


0

Python 2, 90 86 ไบต์

import morse
s=''.join(morse.string_to_morse(input()))
print s.count('.')>s.count('-')

ทำงานในท้องถิ่นของฉันด้วยห้องสมุดมอร์ส -4 ไบต์ ขอบคุณสำหรับเคล็ดลับ @ JoKing!

นอกจากนี้ยังเพิ่ม 1 ไบต์ถ้าอยู่ใน Python 3

Python 3, 87 ไบต์

import morse
s=''.join(morse.string_to_morse(input()))
print(s.count('.')>s.count('-'))

แม้ว่าคำถามจะถือว่าจำนวน '. และ' - จะไม่เท่ากัน; ในกรณีที่เท่ากันรหัสนี้จะคืนค่าเป็น True


ฉันหมายความว่าคุณสามารถใช้inputแทนraw_inputถ้าคุณต้องการ ...
Jo King

@ โจกิ้งที่ฉันพยายาม มันเกิดข้อผิดพลาดและด้วยเหตุนี้จึงต้องหันไปใช้ raw_input
Koishore Roy

คุณเพียงแค่ใส่เครื่องหมายคำพูดรอบสตริงเนื่องจากinputevals STDIN ก่อนส่งผ่านไปยังโปรแกรม
Jo King

นั่นเป็นประเด็นที่ยุติธรรมมาก ฉันรู้สึกงี่เง่าที่หายไป! : 3
Koishore Roy
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.