ฉันชอบเวลาที่เป็นไปตามรูปแบบบางอย่าง โดยเฉพาะอย่างยิ่งฉันชอบเวลาที่ตัวเลขทั้งหมดเหมือนกันหรือตัวเลขทั้งหมดเพิ่มขึ้นแบบเลขคณิตโดยหนึ่งจากซ้ายไปขวา นอกจากนี้ฉันเกลียดอย่างเห็นได้ชัดเมื่อมีคนใส่ตัวอักษรในเวลาของฉันดังนั้นเรื่องไร้สาระของ AM / PM ทั้งหมดนั้นก็ตายไปแล้วสำหรับฉัน ดังนั้นเวลาที่ฉันชอบคือ:

0000 0123 1111 1234 2222 2345

เพื่อความสบายใจของฉันฉันต้องการให้คุณเขียนโปรแกรมเดียวที่ให้เวลาปัจจุบันเป็นอินพุตทั้งสอง: (A)ถ้าไม่ใช่ตอนที่ฉันโปรดปรานโปรดบอกฉันทั้งสองว่ากี่นาที นับตั้งแต่เวลาที่ฉันโปรดปรานครั้งสุดท้ายและ (ii) กี่นาทีนับจากนี้เวลาที่ฉันโปรดปรานต่อไปจะเกิดขึ้น; และ(ข)ถ้ามันเป็นหนึ่งในครั้งที่ชื่นชอบวัสดุเดียว 'ค่าสัญญาณ'

อินพุต

โปรแกรมของคุณควรยอมรับ (ไม่ว่าจะด้วยวิธีใด: อาร์กิวเมนต์ฟังก์ชันstdin, อาร์กิวเมนต์บรรทัดคำสั่ง ฯลฯ ) เวลาปัจจุบันในรูปแบบใดรูปแบบต่อไปนี้:

• เวลาสี่หลักเป็นสตริง

• จำนวนเต็มที่สามารถเป็นศูนย์ทางด้านซ้ายเพื่อให้เวลาสี่หลักเป็นสตริง

• ลำดับของเลขจำนวนเต็มสี่ตัว (หรือน้อยกว่า) เรียงตามลำดับที่จำนวนเต็มตัวแรกในลำดับคือหลักซ้ายสุด (สำคัญ) ในการป้อนเวลา (เช่น0951สามารถแทนได้อย่างถูกต้องในฐานะ[0, 9, 5, 1]หรือ[9, 5, 1])

  • แสดง0000ว่าเป็นลำดับที่มีความยาวเป็นศูนย์

ในกรณีที่มีการป้อนสตริงควรเท่านั้นประกอบด้วยตัวเลขไม่มีทวิภาคหรือเครื่องหมายวรรคตอนอื่น ๆ ปัจจัยการผลิตสามารถสันนิษฐานได้อยู่เสมอที่จะถูกต้องเวลา 24 ชั่วโมง: HHMMที่และ0 <= HH <= 23 0 <= MM <= 59ไม่สนใจความเป็นไปได้ของการกระโดดครั้งที่สอง

เอาท์พุต

โปรแกรมของคุณจะต้องจัดหา (ฟังก์ชันส่งคืนstdoutและอื่น ๆ ก็ใช้ได้) (A)หรือ(B)ตามความเหมาะสมว่าค่าอินพุตเป็นเวลาเป้าหมายหรือไม่

สำหรับ):

ระบุค่าตัวเลขสองค่าในรูปแบบที่เหมาะสมเช่น:

• เอาต์พุตสตริงเดี่ยวพร้อมตัวคั่นที่เหมาะสม

• เอาต์พุตจำนวนเต็ม / สตริงตามลำดับเช่นbashการพิมพ์สองบรรทัดไปที่stdout:

  49
  34
  

• ค่าส่งคืนที่มีความยาวสองคำสั่งเช่นรายการ Python อาร์เรย์ C เป็นต้น [49, 34]

ค่าสามารถมาในลำดับใดก็ได้ ตัวอย่างเช่นทั้งสองอย่างต่อไปนี้เป็นเอาต์พุตที่ถูกต้องสำหรับอินพุต1200:

49 34
34 49

คำสั่งซื้อและตัวคั่นจะต้องเหมือนกันสำหรับค่าอินพุตทั้งหมด!

สำหรับ (B):

สร้างผลลัพธ์ที่ไม่สามารถบรรลุได้เป็นอย่างอื่น ผลลัพธ์เดียวกันจะต้องสร้างขึ้นสำหรับเป้าหมายทั้งหกครั้ง ไม่ จำกัด ลูปไม่ จำกัด

ตัวอย่างอินพุต / เอาท์พุต

YAY!!! ใช้ที่นี่เป็นตัวอย่างที่แสดงให้เห็นและไม่ได้กำหนด

Input      Output
------    --------
 0000      YAY!!!
 0020      20 63
 0105      65 18
 0122      82 1
 0123      YAY!!!
 0124      1 587
 0852      449 139
 1111      YAY!!!
 1113      2 81
 1200      49 34
 1234      YAY!!!
 1357      83 505
 1759      325 263
 1800      326 262
 1801      327 261
 2222      YAY!!!
 2244      22 61
 2345      YAY!!!
 2351      6 9

นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ ช่องโหว่มาตรฐานไม่ได้รับอนุญาต

เยลลี่ , 34 33 32 31 28 ไบต์

3 ไบต์ขอบคุณ Mr. Xcoder .ịและ³ลูกเล่น

d³ḅ60;15j83,588ṁ5¤_\ṠÞAµ.ịxẠ

ลองออนไลน์!

บางส่วนเหมือนกันกับคำตอบของ Jonathan Allanแต่ฉันโพสต์มันเพราะฉันคิดว่ามันแตกต่างจากมันพอสมควรและเขียนอย่างอิสระจากคำตอบ Pyth ของฉัน (และสั้นกว่า: D) ควรมีห้องพักสำหรับการปรับปรุง

อินพุตเป็นจำนวนเต็มเอาต์พุตเป็นอาร์เรย์ของเวลาก่อนหน้าและถัดไปหรืออาร์เรย์ว่างสำหรับช่วงเวลาพิเศษ

คำอธิบาย

1200โดยใช้การป้อนข้อมูลตัวอย่างเช่น

• d³แปลงเวลากับฐาน 100 [12,0]ไปเป็นชั่วโมงและนาทีนี้:
• ḅ60แปลงจากฐาน 60 720นาทีที่จะได้รับทั้งหมด:
• ;15คู่กับ [720, 15]15:
• 83,588 สร้างอาร์เรย์ [83, 588]สร้างอาร์เรย์
• ṁ5 ทำให้ความยาว 5: [83, 588, 83, 588, 83]5:
• ¤รวมการกระทำทั้งสองด้านบน เพียงแค่วิชาเทคนิค
• j รวมคู่กับอาร์เรย์: [720, 83, 588, 83, 588, 83, 15]ร่วมคู่กับอาร์เรย์:
• _\[720, 637, 49, -34, -622, -705, -720]หักค่าแต่ละอาร์เรย์จากครั้งแรกและได้รับผลกลาง:
• ṠÞ เสถียรแปลก ๆ เหล่านี้โดย [-34, -622, -705, -720, 720, 637, 49]Signum:
• A[34, 622, 705, 720, 720, 637, 49]เตะค่าสัมบูรณ์:
• µเริ่มห่วงโซ่ monadic ใหม่ อีกครั้งทางเทคนิค
• .ịใช้รายการสุดท้ายและรายการแรก: [49, 34].
• ×Ạ[49, 34]ซ้ำที่ครั้งหนึ่งถ้ามีเลขศูนย์ไม่มีหรือศูนย์ครั้งเป็นอย่างอื่น

JavaScript (ES6), 87 83 ไบต์

บันทึกแล้ว 4 ไบต์ด้วย @ l4m2

รับอินพุตเป็นสตริง ส่งคืน0อาร์เรย์ใดองค์ประกอบหนึ่งหรือ 2 องค์ประกอบ

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

กรณีทดสอบ

let f =

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

console.log(f('0000')) // YAY!!!
console.log(f('0020')) // 20 63
console.log(f('0105')) // 65 18
console.log(f('0122')) // 82 1
console.log(f('0123')) // YAY!!!
console.log(f('0124')) // 1 587
console.log(f('0852')) // 449 139
console.log(f('1111')) // YAY!!!
console.log(f('1113')) // 2 81
console.log(f('1200')) // 49 34
console.log(f('1234')) // YAY!!!
console.log(f('1357')) // 83 505
console.log(f('1759')) // 325 263
console.log(f('1800')) // 326 262
console.log(f('1801')) // 327 261
console.log(f('2222')) // YAY!!!
console.log(f('2244')) // 22 61
console.log(f('2345')) // YAY!!!
console.log(f('2351')) // 6 9

อย่างไร?

เราไม่สนใจเกี่ยวกับผลลัพธ์ของการ.every()วนซ้ำ โดยมีเงื่อนไขว่าการป้อนข้อมูลที่ถูกต้องก็จะมักจะ falsy สิ่งที่เราสนใจจริง ๆ คือเมื่อใดเราออกจากลูปนี้

เราออกทันทีที่เราพบเวลาที่ชื่นชอบi(แสดงเป็นนาที) ซึ่งมากกว่าหรือเท่ากับเวลาอ้างอิงk(เวลาอินพุตที่tแปลงเป็นนาที) จากนั้นเราจะส่งคืน0หากi == kความล่าช้าหรือ 2 เป็นอย่างอื่น

Befunge-93, 88 85 86 80 74 ไบต์

&:"d"/58**-:"S"-:"b"6*-:"S"v
@._v#!:<\-*53:-"S":-*6"b":-<
:$#<$$\^@.._\#`0

ลองออนไลน์!

ส่งออกจำนวนนาทีตั้งแต่เวลาที่โปรดปรานครั้งสุดท้ายตามด้วยจำนวนนาทีจนกระทั่งถึงเวลาที่ชอบต่อไป (คั่นด้วยลำดับอักขระสองตัว: space, ยัติภังค์) ถ้ามันเป็นเวลาที่ชื่นชอบแล้วศูนย์เดียวจะถูกส่งกลับ

C, 121 ไบต์

*p,l[]={0,83,671,754,1342,1425,1440};f(t){t=t%100+t/100*60;for(p=l;t>*p;++p);*p-t?printf("%d %d",t-p[-1],*p-t):puts("");}

แสดงบรรทัดใหม่หากเวลาเป็นเวลาที่โปรดปราน

ลองออนไลน์!

ทำความสะอาด , 126 ไบต์

import StdEnv
f=[1440,1425,1342,754,671,83,0]
?t#t=t rem 100+t/100*60
=(\(a,b)=(t-hd b,last a-t))(span(\a=t<a||isMember t f)f)

กำหนดฟังก์ชั่น?การใช้และกลับมาInt เมื่ออาร์กิวเมนต์เป็นเวลาที่ชื่นชอบก็เกิดปัญหาโปรแกรมเรียกด้วย (Int, Int)
hd of []

ลองออนไลน์!

Pyth, 48 45 42 ไบต์

&*FJ.u-NY+P*3,83 588 15isMcz2 60,eK._DJ_hK

ลองออนไลน์ ชุดทดสอบ

รหัสใช้เวลาในสตริงเวลาและส่งออกครั้งก่อนหน้าและครั้งถัดไปเป็นอาร์เรย์หรือ0ถ้าเวลาเป็นพิเศษ

สิ่งที่น่าสนใจคือแนวทางที่จำเป็นก็คือ 42 ไบต์:

V+_isMcz2 60+P*3,83 588 15KZIg0=-ZNIZK)_ZB

คำอธิบาย

• cz2 แยกอินพุต (z ) เป็นชิ้นสองอักขระ
• sM หาค่าเป็นจำนวนเต็ม
• i...60แยกวิเคราะห์อาร์เรย์สองรายการที่เป็นฐาน 60
• ,83 588 หมายถึงอาร์เรย์ [83, 588]แสดงให้เห็นถึงอาร์เรย์
• *3 เพิ่มขึ้นเป็นสามเท่า [83, 588, 83, 588, 83, 588]ว่า
• P ลบล่าสุด 588เอาสุดท้าย
• +… 15เพิ่ม15ไปยังจุดสิ้นสุด
• .u-NYเริ่มต้นจากจำนวนการแยกวิเคราะห์ลบแต่ละตัวเลขในอาร์เรย์จากมันและส่งกลับค่ากลาง นี่คือความแตกต่างจากช่วงเวลาพิเศษแต่ละครั้ง
• J กำหนดความแตกต่างเหล่านี้ให้กับ Jกำหนดความแตกต่างเหล่านี้ไป
• *Fคำนวณผลิตภัณฑ์ของความแตกต่าง นี่จะเป็น 0 ถ้าเวลาพิเศษ
• & หยุดการประเมินที่นี่และส่งคืน 0 ถ้าเวลาพิเศษ
• ._DJ จัดเรียงความแตกต่างด้วยเครื่องหมาย
• KKบันทึกว่าในอาร์เรย์
• e ใช้รายการสุดท้ายในอาร์เรย์
• _hK ใช้รายการแรกในอาร์เรย์และคัดค้าน
• , ส่งคืนทั้งสองเป็นอาร์เรย์

เจลลี่ ,  33 32  34 ไบต์

 +3  +2 ไบต์เพื่อแก้ไขค่าดังนั้นเวลาที่ชอบจะเท่ากัน

^{ต้องเป็นวิธีที่สั้นกว่า!}

s2Ḍḅ60
83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\

ลิงก์ monadic ที่ใช้รายการตัวเลขสี่หลักและส่งคืนรายการที่มีจำนวนเต็มสองจำนวน
หากเป็นเวลาที่ชอบผลลัพธ์ทั้งสองรายการจะเป็นศูนย์

ลองออนไลน์! หรือดูชุดทดสอบการทดสอบในตัว

อย่างไร?

s2Ḍḅ60 - helper link, getMinuteOfDay: list of digits, D   e.g. [1,2,3,3]
 2     - literal two                                           2
s      - split into chunks of length                           [[1,2],[3,3]]
  Ḍ    - un-decimal (convert from base 10) (vectorises)        [12,33]
    60 - literal sixty                                         60
   ḅ   - un-base (convert from base)                           753

83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\ - Link: list of digits        e.g. [1,2,3,3]
83,588                      - literal list of integers         [83,588]
       5                    - literal five                     5
      ṁ                     - mould like (implicit range of) [83,588,83,588,83]
        “¡Ð‘                - code-page index list             [0,15]
            j               - join                           [0,83,588,83,588,83,15]
              \             - cumulative reduce with:
             +              -   addition                     [0,83,671,754,1342,1425,1440]
                2           - literal two                      2
               ṡ            - overlapping slices of length     [[0,83],[83,671],[671,754],[754,1342],[1342,1425],[1425,1440]]
                     Ç      - last link (1) as a monad f(D)    753
                    Þ       - sort by:
                   ¥        -   last two links as a dyad:
                 >          -     greater than? (vectorises)    [0, 0] [ 0,  0] [  0,  1] [  1,   1] [   1,   1] [   1,   1]
                  E         -     equal?                          1       1         0         1           1           1
                            -                             -->  [[671,754],[0,83],[83,671],[754,1342],[1342,1425],[1425,1440]]
                      Ḣ     - head                             [671,754]
                        Ç   - last link (1) as a monad f(D)    753
                       ạ    - absolute difference (vectorises) [ 82,  1]
                          \ - cumulative reduce with:
                         a  -   AND                            [ 82,  1]
                            -   -- such that if "liked" then the [0,x] result becomes [0,0] so they are all equal

Husk , 36 ไบต์

?↑2↑0Πṙ_1†aÖ±↔Ġ-::15t*3e588 83B60†d½

ลองออนไลน์!

ขอบคุณZgarb ที่อธิบายให้ฉันทราบว่าบุคคลในครอบครัวทำงานในการแชทกันอย่างไร พยายามเล่นกอล์ฟ↑0แต่ฉันไม่ได้ไปทำงานด้วยเหตุผลอื่น (?) นี่เป็นครั้งแรกที่ฉันได้รับคำตอบแบบไม่แกลบและให้ทิ้งไว้ข้างต้นฉันพอใจกับมันมาก ค่าที่ใช้แทนYAY!!!คือ[] (แต่ฉันหวังว่าจะเปลี่ยนเพื่อวัตถุประสงค์ในการเล่นกอล์ฟ)

คำอธิบาย

? ↑ 2 ↑0Πṙ_1†aÖ±↔Ġ - :: 15t * 3e588 83B60 †d½ | ป้อนข้อมูลเป็นรายการหลักจาก CLA เอาต์พุตไปยัง STDOUT

                                   ½ | แยกรายการออกเป็นสองส่วน
                                 † d | เปลี่ยนแต่ละครึ่งให้เป็นจำนวนเต็ม 10 ฐาน
                              B60 | แปลงจากฐาน 60
                : | ผนวกข้างบนกับ↓ ([15, 83, 588, 83, 588, 83])
                       e588 83 | สร้างรายการองค์ประกอบสองรายการ [588, 83]
                     * 3 | ทำซ้ำสามครั้ง
                    t | ลบองค์ประกอบแรก
                 : 15 | เติม 15
              Ġ- | ใช้การลบแบบสะสมจากด้านขวา
             ↔ | ย้อนกลับ
           Ö± | จัดเรียงอย่างเสถียรโดยเครื่องหมาย (-1, 0 หรือ 1)
         † a | แผนที่ค่าสัมบูรณ์
      ṙ_1 | หมุนหนึ่งขวา
? Π | หากผลิตภัณฑ์เป็นจริงแล้ว:
 ↑ 2 | ใช้องค์ประกอบสองประการแรก
   ↑ 0 | ส่งคืนรายการว่างเปล่ามิฉะนั้น

Kotlin , 293 ไบต์

{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

เชิดชู

{
    fun i(l:List<Int>)=l.all { it ==l[0] } || l.mapIndexed { a, b -> b - a }.all { it ==l[0] }
    val a = (0..1439 + 0).map {
        val h = it/60
        val m = it%60
        listOf(h/10,h%10,m/10,m%10)
    } + listOf(listOf(0,0,0,0))
    val s = a.indexOf(it)
    if (i(it)) 0 to 0 else
        s - a.subList(0, s).indexOfLast {i(it)} to a.subList(s, a.size).indexOfFirst {i(it)}
}

ทดสอบ

var t:(i:List<Int>)-> Pair<Int, Int> =
{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

data class Test(val input: List<Int>, val output: Pair<Int, Int>)

val TEST = listOf(
    Test(listOf(0,0,0,0), 0 to 0),
    Test(listOf(0,0,2,0), 20 to 63),
    Test(listOf(0,1,0,5), 65 to 18),
    Test(listOf(0,1,2,2), 82 to 1),
    Test(listOf(0,1,2,3), 0 to 0),
    Test(listOf(0,1,2,4), 1 to 587),
    Test(listOf(0,8,5,2), 449 to 139),
    Test(listOf(1,1,1,1), 0 to 0),
    Test(listOf(1,1,1,3), 2 to 81),
    Test(listOf(1,2,0,0), 49 to 34),
    Test(listOf(1,2,3,4), 0 to 0),
    Test(listOf(1,3,5,7), 83 to 505),
    Test(listOf(1,7,5,9), 325 to 263),
    Test(listOf(1,8,0,0), 326 to 262),
    Test(listOf(1,8,0,1), 327 to 261),
    Test(listOf(2,2,2,2), 0 to 0),
    Test(listOf(2,2,4,4), 22 to 61),
    Test(listOf(2,3,4,5), 0 to 0),
    Test(listOf(2,3,5,1), 6 to 9)
)

fun main(args: Array<String>) {
    for (t in TEST) {
        val v = t(t.input)
        if (v != t.output) {
            throw AssertionError("$t $v")
        }
    }
}

TIO

TryItOnline