Khi thực hiện các cuộc gọi điện thoại quốc tế, các số điện thoại được thêm tiền tố vào mã cho biết quốc gia đó được đặt ở quốc gia nào. Các mã này là mã tiền tố , có nghĩa là không có mã nào là tiền tố của quốc gia khác.

Bây giờ, đầu ngày hôm nay bạn đã bỏ lỡ một cuộc gọi, và bạn hơi tò mò về cuộc gọi đó có thể đến từ đâu. Vì vậy, bạn muốn tìm kiếm mã gọi. Nhưng, là một mã tiền tố, bạn không chắc chắn nó kết thúc ở đâu, vì vậy bạn quyết định viết một chương trình để tách mã cuộc gọi khỏi phần còn lại của số.

Đầu vào

Là đầu vào, bạn sẽ nhận được một chuỗi bao gồm các chữ số 0-9. Một vài chữ số đầu tiên sẽ là một trong những mã gọi quốc gia được liệt kê bên dưới (điều này có nghĩa là chữ số đầu tiên sẽ không bao giờ 0). Sau mã gọi quốc gia, phần còn lại của đầu vào sẽ chứa 0 hoặc nhiều chữ số theo bất kỳ thứ tự nào - không phải là được đảm bảo là số điện thoại hợp lệ. Chương trình của bạn phải có khả năng xử lý các đầu vào chứa ít nhất 15 chữ số

Đầu ra

Chương trình của bạn sẽ xuất mã gọi quốc gia duy nhất là tiền tố của số. Các đầu ra hợp lệ như sau:

1
20
211
212
213
216
218
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
260
261
262
263
264
265
266
267
268
269
27
290
291
297
298
299
30
31
32
33
34
350
351
352
353
354
355
356
357
358
359
36
370
371
372
373
374
375
376
377
378
379
380
381
382
383
385
386
387
389
39
40
41
420
421
423
43
44
45
46
47
48
49
500
501
502
503
504
505
506
507
508
509
51
52
53
54
55
56
57
58
590
591
592
593
594
595
596
597
598
5993
5994
5997
5999
60
61
62
63
64
65
66
670
672
673
674
675
676
677
678
679
680
681
682
683
685
686
687
688
689
690
691
692
7
800
808
81
82
84
850
852
853
855
856
86
870
875
876
877
878
879
880
881
882
883
886
888
90
91
92
93
94
95
960
961
962
963
964
965
966
967
968
970
971
972
973
974
975
976
977
979
98
991
992
993
994
995
996
998

Danh sách này dựa trên các mã được liệt kê trên danh sách trang mã gọi quốc gia của Wikipedia kể từ phiên bản 915410826, với một vài sửa đổi

• Tất cả các mã được liệt kê là không được chỉ định hoặc ngừng và một số mã được liệt kê là dành riêng cho sử dụng trong tương lai đã bị bỏ qua
• Nếu một mã được liệt kê trên Wikipedia là tiền tố của mã khác, mã sau đó đã bị bỏ qua
• Nếu một quốc gia hoặc lãnh thổ sẽ có nhiều hơn một mã và nếu các mã đó có tiền tố chung, các mã đó sẽ bị bỏ qua có lợi cho tiền tố chung của chúng.

Điều này có thể dẫn đến việc các quốc gia độc lập bị gộp lại với nhau hoặc các vùng lãnh thổ tranh chấp bị gộp lại với một bên yêu sách cụ thể. Đây không phải là một tuyên bố chính trị, và các quyết định về việc bao gồm hoặc bỏ qua các lãnh thổ và quốc gia được đưa ra dựa trên các quy tắc, không phải bất kỳ niềm tin nào tôi giữ về quyền sở hữu hoặc chủ quyền của các thực thể sử dụng chúng.

Nếu được cung cấp một đầu vào không bắt đầu với bất kỳ mã nào trong số này, hành vi của chương trình của bạn không được xác định.

Và cuối cùng:

• Đây là môn đánh gôn , càng ít byte mã thì càng tốt
• Trình của bạn có thể là một chức năng hoặc một chương trình đầy đủ
• Bất kỳ phương thức I / O mặc định nào cũng tốt
• Các lỗ hổng tiêu chuẩn bị cấm

Các trường hợp thử nghiệm

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

JavaScript (ES6),  75 73  71 byte

Đã lưu 1 byte nhờ @Shaggy
Lưu 2 byte nhờ @Neil

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

Hãy thử trực tuyến!

05AB1E , 28 25 24 byte

η•A󾫸tEΓ∞ζ∊u½d•.¥¤ØªKн

Hãy thử trực tuyến!

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

Võng mạc 0.8.2 , 60 byte

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

Hãy thử trực tuyến!

Python 3 , 120 78 byte

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

Hãy thử trực tuyến!

Chứa một số dấu vết:

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

Phiên bản nào đó chưa được chỉnh sửa (trước đó):

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

Hãy thử trực tuyến!

Bash , 328 341 410 byte

Không phải là rất cạnh tranh cho một điểm số golf, nhưng mỗi trong số đó giúp kỹ năng bash của tôi!

Đã lưu 13 byte bằng cách loại bỏ việc xử lý 2 giá trị độ dài chạy; chỉ lưu trữ 3 byte thêm 8 byte vào T, nhưng làm cho câu lệnh case đơn giản hơn nhiều.

Đã lưu 69 byte bằng cách thay đổi cách tiếp cận từ mở rộng bash sang lưu trữ deltas. Liên kết TIO trước đó nằm ở cuối câu trả lời của tôi.

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

Hãy thử trực tuyến!

• Sắp xếp danh sách các tiền tố số
• T là một chuỗi được mã hóa theo chiều dài "sắp xếp" hiển thị delta từ giá trị trước đó. Mỗi nhân vật là một trong những điều sau đây:
  • Giá trị base36 hiển thị mức tăng so với giá trị trước đó
  • 'r': chỉ ra rằng ký tự tiếp theo biểu thị số lượng cơ sở được mã hóa 36 của các giá trị delta lặp lại là 1.
  • '-': chỉ ra rằng 3 ký tự tiếp theo là giá trị delta tiếp theo

Chuỗi T = "16D73r42 [...] -3UR132" theo các quy tắc trên trở thành một danh sách các deltas: "1 6 D 7 3 r4 2 [...] 4995 1 3 2"

Có thể tiết kiệm thêm 2-3 byte bằng cách sử dụng cơ số cao hơn 36 (như 62-64) nhưng Excel chỉ hỗ trợ tối đa 36 và đó là những gì được sử dụng để thực hiện danh sách deltas và chuyển đổi của chúng.

• Khi chạy, T được phân tích cú pháp và mở rộng thành chuỗi S được sử dụng để so sánh số điện thoại được đưa ra trong đối số dòng lệnh 1.

Mở rộng T, S trở thành: "1 7 20 27 30 31 32 33 34 36 [...] 5993 5994 5997 5999"

Hãy thử trực tuyến!

Perl 5 (-p), 44 byte

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

Hãy thử trực tuyến!

Cả TIO và SO đều gặp rắc rối với các ký tự không thể in được, vì vậy chương trình được hiển thị với các chuỗi thoát. Đây là một hexdump của 44 byte thực tế:

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

PHP , 219 byte

Tôi cảm thấy như có rất nhiều cơ hội để cải thiện regex - chơi golf hết mức có thể nhưng tôi cá là nó có thể ngắn hơn ....

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

Hãy thử trực tuyến!

Java 8, 84 byte

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

Bản regex JavaScript của @Arnauld , vì vậy hãy đảm bảo nâng cấp anh ấy!

Hãy thử trực tuyến.

Giải trình:

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

Regex giải thích:

(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 `.*`)

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

Hãy thử trực tuyến!

Câu trả lời JavaScript của cảng Arnauld.

Scala , 411 402 330 byte

Điều này giả sử rằng đối số chỉ chứa các chữ số.

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

Hãy thử trực tuyến!