ভূমিকা

আমি QWERTY কীবোর্ড লেআউটটি ব্যবহার করে একটি মাঝারি গতিতে টাইপ করতে পারি। তবে ইয়েলউডডোরের মতো শব্দের যদি এক টন বারবার অক্ষর থাকে তবে এটি টাইপ করতে একটু বেশি সময় নেয়। এমনকি খারাপটি যখন "জাম্প" এর মতো একটি শব্দতে একই আঙুলটি একাধিক বিভিন্ন টানা অক্ষরের জন্য ব্যবহৃত হয়।

প্রতিটি আঙুলের চিঠি লিখতে আমাকে কতক্ষণ সময় লাগবে তা এখানে (খুব অবৈজ্ঞানিকভাবে মাপা):

কলামগুলি হ'ল আঙুলের নাম, কীস্ট্রোক / সেকেন্ড, সেকেন্ড / কীস্ট্রোক এবং প্রতিটি আঙুল দ্বারা ব্যবহৃত কীগুলি

Typing same letter twice:       
L Pinky 5.2 0.1923076923 1qaz
L Ring  5   0.2          2wsx
L Mid   5.3 0.1886792453 3edc
L Index 5.5 0.1818181818 4rfv5tgb
R Thumb 6.5 0.1538461538 [space]
R Index 6.9 0.1449275362 6yhn7ujm
R Mid   6.3 0.1587301587 8ik,
R Ring  6.2 0.1612903226 9ol.
R Pinky 6.1 0.1639344262 0p;'

Typing different letter on same finger:     
L Pinky 4.6 0.2173913043
L Ring  4.6 0.2173913043
L Mid   4.5 0.2222222222
L Index 5.3 0.1886792453
R Index 5.4 0.1851851852
R Mid   5.1 0.1960784314
R Ring  5.2 0.1923076923
R Pinky 5.2 0.1923076923

সিএসভি ফর্ম্যাটে একই ডেটা ।

লাগবে

.75 * (first_finger_same_letter_time + second_finger_same_letter_time) / 2

দুটি আঙ্গুলের মধ্যে স্যুইচ করার সময়।

চ্যালেঞ্জ

ইনপুট হিসাবে একটি স্ট্রিং দেওয়া হয়েছে, এটি টাইপ করতে কতক্ষণ সময় লাগে?

"টাইমার" প্রথম কীটি চাপার মুহুর্তে শুরু হয় এবং শেষ কী টিপে গেলে শেষ হয়। আপনি কেবল কীপ্রেসগুলির মধ্যে সময় গণনা করছেন।
এটি কোড-গল্ফ । বাইট জিতে সংক্ষিপ্ত উত্তর।
জমা দেওয়া সম্পূর্ণ প্রোগ্রাম বা ফাংশন হতে পারে।
আপনি যেভাবে চান ইনপুট এবং আউটপুট , স্টিডিন / আউট, ফাংশন প্যারাম, ফাইল, কোনও ব্যাপার নয়।
কমপক্ষে 3 দশমিক স্থানে আউটপুট নির্ভুল হওয়া উচিত (রাউন্ডিং ত্রুটির জন্য +/- 0.001 ঠিক আছে)। শীর্ষস্থানীয় 0 1 এর নিচে সংখ্যার জন্য এবং নতুন লাইনের alচ্ছিক পিছনে।
ইনপুট এমন একটি স্ট্রিং হবে যাতে (ছোট হাতের) অ্যাজ, 0-9, স্পেস, সেমিকোলন, কমা, পিরিয়ড এবং অ্যাস্টোস্ট্রোফ থাকে।
আমি সর্বদা আমার ডান থাম্ব দিয়ে ফাঁকা স্থান টাইপ করি।
আমি সাধারণ স্পর্শ টাইপিং আঙ্গুলগুলি ব্যবহার করি (আঙুল-কী ম্যাপিংয়ের জন্য আপনি উপরের টেবিলটিও দেখতে পারেন)।
পরীক্ষার কেস উত্পন্ন করতে ব্যবহৃত রেফারেন্স কোড

পরীক্ষার মামলা

(খালি স্ট্রিং বা যে কোনও এক-বর্ণের স্ট্রিং) - 0.000

aa - 0.192

fff - 0.364

fj - 0.123

the quick brown fox jumped over the lazy dog - 5.795

yellowwooddoor - 1.983

orangewooddoor - 1.841

jump on it, jump on it - 2.748

type on it, type on it - 2.549

abcdefghijklmnopqrstuvwxyz01234567890 ;,.' - 5.746

ok, this may not be the most accurate but it's in the ballpark, maybe within 30 percent or so. - 12.138

code-golf string number

— ড্যানিয়েল এম।
সূত্র

আমরা কি ধরে নিতে পারি ইনপুটটি কমপক্ষে 2 টি চরিত্রের হবে বা 0ইনপুটটি খালি বা একক অক্ষর হলে আমাদের আউটপুট দরকার ?

— কেভিন ক্রুইজসেন 15

ইতিমধ্যে কয়েকটি উত্তর রয়েছে যা এটি পরিচালনা করে, তাই নিয়মগুলি অর্ধেক করে পরিবর্তন করবে না

— ড্যানিয়েল এম।

4

একটি নতুন ধরণের কোড গল্ফ: বাইট গণনার উপর ভিত্তি করে উত্তরগুলি স্কোর করার পরিবর্তে, বিজয়ী হবেন যিনি তাদের প্রোগ্রামটি দ্রুততম টাইপ করতে পারেন।

— 12

7

জাভাস্ক্রিপ্ট (নোড.জেএস) , 180 বাইট

s=>(B=Buffer)(s).map(p=c=>(b='23841410645532207643205431765001333746443'[c*45%91%73%41]*2,t+=1/p?p-b?3/8*(g(b)+g(p)):g(b|c!=s):0,p=b,s=c),t=0,g=x=>10/B('4.2.5-75E6?3>4=4AA')[x])&&t

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

বিলম্ব সংরক্ষণ

$g$ $0\le x \le17$

g = x => 10 / Buffer('4.2.5-75E6?3>4=4AA')[x]

$x$

একই চিঠির জন্য বিলম্ব পেতে দ্বিগুণ বিন সংখ্যা
বিভিন্ন অক্ষরের জন্য বিলম্ব পেতে দ্বিগুণ বিন সংখ্যা + 1

'4.2.5-75E6?3>4=4AA' $10$

$5.2$ chr(52)'4'

একটি চরিত্রকে কী বিনে রূপান্তর করা

$c$ $[0..8]$

i = (((c \times 45) mod 91) mod 73) mod 41

$i = (((c\times 45) \bmod 91)\bmod 73)\bmod 41$

প্রধান লুপ

$t$

t +=                        // add to t:
  1 / p ?                   //   if p is numeric:
    p - b ?                 //     if p is not equal to b:
      3 / 8 * (g(b) + g(p)) //       0.75 * (g(b) + g(p)) / 2
    :                       //     else:
      g(b | c != s)         //       g(b) if c == s or g(b + 1) otherwise
  :                         //   else (first iteration):
    0                       //     leave t unchanged

$p$ $s$

— Arnauld
সূত্র

4

জেলি , 78 বাইট

“bk¶ŀqṣṁq*E’b25+45s2
Øq;"““;“,.'”Zṙ-ØD;"s2ẎW$€3,4¦ẎœiⱮQḢ€ị¢QƑịZƊQ3.75⁵Ḋ?÷$SµƝS

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

“...’b25+45s2 - Link 1, keystrokes per 10 seconds: no arguments
“...’         - base 250 integer = 379310849477441257135820
     b25      - to base 25 = [16,7,7,1,5,1,8,0,10,8,24,9,18,6,17,7,20]
        +45   - add 45 = [61,52,52,46,50,46,53,45,55,53,69,54,63,51,62,52,65]
           s2 - split into twos
              - = [[61,52],[52,46],[50,46],[53,45],[55,53],[69,54],[63,51],[62,52],[65]]
             - For: 0...    1...    2...    3...    4...    6...    8...    9...    space

Øq;"““;“,.'”Zṙ-ØD;"s2ẎW$€3,4¦ẎœiⱮQḢ€ị¢QƑịZƊQ3.75⁵Ḋ?÷$SµƝS - Main Link: list of characters
                                                      µƝ  - for each neighbouring pair:
Øq                                                        -   qwerty = ["qwertyuiop","asdfghjkl","zxcvbnm"]
    ““;“,.'”                                              -   list of lists = ["",";",",.'"]
   "                                                      -   zip with:
  ;                                                       -     concatenate = ["qwertyuiop","asdfghjkl;","zxcvbnm,.'"]
            Z                                             -   transpose = ["qaz","wsx","edc","rfv","tgb","yhn","ujm","ik,","ol.","p;'"]
             ṙ-                                           -   rotate left -1 = ["p;'","qaz","wsx","edc","rfv","tgb","yhn","ujm","ik,","ol."]
               ØD                                         -   digits = "0123456789"
                  "                                       -   zip with:
                 ;                                        -     concatenate = ["0p;'","1qaz","2wsx","3edc","4rfv","5tgb","6yhn","7ujm","8ik,","9ol."]
                   s2                                     -   split into twos = [["0p;'","1qaz"],["2wsx","3edc"],["4rfv","5tgb"],["6yhn","7ujm"],["8ik,","9ol."]]
                            ¦                             -   sparse application...
                         3,4                              -   ...to indices: [3,4]
                       $€                                 -   ...do: last two links as a monad for each:
                     Ẏ                                    -     tighten
                      W                                   -     wrap in a list = [["0p;'","1qaz"],["2wsx","3edc"],["4rfv5tgb"],["6yhn7ujm"],["8ik,","9ol."]]
                             Ẏ                            -   tighten = ["0p;'","1qaz","2wsx","3edc","4rfv5tgb","6yhn7ujm","8ik,","9ol."]
                                 Q                        -   de-duplicate (the neighbouring letters)
                                Ɱ                         -   map with:
                              œi                          -     multi-dimensional index-into    e.g. "fj" -> [[5,3],[6,7]]
                                                          -     (note <space> is not there so yields an empty list)
                                  Ḣ€                      -   head of each                                -> [5,6]
                                                          -     (...and the head of an empty list is 0)
                                     ¢                    -   call the last Link (1) as a nilad
                                    ị                     -   index-into                                  -> [[55,53],[69,54]]
                                                          -     (...and 0 indexes into the rightmost entry)
                                          Ɗ               -   last three links as a monad:
                                       Ƒ                  -     invariant under?:
                                      Q                   -       de-duplicate (1 if so, else 0)
                                         Z                -       transpose                               -> [[55,69],[53,54]]
                                        ị                 -       index-into                              -> [55,69]
                                           Q              -   de-duplicate                                -> [55,69]
                                                    $     -   last two links as a monad:
                                                  ?       -     if...
                                                 Ḋ        -     ...condition: dequeue
                                            3.75          -     ...then: 3.75
                                                ⁵         -     ...else: 10                               -> 3.75
                                                   ÷      -     divide                                    -> [0.06818181818181818,0.05434782608695652]
                                                     S    -   sum                                         -> 0.12252964426877469
                                                        S - sum

— জোনাথন অ্যালান
সূত্র

2

05AB1E , 92 86 বাইট tes

Îü)v•δ'ā∍ë*8U¾Ã•₂в45+2ô9ÝÀžV€Sζ‚ø˜ð",.;'"S.;ykD4/ïD3›-D4›-‚©θè®€ËOUεXè}T/zX_iO3*8/ëθ]O

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা:

Î                     # Push 0 and the input-string
 ü)                   # Create all pairs of the (implicit) input-string
                      # (which will be [] if the input-string is of length 0 or 1)
                      #  i.e. "ab d" → ["a","b"],["b"," "],[" ","d"]]
   v                  # Loop over these pairs `y`:
    •δ'ā∍ë*8U¾Ã•     '#  Push compressed integer 307264255556527588774514
      ₂в              #  Converted to Base-26 as list: [7,1,5,1,8,0,10,8,24,9,18,6,17,7,16,7,20]
        45+           #  Add 45 to each: [52,46,50,46,53,45,55,53,69,54,63,51,62,52,61,52,65]
           2ô         #  Split into parts of size 2: [[52,46],[50,46],[53,45],[55,53],[69,54],[63,51],[62,52],[61,52],[65]]
    9Ý                #  Push list [0,1,2,3,4,5,6,7,8,9]
      À               #  Rotate it once to [1,2,3,4,5,6,7,8,9,0]
       žV             #  Push builtin ["qwertyuiop","asdfghjkl","zxcvbnm"]
         €S           #  Convert each to a list of characters
           ζ          #  Zip/transpose; swapping rows/columns, with space as default filler:
                      #   [["q","a","z"],["w","s","x"],["e","d","c"],["r","f","v"],["t","g","b"],["y","h","n"],["u","j","m"],["i","k"," "],["o","l"," "],["p"," "," "]]
            ‚ø        #  Pair it with the digit list, and zip/transpose again
              ˜       #  Then flatten this entire list:
                      #   ["1","q","a","z","2","w","s","x","3","e","d","c","4","r","f","v","5","t","g","b","6","y","h","n","7","u","j","m","8","i","k"," ","9","o","l"," ","0","p"," "," "]
               ð",.;'"S.;
                      #  Replace the four spaces with [",", ".", ";", "'"] in order
     yk               #  Get the indices of the characters in the pair `y` in this list
                      #   i.e. ["b"," "] → [19,-1]
        4/            #  Divide both by 4
                      #   i.e. [19,-1] → [4.75,-0.25]
          ï           #  Floor the decimals to integers
                      #   i.e. [4.75,-0.25] → [4,-1]
           D3›-       #  If an index is larger than 3: decrease it by 1
                      #   i.e. [4,-1] → [3,-1]
               D4›-   #  If an index is now larger than 4: decrease it by 1 again
       D           ‚  #  Pair it with the original index
                      #   i.e. [[19,-1],[3,-1]]
                    © #  And save it in the register (without popping)
     θè               #  Then use the last of the two to index into the list of pairs
                      #   i.e. [3,-1] → [[55,53],[65]]
       ®€Ë            #  Check for each pair in the register if they're equal
                      #   i.e. [[19,-1],[3,-1]] → [0,0]
          O           #  Take the sum of that
           U          #  And pop and store it in variable `X`
            ε  }      #  Map the pairs in the list to:
             Xè       #   The `X`'th value in the pair
                      #    i.e. [[55,53],[65]] and `X`=0 → [55,65]
     T/               #  Divide each by 10
                      #   i.e. [55,65] → [5.5,6.5]
       z              #  And take 1/value for each
                      #  i.e. [5.5,6.5] → [0.181...,0.153...]
        X_i           #  If variable `X` was 0:
           O          #   Take the sum of these decimal values
                      #    i.e. [0.181...,0.153...] → 0.335...
            3*8/      #   Multiply it by 3, and then divide it by 8
                      #    i.e. 0.335... → 0.125...
          ë           #  Else:
           θ          #   Pop the pair of decimal values, and only leave the last one
   ]                  # Close both the if-else statement and the loop
    O                 # And take the sum of the stack
                      # (which is output implicitly as result)

(বিভাগে আমার এই 05AB1E ডগা দেখুন ইপিএসে দক্ষিন কোরিয়ায় কিভাবে পূর্ণসংখ্যার কম্প্রেস কিভাবে? এবং কিভাবে কম্প্রেস পূর্ণসংখ্যা তালিকা কিভাবে? ) কেন বুঝতে •δ'ā∍ë*8U¾Ã•হয় 307264255556527588774514এবং •δ'ā∍ë*8U¾Ã•₂вহয় [7,1,5,1,8,0,10,8,24,9,18,6,17,7,16,7,20]।

— কেভিন ক্রুইজসেন
সূত্র