Ils m'appellent inspecteur Morse

20

Votre mission, si vous choisissez de l'accepter, est de décider si une chaîne d'entrée donnée est lourde de points ou lourde de tirets.

Une chaîne est lourde de points lorsque sa représentation morse contient plus de points que de tirets. Par exemple, la lettre E est un seul point, ce qui signifie qu'elle est lourde de points.

Contribution

  • La chaîne d'entrée ne contiendra que des caractères dans la plage de [a-z]ou [A-Z]. Vous pouvez décider s'ils doivent tous être en majuscules ou en minuscules. AAAva bien, aaava bien, aAan'est pas.
  • La chaîne d'entrée aura toujours au moins 1 caractère.
  • Vous pouvez supposer que les chaînes d'entrée n'auront jamais autant de points et de tirets.

Production

Vous devez renvoyer Truthy pour les entrées contenant plus de points.
Vous devez renvoyer Falsy pour les entrées contenant plus de tirets.
Edit: je vais également autoriser une valeur positive pour le point et une valeur négative pour le tiret.

Cas de test

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

Référence

Code Morse international

C'est du . Le code le plus court en octets gagne.

Bassdrop Cumberwubwubwub
la source
En relation
Bassdrop Cumberwubwubwub
4
Pouvons-nous retourner une valeur supérieure à 0 pour dotheavy et une valeur négative pour dash-heavy?
Incarnation de l'ignorance
@EmbodimentofIgnorance Cela fonctionne pour moi, tant que vous le spécifiez dans votre message. Je ne pense pas qu'il passe généralement le test de fausse vérité, mais cela semble être une bonne solution dans ce cas, donc je vais le permettre
Bassdrop Cumberwubwubwub

Réponses:

5

APL (Dyalog Extended) , 24  15 octets SBCS

-9 grâce à Ven

Fonction de préfixe tacite anonyme prenant en majuscule comme argument.

>/'.-'⍧∊∘⌂morse

Essayez-le en ligne!

⌂morse convertir en liste de chaînes Morse
 puis
ϵ nlist (aplatir)
'.-'⍧ compter le nombre de points et de tirets en
>/ plus de points que de tirets? (lit. supérieur à la réduction)

Adam
la source
pourquoi ne pas avoir des dfns de précharge étendus par défaut?
ngn
@ngn Il est maintenant intégré
Adám
7

IBM PC DOS, assemblage 8088, 54 35 octets

-19 octets en utilisant la méthode de différence

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

Non assemblé:

; 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

Explication

Implémenté dans la syntaxe Intel / MASM en tant que MACRO (essentiellement une fonction), en utilisant uniquement des instructions compatibles 8088. Entrée en chaîne majuscule (ou +2 octets pour autoriser les casse mixtes), sortie résultat Truthy / Falsy est SF == OF(utiliser JGou JLpour tester).

Les valeurs de la table des différences de lettres sont stockées sous forme de quartets binaires, donc ne prennent que 13 octets au total.

Original (54 octets):

; 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

Explication

Implémenté dans la syntaxe Intel / MASM en tant que MACRO (essentiellement une fonction), en utilisant uniquement des instructions compatibles 8088. Entrer sous forme de chaîne, sortir le résultat Truthy / Falsy dans Carry Flag. Le tableau des scores contient le nombre de tirets et de points par lettre.

L'entrée est en majuscule. Ajoutez 2 octets pour prendre des minuscules ou des majuscules.

Exemple de programme de test (en tant qu'exécutable COM autonome 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$"

Exemple de sortie:

entrez la description de l'image ici

Télécharger le programme de test DD.COM

Ou essayez-le en ligne! Je ne connais pas de TIO en ligne pour diriger le lien vers un exécutable DOS, mais vous pouvez l'utiliser en quelques étapes:

  1. Téléchargez DD.COM en fichier ZIP
  2. Accédez à https://virtualconsoles.com/online-emulators/DOS/
  3. Téléchargez le fichier ZIP que vous venez de télécharger, cliquez sur Démarrer
  4. Tapez DD Helloou DD codeau contenu de votre cœur
640 Ko
la source
Il se peut que je manque quelque chose, mais cette macro ne suppose-t-elle pas AH = 0 à l'entrée? Certes, cette hypothèse est valable lors de l'utilisation du programme de test.
gastropner
1
Bon oeil! L'hypothèse est basée sur les valeurs de registre de démarrage initial de l'exécution DOS, qui pour presque toutes les versions de DOS sont 0000hdestinées à la source AX: fysnet.net/yourhelp.htm
640 Ko
D'un golfeur à l'autre: sympa ! Points de style supplémentaires pour l'utilisation d'instructions purement compatibles 8088. C'est une plate-forme où le golf de code est largement équivalent à l'optimisation, et vraiment un art perdu. Belle utilisation de XLATfaire exactement ce qu'il est censé faire. Si vous optimisiez réellement la vitesse par rapport à la taille, vous voudriez faire des recherches au format WORD. C'est toujours un gain de vitesse même sur le 8088 avec son bus externe anémique 8 bits, car vous doublez le débit sans augmenter la taille du code, sauf pour une XCHGinstruction ou deux.
Cody Gray
@CodyGray merci! C'est toujours amusant quand un défi cadre bien avec la plate-forme et le jeu d'instructions. De plus, c'est bien quand vous pouvez accomplir quelque chose sur le 8088 du PC d'origine en 1 octet (comme XLAT), même s'il faut 6 octets pour effectuer un décalage au niveau du bit à droite à 4 endroits (à l'intérieur de a LOOP).
640 Ko
Ouaip. Pour les performances, vous voudrez certainement faire 4 changements séparés par 1, éliminant le push and pop. Ce n'est même pas beaucoup plus d'octets (+2), donc globalement une victoire nette, mais pas bonne pour le golf. Le vrai plaisir vient quand le défi ne correspond pas à l'ISA, et vous devez vous étirer pour trouver de nouvelles façons innovantes d'appliquer les blocs de construction existants. Les instructions de chaîne de 1 octet sont vraiment agréables sur 8088 pour la performance et le golf. Je les utilise en vrai code. XLAT en est un que je ne trouve pas souvent très utile, je suppose parce que les architectures modernes m'ont biaisé contre les LUT.
Cody Gray
7

Java (JDK) , 131 124 110 84 64 octets

Fait intéressant, «point» est lourd de tirets et «tiret» est lourd de points.

Prend l'entrée dans toutes les majuscules en tant que IntStream(faites défiler vers le bas pour une version avec un réel Stringpour 8 octets supplémentaires). J'ai eu beaucoup d'aide pour jouer à celui-ci: Merci à Expired Data pour avoir joué 20 octets, à Neil pour avoir joué 26 octets, à Olivier Grégoire pour avoir joué 18 octets et à Kevin Cruijssen pour avoir joué 2 octets.

Contient 26 caractères non imprimables à l'intérieur des guillemets doubles.

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

Essayez-le en ligne!

Non golfé:

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 octets

Pour les puristes; prend l'entrée comme un String. Merci à Expired Data pour avoir joué au golf 20 octets, à Neil pour avoir joué au golf 26 octets et à Olivier Grégoire pour avoir joué au golf 10 octets.

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

Essayez-le en ligne.

Non golfé:

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
la source
1
124 octets
Données expirées
1
Faites que 111 octets
Données expirées
2
Pourquoi ne pas utiliser "35344527512513031462452313".charAt(a-65)-51?
Neil
1
66 octets
Olivier Grégoire
1
@ OlivierGrégoire Votre 66 octets est en fait 65, car vous avez oublié de supprimer le point-virgule de fin. Un octet supplémentaire peut être enregistré en utilisant des caractères non imprimables cependant: 64 octets
Kevin Cruijssen
4

Gelée , 21 octets

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

Essayez-le en ligne!

Comment?

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
la source
4

05AB1E , 22 21 octets

Un octet enregistré grâce à Kevin Cruijssen

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

Essayez-le en ligne!

Explication

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

est 35344527512513031462452313 compressé à la base 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
Emigna
la source
Vous pouvez enregistrer un octet en remplaçant la carte par S.
Kevin Cruijssen
@KevinCruijssen: Merci! J'étais sûr d'avoir essayé, mais apparemment pas :)
Emigna
3
usdgpsahsoaboutlopezgbidolcv = ord(c)*3%83%8
@Arnauld: Intéressant! Comment avez-vous découvert cela? Pas à la main j'espère: P
Emigna
1
J'ai forcé toutes les paires de mots et la correspondance la plus longue a été aboutlopez. J'ai ensuite cherché d'autres matchs avec le même multiplicateur et le même modulo. (Il n'est donc absolument pas garanti d'être optimal.)
Arnauld
3

C (gcc) , 84 82 81 79 75 octets

Suppose toutes les majuscules.

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

Essayez-le en ligne!

gastropner
la source
3

Python 2 , 73 70 69 octets

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

Essayez-le en ligne!

Majuscules uniquement

-3 octets, grâce à Erik l'Outgolfer


Version majuscule et minuscule:

Python 2 , 73 71 octets

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

Essayez-le en ligne!

TFeld
la source
2

JavaScript (Node.js) ,  69  68 octets

Attend la chaîne d'entrée en majuscules. Retour0 ou 1.

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

Essayez-le en ligne!

Arnauld
la source
2

Stax , 20 octets

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

Exécuter et déboguer

Déballé, non golfé et commenté, il ressemble à ceci.

"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

Exécutez celui-ci

récursif
la source
2

Ruby , 64 octets

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

Essayez-le en ligne!

Utilise une chaîne magique de 13 octets, 2 nombres 0..7codés dans chaque octet. Soustrayez 3 pour une plage -3..4.

Le code ASCII pour A(et aussi N) pris modulo 13 est par coïncidence, zéro.

Level River St
la source
1

Retina 0.8.2 , 51 octets

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

^<

Essayez-le en ligne! Le lien inclut des cas de test. Accepte uniquement les majuscules (+6 octets pour les majuscules). Voler sans vergogne la chaîne de @ Arnauld mais j'allais quand même utiliser le même algorithme. Explication:

T`L`35344527412513031462452313
.

Remplacez chaque lettre par la différence du nombre de points et de tirets, plus trois, ainsi O=0et H=7.

$*<>>>

Représentez la différence comme ce nombre de <s et de trois >s. (Malheureusement, je ne peux pas utiliser de points car ils sont spéciaux dans l'expression régulière.)

+`<>|><

Retirez les paires de <s et >s correspondantes.

^<

Vérifiez s'il reste encore des points.

Neil
la source
1

Bash + coreutils,  64  60 octets

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

Essayez-le en ligne!

Prend une chaîne en minuscules, renvoie zéro pour la fausse, non nul pour la vérité

Explication

Utilise tr et sed pour créer un programme dc qui ressemble à (pour l'exemple d'entrée «bonjour»):

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
la source
Joué deux octets en mettant simplement le dc dans le pipeline plutôt que d'utiliser la substitution de commandes, puis un autre octet en remplaçant <space>3par z(commodément, j'ai 3 éléments sur la pile à ce stade!) Et un autre octet en remplaçant les guillemets autour de mon programme sed par une seule barre oblique inverse pour échapper au&
Sophia Lechner
1

R , 74 70 octets

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

l'entrée doit être en minuscules, renvoie VRAI ou FAUX

Essayez-le en ligne

Aaron Hayman
la source
1

TI-BASIC (TI-84), 111 octets

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

J'ai utilisé la même chaîne pour déterminer la lourdeur des points que certaines des autres réponses.
Le programme retourne truey ( 1) si la chaîne d'entrée est lourde de points, falsy ( 0) sinon.
La chaîne d'entrée doit être en majuscules.
L'entrée est stockée dans Ans. La sortie est stockée Anset imprimée automatiquement à la fin du programme.

Non golfé:

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

Exemple:

"HELLO
HELLO
prgmCDGF3
           1
"CODE
CODE
prgmCDGF3
           0

Explication:
(TI-BASIC n'a pas de commentaires, supposez que cela ;indique un commentaire)

: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

Remarque: Le nombre d'octets d'un programme est évalué à l'aide de la valeur dans [MEM] > [2] > [7] (124 octets) puis en soustrayant la longueur du nom du programme,CDGF3 (5 octets) et 8 octets supplémentaires utilisés pour stockage du programme:

124 - 5 - 8 = 111 octets

Tau
la source
0

Facteur , 66 octets

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

Essayez-le en ligne!

Galen Ivanov
la source
0

C ++ (compilé avec Visual Studio 2017) 171 octets

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

si nous prenons également en compte le programme principal qui existe à des fins de test.

c'est la variante "bien rangée" non golfée

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

suppose tout en minuscules

der bender
la source
1
Vous voudrez peut-être ajouter un lien TIO . (Aussi, je pense que vous avez une faute de frappe dans le code non golfé: cela 22devrait l'être 2.)
Arnauld
oui, cela pourrait bien être une faute de frappe. je suppose que j'ai corrigé cela dans la version golfée. tio bien je n'ai aucune idée de ce genre de choses (je pense que je l'ai regardé une fois et il ne comportait pas le compilateur im en utilisant donc les résultats entre vs2017 et tio varieraient probablement? pas bon du tout)
der bender
1
145 octets . Les résultats peuvent en effet varier entre VS et TIO. Cela varie parfois aussi pour moi, et j'utilise en fait GCC (bien que MinGW).
gastropner
1
Tweak de @ceilingcat pour 131 octets
gastropner
1
S'appuyant sur @gastropner 111 octets Combiné les deux tableaux en un seul; "132...et "112...devient "353...et 51est la valeur ASCII de3
plafondcat
0

c (118 caractères) renvoie une valeur positive pour over-dot-ness et une valeur négative pour 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;}

non golfé

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
la source
99 octets
Plafond
Je dois avouer que je ne comprends pas complètement la comparaison 1& ( v > (c[I] - 65)), qui est la même que v > c[I] - 65, que je ne peux pas imaginer est jamais fausse, donc nous pourrions supprimer tout cela en riffant sur @ceilingcat pendant 56 octets
gastropner
0

MathGolf , 22 octets

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

Essayez-le en ligne!

Utilise la même méthode que de nombreuses autres réponses, où ⁿ∩┐↑rⁿ¼~<↔"représente le nombre magique 35344527512513031462452313.

maxb
la source
0

Python 2, 90 86 octets

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

travaillé sur mon local avec la bibliothèque morse . -4 octets. Merci pour l'astuce @JoKing!

De plus, c'est 1 octet de plus s'il est en Python 3.

Python 3, 87 octets

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

Bien que la question suppose que le nombre de ". Et" - ne sera pas égal; s'ils sont égaux, ce code renverra True.

Koishore Roy
la source
Je veux dire, vous pouvez utiliser inputau lieu de raw_inputsi vous voulez ...
Jo King
@JoKing j'ai essayé. Il lançait une erreur et a donc dû recourir à raw_input
Koishore Roy
il suffit de mettre des guillemets autour de la chaîne, car inputevals STDIN avant de la passer au programme
Jo King
C'est un point très juste. Je me sens stupide d'avoir raté ça! : 3
Koishore Roy