Mi chiamano ispettore Morse


20

La tua missione, se scegli di accettarla, è decidere se una determinata stringa di input è Dot-heavy o Dash-heavy.

Una stringa è pesante quando la sua rappresentazione morse contiene più punti che trattini. Ad esempio, la lettera E è un punto singolo, il che significa che è punto-pesante.

Ingresso

  • La stringa di input conterrà solo caratteri nell'intervallo di [a-z]o [A-Z]. Puoi decidere se devono essere tutte maiuscole o minuscole. AAAva bene, aaava bene, aAano.
  • La stringa di input avrà sempre almeno 1 carattere di lunghezza.
  • Si può presumere che le stringhe di input non avranno mai la stessa quantità di punti e trattini.

Produzione

È necessario restituire Truthy per input che contengono più caratteri punto.
Dovresti restituire Falsy per input che contengono più trattini.
Modifica: consentirò un valore positivo per punto e un valore negativo anche per trattino.

Casi test

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

Riferimento

Codice Morse Internazionale

Questo è . Vince il codice più breve in byte.



4
Possiamo restituire un valore superiore a 0 per dotheavy e un valore negativo per dash-heavy?
Incarnazione dell'ignoranza l'

@EmbodimentofIgnorance che funziona per me, purché lo specifichi nel tuo post. Non penso che di solito superi il vero test di falsità, ma in questo caso sembra una buona soluzione, quindi lo permetterò
Bassdrop Cumberwubwubwub il

Risposte:


5

APL (Dyalog Extended) , 24  15 byte SBCS

-9 grazie a Ven

Funzione di prefisso tacito anonimo che assume maiuscolo come argomento.

>/'.-'⍧∊∘⌂morse

Provalo online!

⌂morse convertito alla lista di stringhe Morse
 allora
ε nlist (flatten)
'.-'⍧  contare il numero di punti e linee in quanto
>/ più punti di trattini? (lett. maggiore della riduzione)


perché non avere Extended precaricamento DNS predefinito?
ngn

@ngn Ora è integrato
Adám l'

7

IBM PC DOS, 8088 assembly, 54 35 byte

-19 byte usando il metodo della differenza

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

smontato:

; 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

Spiegazione

Implementato nella sintassi Intel / MASM come MACRO (sostanzialmente una funzione), usando solo 8088 istruzioni compatibili. Immettere come stringa maiuscola (o +2 byte per consentire maiuscole / minuscole), il risultato Truthy / Falsy in output èSF == OF (utilizzare JGoJL per testare).

I valori della tabella delle differenze di lettera sono memorizzati come nibble binari, quindi richiede solo 13 byte in totale.

Originale (54 byte):

; 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

Spiegazione

Implementato nella sintassi Intel / MASM come MACRO (sostanzialmente una funzione), usando solo 8088 istruzioni compatibili. Input come stringa, output Truthy / Falsy in Carry Flag. La tabella dei punteggi contiene il numero di trattini e punti per lettera.

L'ingresso è in maiuscolo. Aggiungi 2 byte per prendere lettere minuscole o miste.

Esempio di programma di test (come eseguibile COM autonomo di 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$"

Esempio di output:

inserisci qui la descrizione dell'immagine

Scarica il programma di test DD.COM

Oppure provalo online! Non sono a conoscenza di un TIO online per il collegamento diretto a un eseguibile DOS, tuttavia è possibile utilizzarlo con pochi passaggi:

  1. Scarica DD.COM come file ZIP
  2. Vai a https://virtualconsoles.com/online-emulators/DOS/
  3. Carica il file ZIP appena scaricato, fai clic su Avvia
  4. Digita DD Helloo DD codeal contenuto del tuo cuore

Potrei mancare qualcosa, ma quella macro non assume AH = 0 all'entrata? È vero che tale presupposto è valido quando si utilizza il programma di test.
Gastropner il

1
Buon occhio! L'ipotesi è basata su DOS di esecuzione valori di registro di avvio iniziale, che per quasi tutte le versioni di DOS è 0000hper la fonte di AX: fysnet.net/yourhelp.htm
640KB

Da un golfista di assemblaggio all'altro: bello ! Punti stile extra per l'utilizzo di istruzioni puramente compatibili 8088. Questa è una piattaforma in cui il golf del codice equivale in gran parte all'ottimizzazione e veramente un'arte perduta. Un buon uso di XLATfare esattamente ciò che è destinato a fare. Se stavi effettivamente ottimizzando la velocità rispetto alle dimensioni, ti consigliamo di effettuare ricerche di dimensioni WORD. Questa è ancora una vittoria di velocità anche sull'8088 con il suo bus esterno a 8 bit anemico, perché stai raddoppiando la velocità di trasmissione senza aumentare la dimensione del codice, salvo XCHGun'istruzione o due.
Cody Gray il

@CodyGray grazie! È sempre divertente quando una sfida si allinea perfettamente con la piattaforma e il set di istruzioni. Inoltre è pulito quando puoi realizzare qualcosa sull'8088 del PC originale in 1 byte (come XLAT), anche se ci vogliono 6 byte per fare uno spostamento bit a destra di 4 posizioni (all'interno di a LOOP).
640 KB

Sì. Per quanto riguarda le prestazioni, vorresti sicuramente fare 4 turni separati di 1, eliminando push e pop. Non è nemmeno molti più byte (+2), quindi nel complesso una vincita netta, ma non va bene per il golf. Il vero divertimento arriva quando la sfida non si allinea con l'ISA e devi allungare la mente per trovare modi nuovi e innovativi di applicare i blocchi esistenti. Le istruzioni della stringa da 1 byte sono davvero belle su 8088 per prestazioni e anche golf. Li uso in codice reale. XLAT è uno per cui spesso non trovo molto utile, immagino perché le architetture moderne mi hanno influenzato contro i LUT.
Cody Gray,

7

Java (JDK) , 131 124 110 84 64 byte

È interessante notare che "punto" è un trattino pesante e "trattino" è un punto pesante.

Prende l'input in maiuscolo come IntStream(scorrere verso il basso per una versione con un effettivo Stringper ulteriori 8 byte). Ho molto aiutato a giocare a golf: grazie a Expired Data per giocare a golf 20 byte, a Neil per giocare a golf 26 byte, a Olivier Grégoire per giocare a golf 18 byte e a Kevin Cruijssen per giocare a golf 2 byte.

Contiene 26 caratteri non stampabili all'interno delle doppie virgolette.

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

Provalo 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

Per i puristi; accetta input come a String. Grazie ai dati scaduti per giocare a golf 20 byte, a Neil per giocare a golf 26 byte e ad Olivier Grégoire per giocare a golf 10 byte.

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

Provalo 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



2
Perché non usare "35344527512513031462452313".charAt(a-65)-51?
Neil


1
@ OlivierGrégoire Il tuo 66 byte è in realtà 65, poiché hai dimenticato di rimuovere il punto e virgola finale. Tuttavia, è possibile salvare un altro byte utilizzando caratteri non stampabili: 64 byte
Kevin Cruijssen,

4

Gelatina , 21 byte

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

Provalo online!

Come?

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?

4

05AB1E , 22 21 byte

Salvataggio di un byte grazie a Salvataggio di Kevin Cruijssen

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

Provalo online!

Spiegazione

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

è 35344527512513031462452313 compresso alla 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

È possibile salvare un byte sostituendo la mappa con S.
Kevin Cruijssen il

@KevinCruijssen: grazie! Ero sicuro di averlo provato, ma apparentemente no :)
Emigna il

3
usdgpsahsoaboutlopezgbidolcv = ord(c)*3%83%8

@Arnauld: interessante! Come l'hai scoperto? Spero non a mano: P
Emigna il

1
Ho forzato brutalmente tutte le coppie di parole e la corrispondenza più lunga è stata aboutlopez. Ho quindi cercato altre partite con lo stesso moltiplicatore e lo stesso modulo. (Quindi non è assolutamente garantito che sia ottimale.)
Arnauld




3

Python 2 , 73 70 69 byte

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

Provalo online!

Solo maiuscolo

-3 byte, grazie a Erik the Outgolfer


Entrambe le versioni maiuscole e minuscole:

Python 2 , 73 71 byte

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

Provalo online!



2

Stax , 20 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

"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

Esegui questo


2

Rubino , 64 byte

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

Provalo online!

Utilizza una stringa magica di 13 byte, 2 numeri 0..7codificati in ciascun byte. Sottrai 3 per un intervallo-3..4 .

Il codice ASCII per A(e anche N) preso modulo 13 è per coincidenza zero.


1

Retina 0.8.2 , 51 byte

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

^<

Provalo online!Il link include casi di test. Accetta solo lettere maiuscole (+6 byte per maiuscole e minuscole). Rubare senza vergogna la stringa di @ Arnauld, ma avrei comunque utilizzato lo stesso algoritmo. Spiegazione:

T`L`35344527412513031462452313
.

Cambia ogni lettera nella differenza di numero di punti e trattini, più tre, quindi O=0 eH=7 .

$*<>>>

Rappresenta la differenza come quel numero di < tre> s. (Purtroppo non posso usare i punti perché sono speciali in regex.)

+`<>|><

Rimuovere abbinate coppie di <s e> s.

^<

Controlla se ci sono ancora punti.


1

Bash + coreutils,  64  60 byte

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

Provalo online!

Prende una stringa in minuscolo, produce zero per falsy, diverso da zero per verità

Spiegazione

Usa tr e sed per creare un programma DC che assomigli (per esempio input 'ciao'):

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

Giocato a golf due byte semplicemente inserendo il DC nella pipeline anziché utilizzare la sostituzione dei comandi, quindi un altro byte sostituendolo <space>3con z(convenientemente, ho 3 elementi nello stack in quel punto!) E un altro byte sostituendo le virgolette attorno al mio programma sed con una singola battuta d'arresto per sfuggire a&
Sophia Lechner l'

1

R , 74 70 byte

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

l'input deve essere minuscolo, restituisce VERO o FALSO

Provalo online


1

TI-BASIC (TI-84), 111 byte

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

Ho usato la stessa stringa per determinare la pesantezza del punto come alcune delle altre risposte.
Il programma restituisce truthy ( 1) se la stringa di input è pesante, falsy ( 0) in caso contrario.
La stringa di input deve essere in maiuscolo.
L'ingresso è memorizzato in Ans. L'output viene archiviato Anse stampato automaticamente al termine del programma.

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

Esempio:

"HELLO
HELLO
prgmCDGF3
           1
"CODE
CODE
prgmCDGF3
           0

Spiegazione:
(TI-BASIC non ha commenti, supponiamo che ;indichi un inizio)

: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: il conteggio dei byte di un programma viene valutato utilizzando il valore in [MEM] > [2] > [7] (124 byte) quindi sottraendo la lunghezza del nome del programma,CDGF3 , (5 byte) e altri 8 byte utilizzati per memorizzazione del programma:

124-5-8 = 111 byte




0

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

se prendiamo in considerazione anche il programma principale che esiste a scopo di test, è ancora di più.

questa è la variante non ordinata "ordinata"

#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 tutte le lettere minuscole


1
Potresti voler aggiungere un link TIO . (Inoltre, penso che tu abbia un refuso nel codice ungolfed: questo 22dovrebbe essere 2.)
Arnauld

Sì, potrebbe essere un errore di battitura. immagino di averlo risolto nella versione golfata. tio bene non ho idea di quella roba (penso di averla guardata una volta e non presentava il compilatore che sto usando, quindi i risultati tra vs2017 e tio probabilmente varierebbero? non va affatto bene)
der bender

1
145 byte . I risultati possono effettivamente variare tra VS e TIO. A volte varia anche per me, e attualmente sto usando GCC (sebbene MinGW).
Gastropner il

1
Modifica di @ceilingcat per 131 byte
gastropner

1
Basandosi su @gastropner 111 byte Combinati entrambi gli array in uno; "132...e "112...diventa "353...ed 51è il valore ASCII di3
ceilingcat il

0

c (118 caratteri) restituisce un valore positivo per over-dot -ness e valore negativo per 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;}

un-golfed

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


Devo confessare di non comprendere appieno il confronto 1& ( v > (c[I] - 65)), che è lo stesso di v > c[I] - 65, che non riesco a immaginare sia mai falso, quindi potremmo rimuovere tutto mentre riff su @ceilingcat per 56 byte
gastropner

0

MathGolf , 22 byte

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

Provalo online!

Utilizza lo stesso metodo di molte altre risposte, dove ⁿ∩┐↑rⁿ¼~<↔"rappresenta il numero magico 35344527512513031462452313.


0

Python 2, 90 86 byte

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

ha lavorato sul mio locale con il morse biblioteca . -4 byte. Grazie per la punta @JoKing!

Inoltre, è 1 byte in più se è in Python 3.

Python 3, 87 byte

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

Sebbene la domanda presupponga che il numero di ". E" non sarà uguale; nel caso siano uguali, questo codice restituirà True.


Voglio dire, puoi usare inputinvece che raw_inputse vuoi ...
Jo King

@JoKing ho provato. Stava
generando

devi solo mettere le virgolette attorno alla stringa, dal momento che inputvaluta STDIN prima di passarlo al programma
Jo King

Questo è un punto molto giusto. Mi sento stupido per averlo perso! : 3
Koishore Roy,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.