Eles me chamam de Inspetor Morse

20

Sua missão, se você optar por aceitá-la, é decidir se uma determinada sequência de entrada é pesada em pontos ou em traço.

Uma string é muito pesada quando sua representação em morse contém mais pontos que traços. Por exemplo, a letra E é um único ponto, o que significa que possui muitos pontos.

Entrada

  • A sequência de entrada conterá apenas caracteres no intervalo de [a-z]ou [A-Z]. Você pode decidir se todas devem estar em maiúsculas ou minúsculas. AAAestá bem, aaaestá bem, aAanão está.
  • A sequência de entrada sempre terá pelo menos 1 caractere.
  • Você pode assumir que as seqüências de entrada nunca terão uma quantidade igual de pontos e traços.

Saída

Você deve retornar Truthy para entradas que contenham mais caracteres de ponto.
Você deve retornar o Falsy para entradas que contenham mais caracteres de traço.
Editar: permitirei um valor positivo para ponto e um valor negativo para traço também.

Casos de teste

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

Referência

Código Morse Internacional

Isso é . O menor código em bytes vence.

Bassdrop Cumberwubwubwub
fonte
Related
Bassdrop Cumberwubwubwub 11/03
4
Podemos retornar um valor acima de 0 para pesado e um valor negativo para pesado pesado?
Modalidade de ignorância
@EmbodimentofIgnorance Isso funciona para mim, desde que você o especifique em sua postagem. Eu não acho que geralmente passa no teste de verdade falso, mas parece uma boa solução neste caso, então eu vou permitir
Bassdrop Cumberwubwubwub

Respostas:

5

APL (Dyalog Extended) , 24 SBCS de  15 bytes

-9 graças a Ven

Função de prefixo tácito anônimo, tomando maiúsculas como argumento.

>/'.-'⍧∊∘⌂morse

Experimente online!

⌂morse convertido à lista de cordas Morse
 , em seguida,
ε nlist (achatar)
'.-'⍧ contar o número de pontos e traços em que
>/ mais pontos do que traços? (lit. maior que redução)

Adão
fonte
por que não ter o dfns de pré-carregamento estendido por padrão?
ngn 13/03
@ngn Agora está embutido
Adám 11/04
7

IBM PC DOS, montagem 8088, 54 35 bytes

-19 bytes usando o método da diferença

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

Explicação

Implementado na sintaxe Intel / MASM como um MACRO (basicamente uma função), usando apenas instruções compatíveis com o 8088. Insira como sequência maiúscula (ou +2 bytes para permitir letras maiúsculas), o resultado da saída Truthy / Falsy é SF == OF(use JGou JLpara testar).

Os valores da tabela de diferença de letras são armazenados como petiscos binários, portanto, leva apenas 13 bytes no 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

Explicação

Implementado na sintaxe Intel / MASM como um MACRO (basicamente uma função), usando apenas instruções compatíveis com o 8088. Entrada como string, saída Truthy / Falsy resulta em Carry Flag. A tabela de pontuação contém o número de traços e pontos por letra.

A entrada é maiúscula. Adicione 2 bytes para usar letras minúsculas ou mistas.

Exemplo de programa de teste (como executável COM independente do 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$"

Saída de exemplo:

insira a descrição da imagem aqui

Baixe o programa de teste DD.COM

Ou Experimente Online! Não conheço um TIO online para direcionar o link para um executável do DOS, mas você pode usá-lo com apenas algumas etapas:

  1. Faça o download do DD.COM como um arquivo ZIP
  2. Vá para https://virtualconsoles.com/online-emulators/DOS/
  3. Faça o upload do arquivo ZIP que você acabou de baixar, clique em Iniciar
  4. Digite DD Helloou DD codepara o conteúdo do seu coração
640KB
fonte
Posso estar faltando alguma coisa, mas essa macro não assume AH = 0 na entrada? Concedido, essa suposição é válida ao usar o programa de teste.
gastropner 12/03
1
Bom olho! A suposição é baseada nos valores iniciais do registro de inicialização da execução do DOS, que para quase todas as versões do DOS são 0000hpara a origem do AX: fysnet.net/yourhelp.htm
640KB
De um jogador de golfe para outro: bom ! Pontos de estilo extras para o uso de instruções totalmente compatíveis com o 8088. Essa é uma plataforma em que o código de golfe é basicamente equivalente à otimização e uma verdadeira arte perdida. Bom uso de XLATfazer exatamente o que se destina a fazer. Se você estava realmente otimizando a velocidade sobre o tamanho, desejaria fazer pesquisas no tamanho de WORD. Essa ainda é uma vitória de velocidade, mesmo no 8088 com seu barramento externo anêmico de 8 bits, porque você está dobrando a taxa de transferência sem aumentar o tamanho do código, exceto por uma XCHGou duas instruções.
Cody Gray
@CodyGray thanks! É sempre divertido quando um desafio se alinha bem com a plataforma e o conjunto de instruções. Além disso, é legal quando você pode realizar algo no 8088 em 1 byte do PC original (como XLAT), mesmo que sejam necessários 6 bytes para fazer uma mudança bit a bit para a direita em 4 lugares (dentro de a LOOP).
640KB 13/03
Sim. Para o desempenho, você definitivamente desejaria fazer 4 turnos separados por 1, eliminando o empurrão e o pop. Não há nem mais bytes (+2); portanto, uma vitória líquida, mas não é boa para o golfe. A verdadeira diversão vem quando o desafio não se alinha ao ISA e você precisa se esforçar para encontrar maneiras novas e inovadoras de aplicar os blocos de construção existentes. As instruções de seqüência de caracteres de 1 byte são realmente boas no 8088 para desempenho e também golfe. Eu os uso em código real. O XLAT é para o qual muitas vezes não encontro muito uso, acho que porque as arquiteturas modernas me influenciaram contra as LUTs.
Cody Gray
7

Java (JDK) , 131 124 110 84 64 bytes

Curiosamente, "ponto" é muito pesado e "traço" é muito pesado.

Aceita entrada em todas as maiúsculas como um IntStream(role para baixo para uma versão com uma real Stringpor 8 bytes extras). Tive muita ajuda para jogar este: graças aos dados expirados por jogar 20 bytes, a Neil por jogar 26 bytes, a Olivier Grégoire por jogar 18 bytes e a Kevin Cruijssen por jogar 2 bytes.

Contém 26 caracteres não imprimíveis dentro das aspas duplas.

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

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

Para puristas; recebe entrada como a String. Agradecimentos aos dados expirados por jogar 20 bytes, a Neil por jogar 26 bytes e a Olivier Grégoire por jogar 10 bytes.

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

Experimente online.

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
fonte
1
124 bytes
Data expirada
1
Crie 111 bytes
Data
2
Por que não usar "35344527512513031462452313".charAt(a-65)-51?
Neil
1
66 bytes
Olivier Grégoire
1
@ OlivierGrégoire Na verdade, os seus 66 bytes são 65, pois você esqueceu de remover o ponto e vírgula à direita. No entanto, é possível salvar mais 1 byte usando caracteres não imprimíveis: 64 bytes
Kevin Cruijssen
4

Gelatina , 21 bytes

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

Experimente online!

Quão?

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

05AB1E , 22 21 bytes

Guardou um byte graças a Kevin Cruijssen

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

Experimente online!

Explicação

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

é 35344527512513031462452313 compactado na 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
fonte
Você pode salvar um byte, substituindo o mapa por S.
Kevin Cruijssen 12/03
@KevinCruijssen: Obrigado! Eu tinha certeza que tinha tentado isso, mas aparentemente não :) :)
Emigna 12/03
3
usdgpsahsoaboutlopezgbidolcv = ord(c)*3%83%8
@Arnauld: Interessante! Como você descobriu isso? Não à mão, espero: P
Emigna 12/03
1
Forcei brutalmente todos os pares de palavras e a correspondência mais longa foi aboutlopez. Procurei outras partidas com o mesmo multiplicador e módulo. (Portanto, não é absolutamente garantido que seja ótimo.)
Arnauld
3

C (gcc) , 84 82 81 79 75 bytes

Assume todas as maiúsculas.

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

Experimente online!

gastropner
fonte
3

Python 2 , 73 70 69 bytes

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

Experimente online!

Apenas maiúsculas

-3 bytes, graças a Erik, o Outgolfer


Versão em maiúsculas e minúsculas:

Python 2 , 73 71 bytes

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

Experimente online!

TFeld
fonte
2

Stax , 20 bytes

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

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

"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

Execute este

recursivo
fonte
2

Ruby , 64 bytes

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

Experimente online!

Usa uma string mágica de 13 bytes, 2 números 0..7codificados em cada byte. Subtraia 3 para um intervalo -3..4.

O código ASCII para A(e também N) o módulo 13 obtido é por coincidência, zero.

Level River St
fonte
1

Retina 0.8.2 , 51 bytes

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

^<

Experimente online! O link inclui casos de teste. Aceita apenas maiúsculas (+6 bytes para maiúsculas e minúsculas). Roubando descaradamente a string de @ Arnauld, mas eu usaria o mesmo algoritmo de qualquer maneira. Explicação:

T`L`35344527412513031462452313
.

Altere cada letra pela diferença no número de pontos e traços, mais três, então O=0e H=7.

$*<>>>

Represente a diferença como esse número de se <três >. (Infelizmente, não posso usar pontos porque eles são especiais em regex.)

+`<>|><

Remova os pares correspondentes de <s e >s.

^<

Verifique se ainda restam alguns pontos.

Neil
fonte
1

Bash + coreutils,  64  60 bytes

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

Experimente online!

Pega uma string em minúscula, gera zero para falsidade, diferente de zero para verdade

Explicação

Usa tr e sed para criar um programa dc com a aparência (por exemplo, entrada 'hello'):

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

IK     Push 10, then 0 to the stack
6z-+  Push 6 (three more than the dots minus dashes in 'h'), subtract 3, and accumulate
...    Do the same for all other letters, so the stack now has the total dots minus dashes
^      Raise 10 to this power - precision is zero so this turns negative/positive to falsy/truthy
p      Print result
Sophia Lechner
fonte
Coloquei dois bytes no campo de golfe apenas colocando o dc no pipeline em vez de usar a substituição de comando, depois outro byte substituindo <space>3por z(convenientemente, eu tenho 3 itens na pilha nesse ponto!) E outro byte substituindo as aspas em torno do meu programa sed por uma única barra invertida para escapar da&
Sophia Lechner
1

R , 74 bytes de 70

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

entrada deve estar em minúscula, retorna VERDADEIRO ou FALSO

Experimente online

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

Eu usei a mesma string para determinar o peso dos pontos que algumas das outras respostas.
O programa retornará truthy ( 1) se a sequência de entrada for muito pesada em pontos, falsy ( 0) se não.
A sequência de entrada deve estar em maiúsculas.
A entrada é armazenada em Ans. A saída é armazenada Anse impressa automaticamente quando o programa é concluído.

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

Exemplo:

"HELLO
HELLO
prgmCDGF3
           1
"CODE
CODE
prgmCDGF3
           0

Explicação:
(O TI-BASIC não tem comentários, suponha que isso ;indique um comentário)

: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: A contagem de bytes de um programa é avaliada usando o valor em [MEM] > [2] > [7] (124 bytes) e subtraindo o comprimento do nome do programa,CDGF3 , (5 bytes) e 8 bytes extras usados ​​para armazenando o programa:

124 - 5 - 8 = 111 bytes

Tau
fonte
0

Fator , 66 bytes

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

Experimente online!

Galen Ivanov
fonte
0

C ++ (compilado com o Visual Studio 2017)

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

se levarmos em conta o programa principal que existe para fins de teste, é mais.

esta é a variante "arrumada" não destruída

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

assume todas as letras minúsculas

der bender
fonte
1
Você pode querer adicionar um link TIO . (Além disso, eu acho que você tem um erro de digitação no código ungolfed: esta 22deve ser 2.)
Arnauld
Sim, isso pode muito bem ser um erro de digitação. Eu acho que eu consertei isso na versão golfada. Tio Bem, eu não tenho nenhum indício de que o material (eu acho que eu olhei para ele uma vez e aquilo não apresentam o im compilador usando para resultados entre vs2017 e tio provavelmente iria variar não é bom em tudo?)
der bender
1
145 bytes . Os resultados podem realmente variar entre VS e TIO. Às vezes, também varia para mim e, na verdade, estou usando o GCC (embora o MinGW).
gastropner 12/03
1
Tweak of @ceilingcat for 131 bytes
gastropner 15/04
1
Construindo no @gastropner 111 bytes Combinou as duas matrizes em uma; "132...e "112...torne - se "353...e 51é o valor ASCII de3
ceilingcat
0

c (118 caracteres) retorna um valor positivo para excesso de pontos e valor negativo para excesso de traços

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

sem golfe

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
fonte
99 bytes
ceilingcat 15/04
Devo confessar que não entendo completamente a comparação 1& ( v > (c[I] - 65)), que é a mesma que v > c[I] - 65, que não consigo imaginar que seja falsa, para que pudéssemos remover essa coisa toda enquanto digitando 56 bytes no
@ceilingcat
0

MathGolf , 22 bytes

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

Experimente online!

Usa o mesmo método que muitas outras respostas, onde ⁿ∩┐↑rⁿ¼~<↔"representa o número mágico 35344527512513031462452313.

maxb
fonte
0

Python 2, 90 86 bytes

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

trabalhou no meu local com a biblioteca morse . -4 bytes. Obrigado pela dica @JoKing!

Além disso, é 1 byte a mais se estiver no Python 3.

Python 3, 87 bytes

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

Embora a questão assuma que o número de '.'s e' -'s não será igual; caso sejam iguais, esse código retornará True.

Koishore Roy
fonte
Quero dizer, você pode usar em inputvez de, raw_inputse quiser ...
Jo King
@JoKing eu tentei. Ele estava lançando um erro e, portanto, teve que recorrer a raw_input
Koishore Roy
você só precisa colocar aspas na string, pois inputavalia STDIN antes de passá-la para o programa
Jo King
Esse é um ponto muito justo. Eu me sinto estúpido por perder isso! : 3
Koishore Roy 16/03