Wenn Sie dies akzeptieren, müssen Sie entscheiden, ob eine bestimmte Eingabezeichenfolge punkt- oder strichlastig ist.

Eine Zeichenfolge ist punktlastig, wenn ihre Morse-Darstellung mehr Punkte als Striche enthält. Beispielsweise ist der Buchstabe E ein einzelner Punkt, was bedeutet, dass er punktlastig ist.

Eingang

• Die Eingabezeichenfolge enthält nur Zeichen im Bereich von [a-z]oder [A-Z]. Sie können entscheiden, ob alle in Groß- oder Kleinbuchstaben geschrieben werden sollen. AAAist in Ordnung, aaaist in Ordnung, aAaist nicht.
• Die Eingabezeichenfolge wird immer mindestens 1 Zeichen lang sein.
• Sie können davon ausgehen, dass Eingabezeichenfolgen niemals die gleiche Anzahl von Punkten und Strichen aufweisen.

Ausgabe

Sie sollten Truthy für Eingaben zurückgeben, die mehr Punktzeichen enthalten.
Sie sollten Falsy für Eingaben zurückgeben, die mehr Bindestriche enthalten.
Bearbeiten: Ich erlaube einen positiven Wert für Punkt und einen negativen Wert für Bindestrich.

Testfälle

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

Referenz

Das ist Code-Golf . Kürzester Code in Bytes gewinnt.

APL (Dyalog Extended) , 24 ^{SBCS mit}  15 Bytes

-9 dank Ven

Anonyme implizite Präfixfunktion, die Großbuchstaben als Argument verwendet.

>/'.-'⍧∊∘⌂morse

Probieren Sie es online!

⌂morse konvertieren Liste von Morse Strings
∘ dann
∊  ε nlist (flach) ,
'.-'⍧ die Anzahl der Punkte und Striche in die zählen
>/ mehr Punkte als Striche? (lit. größer als Reduktion)

IBM PC DOS, 8088-Assembly, 54 35 Bytes

-19 Bytes mit der Differenzmethode

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

Zerlegt:

; 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

Erläuterung

Implementiert in Intel / MASM-Syntax als MACRO (im Grunde genommen eine Funktion), wobei nur 8088-kompatible Anweisungen verwendet werden. Eingabe als Groß string (oder +2 Bytes mixed-Fall zu ermöglichen), Ausgang truthy / Falsy Ergebnis ist SF == OF(Einsatz JGoderJL testen).

Die Werte der Buchstabendifferenztabelle werden als binäre Halbbytes gespeichert, sodass insgesamt nur 13 Byte erforderlich sind.

Original (54 Bytes):

; 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

Erläuterung

Implementiert in Intel / MASM-Syntax als MACRO (im Grunde genommen eine Funktion), wobei nur 8088-kompatible Anweisungen verwendet werden. Eingabe als String, Ausgabe des Truthy / Falsy-Ergebnisses in Carry Flag. Die Punktetabelle enthält die Anzahl der Striche und Punkte pro Buchstabe.

Die Eingabe erfolgt in Großbuchstaben. Fügen Sie 2 Bytes hinzu, um Klein- oder Großbuchstaben zu verwenden.

Beispiel-Testprogramm (als eigenständige COM-Programmdatei von 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$"

Beispielausgabe:

Laden Sie das Testprogramm DD.COM herunter

Oder versuchen Sie es online! Mir ist kein Online-TIO für die direkte Verknüpfung mit einer ausführbaren DOS-Datei bekannt. Sie können dies jedoch mit nur wenigen Schritten ausführen:

1. Laden Sie DD.COM als ZIP-Datei herunter
2. Gehen Sie zu https://virtualconsoles.com/online-emulators/DOS/
3. Laden Sie die soeben heruntergeladene ZIP-Datei hoch und klicken Sie auf Start
4. Typ DD Hellooder DD codenach Herzenslust

Java (JDK) , 131 124 110 84 64 Bytes

Interessanterweise ist "dot" strichlastig und "dash" strichlastig.

Nimmt Eingaben in Großbuchstaben als IntStream(Bildlauf nach unten für eine Version mit einem tatsächlichen Wert Stringfür zusätzliche 8 Byte). Ich hatte eine Menge Hilfe beim Golfen: Dank Expired Data für das Golfen von 20 Bytes, dank Neil für das Golfen von 26 Bytes, dank Olivier Grégoire für das Golfen von 18 Bytes und dank Kevin Cruijssen für das Golfen von 2 Bytes.

Enthält 26 nicht druckbare Zeichen in Anführungszeichen.

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

Probieren Sie es online!

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 Byte

Für Puristen; Nimmt Eingaben als String. Dank an Expired Data für das Golfen von 20 Bytes, an Neil für das Golfen von 26 Bytes und an Olivier Grégoire für das Golfen von 10 Bytes.

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

Probieren Sie es online aus.

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

Jelly , 21 Bytes

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

Probieren Sie es online!

Wie?

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?

05AB1E , 22 21 Bytes

Dank Kevin Cruijssen ein Byte gespart

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

Probieren Sie es online!

Erläuterung

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

ist 35344527512513031462452313 auf Basis 255 komprimiert.

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

C # (Visual C # Interactive Compiler) , 47 Byte

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

Verwendet Level River St's 'magische Schnur'. Stellen Sie sicher, dass Sie auch für die Lösung stimmen!

Es ist nicht alltäglich, dass C # Ruby, Python, Javascript, C, Retina und Perl schlägt!

Probieren Sie es online!

Jelly , 23 Bytes

9“¡ȷṡẓh)ėḂYF@’ḃ_4ị@OS0<

Probieren Sie es online!

C (GCC) , 84 82 81 79 75 Bytes

Nimmt alle Großbuchstaben an.

r;f(char*s){for(r=0;*s;r+="+-+,,-*/--*-)+(+),.*,-*+)+"[*s++%65]-43);s=r>0;}

Probieren Sie es online!

Python 2 , 73 70 69 Bytes

lambda s:sum(int(`0x21427b563e90d7783540f`[ord(c)%25])-3for c in s)>0

Probieren Sie es online!

Nur in Großbuchstaben

_{-3 Bytes, danke an Erik den Outgolfer}

Sowohl Groß- als auch Kleinbuchstaben:

Python 2 , 73 71 Bytes

lambda s:sum(int(oct(0x1d7255e954b0ccca54cb)[ord(c)%32])-3for c in s)>0

Probieren Sie es online!

JavaScript (Node.js) ,  69  68 Byte

Erwartet die Eingabezeichenfolge in Großbuchstaben. Kehrt zurück$0$ oder $1$.

s=>Buffer(s).map(n=>s+='30314624523133534452741251'[n%26]-3,s=0)|s>0

Probieren Sie es online!

Stax , 20 Bytes

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

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

"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

Führen Sie dieses aus

Ruby , 64 Bytes

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

Probieren Sie es online!

Verwendet eine magische 13-Byte-Zeichenfolge mit 2 Zahlen 0..7, die in jedem Byte codiert sind. Subtrahiere 3 für einen Bereich-3..4 .

Der ASCII-Code für A(und auch N) Modulo 13 ist zufällig Null.

Retina 0,8,2 , 51 Bytes

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

^<

Probieren Sie es online! Link enthält Testfälle. Akzeptiert nur Großbuchstaben (+6 Bytes für gemischte Groß- und Kleinschreibung). Schamlos die Zeichenkette von @ Arnauld stehlen, aber ich wollte trotzdem den gleichen Algorithmus verwenden. Erläuterung:

T`L`35344527412513031462452313
.

Ändern Sie jeden Buchstaben in den Unterschied in der Anzahl der Punkte und Striche plus drei, also O=0und H=7.

$*<>>>

Stellen Sie die Differenz als diese Anzahl von <s und drei >s dar. (Leider kann ich keine Punkte verwenden, da sie speziell für Regex sind.)

+`<>|><

Entfernen Sie passende Paare von <s und >s.

^<

Überprüfen Sie, ob noch Punkte vorhanden sind.

Bash + Coreutils,  64  60 Bytes

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

Probieren Sie es online!

Nimmt einen String in Kleinbuchstaben, gibt Null für falsch, ungleich Null für wahr aus

Erläuterung

Verwendet tr und sed, um ein DC-Programm zu erstellen, das wie folgt aussieht (für die Beispieleingabe 'Hallo'):

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

R , 74 70 Bytes

f=utf8ToInt;sum(f("42433250265364746315325464")[f(scan(,''))-96]-52)<0

Die Eingabe sollte in Kleinbuchstaben erfolgen, es wird TRUE oder FALSE zurückgegeben

Probieren Sie es online aus

TI-BASIC (TI-84), 111 Bytes

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

Ich habe dieselbe Zeichenfolge zur Bestimmung der Punktschwere verwendet wie einige der anderen Antworten.
Das Programm gibt truthy ( 1) zurück, wenn die Eingabezeichenfolge punktlastig ist, andernfalls falsy ( 0).
Die Eingabezeichenfolge muss in Großbuchstaben erfolgen.
Die Eingabe wird in gespeichert Ans. Die Ausgabe wird in gespeichertAns und nach Abschluss des Programms automatisch ausgedruckt.

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

Beispiel:

"HELLO
HELLO
prgmCDGF3
           1
"CODE
CODE
prgmCDGF3
           0

Erläuterung:
(TI-BASIC hat keine Kommentare, es wird davon ausgegangen, dass dies ;ein Kommentar ist.)

: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

Hinweis: Die Byteanzahl eines Programms wird anhand des Werts in [MEM] > [2] > [7] (124 Bytes) ausgewertet, wobei die Länge des Programmnamens CDGF3(5 Bytes) und zusätzliche 8 Bytes für subtrahiert werden Speichern des Programms:

124 - 5 - 8 = 111 Bytes

Perl 5 -pF , 53 Bytes

$p+=y/a-z/35344526512513031462452313/r-3for@F;$_=$p>0

Probieren Sie es online!

Faktor 66 Bytes

: f ( s -- ? ) >morse [ [ 45 = ] count ] [ [ 46 = ] count ] bi < ;

Probieren Sie es online!

C ++ (kompiliert mit Visual Studio 2017) 171 Byte

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];}

Wenn wir das Hauptprogramm berücksichtigen, das zu Testzwecken existiert, ist es auch mehr.

Dies ist die ungolfed "ordentlich" Variante

#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;
}

nimmt alle Kleinbuchstaben an

c (118 Zeichen) gibt einen positiven Wert für Überstriche und einen negativen Wert für Überstriche zurück

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;}

ungegolft

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;
}

MathGolf , 22 Bytes

{▄="Yⁿ∩┐↑rⁿ¼~<↔"$▒3-§+

Probieren Sie es online!

Verwendet dieselbe Methode wie viele andere Antworten, wobei ⁿ∩┐↑rⁿ¼~<↔"die magische Zahl dargestellt wird 35344527512513031462452313.

Python 2, 90 86 Bytes

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

arbeitete an meinem Lokal mit der Morsebibliothek . -4 Bytes. Danke für den Tipp @JoKing!

Es ist auch 1 Byte mehr, wenn es in Python 3 ist.

Python 3, 87 Bytes

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

Obwohl die Frage davon ausgeht, dass die Anzahl von '.' Und '-' nicht gleich sein wird; Wenn sie gleich sind, gibt dieser Code True zurück.