Quando si effettuano chiamate internazionali, ai numeri di telefono viene aggiunto un prefisso che indica in quale paese si trova il numero. Questi codici sono prefissi , il che significa che nessun codice è un prefisso di un altro.

Ora, prima di oggi hai perso una chiamata e sei un po 'curioso da dove potrebbe provenire quella chiamata. Quindi vuoi cercare il codice chiamante. Ma, essendo un prefisso, non sei sicuro di dove finisca, quindi decidi di scrivere un programma per separare il codice chiamante dal resto del numero.

Ingresso

Come input, riceverai una stringa composta da cifre 0-9. Le prime cifre saranno uno dei codici di chiamata del paese elencati di seguito (ciò significa che la prima cifra non sarà mai 0). Dopo che il codice chiamante paese, il resto dell'ingresso conterrà zero o più cifre in qualsiasi ordine - è non è garantito per essere un numero di telefono valido. Il tuo programma deve essere in grado di gestire input contenenti almeno 15 cifre

Produzione

Il tuo programma dovrebbe generare il prefisso univoco del paese che è un prefisso del numero. Le uscite valide sono le seguenti:

Questo elenco si basa sui codici elencati nell'elenco di Wikipedia dei codici delle chiamate nazionali alla pagina 915410826, con alcune modifiche

Tutti i codici elencati come non assegnati o fuori produzione e alcuni codici elencati come riservati per uso futuro sono stati omessi
Se un codice elencato su Wikipedia è un prefisso di un altro, quest'ultimo è stato omesso
Se un singolo paese o territorio avrebbe più di un codice e se tali codici avessero un prefisso comune, tali codici vengono omessi a favore del loro prefisso comune.

Ciò può comportare il raggruppamento di paesi indipendenti o il contenimento di territori contesi con un determinato richiedente. Questo non è inteso come una dichiarazione politica e le decisioni sull'inclusione o l'omissione di territori e stati sono state prese sulla base dei codici, non di tutte le convinzioni che ritengo relative alla proprietà o alla sovranità delle entità che le utilizzano.

Se viene fornito un input che non inizia con nessuno di questi codici, il comportamento del programma non è definito.

E infine:

Questo è code-golf , meno byte di codice è meglio
L'invio può essere una funzione o un programma completo
Tutti i metodi I / O predefiniti vanno bene
Le scappatoie standard sono vietate

Casi test

input -> output
5292649259 -> 52
3264296721 -> 32
1550 -> 1
33121394 -> 33
7 -> 7
2542112543 -> 254
2005992972 -> 20
350 -> 350
360 -> 36
8505234469 -> 850
9795586334 -> 979
148985513598795 -> 1
222222 -> 222
5999995 -> 5999

— Sara J
fonte

Forse dovresti input | outputinvece fare una linea tratteggiata sotto a meno che tu non voglia inputessere tradotto output.

— JL2210,

10

JavaScript (ES6), 75 73 71 byte

Salvato 1 byte grazie a @Shaggy
Salvato 2 byte grazie a @Neil

s=>/1|7|(2[^07]|3[578]|42|599?|50|6[789]|8[0578]|9[679]|.)./.exec(s)[0]

Provalo online!

— Arnauld
fonte

Penso che 599?|50possa sostituire 599|5[09].

— Neil,

@Neil Indeed. Grazie!

— Arnauld,

Funziona s=>/(2[^07]|3[578]|42|599?|50|6[789]|8[0578]|9[679]|[^17]|)./.exec(s)[0]per 72 byte?

— Ovs,

1

@ovs Sì, ma la versione attuale è in realtà 71 byte - il conteggio dei byte era obsoleto.

— Arnauld,

9

05AB1E , 28 25 24 byte

η•Aó¾«¸tEΓ∞ζ∊u½d•.¥¤ØªKн

Provalo online!

η                            # prefixes of the input
 •Aó¾«¸tEΓ∞ζ∊u½d•            # compressed integer 211112166111113621489811655218129
                 .¥          # undelta: [0, 2, 3, 4, 5, 6, 8, 9, 15, 21, 22, 23, 24, 25, 26, 29, 35, 37, 38, 42, 50, 59, 67, 68, 69, 75, 80, 85, 87, 88, 96, 97, 99, 108]
                   ¤         # last element of that list: 108
                    Ø        # nth prime: 599
                     ª       # append it to the list
                      K      # remove all those values from the list of prefixes
                       н     # get the first prefix left

— Grimmy
fonte

6

Retina 0.8.2 , 60 byte

!`^(2[1-69]?|3[578]?|42?|599?|50?|6[789]?|8[578]?|9[679]?)?.

Provalo online!

— Neil
fonte

Il tuo input nel TIO include già la risposta;) So che il tuo codice non li sta usando, ma sembra un po 'confuso tbh.

— Kevin Cruijssen,

4

Python 3 , 120 78 byte

f=lambda n:{n//10+3}-{*b'	 &()-5>FGHSXZ[cdf',602}and f(n//10)or n

Provalo online!

Contiene alcuni non stampabili:

00000000: 663d 6c61 6d62 6461 206e 3a7b 6e2f 2f31  f=lambda n:{n//1
00000010: 302b 337d 2d7b 2a62 2705 0306 0708 090b  0+3}-{*b'.......
00000020: 0c18 191a 1b1c 1d20 2628 292d 353e 4647  ....... &()-5>FG
00000030: 4853 585a 5b63 6466 272c 3630 327d 616e  HSXZ[cdf',602}an
00000040: 6420 6628 6e2f 2f31 3029 6f72 206e       d f(n//10)or n

Versione un po 'ungolfed (precedente):

f=lambda n:{n/10}-{0,2,3,4,5,6,8,9,21,22,23,24,25,26,29,35,37,38,42,50,59,599,67,68,69,80,85,87,88,96,97,99}and f(n/10)or n

Provalo online!

— OVS
fonte

4

Bash , 328 341 410 byte

Non molto competitivo per un punteggio di golf, ma ognuno di questi aiuta le mie abilità bash!

Salvato 13 byte eliminando la gestione di valori di lunghezza di esecuzione di 2 byte; la memorizzazione di soli 3 byte aggiunge 8 byte a T, ma rende l'istruzione case molto più semplice.

Risparmiato 69 byte modificando l'approccio dall'espansione bash alla memorizzazione dei delta. Il precedente link TIO è in fondo alla mia risposta.

T='16D73r423112r62r72r6F1224r53-03511322rZr32r9L1611-01Fr9BrD2112V12-025r9-029r8-0202rB2r7-0308-162121E5r832-02082r72Cr52-3UR132'
A(){
V=$[V+36#$1]
S="$S $V"
}
R(){
read -n$1 d
}
while read -n1 c;do
case $c in -)R 3;A $d;;r)R 1;for((i=1;$i<=36#$d;i++)){ A 1;};;*)A $c;;esac;done<<<$T
for s in $S;do [[ $1 =~ ^$s ]]&&echo $s;done

Provalo online!

Ordinato numericamente l'elenco dei prefissi
T è una "codifica" di una stringa codificata per la lunghezza che mostra il delta del valore precedente. Ogni personaggio è uno dei seguenti:
- Un valore base36 che mostra l'aumento dal valore precedente
- 'r': indica che il carattere successivo indica il numero codificato base36 di valori delta ripetuti pari a 1.
- '-': indica che i successivi 3 caratteri sono il valore delta successivo

La stringa T = "16D73r42 [...] -3UR132" seguendo le regole sopra diventa un elenco di delta: "1 6 D 7 3 r4 2 [...] 4995 1 3 2"

Potrebbe salvare 2-3 più byte usando una radice maggiore di 36 (come 62-64) ma Excel supporta solo nativamente fino a 36, ed è quello che era usato per fare la lista dei delta e le loro conversioni.

Durante l'esecuzione, T viene analizzato ed espanso nella stringa S utilizzata per il confronto del numero di telefono indicato nell'argomento 1 della riga di comando.

L'espansione di T, S diventa: "1 7 20 27 30 31 32 33 34 36 [...] 5993 5994 5997 5999"

~~Provalo online!~~

— Spuck
fonte

2

Perl 5 (-p), 44 byte

$\=chop until/^599$/+vec"\x7D\x03\xE0\x27\x68\x04\x04\x08\x38\x00\xA1\x01\x0B",$_,1

Provalo online!

Sia TIO che SO hanno problemi con caratteri non stampabili, quindi il programma viene mostrato con sequenze di escape. Ecco un dump esadecimale degli attuali 44 byte:

0000000: 245c 3d63 686f 7020 756e 7469 6c2f 5e35  $\=chop until/^5
0000010: 3939 242f 2b76 6563 227d 03e0 2768 0404  99$/+vec"}..'h..
0000020: 0838 00a1 010b 222c 245f 2c31            .8....",$_,1

— Grimmy
fonte

1

PHP , 219 byte

Sento che c'è molto spazio per migliorare il regex: ho giocato a golf per quanto posso, ma scommetto che può essere molto più corto ...

preg_match('/(1|7|2(0|1[12368]|[2346].|5[^9]|7|9[01789])|3[578]?.|42?[013]|5([1-8]|0.|99?[3479])|6([0-6]|7[^1]|8[^4]|9[012])|8(0[08]|[1246]|5[02356]|7[05-9]|8[0-368])|9([0-58]|6[^9]|7[^8]|9[1-8]))/',$argn,$r);echo$r[0];

Provalo online!

— XMark
fonte

1

Java 8, 84 byte

s->s.replaceAll("(1|7|(2[^07]|3[578]|42|599?|50|6[789]|8[0578]|9[679]|.).).*","$1");

Porta del regex JavaScript di @Arnauld , quindi assicurati di votarlo!

Provalo online.

Spiegazione:

s->                    // Method with String as both parameter and return-type
  s.replaceAll("(1|7|(2[^07]|3[578]|42|599?|50|6[789]|8[0578]|9[679]|.).).*",
                       //  Replace this regex-match
               "$1");  //  With this replacement

Spiegazione Regex:

(1|7|(2[^07]|3[578]|42|599?|50|6[789]|8[0578]|9[679]|.).).*  // MATCH:
 1                                                           //  a 1
  |7                                                         //  or a 7
    |(                                                )      //  or:
      2[^07]                                                 //   a 2 not followed 0 nor 7
            |3[578]                                          //   or a 3 followed by 5, 7, or 8
                   |42                                       //   or a 42
                      |599?                                  //   or a 59 or a 599
                           |50                               //   or a 50
                              |6[789]                        //   or a 6 followed by 7, 8, or 9
                                     |8[0578]                //   or an 8 followed by 0, 5, 7, or 8
                                             |9[679]         //   or a 9 followed by 6, 7, or 9
                                                    |.       //   or any single digit
                                                       .     //  followed by any single digit
(                                                       )    //  All captured in capture group 1
                                                         .*  //  With 0 or more digits following

$1                                                           // REPLACEMENT:
$1                                                           //  The match of capture group 1,
                                                             //  (effectively removing the
                                                             //   remaining digits of `.*`)

— Kevin Cruijssen
fonte

0

Python 3 , 96 byte

lambda s:re.sub('(1|7|(2[^07]|3[578]|42|599?|50|6[789]|8[0578]|9[679]|.).).*',r'\1',s)
import re

Provalo online!

La risposta JavaScript di Port of Arnauld.

— Jitse
fonte

0

Scala , 411 402 330 byte

Ciò presuppone che l'argomento contenga solo cifre.

"(1|(2(0|(1[12368])|([2346]\\d)|(5[^9])|7|(9[^2-6])))|(3(([0-4])|([57]\\d)|6|(8[^48])|9))|(4([^2]|(2[013])))|(5((0\\d)|[^09]|(9([^9]|(9[3479])))))|(6([0-6]|(7[^1])|(8[^4])|(9[0-2])))|7|(8((0[08])|[1246]|(5[02356])|(7[05-9])|(8[^4579])))|(9([0-58]|(6[^9])|(7[^8])|(9[^079]))))(.*)".r.unapplySeq(args(0)).foreach(l=>println(l.head))

Provalo online!

— jkeatley
fonte

Da dove chiamano?

Ingresso

Produzione

Casi test

JavaScript (ES6), 75 73 71 byte

05AB1E , 28 25 24 byte

Retina 0.8.2 , 60 byte

Python 3 , 120 78 byte

Bash , 328 341 410 byte

Perl 5 (-p), 44 byte

PHP , 219 byte

Java 8, 84 byte

Python 3 , 96 byte

Scala , 411 402 330 byte