Numeri che sono in realtà lettere


42

Dato un valore intero non negativo, scrivere un programma che converte il numero in esadecimale e ritorna un valore truthy se la forma esadecimale del numero contiene solo i caratteri Aattraverso Fe un valore falsey altrimenti.


Casi test

10
==> True (A in hexadecimal)

100
==> False (64 in hexadecimal)

161
==> False (A1 in hexadecimal)

11259375
==> True (ABCDEF in hexadecimal)

0
==> False (0 in hexadecimal)

Bonus: -40 byte se il programma stampa Only lettersper la sfida sopra descritta, Only numbersse la versione esadecimale del numero contiene solo le cifre 0-9e Mixse il numero esadecimale contiene almeno un numero e almeno una lettera.


Questo è il codice golf. Si applicano le regole standard. Vince il codice più breve in byte. Sono consentite funzioni o programmi completi.


2
Attualmente sto redigendo una risposta in Golfical.
SuperJedi224,

La mia idea attuale: converti in base 16 string, quindi vedi se tenta di analizzare quella stringa quando ritorna un numero 10 baseNaN
Cyoce

@Cyoce Potrebbe funzionare, a seconda della lingua scelta
SuperJedi224,

3
Bonus non realistico (ancora una volta): solo la stringa MixOnlynumberslettersè di 21 caratteri
edc65

3
Dici "input intero positivo", ma 0 è un caso di test.
xnor

Risposte:


22

Pyth, 43 - 40 = 3 byte

?&K@J.HQG-JG"Mix"%"Only %sers"?K"lett""numb

Suite di test

Questo ottiene il bonus. Only numberse Only lettersfortunatamente differiscono solo per 4 lettere. Viene utilizzata la formattazione in stile printf %.

Il sistema di selezione si ottiene prendendo sia l'intersezione dell'esagono con G, l'alfabeto, sia sottraendo G. Se nessuno dei due finisce per falsare, è un mix, mentre se l'intersezione è falsa, sono numeri e se la sottrazione è falsa, sono lettere.


1
Accidenti a questo Pyth è strano. Sarebbe molto bello se potessi ottenere un punteggio negativo però.
KaareZ,

15

Pyth, 6 byte

!-.HQG

  .HQ   # Converts the input to hexadecimal
 -   G  # Deletes all letters
!       # If empty, output True, else False

Provalo qui


12

Gelatina , 6 byte

b16>9P

Provalo online!

Come funziona

b16>9P  Input: z

b16     Convert the input to base 16.
   >9   Compare each resulting digit with 9; return 1 iff greater.
     P  Take the product of the resulting Booleans.

Non c'è un built-in per 16 o non è una cosa?
Calcolatrice

1
C'è adesso. Questa è stata una delle prime risposte di Jelly ...
Dennis

11

TeaScript , 11 byte 13 15 16

xT(16)O(Sz)

Abbastanza semplice. Questo utilizza TeaScript 2.0. Puoi ottenere questa versione da Github

Spiegazione

        // Implicit: x = input, Sz = alphabet
xT(16)  // input -> hex
O(Sz)   // Only letters?

Provalo online (versione leggermente modificata che funziona sul web)


3
Il voto negativo è lungo perché è lungo? C'è qualcos'altro che non va in questa risposta di cui non sono a conoscenza? O a qualcuno non piace personalmente questa risposta?
Downgoat,

2
Non direi che 16 o 13 byte sono lunghi!
Luis Mendo,

23
Devi ammettere che il down-goating dei tuoi post è piuttosto allettante.
Dennis,

10

Python, 24 byte

lambda n:min('%x'%n)>'9'

Converte l'input in una stringa esadecimale (senza 0xprefisso) con '%x'%n. Vede se tutti i suoi caratteri sono maggiori di '9'(quali lettere) vedendo se minè sopra '9'.


Non so come Python gestisca caratteri / numeri, ma il codice ASCII '9'è 54. Quindi, se riesci a scrivere ...>54, puoi salvare un byte.
CompuChip

@CompuChip Python non tratta i caratteri o le stringhe come numeri. In effetti, Python 2 li considera più grandi di tutti i numeri.
xnor

8

MATL , 10

i16YA1Y2mA

Esempi

>> matl i16YA1Y2mA
> 240
0
>> matl i16YA1Y2mA
> 255
1

Spiegazione

i       % input                         
16YA    % convert to string representation in base 16
1Y2     % predefined literal: 'A':'Z'
m       % true for set member             
A       % all

Sfida bonus: 53−40 = 13

i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]

Esempi

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 255
Only letters

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 100
Only numbers

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 240
Mix

Spiegazione

i                       % input                                                 
16YA                    % convert integer to string representation in base 16
1Y2                     % predefined literal: 'A':'Z'
m                       % true for set member       
XK                      % copy to clipboard K                 
A                       % all                                   
?                       % if (top of the stack)                 
  'Only letters'        % string literal                                        
}                       % else                 
  K                     % paste from clipboard K      
  a                     % any                
  ?                     % if (top of the stack)      
    'Mix'               % string literal    
  }                     % else                                                  
    'Only numbers'      % string literal           
  ]                     % end             
]                       % end          

2
hmmm che cos'è? sembra che Matlab abbia un po 'di potere nuc ora!
Abr001am

@ Agawa001 Hahaha. Sorta di
Luis Mendo il


8

C, 46 43 37 byte

Ora con più ricorsione! (Grazie Dennis):

F(x){return(x%16>9)*(x<16?:F(x/16));}

Bonus: anche più breve (33 byte), ma non riesce per x = 0:

F(x){return!x?:(x%16>9)*F(x/16);}

b;F(x){for(b=x;x;x/=16)b*=x%16>9;return b;}

F()prende un inte restituisce 0(falso) o diverso da zero (vero).

Non ho nemmeno provato a ottenere il bonus, "MixOnly lettersnumbers"impiega 23 byte da solo, il tracciamento della nuova condizione avrebbe richiesto 9 byte aggiuntivi, printf()è di 8 byte, che aggiunge fino a 40, annullando lo sforzo.

Test principale:

#include <stdio.h>

int main() {
  int testdata[] = {10, 100, 161, 11259375, 0};
  for (int i = 0; i < 5; ++i) {
    int d = testdata[i];
    printf("%d (0x%x) -> %s\n", d, d, F(d)?"yep":"nope");
  }
}

Cosa ?:? Ho dovuto sostituirlo con ||per farlo compilare. Inoltre, puoi salvare un byte sostituendo il *con un &evitando così la ()s a sinistra (anche se devi aggiungere uno spazio)?
Neil,

@Neil a?:bè un'estensione GNU che valuta ase aè un valore veritiero, altrimenti a b. È utile per gestire puntatori null come send(message ?: "(no message)");. So che non è portatile, ma la portabilità del codice non è mai un problema nel golf del codice :)
Stefano Sanfilippo,

@StefanoSanfilippo puoi ottenere questo in 33byte facendo questo: F(x){x=(x%16>9)*(x<16?:F(x/16));}questo abusa di un bug (GCC) in cui se non c'è una variabile di ritorno in una funzione e l'argomento principale è stato impostato, restituirà automaticamente l'argomento principale in alcuni casi ( basato su quale logica è stata fatta), e questo sembra essere uno di quei casi! Provalo online: bit.ly/2pR52UH
Albert Renshaw il

8

Python 3, 30 29 byte

1 byte rimosso grazie a sysreq e Python 3.

lambda n:hex(n)[2:].isalpha()

Semplice lambdae affettato.


7

Perl 6 , 18 byte

{.base(16)!~~/\d/} # 18 bytes

utilizzo:

# give it a name
my &code = {.base(16)!~~/\d/}

for 10, 100, 161, 11259375, 0 {
  printf "%8s %6s %s\n", $_, .base(16), .&code
}

      10      A True
     100     64 False
     161     A1 False
11259375 ABCDEF True
       0      0 False

7

Mathematica, 32 byte

Tr@DigitCount[#,16,0~Range~9]<1&

Spiegazione:

                               &   A function returning whether
Tr@                                 the sum of elements of
   DigitCount[ ,  ,         ]        the numbers of
                   0~Range~9          zeros, ones, ..., nines in
                16                    the hexadecimal expansion of
              #                       the first argument
                             <1     is less than one.

7

Javascript, ES6, nessuna regexp, 28 byte

F=n=>n%16>9&&(n<16||F(n>>4))

C'è anche questa versione da 27 byte ma restituisce il valore inverso.

F=n=>n%16<10||n>15&&F(n>>4)

Bello! È inoltre possibile riorganizzarlo in questo modo per 23 byte:F=n=>!n||n%16>9&F(n>>4)
user81655

@ user81655 - Sfortunatamente, quella versione restituisce true per 0, quindi non è corretta.
zocky,

Oh giusto, immagino che il più corto sarebbe F=n=>n%16>9&&n<16|F(n>>4)allora.
user81655

@ user81655 Sono abbastanza sicuro che devi cortocircuitare il file ||, ma penso che potresti cavartela usando &invece &&che in quel caso.
Neil,

@Neil Perché? L'hai provato?
user81655

7

Julia, 18 byte

n->isalpha(hex(n))

Questa è una funzione anonima che accetta un numero intero e restituisce un valore booleano. Per chiamarlo, dagli un nome, ad es f=n->....

L'input viene convertito in una stringa esadecimale usando hex, quindi controlliamo se è interamente composto da caratteri alfabetici usando isalpha.


6

JavaScript ES6, 29

Nessun bonus

n=>!/\d/.test(n.toString(16))

Con il nuovo valore di -40 il bonus è più vicino ora ... ma non abbastanza. Punteggio bonus 70 71 - 40 => 30 31

n=>/\d/.test(n=n.toString(16))?1/n?'Only numbers':'Mix':'Only letters'

Test snippet (digitare un numero all'interno della casella di input)

#I { width:50%}
<input id=I oninput="test()"/><br>
Hex <span id=H></span><br>
Result <span id=R></span>


-n-1= ~ngiusto?
CalcolatriceFeline

@CatsAreFluffy se n non è numerico come 'A' (questo è l'intero punto di questa sfida), ~n == -1mentre-n-1 == NaN
edc65

4

GS2 , 6 byte

V↔i/◙s

Il codice sorgente utilizza la codifica CP437. Provalo online!

Come funziona

V       Evaluate the input.
 ↔      Push 16.
  i     Perform base conversion.
   /    Sort.
    ◙   Push [10].
     s  Perform greater-or-equal comparison.


4

Java, 46 44 38 byte

i->i.toHexString(i).matches("[a-f]+");

One-liner piuttosto semplice che converte l'intero in una stringa esadecimale e usa regex per determinare se tutti i caratteri sono lettere.

-2 byte grazie a @ Eng.Fouad.


"[a-f]+"risparmierebbe 2 byte.
Ing

Non riesce per 516 ..
CalculatorFeline

@CatsAreFluffy No, non lo è.
TNT,

Bene, ora determina se la stringa contiene una lettera esadecimale, quindi rimuovi +–è uno spreco di byte.
CalculatorFeline

@CatsAreFluffy No. matches restituisce true se l'intera stringa può essere adattata dal regex specificato. [a-f]senza il segno più non è corretto poiché non corrisponde all'intera stringa dato che contiene più di un carattere; lo farebbe se e solo se fosse presente un carattere valido.
TNT,


3

Rubino, 19 byte

->n{!('%x'%n)[/\d/]}

Ungolfed:

-> n {
  !('%x'%n)[/\d/]
}

Uso:

f=->n{!('%x'%n)[/\d/]} # Assigning it to a variable
f[0]
=> false
f[10]
=> true
f[100]
=> false
f[161]
=> false
f[11259375]
=> true

Con bonus, 70 - 40 = 30 byte

->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}

Uso:

f=->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}
f[10]
=> Only letters
f[100]
=> Only numbers
f[161]
=> Mix

In ritardo, ma '%x'%n!~/\d/è un controllo più breve per la soluzione uno e la soluzione due ha un conteggio dei byte non elaborati di 70, non di 75.
Inchiostro valore

3

Perl, 69 - 40 = 29 byte

$_=sprintf"%X",<>;print s/\d//?$_?"Mix":"Only numbers":"Only letters"

2

Ceylon, 55 byte

Boolean l(Integer n)=>!any(formatInteger(n,16)*.digit);

Semplice ... formattiamo ncome un numero esadecimale (che produce una stringa), chiamiamo su ogni carattere di quella stringa il .digitnumero (che restituisce vero se è una cifra), quindi controlliamo se qualcuno di loro è vero, quindi negiamo questo.

La versione con bonus ha un punteggio molto più alto di 119 - 25 = 94 :

String c(Integer n)=>let(s=formatInteger(n),d=s*.digit)(every(d)then"Only numbers"else(any(d)then"Mix"else"Only letters"));

Non sono sicuro di come si possa rendere una versione bonus abbastanza corta da essere migliore della versione no-bonus, anche solo quelle stringhe hanno una lunghezza di 28 insieme. Forse un linguaggio che rende veramente difficile produrre un valore di verità / falsità.

Ecco una versione formattata:

String c(Integer n) =>
        let (d = formatInteger(n,16)*.digit)
    (every(d) then "Only numbers"
                else (any(d) then "Mix"
                    else "Only letters"));

2

Ruggine, 70 byte

fn f(n:i32)->bool{format!("{:x}",n).chars().all(|c|c.is_alphabetic())}

Perché, sai, Java Rust.

In realtà è abbastanza elegante, però:

format!("{:x}", n)         // format n as hex (:x)
  .chars()                 // get an Iter over the characters
  .all(                    // do all Iter elements satisfy the closure?
    |c| c.is_alphabetic()  // self-explanatory
  )

Ma è un peccato che la definizione della funzione boilerplate sia così lunga ....: P


Ho un'idea. Più chiusure!
CalculatorFeline


2

Scherzi a parte, 12 byte

4ª,¡OkúOkd-Y

Dump esadecimale:

34a62cad4f6b
a34f6b642d59

Provalo online

È uguale alle risposte dell'altra lingua dello stack. Sarebbe solo 7 byte se Seriamente supportasse ancora la sottrazione di stringhe.

EDIT: Seriamente ora supporta la sottrazione di stringhe e la seguente soluzione a 7 byte ora funziona:

ú4╙,¡-Y

Dump esadecimale:

a334d32cad2d59

Provalo online


1
11: 4╙,¡#S;ú∩S=(o o molti modi per scrivere :16:in due byte: P)
Mego

Non sapevo che SI pensasse.
Quintopia,

2

05AB1E , 2 byte (non concorrenti)

Codice:

ha

Ha! Sono due byte! Purtroppo non competere perché questa lingua postdatizza la sfida :(

Spiegazione:

h   # Convert input to hexadecimal
 a  # is_alpha, checks if the value only contains letters

Provalo online! oppure Verifica tutti i casi di test!


1
hdÔ©1åi•4?ŸâτΛ•}®0åi•4?ŸàpÕTà•}®g2Qi•²•} 36 B` per il bonus risultante ... 6 in più! Wooooo bonus!
Magic Octopus Urn



2

SmileBASIC 3.2.1, 78 byte

INPUT V FOR I=0 TO 9
IF INSTR(HEX$(V),STR$(I))>-1 THEN ?"FALSE"END
NEXT?"TRUE"

Non vedo alcun carattere non ASCII qui (a meno che non ce ne siano alcuni); questo contatore è il decisore definitivo e dice 81.
cat

1
Non importa che l'implementazione usi UTF-16 internamente; nel resto del mondo potrebbero anche essere caratteri UTF-8 nell'intervallo 0-127, quindi il conteggio dei byte è 81.
cat

Grazie per il feedback, non ero sicuro che "byte" significasse che avrei dovuto contare 2 per carattere. 81 lo è.
snail_

In realtà, l'attuale consenso + 10 / -0 (che, a proposito, ora non sono d'accordo) è che dobbiamo sempre usare la codifica utilizzata da un interprete. Se non sei d'accordo, pubblica un'opinione dissenziente su tale domanda.
lirtosiast,

@ThomasKwa pfft, ok, oops, ora lo so meglio. Non mi rendevo conto che ci fosse un consenso al riguardo e spendo un bel po 'di tempo in meta.
cat

1

Japt, 12 byte

!UsG r"[a-f]

Provalo online!

Come funziona

!UsG r"[a-f] // Implicit: U = input integer, G = 16
 UsG         // Convert U to a base-16 string.
     r"[a-f] // Replace all lowercase letters with an empty string.
!            // Take the logical NOT of the result.
             // This returns true for an empty string; false for anything else.

Penso che !!UsG r"\\dpotrebbe funzionare e salvare un byte
Downgoat il

@Downgoat Buona osservazione, ma restituisce vero per qualsiasi numero che contiene una lettera.
Produzioni ETH il

1

Gema, 41 personaggi

*=@c{@radix{10;16;*}}
c:<D>=f@end;?=;\Z=t

Non c'è booleano in Gema, quindi genera semplicemente "t" o "f".

Esecuzione di esempio:

bash-4.3$ echo -n '11259375' | gema '*=@c{@radix{10;16;*}};c:<D>=f@end;?=;\Z=t'
t
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.