Skąd oni dzwonią?

19

Podczas wykonywania połączeń międzynarodowych numery telefonów są poprzedzone kodem wskazującym kraj, w którym znajduje się numer. Kody te są kodami prefiksów , co oznacza, że ​​żaden kod nie jest prefiksem innego.

Teraz, wcześniej tego dnia nie udało Ci się odebrać połączenia i jesteś trochę ciekawy, skąd to połączenie mogło pochodzić. Więc chcesz sprawdzić kod wywołujący. Ale będąc kodem prefiksu, nie jesteś do końca pewien, gdzie się kończy, więc decydujesz się napisać program, który oddzieli kod wywołujący od reszty numeru.

Wejście

Jako dane wejściowe otrzymasz ciąg składający się z cyfr 0-9. Pierwsze kilka cyfr będzie jednym z wymienionych poniżej numerów kierunkowych kraju (oznacza to, że pierwsza cyfra nigdy nie będzie 0). Po kraju kodu wywołującego, reszta wejściu będzie zawierać zero lub więcej cyfr w dowolnej kolejności - to nie gwarantuje się poprawny numer telefonu. Twój program musi być w stanie obsłużyć dane wejściowe zawierające co najmniej 15 cyfr

Wynik

Twój program powinien wypisać unikalny kod kraju, który jest prefiksem numeru. Prawidłowe dane wyjściowe są następujące:

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

Ta lista oparta jest na kodach wymienionych na stronie z listą kodów krajowych w Wikipedii w wersji 915410826, z kilkoma modyfikacjami

  • Wszystkie kody wymienione jako nieprzypisane lub wycofane, a niektóre kody wymienione jako zastrzeżone do wykorzystania w przyszłości zostały pominięte
  • Jeśli kod wymieniony w Wikipedii jest prefiksem innego, ten ostatni został pominięty
  • Jeżeli jeden kraj lub terytorium miałby więcej niż jeden kod i jeśli kody te miałyby wspólny prefiks, kody te są pomijane na korzyść ich wspólnego prefiksu.

Może to spowodować skupienie niepodległych krajów lub spory o terytoria z określonym roszczeniem. Nie jest to zamierzone oświadczenie polityczne, a decyzje o włączeniu lub zaniechaniu terytoriów i państw zostały podjęte na podstawie kodeksów, a nie jakichkolwiek moich przekonań dotyczących własności lub suwerenności podmiotów je wykorzystujących.

Jeśli podano dane wejściowe, które nie zaczynają się od żadnego z tych kodów, zachowanie programu jest niezdefiniowane.

I w końcu:

Przypadki testowe

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
code-golf string kolmogorov-complexity subsequence Sara J.
źródło
Być może powinieneś input | outputzamiast tego zrobić kreskę pod linią, chyba że chcesz inputzostać przetłumaczony output.
JL2210

Odpowiedzi:

10

JavaScript (ES6),  75 73  71 bajtów

Zapisano 1 bajt dzięki @Shaggy
Zapisano 2 bajty dzięki @Neil

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

Wypróbuj online!

Arnauld
źródło
Myślę, że 599?|50może zastąpić 599|5[09].
Neil
@Neil Indeed. Dzięki!
Arnauld
Czy s=>/(2[^07]|3[578]|42|599?|50|6[789]|8[0578]|9[679]|[^17]|)./.exec(s)[0]działa na 72 bajty?
ovs
1
@ovs Tak, ale obecna wersja ma w rzeczywistości 71 bajtów - liczba bajtów była nieaktualna.
Arnauld
9

05AB1E , 28 25 24 bajtów

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

Wypróbuj 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
Ponury
źródło
6

Retina 0.8.2 , 60 bajtów

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

Wypróbuj online!

Neil
źródło
Twój wkład w TIO zawiera już odpowiedź;) Wiem, że twój kod ich nie używa, ale wygląda trochę myląco.
Kevin Cruijssen
4

Python 3 , 120 78 bajtów

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

Wypróbuj online!

Zawiera niektóre niedrukowalne: 

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

Nieco golfowa (wcześniejsza) wersja:

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

Wypróbuj online!

ovs
źródło
4

Bash , 328 341 410 bajtów

Niezbyt konkurencyjny dla wyniku golfowego, ale każdy z nich pomaga moim umiejętnościom bashowym!

Zaoszczędzono 13 bajtów, eliminując obsługę 2-bajtowych wartości długości przebiegu; przechowywanie tylko 3 bajtów dodaje 8 bajtów do T, ale znacznie ułatwia instrukcję case.

Zaoszczędzono 69 bajtów, zmieniając podejście z rozwijania bash na przechowywanie delt. Poprzedni link TIO znajduje się na dole mojej odpowiedzi.

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

Wypróbuj online!

  • Posortowano listę prefiksów numerycznie
  • T jest „rodzajem” zakodowanego ciągu znaków pokazującego deltę od poprzedniej wartości. Każda postać jest jedną z następujących czynności:
    • Wartość podstawowa 36 pokazująca wzrost w stosunku do poprzedniej wartości
    • „r”: wskazuje, że następny znak wskazuje zakodowaną liczbę podstawową 36 powtórzonych wartości delta 1.
    • „-”: wskazuje, że kolejne 3 znaki to następna wartość delta

Ciąg T = „16D73r42 [...] -3UR132” zgodny z powyższymi regułami staje się listą delt: „1 6 D 7 3 r4 2 [...] 4995 1 3 2”

Można zaoszczędzić 2-3 bajty więcej, stosując wyższą podstawę niż 36 (jak 62-64), ale Excel natywnie obsługuje tylko do 36, i to właśnie robiło listę delt i ich konwersji.

  • Podczas pracy T jest analizowany i rozwijany do ciągu S używanego do porównania numeru telefonu podanego w argumencie 1 wiersza poleceń.

Rozszerzenie T, S staje się: „1 7 20 27 30 31 32 33 34 36 [...] 5993 5994 5997 5999”

Wypróbuj online!

spuck
źródło
2

Perl 5 (-p), 44 bajty

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

Wypróbuj online!

Zarówno TIO, jak i SO mają problemy z niedrukowalnymi znakami, więc program wyświetla sekwencje specjalne. Oto zrzut rzeczywistych 44 bajtów:

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
Ponury
źródło
1

PHP , 219 bajtów

Wydaje mi się, że jest wiele miejsca na poprawienie wyrażenia regularnego - grałem w golfa tak daleko, jak to możliwe, ale założę się, że może być znacznie krótszy ...

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

Wypróbuj online!

XMark
źródło
1

Java 8, 84 bajtów

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

Port wyrażenia regularnego JavaScript w @Arnauld , więc upewnij się, że go głosujesz!

Wypróbuj online.

Wyjaśnienie:

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

Wyjaśnienie 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
źródło
0

Scala , 411 402 330 bajtów

Zakłada się, że argument zawiera tylko cyfry.

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

Wypróbuj online!

jkeatley
źródło