নির্বিচার বেস রূপান্তর [বন্ধ]

Question

এমন একটি রুটিন তৈরি করুন যা একটি সংখ্যার বেস সিস্টেমের মধ্যে একটি ব্লকের অ্যারে নেয় এবং এগুলিকে অন্য সংখ্যার বেস সিস্টেমে ব্লকের অ্যারেতে রূপান্তর করে। সিস্টেমগুলি থেকে এবং উভয়ই স্বেচ্ছাসেবী এবং প্যারামিটার হিসাবে গ্রহণ করা উচিত। ইনপুট অ্যারেটি একটি স্বেচ্ছাসেবী দৈর্ঘ্য হতে পারে (যদি এমন কোনও ভাষা ব্যবহার করা হয় যেখানে অ্যারের সাথে অ্যারের দৈর্ঘ্য সংরক্ষণ করা হয় না, যেমন সি, একটি দৈর্ঘ্যের প্যারামিটারটি ফাংশনে পাস করা উচিত)।

এটি কীভাবে কাজ করা উচিত তা এখানে:

fromArray = [1, 1]
fromBase = 256
toBase = 16
result = convertBase(fromArray, fromBase, toBase);

যা প্রত্যাবর্তন করা উচিত [0, 1, 0, 1]বা সম্ভবত [1, 0, 1](নেতারা 0optionচ্ছিক কারণ তারা উত্তরের মান পরিবর্তন করে না)।

এখানে কিছু পরীক্ষার ভেক্টর রয়েছে:

1. পরিচয় পরীক্ষার ভেক্টর

   fromArray = [1, 2, 3, 4]
   fromBase = 16
   toBase = 16
   result = [1, 2, 3, 4]
   

2. তুচ্ছ পরীক্ষা ভেক্টর

   fromArray = [1, 0]
   fromBase = 10
   toBase = 100
   result = [10]
   

3. বিগ টেস্ট ভেক্টর

   fromArray = [41, 15, 156, 123, 254, 156, 141, 2, 24]
   fromBase = 256
   toBase = 16
   result = [2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8]
   

4. সত্যই বিগ টেস্ট ভেক্টর

   fromArray = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
   fromBase = 2
   toBase = 10
   result = [1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3]
   

5. অ-সম বেস ভেক্টর

   fromArray = [41, 42, 43]
   fromBase = 256
   toBase = 36
   result = [1, 21, 29, 22, 3]
   

অন্যান্য মানদণ্ড / বিধি:

1. সমস্ত পূর্ণসংখ্যার ভেরিয়েবলগুলি সমস্ত বুদ্ধিমান ইনপুট ব্যাপ্তির জন্য 32 বিট স্বাক্ষরিত পূর্ণসংখ্যার মধ্যে ফিট করা উচিত।

2. আপনি মধ্যস্থতাকারী প্রতিনিধিত্বতে রূপান্তর করতে পারেন, যতক্ষণ না মধ্যস্থতাকারী 32 বিট স্বাক্ষরিত পূর্ণসংখ্যার অ্যারে ছাড়া আর কিছুই না।

3. 2 থেকে 256 পর্যন্ত ঘাঁটিগুলি পরিচালনা করার প্রত্যাশা করুন than এর চেয়ে উচ্চতর ঘাঁটিগুলিকে সমর্থন করার কোনও দরকার নেই (তবে আপনি যদি চান, সর্ব মাধ্যমে)।

4. কমপক্ষে 1000 টি উপাদান পর্যন্ত ইনপুট এবং আউটপুট মাপগুলি পরিচালনা করার প্রত্যাশা করুন । একটি সমাধান যা 2 ^ 32-1 উপাদানগুলিতে স্কেল করে ভাল হবে তবে 1000 ঠিক আছে।

5. এই বিধিগুলি পূরণ করবে যে সংক্ষিপ্ততম কোড থাকার বিষয়ে এটি অগত্যা নয়। এটি সবচেয়ে পরিষ্কার এবং সবচেয়ে মার্জিত কোড থাকার সম্পর্কে।

এখন, এটি করা ঠিক তুচ্ছ নয়, সুতরাং প্রায় উত্তর কার্যকরভাবে গ্রহণযোগ্য হতে পারে!

Comments

# 1 এর অর্থ কি আমরা একটি বিগিন্ট প্রকার ব্যবহার করতে পারি না?

— কিথ র্যান্ডাল

@ কিথ: সঠিক। শুধুমাত্র 32 বিট পূর্ণসংখ্যা।

— একারমেক্সেল

আপনি "স্বাক্ষরিত পূর্ণসংখ্যা" বলছেন তবে উদাহরণগুলি কেবল ইতিবাচক পূর্ণসংখ্যার জন্য, সুতরাং: আমাদের কী নেতিবাচক পরিচালনা করতে হবে?

— ইলেভেক্স

@ এলেভেক্স: আমি নেতিবাচক হ্যান্ডেল করার প্রয়োজন দেখছি না। যদি negativeণাত্মকভাবে পরিচালনা করা হয় তবে তা রূপান্তরকারীর বাইরে থাকবে।

— ইরকমেক্সেল

তারা সবসময় পূর্ণসংখ্যার ঘাঁটি হয়?

— পিটার ওলসন

Answer 1

পাইথন

# divides longnum src (in base src_base) by divisor
# returns a pair of (longnum dividend, remainder)
def divmod_long(src, src_base, divisor):
  dividend=[]
  remainder=0
  for d in src:
    (e, remainder) = divmod(d + remainder * src_base, divisor)
    if dividend or e: dividend += [e]
  return (dividend, remainder)

def convert(src, src_base, dst_base):
  result = []
  while src:
    (src, remainder) = divmod_long(src, src_base, dst_base)
    result = [remainder] + result
  return result

Comments

ধন্যবাদ. আমি এই জাতীয় একটি রুটিন খুঁজছিলাম। যদিও এটি জাভাস্ক্রিপ্টে রূপান্তর করতে আমার কিছু সময় লেগেছে। আমি সম্ভবত এটি কিছুটা গল্ফ করব এবং মজাদার জন্য এখানে পোস্ট করব।

— স্টিফেন পেরেলসন 21

Answer 2

এখানে একটি হাস্কেল সমাধান রয়েছে

import Data.List
import Control.Monad

type Numeral = (Int, [Int])

swap              ::  (a,b) -> (b,a)
swap (x,y)        =   (y,x)

unfoldl           ::  (b -> Maybe (b,a)) -> b -> [a]
unfoldl f         =   reverse . unfoldr (fmap swap . f)

normalize         ::  Numeral -> Numeral
normalize (r,ds)  =   (r, dropWhile (==0) ds)

divModLongInt            ::  Numeral -> Int -> (Numeral,Int)
divModLongInt (r,dd) dv  =   let  divDigit c d = swap ((c*r+d) `divMod` dv)
                                  (remainder, quotient) = mapAccumR divDigit 0 (reverse dd)
                             in   (normalize (r,reverse quotient), remainder)

changeRadixLongInt       ::  Numeral -> Int -> Numeral
changeRadixLongInt n r'  =   (r', unfoldl produceDigit n)
  where  produceDigit  (_,[])   =  Nothing
         produceDigit  x        =  Just (divModLongInt x r')

changeRadix :: [Int] -> Int -> Int -> [Int]
changeRadix digits origBase newBase = snd $ changeRadixLongInt (origBase,digits) newBase

doLine line = let [(digits,rest0)] = reads line
                  [(origBase,rest1)] = reads rest0
                  [(newBase,rest2)] = reads rest1
              in show $ changeRadix digits origBase newBase

main = interact (unlines . map doLine . lines)

এবং প্রশ্ন থেকে পরীক্ষা চালানো:

$ ./a.out 
[1,2,3,4] 16 16
[1,2,3,4]
[1,0] 10 100
[10]
[41, 15, 156, 123, 254, 156, 141, 2, 24] 256 16
[2,9,0,15,9,12,7,11,15,14,9,12,8,13,0,2,1,8]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] 2 10
[1,2,3,7,9,4,0,0,3,9,2,8,5,3,8,0,2,7,4,8,9,9,1,2,4,2,2,3]
[41, 42, 43] 256 36
[1,21,29,22,3]

Comments

কি শান্তি. সেটা খুবই ভালো! এখন, আমি যদি কেবল এটি বুঝতে পারি: -) ... (তবে এটি এখন আমার কাজ) ...

— ircmaxell

Answer 3

আর

হ্যান্ডলগুলি উপাদান অনেক হাজার হাজার ^* এক মিনিটেরও কম হবে।

addb <- function(v1,v2,b) {
    ml <- max(length(v1),length(v2))
    v1 <- c(rep(0, ml-length(v1)),v1)
    v2 <- c(rep(0, ml-length(v2)),v2)
    v1 = v1 + v2
    resm = v1%%b
    resd = c(floor(v1/b),0)
    while (any(resd != 0)) {
        v1 = c(0,resm) + resd
        resm = v1%%b
        resd = c(floor(v1/b),0)
    }
    while (v1[1] == 0) v1 = v1[-1]
    return(v1)
}

redb <- function(v,b) {
    return (addb(v,0,b))
}

mm = rbind(1)

mulmat <- function(fromb, tob, n) {
    if (dim(mm)[2] >= n) return(mm)
    if (n == 1) return(1)
    newr = addb(mulmat(fromb,tob,n-1) %*% rep(fromb-1,n-1), 1, tob)
    newm = mulmat(fromb,tob,n-1)
    while (is.null(dim(newm)) || dim(newm)[1] < length(newr)) newm = rbind(0,newm)
    mm <<-  cbind(newr, newm)
    return(mm)
}

dothelocomotion <- function(fromBase, toBase, v) {
    mm  <<- rbind(1)
    return(redb(mulmat(fromBase, toBase, length(v)) %*% v, toBase))
}

^{* জন্য 500 টি উপাদান আপনাকে ডিফল্ট পুনরাবৃত্তি স্তর বাড়াতে হবে বাmm ম্যাট্রিক্সটি পুনরায় সেট করবেন নাdothelocomotion()}

উদাহরণ:

v1 = c(41, 15, 156, 123, 254, 156, 141, 2, 24)
dothelocomotion(256,16,v1)
2  9  0 15  9 12  7 11 15 14  9 12  8 13  0  2  1  8

dothelocomotion(256,36,c(41,42,43))
1 21 29 22  3

dothelocomotion(2,10, rep(1,90))
1 2 3 7 9 4 0 0 3 9 2 8 5 3 8 0 2 7 4 8 9 9 1 2 4 2 2 3

Answer 4

একটি কম অপ্রচলিত এবং দ্রুত জাভাস্ক্রিপ্ট সংস্করণ:

function convert (number, src_base, dst_base)
{
    var res = [];
    var quotient;
    var remainder;

    while (number.length)
    {
        // divide successive powers of dst_base
        quotient = [];
        remainder = 0;
        var len = number.length;
        for (var i = 0 ; i != len ; i++)
        {
            var accumulator = number[i] + remainder * src_base;
            var digit = accumulator / dst_base | 0; // rounding faster than Math.floor
            remainder = accumulator % dst_base;
            if (quotient.length || digit) quotient.push(digit);
        }

        // the remainder of current division is the next rightmost digit
        res.unshift(remainder);

        // rinse and repeat with next power of dst_base
        number = quotient;
    }

    return res;
}

গণনার সময় ও হিসাবে বেড়ে যায় (অঙ্কের সংখ্যা ² )
বড় সংখ্যক জন্য খুব দক্ষ নয়।
বিশেষ সংস্করণ লাইন বেস 64 এনকোডিং গণনাগুলি গতি বাড়ানোর জন্য বেস অনুপাতের সুবিধা গ্রহণ করে।

Comments

god

— শ্বরের

Answer 5

জাভাস্ক্রিপ্ট

পাইথন উত্তরের জন্য আপনাকে ধন্যবাদ কেথ র্যান্ডাল। আমি আমার সমাধানটির সংক্ষিপ্তসারগুলির সাথে লড়াই করছি এবং আপনার যুক্তিটি অনুলিপি করে শেষ করেছি। যদি কেউ এই সমাধানটিতে কোনও ভোট প্রদান করে কারণ এটি কাজ করে তবে দয়া করে কীথের সমাধানকেও একটি ভোট দিন।

function convert(src,fb,tb){
  var res=[]
  while(src.length > 0){
    var a=(function(src){
      var d=[];var rem=0
      for each (var i in src){
        var c=i+rem*fb
        var e=Math.floor(c/tb)
        rem=c%tb
        d.length||e?d.push(e):0
      }
      return[d,rem]
    }).call(this,src)
    src=a[0]
    var rem=a[1]
    res.unshift(rem)
  }
  return res
}

টেস্ট

console.log(convert([1, 2, 3, 4], 16, 16))
console.log(convert([1, 0], 10, 100))
console.log(convert([41, 15, 156, 123, 254, 156, 141, 2, 24], 256, 16))
console.log(convert([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 2, 10))
console.log(convert([41, 42, 43], 256, 36))

/*
Produces:
[1, 2, 3, 4]
[10]
[2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8]
[1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3]
[1, 21, 29, 22, 3]
*/

এটি সম্ভবত অনেক সঙ্কুচিত হতে পারে, তবে আমি আসলে এটি সামান্য পার্শ্ব প্রকল্পের জন্য ব্যবহার করতে চাই। তাই আমি এটিকে পঠনযোগ্য (কিছুটা) রেখেছি এবং ভেরিয়েবলগুলি পরীক্ষা করে রাখার চেষ্টা করেছি।

Comments

এটা কিভাবে জাভাস্ক্রিপ্ট? প্রতিটির জন্য, প্রত্যেকটির জন্য?

— হার্নান এচে

3 টি অক্ষরের উপরে কোনও ভেরিয়েবলের নাম, অবহেলিত for eachবিবৃতি এবং চোখের জল সংযোজন যেমন d.length||e?d.push(e):0... এটি কি একটি আপত্তিজনক কোড চ্যালেঞ্জ বা কিছু? আপনি বোধগম্য বাক্য গঠন এবং আরও ভাল পারফরম্যান্স সহ একই জিনিস লিখতে পারেন।

@ কুরোইনকো এটি কোড গল্ফ। আপনি কি আশা করছিলেন? আপ-টু-ডেট মান ব্যবহার করে পরিষ্কার, পঠনযোগ্য কোড? আমি কখনই দাবি করি না যে আমার উত্তরটি নিখুঁত ছিল এবং আমি অবশ্যই এটি কোনও উত্পাদনের প্রকল্পের মতো ব্যবহার করব না।

— স্টিফেন পেরেলসন

ওয়েল আমি আসলে জাভাস্ক্রিপ্টে এই অ্যালগরিদমটি কিছু কারণে প্রয়োজন ছিল এবং পাইথন দ্রবণটিকে বেস হিসাবে গ্রহণ করে আমাকে এটিকে আবার স্ক্র্যাচ থেকে পুনরায় লিখতে হয়েছিল। আমি আপনার অবদানের প্রশংসা করি, কিন্তু ব্যবহারিক উদ্দেশ্যে এটি খুব কমই আইএমএইচওতে ব্যবহারযোগ্য ছিল।

Answer 6

ম্যাথামেটিকাল

কোনও ভেরিয়েবল সংজ্ঞায়িত করা হয়নি, যেকোন ইনপুট মেমরির সাথে মাপসই করা হবে accepted

f[i_, sb_, db_] := IntegerDigits[FromDigits[i, sb], db];

পরীক্ষামূলক চালনা:

f[{1,2,3,4},16,16]
f[{1,0},10,100]
f[{41,15,156,123,254,156,141,2,24},256,16]
f[{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},2,10]
f[{41,42,43},256,36]

আউট

{1,2,3,4}
{10}
{2,9,0,15,9,12,7,11,15,14,9,12,8,13,0,2,1,8}
{1,2,3 7,9,4,0,0,3,9,2,8,5,3,8,0,2,7,4,8,9,9,1,2,4,2,2,3}
{1,21,29,22,3}

Answer 7

scala:

def toDecimal (li: List[Int], base: Int) : BigInt = li match {                       
  case Nil => BigInt (0)                                                             
  case x :: xs => BigInt (x % base) + (BigInt (base) * toDecimal (xs, base)) }  

def fromDecimal (dec: BigInt, base: Int) : List[Int] =
  if (dec==0L) Nil else (dec % base).toInt :: fromDecimal (dec/base, base)

def x2y (value: List[Int], from: Int, to: Int) =
  fromDecimal (toDecimal (value.reverse, from), to).reverse

পরীক্ষাগুলি সহ টেস্টকোড:

def test (li: List[Int], from: Int, to: Int, s: String) = {
 val erg= "" + x2y (li, from, to)
 if (! erg.equals (s))
   println ("2dec: " + toDecimal (li, from) + "\n\terg: " + erg + "\n\texp: " + s)
}   

 test (List (1, 2, 3, 4), 16, 16, "List(1, 2, 3, 4)")
 test (List (1, 0), 10, 100, "List(10)")
 test (List (41, 15, 156, 123, 254, 156, 141, 2, 24), 256, 16, "List(2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8)") 
 test (List (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), 
   2, 10, "List(1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3)") 
 test (List (41, 42, 43), 256, 36, "List(1, 21, 29, 22, 3)")

সমস্ত পরীক্ষা পাস।

Answer 8

জে, ¹⁰⁹ 105

হাজার অঙ্কের ঘাম নেই Hand কোন পূর্ণসংখ্যা ক্ষতিগ্রস্থ!

e=:<.@%,.|~
t=:]`}.@.(0={.)@((e{:)~h=:+//.@)^:_
s=:[t[:+/;.0]*|.@>@(4 :'x((];~[t((*/e/)~>@{.)h)^:(<:#y))1')

উদাহরণ

256 16 s 41 15 156 123 254 156 141 2 24
2 9 0 15 9 12 7 11 15 14 9 12 8 13 0 2 1 8

256 36 s 41 42 43
1 21 29 22 3

16 16 s 1 2 3 4
1 2 3 4

256 46 s ?.1000$45
14 0 4 23 42 7 11 30 37 10 28 44 ...

time'256 46 s ?.3000$45'  NB. Timing conversion of 3000-vector.
1.96s

এটি খাটো হয়ে যায়।

Answer 9

স্মলটালক, 128

o:=[:n :b|n>b ifTrue:[(o value:n//b value:b),{n\\b}]ifFalse:[{n}]].
f:=[:a :f :t|o value:(a inject:0into:[:s :d|s*f+d])value:t].

পরীক্ষা:

f value:#[41 15 156 123 254 156 141 2 24]
  value:256
  value:16. 
    -> #(2 9 0 15 9 12 7 11 15 14 9 12 8 13 0 2 1 8)

f value:#[1 2 3 4]
  value:16
  value:16.
    -> #(1 2 3 4)

f value:#[1 0]
  value:10
  value:100.
    -> #(10)

f value:#[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
  value:2
  value:10.
    -> #(1 2 3 7 9 4 0 0 3 9 2 8 5 3 8 0 2 7 4 8 9 9 1 2 4 2 2 3)

f value:#[41 42 43]
  value:256
  value:36.
    -> #(1 21 29 22 3)

এবং আপনার বিশেষ বিনোদনের জন্য ( চ্যালেঞ্জ: চিত্র নির্ধারণ করুন, ইনপুট মান সম্পর্কে কী বিশেষ )

f value:#[3 193 88 29 73 27 40 245 35 194 58 189 243 91 104 156 144 128 0 0 0 0]
  value:256
  value:1000.
    -> #(1 405 6 117 752 879 898 543 142 606 244 511 569 936 384 0 0 0)