Sie nennen mich Inspektor Morse

20

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

Internationaler Morsecode

Das ist . Kürzester Code in Bytes gewinnt.

Bassdrop Cumberwubwubwub
quelle
Related
Bassdrop Cumberwubwubwub
4
Können wir für dotheavy einen Wert über 0 und für dash-heavy einen negativen Wert zurückgeben?
Verkörperung der Ignoranz
@EmbodimentofIgnorance Das funktioniert für mich, solange Sie es in Ihrem Beitrag angeben. Ich glaube nicht, dass es normalerweise die wahrheitsgemäße falsche Prüfung besteht, aber es fühlt sich in diesem Fall wie eine gute Lösung an, also werde ich es zulassen
Bassdrop Cumberwubwubwub

Antworten:

5

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)

Adam
quelle
warum nicht standardmäßig Extended preload dfns?
13.
@ngn Es ist jetzt eingebaut
Adám
7

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:

Bildbeschreibung hier eingeben

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
640 KB
quelle
Ich vermisse vielleicht etwas, aber geht dieses Makro bei der Eingabe nicht von AH = 0 aus? Zugegeben, diese Annahme ist gültig, wenn das Testprogramm verwendet wird.
Gastropner
1
Gutes Auge! Die Annahme basiert auf den Werten des Startregisters für die DOS-Ausführung, die für fast alle DOS-Versionen 0000hfür AX gelten. Quelle: fysnet.net/yourhelp.htm
640KB
Von einem Versammlungsgolfspieler zum anderen: Nett ! Zusätzliche Stilpunkte für die Verwendung von 8088-kompatiblen Anweisungen. Dies ist eine Plattform, auf der Code-Golfing weitgehend der Optimierung gleichkommt und eine wirklich verlorene Kunst ist. Nette Anwendung XLAT, um genau das zu tun, was es soll. Wenn Sie tatsächlich auf Geschwindigkeit über Größe optimiert haben, möchten Sie WORD-Lookups durchführen. Dies ist auch auf dem 8088 mit seinem anämischen externen 8-Bit-Bus immer noch ein Geschwindigkeitsgewinn, da Sie den Durchsatz verdoppeln, ohne die Codegröße zu erhöhen, außer für eine XCHGoder zwei Anweisungen.
Cody Grey
@CodyGray danke! Es macht immer Spaß, wenn eine Herausforderung mit der Plattform und dem Befehlssatz harmoniert. Außerdem ist es ordentlich, wenn Sie etwas auf dem 8088 des Original-PCs in 1 Byte (z. B. XLAT) ausführen können, obwohl es 6 Byte dauert, um eine bitweise Verschiebung nach rechts um 4 Stellen (innerhalb von a LOOP) durchzuführen .
640 KB,
Jep. Um die Leistung zu verbessern, sollten Sie auf jeden Fall vier Schichten pro Schicht machen, um Push und Pop zu vermeiden. Es ist nicht einmal so viel mehr Bytes (+2), also insgesamt ein Nettogewinn, aber nicht gut zum Golfen. Der wirkliche Spaß kommt, wenn die Herausforderung nicht mit der ISA übereinstimmt und Sie Ihren Verstand dehnen müssen, um neue, innovative Möglichkeiten zum Anwenden der vorhandenen Bausteine ​​zu finden. Die 1-Byte-String-Anweisungen sind auf 8088 für Leistung und auch Golf sehr schön. Ich benutze sie in echtem Code. XLAT ist eine, für die ich nicht oft eine Verwendung finde, da mich moderne Architekturen gegen LUTs voreingenommen haben.
Cody Grey
7

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
OOBalance
quelle
1
124 Bytes
Abgelaufene Daten
1
Machen Sie das 111 Bytes
Abgelaufene Daten
2
Warum nicht benutzen "35344527512513031462452313".charAt(a-65)-51?
Neil
1
66 Bytes
Olivier Grégoire
1
@ OlivierGrégoire Dein 66-Byte ist tatsächlich 65, da du vergessen hast, das nachgestellte Semikolon zu entfernen. 1 weiteres Byte kann jedoch mit nicht druckbaren Zeichen gespeichert werden: 64 Byte
Kevin Cruijssen
4

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?
Jonathan Allan
quelle
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
Emigna
quelle
Sie können ein Byte speichern, indem Sie die Karte durch ersetzen S.
Kevin Cruijssen
@ KevinCruijssen: Danke! Ich war mir sicher, dass ich das versucht hatte, aber anscheinend nicht :)
Emigna
3
Nur zum Spaß: Mit der Zeichenfolge usdgpsahsoaboutlopezgbidol(Verkettung von 8 Wörtern aus dem Wörterbuch) können die Werte abgerufen werden: für jedes Zeichencdort: v = ord(c)*3%83%8.
Arnauld
@ Arnauld: Interessant! Wie haben Sie das herausgefunden? Ich hoffe nicht von Hand: P
Emigna
1
Ich habe alle Wortpaare brutal gezwungen und die längste Übereinstimmung war aboutlopez. Ich habe dann nach anderen Übereinstimmungen mit demselben Multiplikator und Modulo gesucht. (Es ist also absolut nicht garantiert, dass es optimal ist.)
Arnauld,
3

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!

Gastropner
quelle
3

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!

TFeld
quelle
2

JavaScript (Node.js) ,  69  68 Byte

Erwartet die Eingabezeichenfolge in Großbuchstaben. Kehrt zurück0 oder 1.

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

Probieren Sie es online!

Arnauld
quelle
2

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

rekursiv
quelle
2

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.

Level River St
quelle
1

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.

Neil
quelle
1

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
Sophia Lechner
quelle
Golfed zwei Bytes, indem Sie einfach den DC in die Pipeline setzen, anstatt die Befehlssubstitution zu verwenden, dann ein weiteres Byte durch Ersetzen <space>3mit z(praktischerweise habe ich zu diesem Zeitpunkt 3 Elemente auf dem Stapel!) Und ein weiteres Byte durch Ersetzen der Anführungszeichen um mein sed-Programm durch ein einziger Backslash, um der&
Sophia Lechner
1

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

Aaron Hayman
quelle
1

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

Tau
quelle
0

Faktor 66 Bytes

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

Probieren Sie es online!

Galen Ivanov
quelle
0

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

der bender
quelle
1
Möglicherweise möchten Sie einen TIO-Link hinzufügen . (Ich denke auch, dass Sie einen Tippfehler im ungolfed Code haben: das 22sollte sein 2.)
Arnauld
Ja, das könnte ein Tippfehler sein. Ich glaube, ich habe das in der Golfversion behoben. tio gut, ich habe keine Ahnung von diesem Zeug (ich glaube, ich habe es einmal angeschaut und es hat nicht den Compiler im mit so Ergebnissen zwischen vs2017 und tio würde wahrscheinlich variieren? überhaupt nicht gut)
der Bender
1
145 Bytes . Die Ergebnisse können in der Tat zwischen VS und TIO variieren. Es variiert manchmal auch für mich und ich benutze tatsächlich GCC (wenn auch MinGW).
Gastropner
1
Tweak von @ceilingcat für 131 Bytes
Gastropner
1
Aufbauend auf @gastropner 111 Bytes Kombiniert beide Arrays zu einem; "132...und "112...wird "353...und 51ist der ASCII-Wert von3
ceilingcat
0

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;
}
mreff555
quelle
99 Bytes
Ceilingcat
Ich muss gestehen, dass ich den Vergleich nicht vollständig verstehe 1& ( v > (c[I] - 65)), der der gleiche ist v > c[I] - 65, von dem ich mir nicht vorstellen kann, dass er jemals falsch ist. Deshalb könnten wir das Ganze entfernen, während wir auf @ceilingcat für 56 Bytes
riffeln
0

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.

maxb
quelle
0

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.

Koishore Roy
quelle
Ich meine, Sie können inputanstelle von verwenden, raw_inputwenn Sie möchten ...
Jo King
@JoKing ich habe es versucht. Es warf einen Fehler und musste daher auf raw_input
Koishore Roy
Sie müssen den String nur mit Anführungszeichen versehen, da inputSTDIN ausgewertet wird, bevor er an das Programm übergeben wird
Jo King,
Das ist ein sehr fairer Punkt. Ich fühle mich dumm, das verpasst zu haben! : 3
Koishore Roy