Al hacer llamadas telefónicas internacionales, los números de teléfono tienen el prefijo con un código que indica en qué país se encuentra el número. Estos códigos son códigos de prefijo , lo que significa que ningún código es el prefijo de otro.

Ahora, más temprano hoy perdiste una llamada y tienes curiosidad de saber de dónde podría haber venido esa llamada. Entonces quieres buscar el código de llamada. Pero, al ser un código de prefijo, no está seguro de dónde termina, por lo que decide escribir un programa para separar el código de llamada del resto del número.

Entrada

Como entrada, recibirá una cadena que consta de los dígitos 0-9. Los primeros dígitos serán uno de los códigos de llamadas de país que se enumeran a continuación (esto significa que el primer dígito nunca lo será 0). Después de que el código de llamada del país, el resto de la entrada contendrá cero o más dígitos en cualquier orden - se no garantiza que sea un número de teléfono válido. Su programa debe poder manejar entradas que contengan al menos 15 dígitos

Salida

Su programa debe generar el código de llamada de país único que es un prefijo del número. Las salidas válidas son las siguientes:

Esta lista se basa en los códigos enumerados en la lista de Wikipedia de la página de códigos de llamadas de países a partir de la revisión 915410826, con algunas modificaciones

Todos los códigos listados como no asignados o descontinuados y algunos códigos listados como reservados para uso futuro se omitieron
Si un código listado en Wikipedia es un prefijo de otro, este último se omite
Si un solo país o territorio tuviera más de un código, y esos códigos tuvieran un prefijo común, esos códigos se omiten a favor de su prefijo común.

Esto puede dar como resultado que países independientes se agrupen, o territorios en disputa se agrupen con un reclamante particular. Esto no pretende ser una declaración política, y las decisiones sobre la inclusión u omisión de territorios y estados se tomaron con base en los códigos, no en ninguna creencia que tengo con respecto a la propiedad o soberanía de las entidades que los utilizan.

Si recibe una entrada que no comienza con ninguno de estos códigos, el comportamiento de su programa no está definido.

Y finalmente:

Esto es código golf , menos bytes de código es mejor
Su envío puede ser una función o un programa completo
Cualquiera de los métodos de E / S predeterminados está bien
Las lagunas estándar están prohibidas.

Casos de prueba

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
fuente

Tal vez deberías hacerlo input | outputcon una línea de guión debajo a menos que quieras inputser traducido output.

— JL2210

10

JavaScript (ES6), 75 73 71 bytes

Guardado 1 byte gracias a @Shaggy
Guardado 2 bytes gracias a @Neil

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

Pruébalo en línea!

— Arnauld
fuente

Creo que 599?|50puede reemplazar 599|5[09].

— Neil

@Neil De hecho. ¡Gracias!

— Arnauld

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

— ovs

1

@ovs Sí, pero la versión actual es en realidad de 71 bytes: el recuento de bytes estaba desactualizado.

— Arnauld

9

05AB1E , 28 25 24 bytes

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

Pruébalo en línea!

η                            # 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

— Mugriento
fuente

6

Retina 0.8.2 , 60 bytes

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

Pruébalo en línea!

— Neil
fuente

Su entrada en el TIO ya incluye la respuesta;) Sé que su código no los está usando, pero parece un poco confuso.

— Kevin Cruijssen

4

Python 3 , 120 78 bytes

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

Pruébalo en línea!

Contiene algunos no imprimibles:

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

Versión ungolfed (anterior):

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

Pruébalo en línea!

— ovs
fuente

4

Bash , 328341 410 bytes

No es muy competitivo para un puntaje de golf, ¡pero cada uno de estos ayuda a mis habilidades de bash!

Ahorró 13 bytes al eliminar el manejo de valores de longitud de ejecución de 2 bytes; almacenar solo 3 bytes agrega 8 bytes a T, pero hace que la declaración del caso sea mucho más simple.

Ahorró 69 bytes al cambiar el enfoque de expansión de bash a almacenar deltas. El enlace TIO anterior está al final de mi respuesta.

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

Pruébalo en línea!

Ordenado la lista de prefijos numéricamente
T es un "tipo de" cadena codificada de longitud de ejecución que muestra el delta del valor anterior. Cada personaje es uno de los siguientes:
- Un valor base36 que muestra el aumento del valor anterior
- 'r': indica que el siguiente carácter indica el número codificado en base36 de valores delta repetidos de 1.
- '-': indica que los siguientes 3 caracteres son el siguiente valor delta

La cadena T = "16D73r42 [...] -3UR132" que sigue las reglas anteriores se convierte en una lista de deltas: "1 6 D 7 3 r4 2 [...] 4995 1 3 2"

Podría ahorrar 2-3 bytes más usando una raíz más alta que 36 (como 62-64) pero Excel solo admite de forma nativa hasta 36, y eso es lo que solía hacer la lista de deltas y sus conversiones.

Al ejecutarse, T se analiza y se expande en la cadena S utilizada para la comparación del número de teléfono dado en el argumento 1 de la línea de comando.

La expansión T, S se convierte en: "1 7 20 27 30 31 32 33 34 36 [...] 5993 5994 5997 5999"

~~Pruébalo en línea!~~

— golpear
fuente

2

Perl 5 (-p), 44 bytes

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

Pruébalo en línea!

Tanto TIO como SO tienen problemas con los caracteres no imprimibles, por lo que el programa se muestra con secuencias de escape. Aquí hay un hexdump de los 44 bytes reales:

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

— Mugriento
fuente

1

PHP , 219 bytes

Siento que hay mucho espacio para mejorar la expresión regular: lo jugué todo lo que pude, pero apuesto a que puede ser mucho más 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];

Pruébalo en línea!

— XMark
fuente

1

Java 8, 84 bytes

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

Puerto de expresión regular de JavaScript @Arnauld , ¡así que asegúrese de votarlo!

Pruébalo en línea.

Explicación:

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

Explicación de expresiones regulares:

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

0

Python 3 , 96 bytes

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

Pruébalo en línea!

La respuesta de JavaScript del puerto de Arnauld.

— Jitse
fuente

0

Scala , 411 402 330 bytes

Esto supone que el argumento solo contiene dígitos.

"(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))

Pruébalo en línea!

— jkeatley
fuente

¿De dónde están llamando?

Entrada

Salida

Casos de prueba

JavaScript (ES6), 75 73 71 bytes

05AB1E , 28 25 24 bytes

Retina 0.8.2 , 60 bytes

Python 3 , 120 78 bytes

Bash , 328341 410 bytes

Perl 5 (-p), 44 bytes

PHP , 219 bytes

Java 8, 84 bytes

Python 3 , 96 bytes

Scala , 411 402 330 bytes