Ao fazer chamadas telefônicas internacionalmente, os números de telefone são prefixados com um código que indica em que país o número está localizado. Esses códigos são códigos de prefixo , o que significa que nenhum código é o prefixo de outro.

Agora, hoje cedo, você perdeu uma ligação e está meio curioso de onde a ligação pode ter ocorrido. Então, você deseja procurar o código de chamada. Mas, sendo um código de prefixo, você não tem certeza de onde termina, então decide escrever um programa para separar o código de chamada do resto do número.

Entrada

Como entrada, você receberá uma sequência composta pelos dígitos 0-9. Os primeiros dígitos serão um dos códigos de chamada do país listados abaixo (isso significa que o primeiro dígito nunca será 0). Depois que o código de chamada país, o resto da entrada irá conter zero ou mais dígitos em qualquer ordem - é não garantido para ser um número de telefone válido. Seu programa deve ser capaz de lidar com entradas que contenham pelo menos 15 dígitos

Resultado

Seu programa deve gerar o código de chamada de país exclusivo que é um prefixo do número. As saídas válidas são as seguintes:

Esta lista é baseada nos códigos listados na página de códigos de chamadas de países da Wikipedia na revisão 915410826, com algumas modificações

Todos os códigos listados como não atribuídos ou descontinuados e alguns códigos listados como reservados para uso futuro foram omitidos
Se um código listado na Wikipedia é um prefixo de outro, o último foi omitido
Se um único país ou território tiver mais de um código e se esses códigos tiverem um prefixo comum, esses códigos serão omitidos em favor de seu prefixo comum.

Isso pode resultar em países independentes sendo agrupados ou territórios disputados sendo agrupados com um reclamante específico. Isso não pretende ser uma declaração política, e as decisões sobre a inclusão ou omissão de territórios e estados foram tomadas com base nos códigos, e não em nenhuma crença que tenho sobre a propriedade ou soberania das entidades que os utilizam.

Se for fornecida uma entrada que não comece com nenhum desses códigos, o comportamento do seu programa é indefinido.

E finalmente:

Isso é código-golfe , menos bytes de código é melhor
Seu envio pode ser uma função ou um programa completo
Qualquer um dos métodos de E / S padrão é bom
As brechas padrão são proibidas

Casos de teste

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

Talvez você deva fazer input | outputum traço por baixo, a menos que queira inputser traduzido output.

— JL2210 19/09

10

JavaScript (ES6), 75 73 71 bytes

Guardou 1 byte graças a @Shaggy Guardou
2 bytes graças a @Neil

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

Experimente online!

— Arnauld
fonte

Eu acho que 599?|50pode substituir 599|5[09].

— Neil

@ Neil De fato. Obrigado!

— Arnauld

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

— ovs 19/09

1

@ovs Sim, mas a versão atual é na verdade 71 bytes - a contagem de bytes estava desatualizada.

— Arnauld

9

05AB1E , 28 25 24 bytes

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

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

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

Experimente online!

— Neil
fonte

Sua entrada no TIO já inclui a resposta;) Eu sei que seu código não está usando-os, mas parece um pouco confuso tbh.

— Kevin Cruijssen 19/09

4

Python 3 , 120 78 bytes

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

Experimente online!

Contém alguns imprimíveis:

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

Versão um pouco não destruída (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

Experimente online!

— ovs
fonte

4

Bash , 328341 410 bytes

Não é muito competitivo para uma pontuação de golfe, mas cada um deles ajuda minhas habilidades no bash!

Economizou 13 bytes, eliminando a manipulação de valores de comprimento de execução de 2 bytes; armazenar apenas 3 bytes adiciona 8 bytes a T, mas torna a declaração de caso muito mais simples.

Economizou 69 bytes mudando a abordagem da expansão do bash para o armazenamento de deltas. O link TIO anterior está na parte inferior da minha resposta.

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

Experimente online!

Classificou a lista de prefixos numericamente
T é um "tipo de" sequência codificada de comprimento de execução, mostrando o delta do valor anterior. Cada caractere é um dos seguintes:
- Um valor base36 mostrando o aumento em relação ao valor anterior
- 'r': indica que o próximo caractere indica o número codificado em base36 de valores delta repetidos de 1.
- '-': indica que os próximos 3 caracteres são o próximo valor delta

A sequência T = "16D73r42 [...] -3UR132", seguindo as regras acima, torna-se uma lista de deltas: "1 6 D 7 3 r4 2 [...] 4995 1 3 2"

Pode salvar de 2 a 3 bytes a mais usando um radix maior que 36 (como 62-64), mas o Excel suporta apenas até 36 nativamente, e é isso que costumava fazer a lista de deltas e suas conversões.

Em execução, T é analisado e expandido para a sequência S usada para a comparação do número de telefone fornecido no argumento 1 da linha de comando.

A expansão de T, S se torna: "1 7 20 27 30 31 32 33 34 36 [...] 5993 5994 5997 5999"

~~Experimente online!~~

— spuck
fonte

2

Perl 5 (-p), 44 bytes

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

Experimente online!

Tanto o TIO quanto o SO têm problemas com caracteres não imprimíveis, portanto, o programa é mostrado com seqüências de escape. Aqui está um hexdump dos 44 bytes reais:

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 bytes

Eu sinto que há muito espaço para melhorar o regex - joguei o máximo possível, mas aposto que pode ser bem mais curto ...

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

Experimente online!

— XMark
fonte

1

Java 8, 84 bytes

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

Porto da regex JavaScript de @Arnauld , certifique-se de vomitá-lo!

Experimente online.

Explicação:

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

Explicação 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 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

Experimente online!

Resposta JavaScript do Port of Arnauld.

— Jitse
fonte

0

Scala , 411 402 330 bytes

Isso pressupõe que o argumento contenha apenas 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))

Experimente online!

— jkeatley
fonte

De onde eles estão ligando?

Entrada

Resultado

Casos de teste

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