स्ट्रिंग के लिए वर्णों की सूची कैसे बदलें?

Question

एफ # में मैं चार्स की एक सूची को स्ट्रिंग में बदलना चाहता हूं। निम्नलिखित कोड पर विचार करें: मैं बस lChars.ToString करते हैं

let lChars = ['a';'b';'c'] 

, मैं "[; 'बी' 'सी' 'एक']" मिलता है। मैं "एबीसी" प्राप्त करने की कोशिश कर रहा हूं। मुझे एहसास है कि मैं संभवतया एक सूची कर सकता हूं। मुझे लगता है कि प्रभाव पाने के लिए मुझे लगता है लेकिन ऐसा लगता है कि ऐसा करने के लिए पुस्तकालय में कुछ आदिम बनाया जाना चाहिए।

इस पर थोड़ा सा संदर्भ देने के लिए, मैं स्ट्रिंग में अलग-अलग वर्णों पर कुछ जोड़-विमर्श कर रहा हूं और जब मैं कर रहा हूं, तो मैं परिणामी स्ट्रिंग को प्रदर्शित करना चाहता हूं।

मैंने इसे गुगल करने की कोशिश की है और इस तरह से कोई खुशी नहीं है। क्या मुझे बुलेट को काटने और इस परिवर्तन को करने के लिए List.reduce अभिव्यक्ति बनाने की आवश्यकता है या क्या ऐसा करने के लिए कुछ और शानदार तरीका है? यहाँ अभी तक अपने काम करने के लिए एक और अजीब तरीका है:: दुर्भाग्य से

type t = 
    | N 
    | S of string 
    static member Zero 
    with get() = N 
    static member (+) (a: t, b: t) = 
    match a,b with 
     | S a, S b -> S (a+b) 
     | N, _ -> b 
     | _, N -> a 

let string_of_t = function 
    |N -> "" 
    |S s -> s 

let t_of_char c = S (string c) 

['a'; 'b'; 'c'] |> List.map t_of_char |> List.sum |> string_of_t 

, बस 'शून्य' के सदस्य के साथ System.String विस्तार

Answer 1

आप

System.String.Concat(Array.ofList(lChars)) 

Answer 2

['a';'b';'c'] |> List.fold_left (fun acc c -> acc^(string c)) "" 

संपादित करने की कोशिश की है स्ट्रिंग के साथ List.sum का उपयोग करने की अनुमति नहीं है।

संपादित (जुलेट का जवाब): हाँ, आप सही हैं, बाएं गुना धीमा है। लेकिन मैं और अधिक धीमी गति से पता सही :) गुना:

#r "FSharp.PowerPack" 

List.fold_right (String.make 1 >> (^)) ['a';'b';'c'] "" 

और निश्चित रूप से वहाँ तेजी से और सरल है:

new System.String(List.to_array ['1';'2';'3']) 

Answer 3

कितने तरीकों से आप एफ # में एक स्ट्रिंग का निर्माण कर सकते हैं? यहाँ एक और मुट्ठी भर है:

let chars = ['H';'e';'l';'l';'o';',';' ';'w';'o';'r';'l';'d';'!'] 

//Using an array builder 
let hw1 = new string [|for c in chars -> c|] 

//StringBuilder-Lisp-like approach 
open System.Text 
let hw2 = 
    string (List.fold (fun (sb:StringBuilder) (c:char) -> sb.Append(c)) 
         (new StringBuilder()) 
         chars) 

//Continuation passing style 
let hw3 = 
    let rec aux L k = 
     match L with 
     | [] -> k "" 
     | h::t -> aux t (fun rest -> k (string h + rest)) 
    aux chars id 

संपादित करें: समय दिलचस्प हो सकता है? मैं कार्यों में hw1..3 कर दिया और उन्हें 500000 यादृच्छिक वर्णों की एक सूची खिलाया:

• hw1: 51ms
• hw2: 16ms
• hw3: एर ... काफी देर तक एक दाढ़ी बढ़ने के लिए? मुझे लगता है कि यह सिर्फ मेरी सारी याददाश्त खा लिया।

Answer 4

और मैं 'sprintf' का इस्तेमाल किया मुझे लगता है आसान:

let t = "Not what you might expect" 
let r = [ for i in "aeiou" -> i] 
let q = [for a in t do if not (List.exists (fun x -> x=a) r) then yield a] 
let rec m = function [] -> "" | h::t -> (sprintf "%c" h) + (m t) 
printfn "%A" (m q) 

Answer 5

निम्नलिखित समाधान मेरे लिए काम करता है:

let charList = ["H";"E";"L";"L";"O"] 

let rec buildString list = 
    match list with 
    | [] -> "" 
    | head::tail -> head + (buildString tail) 

let resultBuildString = buildString charList