Me llaman inspector Morse

20

Su misión, si elige aceptarla, es decidir si una cadena de entrada dada tiene mucho Dot o Dash.

Una cadena tiene muchos puntos cuando su representación morse contiene más puntos que guiones. Por ejemplo, la letra E es un solo punto, lo que significa que tiene mucho Dot.

Entrada

  • La cadena de entrada solo contendrá caracteres en el rango de [a-z]o [A-Z]. Puede decidir si todas deben estar en mayúscula o en minúscula. AAAestá bien, aaaestá bien, aAano lo está.
  • La cadena de entrada siempre tendrá al menos 1 carácter de longitud.
  • Puede suponer que las cadenas de entrada nunca tendrán la misma cantidad de puntos y guiones.

Salida

Debería devolver Truthy para las entradas que contienen más caracteres de punto.
Debería devolver Falsy para las entradas que contienen más caracteres de guión.
Editar: también permitiré un valor positivo para punto y un valor negativo para guión.

Casos de prueba

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

Referencia

Código Morse Internacional

Este es el . El código más corto en bytes gana.

Bassdrop Cumberwubwubwub
fuente
Relacionado
Bassdrop Cumberwubwubwub
44
¿Podemos devolver un valor superior a 0 para dotheavy y un valor negativo para dash-heavy?
Encarnación de la ignorancia
@EmbodimentofIgnorance Eso funciona para mí, siempre que lo especifiques en tu publicación. No creo que generalmente pase la prueba de falsedad verdadera, pero se siente como una buena solución en este caso, así que lo permitiré
Bassdrop Cumberwubwubwub

Respuestas:

5

APL (Dyalog Extended) , 24  15 bytes SBCS

-9 gracias a Ven

La función de prefijo tácito anónimo toma mayúsculas como argumento.

>/'.-'⍧∊∘⌂morse

Pruébalo en línea!

⌂morse convertido a la lista de cadenas Morse
 entonces
ε nlist (aplanar)
'.-'⍧ contar el número de puntos y rayas en la que
>/ más puntos que los guiones? (lit. mayor que la reducción)

Adán
fuente
¿por qué no tener dfns de precarga extendidos por defecto?
ngn
@ngn Ahora está integrado
Adám
7

IBM PC DOS, ensamblaje 8088, 54 35 bytes

-19 bytes usando el método de diferencia

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

Desmontado:

; 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

Explicación

Implementado en la sintaxis Intel / MASM como MACRO (básicamente una función), utilizando solo instrucciones compatibles con 8088. Ingrese como cadena en mayúsculas (o +2 bytes para permitir mayúsculas y minúsculas), el resultado de Verdad / Falsificación de salida es SF == OF(use JGo JLpara probar).

Los valores de la tabla de diferencia de letras se almacenan como nibbles binarios, por lo que solo toma 13 bytes en total.

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

Explicación

Implementado en la sintaxis Intel / MASM como MACRO (básicamente una función), utilizando solo instrucciones compatibles con 8088. Ingresar como cadena, generar el resultado Verdad / Falsificación en Carry Flag. La tabla de puntuación contiene el número de guiones y puntos por letra.

La entrada es mayúscula. Agregue 2 bytes para tomar minúsculas o mixto.

Programa de prueba de ejemplo (como ejecutable COM independiente de 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$"

Salida de ejemplo:

ingrese la descripción de la imagen aquí

Descargar programa de prueba DD.COM

O Pruébelo en línea! No conozco un TIO en línea para vincular directamente a un ejecutable de DOS, sin embargo, puede usar esto con solo unos pocos pasos:

  1. Descargue DD.COM como un archivo ZIP
  2. Vaya a https://virtualconsoles.com/online-emulators/DOS/
  3. Cargue el archivo ZIP que acaba de descargar, haga clic en Inicio
  4. Escriba DD Helloo DD codeal contenido de su corazón
640 KB
fuente
Puede que me falte algo, pero ¿esa macro no asume AH = 0 al ingresar? De acuerdo, esa suposición es válida cuando se utiliza el programa de prueba.
Gastropner
1
¡Buen ojo! La suposición se basa en los valores del registro de inicio inicial de la ejecución de DOS, que para casi todas las versiones de DOS es 0000hpara la fuente AX: fysnet.net/yourhelp.htm
640 KB
De un golfista de asamblea a otro: ¡ bien ! Puntos de estilo adicionales por usar instrucciones puramente compatibles con 8088. Esa es una plataforma donde el golf de código es en gran medida equivalente a la optimización, y realmente un arte perdido. Buen uso de XLAThacer exactamente lo que debe hacer. Si realmente estuviera optimizando la velocidad sobre el tamaño, desearía realizar búsquedas del tamaño de WORD. Esto sigue siendo una ganancia de velocidad incluso en el 8088 con su anémico bus externo de 8 bits, porque está duplicando el rendimiento sin aumentar el tamaño del código, excepto por una XCHGinstrucción o dos.
Cody Gray
@CodyGray gracias! Siempre es divertido cuando un desafío se alinea muy bien con la plataforma y el conjunto de instrucciones. Además, es bueno cuando puede lograr algo en el 8088 de la PC original en 1 byte (como XLAT), a pesar de que se necesitan 6 bytes para hacer un desplazamiento bit a la derecha en 4 lugares (dentro de a LOOP).
640 KB
Sip. Para el rendimiento, definitivamente querría hacer 4 turnos separados por 1, eliminando el empuje y el estallido. Ni siquiera son muchos más bytes (+2), por lo que en general es una ganancia neta, pero no es bueno para el golf. La verdadera diversión llega cuando el desafío no se alinea con el ISA, y hay que estirar la mente para encontrar formas nuevas e innovadoras de aplicar los bloques de construcción existentes. Las instrucciones de cadena de 1 byte son realmente buenas en 8088 para rendimiento y golf. Los uso en código real. XLAT es uno para el que no encuentro mucho uso, supongo porque las arquitecturas modernas me han sesgado en contra de los LUT.
Cody Gray
7

Java (JDK) , 131 124 110 84 64 bytes

Curiosamente, "dot" tiene mucho guión y "dash" tiene mucho punto.

Toma la entrada en mayúsculas como un IntStream(desplácese hacia abajo para una versión con un real Stringde 8 bytes adicionales). He recibido mucha ayuda para jugar golf: gracias a los datos caducados por jugar 20 bytes, a Neil por jugar 26 bytes, a Olivier Grégoire por jugar 18 bytes y a Kevin Cruijssen por jugar 2 bytes.

Contiene 26 caracteres no imprimibles dentro de las comillas dobles.

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

Pruébalo en línea!

Sin 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 bytes

Para los puristas; toma entrada como a String. Gracias a los datos vencidos por jugar al golf 20 bytes, a Neil por jugar al golf 26 bytes y a Olivier Grégoire por jugar al golf 10 bytes.

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

Pruébalo en línea.

Sin 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
fuente
1
124 bytes
Datos
1
Haga que 111 bytes
Datos
2
¿Por qué no usar "35344527512513031462452313".charAt(a-65)-51?
Neil
1
66 bytes
Olivier Grégoire
1
@ OlivierGrégoire Su 66 bytes es en realidad 65, ya que olvidó eliminar el punto y coma final. Sin embargo, se puede guardar 1 byte más usando caracteres no imprimibles: 64 bytes
Kevin Cruijssen
4

Jalea , 21 bytes

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

Pruébalo en línea!

¿Cómo?

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
fuente
4

05AB1E , 22 21 bytes

Salvó un byte gracias a Kevin Cruijssen

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

Pruébalo en línea!

Explicación

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

es 35344527512513031462452313 comprimido a 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
fuente
Puede guardar un byte reemplazando el mapa con S.
Kevin Cruijssen
@KevinCruijssen: ¡Gracias! Estaba seguro de haber intentado eso, pero aparentemente no :)
Emigna
3
usdgpsahsoaboutlopezgbidolCv = ord(c)*3%83%8
@Arnauld: ¡Interesante! ¿Cómo lo descubriste? No a mano, espero: P
Emigna
1
Forcé la fuerza bruta a todos los pares de palabras y la coincidencia más larga fue aboutlopez. Luego busqué otras coincidencias con el mismo multiplicador y módulo. (Por lo tanto, no se garantiza que sea óptimo).
Arnauld
3

C (gcc) , 84 82 81 79 75 bytes

Asume todos los gorros.

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

Pruébalo en línea!

gastropner
fuente
3

Python 2 , 73 70 69 bytes

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

Pruébalo en línea!

Solo mayúsculas

-3 bytes, gracias a Erik the Outgolfer


Versión en mayúsculas y minúsculas:

Python 2 , 73 71 bytes

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

Pruébalo en línea!

TFeld
fuente
2

Stax , 20 bytes

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

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

"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

Ejecute este

recursivo
fuente
2

Ruby , 64 bytes

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

Pruébalo en línea!

Utiliza una cadena mágica de 13 bytes, 2 números 0..7codificados en cada byte. Resta 3 para un rango -3..4.

El código ASCII para A(y también N) tomado el módulo 13 es por coincidencia, cero.

Level River St
fuente
1

Retina 0.8.2 , 51 bytes

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

^<

Pruébalo en línea! El enlace incluye casos de prueba. Solo acepta mayúsculas (+6 bytes para mayúsculas y minúsculas). Robando descaradamente la cadena de @ Arnauld, pero de todos modos iba a usar el mismo algoritmo. Explicación:

T`L`35344527412513031462452313
.

Cambie cada letra a la diferencia en números de puntos y guiones, más tres, así que O=0y H=7.

$*<>>>

Representa la diferencia como ese número de <sy tres >s. (Lamentablemente, no puedo usar puntos porque son especiales en expresiones regulares).

+`<>|><

Eliminar los pares coincidentes de <sy >s.

^<

Comprueba si todavía quedan puntos.

Neil
fuente
1

Bash + coreutils,  64  60 bytes

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

Pruébalo en línea!

Toma una cadena en minúsculas, genera cero para falsedad, no cero para verdad

Explicación

Utiliza tr y sed para crear un programa de CC que se ve así (para la entrada de ejemplo 'hola'):

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
fuente
Golfé dos bytes simplemente colocando el dc en la tubería en lugar de usar la sustitución de comandos, luego otro byte reemplazándolo <space>3con z(convenientemente, ¡tengo 3 elementos en la pila en ese punto!) Y otro byte reemplazando las comillas alrededor de mi programa sed con una sola barra invertida para escapar de&
Sophia Lechner
1

R , 74 70 bytes

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

la entrada debe ser minúscula, devuelve VERDADERO o FALSO

Pruébalo en línea

Aaron Hayman
fuente
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

Utilicé la misma cadena para determinar la pesadez de puntos que algunas de las otras respuestas.
El programa devuelve truey ( 1) si la cadena de entrada tiene muchos puntos, y falsey ( 0) si no.
La cadena de entrada debe estar en mayúsculas.
La entrada se almacena en Ans. La salida se almacena Ansy se imprime automáticamente cuando se completa el programa.

Sin 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

Ejemplo:

"HELLO
HELLO
prgmCDGF3
           1
"CODE
CODE
prgmCDGF3
           0

Explicación:
(TI-BASIC no tiene comentarios, suponga que ;indica un comentario)

: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

Nota: El recuento de bytes de un programa se evalúa utilizando el valor en [MEM] > [2] > [7] (124 bytes) y luego restando la longitud del nombre del programa CDGF3, (5 bytes) y 8 bytes adicionales utilizados para almacenar el programa:

124 - 5 - 8 = 111 bytes

Tau
fuente
0

C ++ (compilado con 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];}

si tomamos en cuenta el programa principal que existe para fines de prueba también es más.

esta es la variante "ordenada" sin golf

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

asume todo en minúsculas

der bender
fuente
1
Es posible que desee agregar un enlace TIO . (Además, creo que tiene un error tipográfico en el código no reflejado: esto 22debería ser 2.)
Arnauld
Sí, esto puede ser un error tipográfico. Supongo que lo arreglé en la versión de golf Bueno, no tengo ni idea de eso (creo que lo miré una vez y no incluía el compilador que estoy usando, por lo que los resultados entre vs2017 y tio probablemente variarían) no es bueno en absoluto)
der bender
1
145 bytes . Los resultados pueden variar entre VS y TIO. A veces también varía para mí, y en realidad estoy usando GCC (aunque MinGW).
Gastropner
1
Ajuste de @ceilingcat para 131 bytes
gastropner
1
Construyendo sobre @gastropner 111 bytes Combinó ambas matrices en una; "132...y "112...convertirse "353...y 51es el valor ASCII de3
ceilingcat
0

c (118 caracteres) devuelve un valor positivo para over-dot-ness y negativo para 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;}

sin 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
fuente
99 bytes
ceilingcat
Debo confesar que no entiendo completamente la comparación 1& ( v > (c[I] - 65)), que es lo mismo v > c[I] - 65que no puedo imaginar que sea falsa, por lo que podríamos eliminar todo eso mientras analizamos @ceilingcat por 56 bytes
gastropner
0

MathGolf , 22 bytes

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

Pruébalo en línea!

Utiliza el mismo método que muchas otras respuestas, donde ⁿ∩┐↑rⁿ¼~<↔"representa el número mágico 35344527512513031462452313.

maxb
fuente
0

Python 2, 90 86 bytes

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

trabajé en mi local con la biblioteca morse . -4 bytes. Gracias por el consejo @JoKing!

Además, es 1 byte más si está en Python 3.

Python 3, 87 bytes

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

Aunque la pregunta asume que el número de '.'s y' -'s no será igual; en caso de que sean iguales, este código devolverá True.

Koishore Roy
fuente
Quiero decir, puedes usar en inputlugar de raw_inputsi quieres ...
Jo King
@JoKing lo intenté. Estaba arrojando un error y, por lo tanto, tuvo que recurrir a raw_input
Koishore Roy
solo tiene que poner comillas alrededor de la cadena, ya que inputevalúa STDIN antes de pasarlo al programa
Jo King
Ese es un punto muy justo. Me siento estúpido por perder eso! : 3
Koishore Roy