एक ट्रेन एक लेबल वाले पुल को पार करती है

9

सकारात्मक पूर्णांक के अंकों के साथ लेबल की गई टाइलों द्वारा गठित लंबाई बी के एक पुल पर विचार करें । उदाहरण के लिए, यदि बी 41 था, तो यह इस तरह दिखेगा:

-----------------------------------------
12345678910111213141516171819202122232425

अब पुल पार करने वाली लंबाई T की ट्रेन की कल्पना करें । ट्रेन का सबसे बाईं ओर स्थिति X (1-अनुक्रमित) से शुरू होती है । समस्या की बेहतर समझ पाने के लिए, आइए हम B = 41, T = 10, X = 10 के साथ इस घटना की एक योजना बनाते हैं । ट्रेन को समान संकेतों ( =) और रेखाओं का उपयोग करके तैयार किया गया है :

         __________
         | ======== |
         | ======== |
-----------------------------------------
12345678910111213141516171819202122232425

प्रत्येक स्टेप पर, जिस अद्वितीय टाइल पर यह स्थित है, ट्रेन आगे बढ़ सकती है। उदाहरण के लिए, ट्रेन जिन टाइलों के ऊपर खड़ी होती है, वे हैं: [1, 0, 1, 1, 1, 2, 1, 3, 1, 4]अद्वितीय (कम आकार की) टाइलें हैं: [1, 0, 2, 3, 4]और उनकी राशि है 10। इसलिए, ट्रेन 10टाइल्स से आगे बढ़ सकती है । हमें इसे फिर से खींचना चाहिए और इस प्रक्रिया को तब तक दोहराना चाहिए जब तक कि ट्रेन के बाएं हिस्से ने आखिरी टाइल न पार कर ली हो:

                   __________
                   | ======== |
                   | ======== |
-----------------------------------------
12345678910111213141516171819202122232425

अद्वितीय टाइलों का योग: १ + ५ + ६ + + + = + ९ = ३६. ट्रेन को ३६ टाइल्स से आगे बढ़ाना ...

                                                       __________
                                                       | ======== |
                                                       | ======== |
-----------------------------------------
12345678910111213141516171819202122232425

ट्रेन ने स्पष्ट रूप से पुल को पूरी तरह से पार किया, इसलिए हमें अब रुकना चाहिए।

चूँकि अंदर के लोग ऊब चुके हैं, इसलिए वे उन टाइलों की गिनती करते हैं जिन्हें ट्रेन ने हर बार आगे बढ़ाया है। इस विशिष्ट मामले में, 10और 36। सब कुछ समेटते हुए, 46पुल के गुजरने से पहले ही ट्रेन चल पड़ी।

कार्य

तीन सकारात्मक पूर्णांक, बी (पुल की लंबाई), टी (ट्रेन की लंबाई) और एक्स (शुरुआती स्थिति, 1-अनुक्रमित ) को देखते हुए, आपका काम यह निर्धारित करना है कि नियमों का पालन करते हुए पुल को पार करने तक ट्रेन कितनी टाइलों को स्थानांतरित कर चुकी है। ऊपर।

  • आप मान सकते हैं कि:
    • B , T से अधिक है ।
    • X , B से कम है ।
    • टी कम से कम 2 है ।
    • ट्रेन अंतत: पुल को पार कर जाती है।
  • हमारे सभी मानक नियम लागू होते हैं।
  • ये है कोड गोल्फ, इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है!

परीक्षण के मामलों

इनपुट ([बी, टी, एक्स]) -> आउटपुट

[४१, १०, १०] -> ४६
[४०, १०, १०] -> ४६
[३०, ४, १६] -> २४
[५०, ६, ११] -> ५०

पिछले परीक्षण मामले के लिए एक और काम किया उदाहरण:

पुल की लंबाई 50, ट्रेन 6 और शुरुआती स्थिति 11 है।

          ______
          | ==== |
          | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

अद्वितीय टाइलें: [0, 1, 2]। सम: ३।

             ______
             | ==== |
             | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

अद्वितीय टाइलें: [1, 2, 3, 4]। सम: १०।

                       ______
                       | ==== |
                       | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

अद्वितीय टाइलें: [1, 7, 8, 9]। सम: २५।

                                                ______
                                                | ==== |
                                                | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

अद्वितीय टाइलें: [९, ३]। सम: १२।
                                                            ______
                                                            | ==== |
                                                            | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

ट्रेन पुल पर मौजूद है। कुल योग: 3 + 10 + 25 + 12 = 50।
code-golf  math  integer 
— श्री एक्सकोडर
स्रोत
6
क्या हम मान सकते हैं कि ट्रेन अंततः पुल को पार करती है? जैसे इनपुट के लिए (200, 2, 169), ट्रेन में फंस जाता 00है …9899100101102…।
— लिन
@ लियोन थोड़ी देर, हां, आप कर सकते हैं।
— श्री एक्सकोडर

जवाबों:

3

भूसी , 20 बाइट्स

ṁ←U¡S↓←moΣuX_⁰↓Θ↑ṁdN

इसे ऑनलाइन आज़माएं!

T , B , X क्रम में तीन तर्क देता है ।

व्याख्या

ṁ←U¡S↓←moΣuX_⁰↓Θ↑ṁdN
                 ṁdN    Build the list of digits of natural numbers
              ↓Θ↑       Take the first B digits, add a 0 in front
                        then drop the first X digits
           X_⁰          Get all sublists of length T
       moΣu             Map the sum of unique values of each sublist

   ¡S↓←                 Repeatedly drop as many elements from the start of the list as the
                        first element of the list says;
                        keep all partial results in an infinite list.

  U                     Take elements until the first repeated one
                        (drops tail of infinite empty lists)

ṁ←                      Sum the first elements of each remaining sublist
— सिंह
स्रोत
6

पायथन 2 , 110 105 104 103 100 97 96 बाइट्स

  • श्री Xcoder के लिए पांच बाइट्स धन्यवाद सहेजा ; अनावश्यक असाइनमेंट को हटा दिया गया, उपलब्ध व्हाट्सएप में नकार को स्थानांतरित कर दिया।
  • श्री एक्सकोडर के लिए एक बाइट धन्यवाद बचा लिया ; को गोल्फ [~-x:x+~-t]दिया [~-x:][:t]।
  • एक बाइट को बचाया; को गोल्फ ...range(1,-~b)))[:b]दिया ...range(b)))[1:-~b]।
  • तीन बाइट्स बचाए; को गोल्फ [1:-~b][~-x:]दिया [:-~b][x:]।
  • तीन बाइट्स बचाए; को गोल्फ [:-~b][x:]दिया [x:-~b]।
  • लिन को एक बाइट का धन्यवाद दिया ; whileएक execबयान के लिए पाश गोल्फ ।
b,t,x=input();S=x;exec"x+=sum(set(map(int,''.join(map(str,range(b)))[x:-~b][:t])));"*b;print-S+x

इसे ऑनलाइन आज़माएं!

— जोनाथन फ्रेच
स्रोत
एक वैकल्पिक 105 बाइट्स लंबे समाधान।
— जोनाथन फ्रेच
104 बाइट्स । [~-x:x+~-t]द्वारा प्रतिस्थापित किया जा सकता है[x-1:][:t]
— श्री Xcoder
exec"x+=sum(set(map(int,''.join(map(str,range(b)))[x:-~b][:t])));"*b96 के लिए काम करता है। ( bपुल को छोड़ने के लिए ट्रेन कभी भी अधिक कदम नहीं उठाएगी, और यह पूरी कार्रवाई x+=0एक बार
— लिन
4

हास्केल, 106 102 बाइट्स

import Data.List
(b#t)x|x>b=0|y<-sum[read[c]|c<-nub$take t$drop(x-1)$take b$show=<<[1..]]=y+(b#t)(x+y)

इसे ऑनलाइन आज़माएं!

(b#t)x
   |x>b=0                 -- if the train has left the bridge, return 0
   |y<-sum[   ]           -- else let y be the sum of
      read[c]|c<-         -- the digits c where c comes from
        nub               -- the uniquified list of
            show=<<[1..]] -- starting with the digits of all integers concatenated
          take b          -- taking b digits (length of bridge)
         drop(x-1)        -- dropping the part before the train
        take t            -- take the digits under the train
     =y+(b#t)(x+y)        -- return y plus a recursive call with the train advanced
— nimi
स्रोत
3

आर , 123 बाइट्स

function(B,T,X){s=substring
while(X<B){F=F+(S=sum(unique(strtoi(s(s(paste(1:B,collapse=''),1,B),K<-X+1:T-1,K)))))
X=X+S}
F}

बस वर्णित एल्गोरिथ्म को लागू करता है।

आर स्ट्रिंग्स में काफी भयानक है।

function(B,T,X){
 s <- substring                         # alias
 b <- s(paste(1:B,collapse=''),1,B)     # bridge characters
 while(X<B){                            # until we crossed the bridge
  K <- X+1:T-1                          # indices of the characters
  S <- s(b,K,K)                         # the characters from b
  S <- sum(unique(strtoi(S)))           # sum
  F <- F + S                            # F defaults to 0 at the beginning
  X <- X + S                            # advance the train
 }
 F                                      # number of steps, returned
}

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत
2

जेली ,  22  21 बाइट्स

ḣ⁵QS
RDẎḣ⁸ṫṫÇ‘$$ÐĿÇ€S

एक पूर्ण कार्यक्रम तीन तर्क ले रहा है - आदेश बी , एक्स , टी - जो परिणाम प्रिंट करता है।

इसे ऑनलाइन आज़माएं!

कैसे?

ḣ⁵QS - Link 1, calculate next jump: list of digits, bridge under and beyond train's left
 ⁵   - program's fifth command line argument (3rd input) = T (train length)
ḣ    - head to index (get the digits of the tiles under the train)
  Q  - de-duplicate
   S - sum

RDẎḣ⁸ṫṫÇ‘$$ÐĿÇ€S - Main link: number, B (bridge length); number, X (starting position)
R                - range(B) = [1,2,3,...,B-1,B]
 D               - to decimal list (vectorises) = [[1],[2],[3],...,[digits of B-1],[digits of B]]
  Ẏ              - tighten (flatten by one) = [1,2,3,...,digits of B-1,digits of B]
    ⁸            - chain's left argument, B
   ḣ             - head to index (truncate to only the bridge's digits)
     ṫ           - tail from index (implicit X) (truncate from the train's left)
           ÐĿ    - loop, collecting results, until no more change occurs:
          $      -   last two links as a monad:
         $       -     last two links as a monad:
       Ç         -       call last link (1) as a monad (get next jump)
        ‘        -       increment
      ṫ          -     tail from that index (remove the track to the left after train jumps)
             Ç€  - call last link (1) as a monad for €ach (gets the jump sizes taken again)
               S - sum
                 - implicit print
— जोनाथन एलन
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 117 बाइट्स

f=(B,T,X,g=b=>b?g(b-1)+b:'',o=0)=>X<B?[...g(B).substr(X-1,T)].map((e,i,a)=>o+=i+X>B|a[-e]?0:a[-e]=+e)&&o+f(B,T,X+o):0

पुनरावर्ती कार्यों की एक जोड़ी:

  1. f() ट्रेन की चाल को दर्शाता है।
  2. g() संख्या की स्ट्रिंग बनाता है।

कम गोल्फ वाला:

f=
(B,T,X,
 g=b=>b?g(b-1)+b:'',                       //creates the string of numbers
 o=0                                       //sum of tiles the train sits on
)=>
  X<B?                                     //if we're not past the bridge:
      [...g(B).substr(X - 1,T)].map(       //  grab the tiles we're sitting on
        (e,i,a)=>o += i + X > B |          //  if we've passed the bridge,
                      a[-e] ? 0 :          //  ... or we've seen this tile before, add 0 to o
                              a[-e] = +e   //  else store this tile and add its value to o
      ) &&
      o + f(B,T,X+o) :                     //recurse
  0

कोड स्निपेट दिखाएं

— रिक हिचकॉक
स्रोत
0

PHP> = 7.1, 153 बाइट्स

<?$s=substr;[,$p,$q,$r]=$argv;while($i<$p)$a.=++$i;$a=$s($a,0,$p);;while($r<$p){$x+=$n=array_sum(array_unique(str_split($s($a,$r-1,$q))));$r+=$n;}echo$x;

इसे ऑनलाइन आज़माएं!

इसे PHP के निचले संस्करणों के साथ संगत बनाने के [,$p,$q,$r]=लिए, list(,$p,$q,$r)=(+4 बाइट्स) में बदलें ।

<?
[,$bridgelen,$trainlen,$position] = $argv;                  // grab input
while($i<$bridgelen)                                        // until the bridge is long enough...
  $bridgestr .= ++$i;                                       // add to the bridge
$bridgestr = substr($bridgestr,0,$bridgelen);               // cut the bridge down to size (if it splits mid-number)
while($position<$bridgelen){                                // while we are still on the bridge...
  $currtiles =                                              // set current tiles crossed to the...
    array_sum(                                              // sum of tiles...
      array_unique(                                         // uniquely...
        str_split(substr($bridgestr,$position-1,$trainlen)) // under the train
      )
    )
  ;
  $totaltiles += $currtiles;                                // increment total tiles crossed
  $position += $currtiles;                                  // set new position
}
echo $totaltiles;                                           // echo total tiles crossed
— Jo।
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.