আর এ গল্ফ করার টিপস


58

আমি আর স্ট্যাটিস্টিকাল ভাষায় গল্ফ করার টিপস সন্ধান করছি। আর সম্ভবত গল্ফের জন্য একটি প্রচলিত পছন্দ। তবে এটি কিছু সংক্ষিপ্তভাবে কিছু কাজ করে (সিকোয়েন্সস, এলোমেলোতা, ভেক্টর এবং তালিকা), অনেকগুলি অন্তর্নির্মিত ফাংশনের খুব সংক্ষিপ্ত নাম রয়েছে এবং এর একটি alচ্ছিক লাইন টার্মিনেটর (;) রয়েছে। আর-তে কোড গল্ফ সমস্যা সমাধানে সহায়তা করার জন্য আপনি কোন টিপস এবং কৌশলগুলি দিতে পারেন?


14
এই প্রশ্নের উত্তর আর-এর জন্য অ্যান্টি-স্টাইলগাইড হিসাবে দ্বিগুণ হতে পারে, প্রদত্ত কোড গল্ফের সত্যিকার অর্থেই আপনাকে এই কাজগুলি করার একমাত্র সময় :-)
অ্যান্ড্রু ব্রাজা

উত্তর:


44

কিছু টিপস:

  1. আর এ, এটি <-ওভার ব্যবহার করার পরামর্শ দেওয়া হচ্ছে =। গল্ফিংয়ের জন্য, বিপরীতটি যেহেতু =খাটো ...
  2. আপনি যদি কোনও ফাংশনটিকে একাধিকবার কল করেন তবে এর জন্য একটি সংক্ষিপ্ত নাম সংজ্ঞায়িত করা প্রায়শই উপকারী:

    as.numeric(x)+as.numeric(y)
    
    a=as.numeric;a(x)+a(y)
    
  3. আংশিক মিলটি আপনার বন্ধু হতে পারে, বিশেষত যখন ফাংশনগুলি তালিকা দেয় যা আপনার কেবল একটি আইটেমের প্রয়োজন। তুলনা rle(x)$lengthsকরার জন্যrle(x)$l

  4. অনেক চ্যালেঞ্জের জন্য আপনাকে ইনপুট পড়তে হবে। scanএটির জন্য প্রায়শই ভাল ফিট থাকে (ব্যবহারকারী একটি খালি লাইন প্রবেশ করে ইনপুটটি শেষ করে)।

    scan()    # reads numbers into a vector
    scan(,'') # reads strings into a vector
    
  5. জবরদস্তি দরকারী হতে পারে। t=1চেয়ে অনেক খাটো t=TRUE। বিকল্পভাবে, switchআপনাকে মূল্যবান অক্ষরগুলিও সংরক্ষণ করতে পারে তবে আপনি 0,1 এর পরিবর্তে 1,2 ব্যবহার করতে চাইবেন।

    if(length(x)) {} # TRUE if length != 0
    sum(x<3)         # Adds all the TRUE:s (count TRUE)
    
  6. যদি কোনও ফাংশন জটিল কিছুকে গণনা করে এবং একই মূল মানের উপর ভিত্তি করে আপনার অন্যান্য বিভিন্ন ধরণের গণনার প্রয়োজন হয় তবে এটি বেশিরভাগ ক্ষেত্রেই উপকারী: ক) এটি ছোট ফাংশনে বিভক্ত করুন, খ) তালিকা হিসাবে আপনার প্রয়োজনীয় সমস্ত ফলাফল ফিরিয়ে দিন, বা গ) এটি ফাংশনের আর্গুমেন্টের উপর নির্ভর করে বিভিন্ন ধরণের মান ফেরত দিতে পারে।

  7. যে কোনও ভাষায়, এটি ভালভাবে জেনে নিন - আর এর হাজারো ফাংশন রয়েছে, সম্ভবত কিছু কিছু রয়েছে যা খুব কম চরিত্রেই সমস্যাটি সমাধান করতে পারে - কৌশলটি হ'ল কোনটি জানা!

কিছু অস্পষ্ট কিন্তু দরকারী ফাংশন:

sequence
diff
rle
embed
gl # Like rep(seq(),each=...) but returns a factor

কিছু অন্তর্নির্মিত ডেটা সেট এবং প্রতীক:

letters     # 'a','b','c'...
LETTERS     # 'A','B','C'...
month.abb   # 'Jan','Feb'...
month.name  # 'January','Feburary'...
T           # TRUE
F           # FALSE
pi          # 3.14...

22
  1. এর সাথে প্যাকেজ আমদানির পরিবর্তে libraryপ্যাকেজটি ব্যবহার করে ভেরিয়েবলটি ধরুন ::। নিম্নলিখিতগুলি তুলনা করুন:

    library(splancs);inout(...)
    splancs::inout(...)
    

    অবশ্যই, এটি কেবলমাত্র বৈধ যদি প্যাকেজ থেকে একটি একক ফাংশন ব্যবহার করা হয়।

  2. এটি কখন তুচ্ছ কিন্তু কখন কোনও টমিকে কোনও ফাংশন এলিয়াস করার কৌশলটি ব্যবহার করতে হবে তা একটি নিয়মের নিয়ম: যদি আপনার ফাংশনের নামটির দৈর্ঘ্য হয় mএবং nসময় ব্যবহার করা হয় তবে কেবলমাত্র উলেফ হলেই m*n > m+n+3(কারণ আপনি যে উপন্যাসটি ব্যয় করছেন তার সংজ্ঞা দেওয়ার সময় m+3এবং তারপরেও আপনি ব্যয় করছেন 1 প্রতিবারের মতো ব্যবহার করা হয়)। একটি উদাহরণ:

    nrow(a)+nrow(b)     # 4*2 < 4+3+2
    n=nrow;n(a)+n(b)
    length(a)+length(b) # 6*2 > 6+3+2
    l=length;l(a)+l(b)
    
  3. কার্যকারিতা এর পার্শ্ব-প্রতিক্রিয়া হিসাবে জোর করা:

    • ব্যবহারের পরিবর্তে as.integer, অক্ষরের স্ট্রিংগুলি ব্যবহার করে পূর্ণসংখ্যায় জোর করা যেতে পারে ::

      as.integer("19")
      ("19":1)[1] #Shorter version using force coercion.
      
    • পূর্ণসংখ্যা, সংখ্যা ইত্যাদির pasteপরিবর্তে একইভাবে অক্ষরটিতে জোর করা যেতে পারে as.character:

      as.character(19)
      paste(19) #Shorter version using force coercion.
      

6
পুনঃ 3 য় টিপ, el("19":1)এক বাইট দ্বারা আরও খাটো।
জয়সি

19

কিছু খুব নির্দিষ্ট গল্ফিং টিপস:

  • আপনি একটি ভেক্টরের দৈর্ঘ্য বের করে আনতে হবে, sum(x|1)চেয়ে খাটো length(x)যতদিন xসাংখ্যিক পূর্ণসংখ্যা, জটিল বা যৌক্তিক।
  • যদি আপনার কোনও ভেক্টরের শেষ উপাদানটি বের করার দরকার হয় তবে ভেক্টরটি পিছনের দিকে ব্যবহার করে rev()এবং (বা উপরের টিপটি ব্যবহার করে ), (বা --- ধন্যবাদ জিউসেপ!) এর x[1]পরিবর্তে পিছনে দিকে ভেক্টরটি আরম্ভ করার জন্য সস্তা (যদি সম্ভব হয়) হতে পারে be এ সম্পর্কে সামান্য প্রকরণ (যেখানে দ্বিতীয়-শেষ উপাদানটি পছন্দ হয়েছিল) এখানে দেখা যাবে । এমনকি যদি আপনি ভেক্টরটিকে পিছনের দিকে আরম্ভ করতে না পারেন তবে এখনও তার চেয়ে ছোট (এবং এটি চরিত্রের ভেক্টরগুলির পক্ষেও কাজ করে)। কখনও কখনও আপনার এমনকি প্রয়োজন হয় না , উদাহরণস্বরূপ পরিবর্তে ব্যবহার করে ।x[length(x)]x[sum(x|1)]tail(x,1)rev(x)[1]x[sum(x|1)]revn:11:n
  • (যেমনটি এখানে দেখা যায় )। আপনি যদি ম্যাট্রিক্সে কোনও ডেটা ফ্রেমকে জোর করে চাপাতে চান তবে ব্যবহার করবেন না as.matrix(x)। ট্রান্সপোজের ট্রান্সপোজ নিন t(t(x)),।

  • ifএকটি আনুষ্ঠানিক কাজ। উদাহরণস্বরূপ, এর "if"(x<y,2,3)চেয়ে ছোট if(x<y)2 else 3(যদিও অবশ্যই 3-(x<y)এটি উভয়ের চেয়ে কম)। এটি কেবলমাত্র অক্ষরগুলি সংরক্ষণ করে যদি আপনার প্রায়শই এইভাবে তৈরি করতে অতিরিক্ত জোড় ধনুর্বন্ধনী প্রয়োজন হয় না।

  • সংখ্যাসূচক বস্তুর অ-সাম্যতা পরীক্ষা করার জন্য, এর if(x-y)চেয়ে কম হয় if(x!=y)। যে কোনও ননজারো সংখ্যাসূচক হিসাবে বিবেচিত হয় TRUE। আপনি যদি সাম্যের পরীক্ষা করছেন, বলুন, if(x==y)a else bতারপরে চেষ্টা if(x-y)b else aকরুন। আগের বিষয়টিও দেখুন।

  • elযখন আপনাকে তালিকা থেকে কোনও আইটেম বের করতে হবে তখন ফাংশনটি কার্যকর । সর্বাধিক সাধারণ উদাহরণটি সম্ভবত strsplit: এর el(strsplit(x,""))চেয়ে কম বাইট strsplit(x,"")[[1]]

  • ( এখানে ব্যবহৃত হিসাবে ) ভেক্টর এক্সটেনশান আপনাকে অক্ষরগুলি সংরক্ষণ করতে পারে: ভেক্টরের vদৈর্ঘ্য থাকলে আপনি ত্রুটি ছাড়াই nনির্ধারণ করতে পারেন v[n+1]। উদাহরণস্বরূপ, আপনি যদি প্রথমে দশটি কল্পকাহিনীটি মুদ্রণ করতে চান তবে আপনি করতে পারেন: v=1;for(i in 2:10)v[i]=v[i-1]*iবরং v=1:10:for(...)(যদিও সর্বদা হিসাবে, আরও একটি উপায় রয়েছে, ভাল: উপায় cumprod(1:10))

  • কখনও কখনও, পাঠ্যভিত্তিক চ্যালেঞ্জগুলির জন্য (বিশেষত 2-ডি বিষয়গুলি), plotপাঠ্যের চেয়ে catএটি আরও সহজ । কোন অক্ষর চক্রান্ত করা হয়েছে pch=তা plotনিয়ন্ত্রণ করার যুক্তি । এটি pc=একটি বাইট সংরক্ষণ করার জন্য সংক্ষিপ্ত করা যেতে পারে (যা একটি সতর্কতাও দেবে)। উদাহরণ এখানে

  • একটি নম্বর মেঝে নিতে, ব্যবহার করবেন না floor(x)x%/%1পরিবর্তে ব্যবহার করুন।

  • কোনও সংখ্যাসূচক বা পূর্ণসংখ্যার ভেক্টরের উপাদানগুলি সমস্ত সমান কিনা তা পরীক্ষা করতে আপনি প্রায়শই sdভার্বোজের মতো কিছু ব্যবহার করতে পারেন all.equal। সমস্ত উপাদান যদি একই হয় তবে তাদের মানক বিচ্যুতি শূন্য ( FALSE) অন্যথায় মানক বিচ্যুতিটি ইতিবাচক ( TRUE)। উদাহরণ এখানে

  • কিছু ফাংশন যা আপনি পূর্ণসংখ্যার ইনপুট প্রয়োজন তা আশা করবেন না আসলে। উদাহরণস্বরূপ, seq(3.5)ফিরে আসবে 1 2 3( :অপারেটরের ক্ষেত্রেও এটি সত্য )। এই কল এড়াতে পারেন floorএবং কখনো কখনো আপনি ব্যবহার করতে পারেন এর মানে হল /পরিবর্তে %/%


1
tail(v,1)rev(v)[1]"একটি অ্যারের শেষ উপাদান" গল্ফিং টিপ হিসাবে একই দৈর্ঘ্য ।
জিউসেপে

read.csv(t="a,b,c",,F)তুলনায় খাটো el(strsplit("a,b,c",","))
জে.ডে

18
  1. অন্তর্নির্মিত আপত্তি Tএবং F। ডিফল্টরূপে, তারা মূল্যায়ন TRUEএবং FALSEযা স্বয়ংক্রিয়ভাবে numerics রূপান্তরিত করা যেতে পারে, 1এবং 0, এবং তারা স্বেচ্ছায় পুনরায় সংজ্ঞায়িত করা যায়। এর অর্থ হ'ল আপনার কোনও কাউন্টার শুরু করার দরকার নেই (উদা i=0... i=i+1), আপনি কেবল প্রয়োজন হিসাবে Tবা Fপ্রয়োজন হিসাবে ব্যবহার করতে পারেন (এবং F=F+1পরে সরাসরি চলে যান)।
  2. মনে রাখবেন যে ফাংশনগুলি ডাকা শেষ অবজেক্টটি ফিরিয়ে দেয় এবং সুস্পষ্ট return()কলের প্রয়োজন হয় না ।
  3. সাধারণত ব্যবহৃত ফাংশনগুলির জন্য সংক্ষিপ্ত ডাকনাম সংজ্ঞা দেওয়া যেমন দুর্দান্ত p=paste। আপনি যদি একটি ফাংশন প্রচুর ব্যবহার করেন এবং ঠিক দুটি যুক্তি দিয়ে, এটি সম্ভবত একটি ইনফিক্সিং ওরফে আপনাকে কিছু বাইট সংরক্ষণ করবে। ইনফিক্সিং এলিয়াসগুলি অবশ্যই ঘিরে থাকতে হবে %। উদাহরণ স্বরূপ:

    `%p%`=paste

    এবং পরবর্তীকালে x%p%y, যা এর চেয়ে 1 বাইট কম p(x,y)। ইনফিক্সিং ওরফে সংজ্ঞাটি ইন-ইনপিক্সিংয়ের চেয়ে 4 বাইট বেশি লম্বা p=paste, সুতরাং আপনার অবশ্যই নিশ্চিত হওয়া উচিত যে এটি উপযুক্ত।


9
আপনি আদিম ফাংশনগুলি ব্যবহার করতে পারেন এবং আপনি অনেকগুলি বাইট সংরক্ষণ করতে পারেন:`+`=paste; x+y
মাসক্লিনস

14

ব্যবহার if, ifelseএবং`if`

আর। গল্ফ-অনুকূল সমাধানগুলিতে যদি বিবৃতিগুলি করতে পারে তবে অনেকগুলি পরিবর্তন হতে পারে।

অধিকার

  1. ifনিয়ন্ত্রণ প্রবাহ জন্য হয়। এটি ভেক্টরাইজড নয়, অর্থাত্ 1 দৈর্ঘ্যের শর্তগুলি মূল্যায়ন করতে পারে It এটির else(বিকল্পভাবে) অন্য কোনও মান ফেরত দেওয়া দরকার ।
  2. ifelseএকটি ফাংশন। এটি ভেক্টরাইজড এবং নির্বিচার দৈর্ঘ্যের মানগুলি ফিরিয়ে দিতে পারে। এটির তৃতীয় যুক্তি (অন্য মানটি) ফরয *
  3. `if`একই সিনট্যাক্স সহ একটি ফাংশন ifelse। এটি ভেক্টরাইজড নয়, কোনও রিটার্ন যুক্তিও বাধ্যতামূলক নয়।

* এটি প্রযুক্তিগতভাবে বাধ্যতামূলক নয়; ifelse(TRUE,x)ঠিক কাজ করে তবে তৃতীয় যুক্তিটি খালি থাকলে এবং শর্তটি যদি মূল্যায়ন করে তবে এটি ত্রুটি ছুঁড়ে FALSE। সুতরাং এটি ব্যবহার করা কেবলমাত্র নিরাপদ যদি আপনি নিশ্চিত হন যে শর্তটি সর্বদা রয়েছে TRUE, এবং যদি এটি হয় তবে আপনি কেন যদি একটি বিবৃতি দিয়ে বিরক্ত করছেন?

উদাহরণ

এগুলি সমস্ত সমতুল্য:

if(x)y else z # 13 bytes
ifelse(x,y,z) # 13 bytes
`if`(x,y,z)   # 11 bytes

elseআপনি যদি কোডটিতে সরাসরি স্ট্রিং ব্যবহার করেন তবে আশেপাশের স্পেসগুলির প্রয়োজন নেই:

if(x)"foo"else"bar"   # 19 bytes
ifelse(x,"foo","bar") # 21 bytes
`if`(x,"foo","bar")   # 19 bytes

এখনও অবধি, `if`বিজয়ী মনে হচ্ছে, যতক্ষণ না আমাদের কাছে ভেক্টরাইজড ইনপুট নেই। তবে যেসব ক্ষেত্রে আমরা অন্য শর্তটি যত্ন করি না সেগুলি সম্পর্কে কী বলা যায়? বলুন আমরা শর্তটি থাকলে কেবল কিছু কোড কার্যকর করতে চাই TRUE। একা এক লাইনের কোডের জন্য, ifসাধারণত সেরা:

if(x)z=f(y)         # 11 bytes
ifelse(x,z<-f(y),0) # 19 bytes
`if`(x,z<-f(y))     # 15 bytes

একাধিক লাইনের কোডের জন্য, ifএখনও বিজয়ী:

if(x){z=f(y);a=g(y)}        # 20 bytes
ifelse(x,{z=f(y);a=g(y)},0) # 27 bytes
`if`(x,{z=f(y);a=g(y)})     # 23 bytes

আরেকটা সম্ভাবনাও যেখানে আমরা এর কি অন্য শর্ত যত্নশীল, এবং যেখানে আমরা নির্বিচারে কোড চালানো বদলে কোন মান ফিরিয়ে দিতে চাই। এই ক্ষেত্রে, ifএবং `if`বাইট গণনা সমতুল্য।

if(x)a=b else z=b   # 17 bytes
ifelse(x,a<-b,z<-b) # 19 bytes
`if`(x,a<-b,z<-b)   # 17 bytes

if(x){z=y;a=b}else z=b   # 22 bytes
ifelse(x,{z=y;a=b},z<-b) # 24 bytes
`if`(x,{z=y;a=b},z<-b)   # 22 bytes

if(x)a=b else{z=b;a=y}   # 22 bytes
ifelse(x,a<-b,{z=b;a=y}) # 24 bytes
`if`(x,a<-b,{z=b;a=y})   # 22 bytes

if(x){z=y;a=b}else{z=b;a=y}   # 27 bytes
ifelse(x,{z=y;a=b},{z=b;a=y}) # 29 bytes
`if`(x,{z=y;a=b},{z=b;a=y})   # 27 bytes

সারাংশ

  1. আপনার ifelseদৈর্ঘ্যের ইনপুট থাকলে> 1 ব্যবহার করুন।

  2. আপনি যদি অনেকগুলি কোডের কোড প্রয়োগের পরিবর্তে কোনও সাধারণ মানটি ফিরিয়ে দিচ্ছেন তবে `if`ফাংশনটি ব্যবহার করা সম্ভবত পুরো if... elseস্টেটমেন্টের চেয়ে কম ।

  3. আপনি যদি কেবল একটি একক মান চান তবে TRUE, ব্যবহার করুন if

  4. স্বেচ্ছাসেবক কোড সম্পাদন করার জন্য, `if`এবং ifবাইট গণনা অনুসারে সাধারণত একই হয়; আমি সুপারিশ করি ifমূলত কারণ এটি পড়া সহজ।


1
নিস! খুব ভাল তুলনা, +1!
বিলিউব

13
  1. আপনি বর্তমান পরিবেশে একটি ভেরিয়েবল বরাদ্দ করতে পারবেন যখন একই সাথে এটি কোনও ফাংশনের যুক্তি হিসাবে সরবরাহ করে:

    sum(x <- 4, y <- 5)
    x
    y
  2. যদি আপনি একটি সাবটেক্ট করে থাকেন data.frameএবং আপনার অবস্থা এর কয়েকটি কলামের উপর নির্ভর করে তবে আপনি (বা ) data.frameব্যবহার করে নামটি পুনরাবৃত্তি করা এড়াতে পারবেন ।withsubset

    d <- data.frame(a=letters[1:3], b=1:3, c=4:6, e=7:9)
    with(d, d[a=='b' & b==2 & c==5 & e==8,])

    পরিবর্তে

    d[d$a=='b' & d$b==2 & d$c==5 & d$e==8,]

    অবশ্যই, এটি কেবলমাত্র অক্ষর সংরক্ষণ করে যদি আপনার উল্লেখের data.frameদৈর্ঘ্যের দৈর্ঘ্য অতিক্রম করে cewith(,)

  3. if...elseব্লকগুলি চূড়ান্ত বিবৃতিটির মানটি ফিরিয়ে দিতে পারে যা ব্লকের কোনও অংশ কার্যকর করে। উদাহরণস্বরূপ, পরিবর্তে

    a <- 3
    if (a==1) y<-1 else
    if (a==2) y<-2 else y<-3

    তুমি লিখতে পারো

    y <- if (a==1) 1 else 
         if (a==2) 2 else 3

4
(1) সম্পর্কে কেবল সতর্কতা হ'ল আপনি যখন এটি করেন যে আপনি নাম যুক্তি দ্বারা অর্ডার দিয়ে এটি পাস করছেন। যদি f <- function(a,b) cat(a,b), তবে f(a <- 'A', b <- 'B')হিসাবে একই হয় না f(b <- 'B', a <- 'A')
এরি বি ফ্রেডম্যান

11

অন্তর্নিহিত ধরণের রূপান্তর

ফাংশনগুলি as.character, as.numericএবং as.logicalখুব বাইট-ভারী। আসুন তাদের ছাঁটাই।

সাংখ্যিক (4 বাইট) থেকে যৌক্তিক রূপান্তর

মনে করুন xএকটি সংখ্যক ভেক্টর। লজিক্যাল না অপারেটর ব্যবহার !পরোক্ষভাবে একটি লজিক্যাল ভেক্টর, যেখানে সাংখ্যিক recasts 0হয় FALSEএবং অশূন্য মান TRUE!তারপরে এটি উল্টে যায়।

x=!x

x=0:3;x=!xআয় TRUE FALSE FALSE FALSE

সংখ্যা বা লজিকাল (7 বাইট) থেকে অক্ষরে রূপান্তর

এটি একটি মজার এক। ( এই টুইট থেকে ।)

x[0]=''

আর দেখেন আপনি ভেক্টর আপডেট করছি যে xসঙ্গে ''ক্লাসের যা character। সুতরাং এটি xশ্রেণিতে বিভক্ত হয় characterতাই এটি নতুন ডেটার পয়েন্টের সাথে সামঞ্জস্যপূর্ণ। এর পরে, এটা করা যায় ''যথাযথ জায়গায় ... কিন্তু সূচক 0অস্তিত্ব নেই (এই কৌতুক এছাড়াও সাথে কাজ করে Inf, NaN, NA, NULL, ইত্যাদি)। ফলস্বরূপ, xশুধুমাত্র ক্লাসে পরিবর্তিত হয়।

x=1:3;x[0]=''প্রত্যাবর্তন "1" "2" "3", এবং x=c(TRUE,FALSE);x[0]=''ফিরে "TRUE" "FALSE"

আপনার কর্মক্ষেত্রে যদি ইতিমধ্যে কোনও চরিত্রের অবজেক্টটি সংজ্ঞায়িত করা থাকে তবে আপনি ''বাইট সংরক্ষণ করার পরিবর্তে এটি ব্যবহার করতে পারেন । যেমন x[0]=y!

নির্দিষ্ট শর্তে (n বাইট) সংখ্যাসূচক বা লজিকাল থেকে অক্ষরে রূপান্তর

জে .ডো মন্তব্যগুলিতে একটি ছয়-বাইট সমাধান উল্লেখ করেছেন:

c(x,"")

এটি কাজ করে যদি xপারমাণবিক হয় এবং যদি আপনি এটি কোনও ফাংশনে পাস করার ইচ্ছা করেন যা একটি পারমাণবিক ভেক্টর প্রয়োজন। (ফাংশনটি যুক্তির উপাদানগুলিকে উপেক্ষা করার বিষয়ে একটি সতর্কতা নিক্ষেপ করতে পারে))

লজিকাল (4 বাইট) থেকে সংখ্যায় রূপান্তর

আপনি উপরের (উদাঃ x[0]=3) থেকে মজাদার সূচক কৌশলটি ব্যবহার করতে পারেন তবে প্রকৃতপক্ষে আরও দ্রুত উপায় রয়েছে:

x=+x

ধনাত্মক অপারেটর স্পষ্টভাবে সংখ্যক ভেক্টর হিসাবে ভেক্টরকে পুনরুক্ত করে, তাই TRUE FALSEহয়ে যায় 1 0


আপনার শেষ কৌশল হিসাবে x=+xরাখা যেতে পারে । TRUE1
জিউসেপ

@ জিউসেপ ওহ, দুহ, অবশ্যই! ধন্যবাদ, এখনই আপডেট হয়েছে।
rturnbull

সংখ্যাসূচক বা লজিকাল থেকে অক্ষরে রূপান্তর। আপনি c(x,"")যদি xপারমাণবিক হন তবে এটি ব্যবহার করতে পারেন তবে শর্ত থাকে যে আপনি যদি এমন xকোনও ফাংশন ব্যবহার করতে যা যা কেবল প্রথম উপাদানটির বিষয়ে চিন্তা করে তবে এটি অভিযোগ করতে পারে)। এটি তুলনায় 1 বাইট সস্তা x[0]="";
জে.ডো

10

আর-এ লুপ করুন

মাঝেমধ্যে, আমি নিজেকে আর এর একটি do-whileলুপ পেতে ইচ্ছুক , কারণ:

 some_code
while(condition){
 some_code # repeated
}

এটি অনেক দীর্ঘ এবং খুব অবিচ্ছিন্ন। তবে, আমরা এই আচরণটি পুনরুদ্ধার করতে পারি এবং {ফাংশনটির শক্তি দিয়ে কিছু বাইট ছাঁটাই করতে পারি ।

{এবং (প্রতিটি .Primitiveফাংশন আর।

তাদের জন্য দস্তাবেজগুলি পড়ে:

কার্যকরভাবে, (শব্দার্থগতভাবে পরিচয়ের সমতুল্য function(x) x, যেখানে {খানিকটা আকর্ষণীয়, উদাহরণ দেখুন।

এবং মান অধীনে,

জন্য (, যুক্তি মূল্যায়ন ফলাফল। এটিতে দৃশ্যমানতা সেট রয়েছে তাই শীর্ষ-স্তরে ব্যবহৃত হলে স্বয়ংক্রিয়ভাবে মুদ্রণ হবে।

জন্য {, সর্বশেষ প্রকাশের ফলাফল মূল্যায়ন । এটিতে সর্বশেষ মূল্যায়নের দৃশ্যমানতা রয়েছে।

(সামনে জোর দাও)

তাহলে এর অর্থ কি? এর অর্থ একটি ডু-ওয়েল লুপ যতটা সহজ

while({some_code;condition})0

কারণ এক্সপ্রেশন ভিতরে {}হয় প্রতিটি মূল্যায়ন, এবং শুধুমাত্র গত এক দ্বারা ফিরিয়ে দেওয়া হয় {, আমাদের মূল্যায়নের করতে সক্ষম হবেন some_codeলুপ প্রবেশের আগে, এবং এটা প্রতিটি সময় রান conditionহয় TRUE(অথবা truthy)। 0অনেক 1 বাইট এক্সপ্রেশন যে "বাস্তব" শরীরের ফর্ম অন্যতম whileলুপ।


10
  1. outerদুটি তালিকার সমস্ত সংমিশ্রণে একটি স্বেচ্ছাসেবী ফাংশন প্রয়োগ করতে অপব্যবহার করুন । প্রথম আরোগুলি অনুসারে i, j সহ সূচকযুক্ত একটি ম্যাট্রিক্স কল্পনা করুন, তারপরে আপনি প্রতিটি জোড়ের জন্য একটি স্বেচ্ছাসেবী ফাংশন (i, j) সংজ্ঞায়িত করতে পারেন।

  2. এর Mapশর্টকাট হিসাবে ব্যবহার করুন mapply। আমার দাবিটি এমন mapplyপরিস্থিতিতে লুপের চেয়ে সস্তা যেখানটিতে আপনাকে সূচি অ্যাক্সেস করতে হবে। আর.তে তালিকা কাঠামো আপত্তিজনক unlistব্যয়বহুল। methods::elআপনাকে সস্তাভাবে প্রথম উপাদানটি তালিকাভুক্ত করতে দেয়। স্থানীয়ভাবে তালিকা সমর্থন সহ ফাংশনগুলি ব্যবহার করার চেষ্টা করুন।

  3. do.callস্বেচ্ছাসেবী ইনপুট সহ ফাংশন কলগুলিকে সাধারণকরণ করতে ব্যবহার করুন ।

  4. এর জন্য জমা হওয়া আরোগুলি Reduceকোড গল্ফের জন্য অত্যন্ত সহায়ক।

  5. সাথে লাইনে কনসোল cat(blah, "\n")লিখতে লিখতে সস্তা write(blah, 1)। "" N "সহ হার্ড কোডিং স্ট্রিং কিছু পরিস্থিতিতে সস্তা হতে পারে।

  6. যদি কোনও ফাংশন ডিফল্ট আর্গুমেন্টের সাথে আসে তবে আপনি সরাসরি এন-থ আর্গুমেন্ট নির্দিষ্ট করতে ফাংশন (,, এন-আরগ) ব্যবহার করতে পারেন। উদাহরণ: seq(1, 10, , 101)কিছু ফাংশনে আংশিক যুক্তির মিলটি সমর্থিত। উদাহরণ: seq(1, 10, l = 101)

  7. আপনি যদি স্ট্রিং ম্যানিপুলেশন জড়িত একটি চ্যালেঞ্জ দেখতে পান, কেবল পিছনের বোতামটি টিপুন এবং পরবর্তী প্রশ্নটি পড়ুন। strsplitআর গল্ফ নষ্ট করার জন্য এককভাবে দায়ী।

2018 থেকে নতুন সন্ধান করা কিছু টিপসের জন্য এখন

  1. A[cbind(i,j)] = zম্যাট্রিকেসগুলি হেরফের করার একটি ভাল উপায় হতে পারে। এই অপারেশনটি আপনাকে i, j, zসঠিক দৈর্ঘ্যের সাথে ভেক্টর হিসাবে ডিজাইন করে খুব দক্ষ বুদ্ধিযুক্ত। আপনি প্রকৃত সূচক / অ্যাসাইন ফাংশন কল করে আরও বেশি সঞ্চয় করতে পারেন "[<-"(cbind(i,j), z)। কল করার এই উপায়ে পরিবর্তিত ম্যাট্রিক্স প্রদান করে।

  2. \nলাইন ব্রেকগুলির পরিবর্তে একটি নতুন লাইন ব্যবহার করুন ।

  3. লাইন গুনতে নিচে চলা আপনার বাইটগুলি বাঁচাতে পারে। ইন-লাইন অ্যাসাইনমেন্ট lapply(A<-1:10,function(y) blah)এবং ফাংশন আরগস অ্যাসাইনমেন্ট হ'ল function(X, U = X^2, V = X^3)এটি করার উপায়।

  4. আর "[<-"তে একটি ফাংশন (এবং এটি আমার প্রাচীন প্রশ্নের সাথে সম্পর্কিত ) এটি যেমন অপারেশনের জন্য দায়ী অন্তর্নিহিত ফাংশন x[1:5] = rnorm(5)। নাম দিয়ে ফাংশনটি কল করার ঝরঝরে সম্পত্তি আপনাকে পরিবর্তিত ভেক্টরকে ফেরত দিতে দেয়। ক্রমযুক্ত শব্দগুলি "[<-"(x, 1:5, normr(5))পরিবর্তিত এক্স প্রদান করে ব্যতীত উপরের কোডের মতো প্রায় একই জিনিস করে। সম্পর্কিত "দৈর্ঘ্য <-", "নাম <-", "কিছুই <-" সমস্ত ফেরত পরিবর্তিত আউটপুট


1
আমি মনে করি ব্যবহার "[<-"করা তার নিজস্ব "টিপস" উত্তরের উপযুক্ত, কারণ এটি পরিবর্তিত অ্যারে / ম্যাট্রিক্স / যা কিছু ফিরিয়ে দেবে।
জিউসেপে

10
  1. ইন-লাইন মানগুলি সংরক্ষণ করুন : অন্যরা উল্লেখ করেছে যে আপনি মানগুলিকে ক্রম দিয়ে পাস করতে পারেন এবং এগুলি অন্য কোথাও ব্যবহারের জন্য নির্ধারণ করতে পারেন

    sum(x<- 1:10, y<- seq(10,1,2))

    তবে একই লাইনে ব্যবহারের জন্য আপনি ইনলাইন মানগুলিও সংরক্ষণ করতে পারেন !

    এই ক্ষেত্রে

    n=scan();(x=1:n)[abs(x-n/2)<4]

    থেকে পড়ুন stdin, একটি পরিবর্তনশীল তৈরি করে x=1:n, তারপরে xসেই মানটির ব্যবহার করে সূচিগুলি x। এটি কখনও কখনও বাইট সংরক্ষণ করতে পারে।

  2. খালি ভেক্টরটির উপাধি আপনি উভয় ফিরে আসার সাথে সাথে {}খালি ভেক্টর c()হিসাবে ব্যবহার করতে পারেন NULL

  3. বেস রূপান্তরn বেস 10 এর পূর্ণসংখ্যার জন্য , ব্যবহার করুন n%/%10^(0:nchar(n))%%10। এটি একটি পিছনে শূন্য ছেড়ে যাবে, সুতরাং এটি যদি আপনার পক্ষে গুরুত্বপূর্ণ হয় তবে n%/%10^(1:nchar(n)-1)%%10এটি অ্যারে সূচকের চেয়ে কম হিসাবে ব্যবহার করুন । এটি floor(log(n,b))+1পরিবর্তে ব্যবহার করে অন্যান্য ঘাঁটিতে অভিযোজিত হতে পারেnchar(n)

  4. ব্যবহার seqএবং: : বরং ব্যবহার না করে 1:length(l)(অথবা 1:sum(x|1)), আপনি ব্যবহার করতে পারেন seq(l)যতদিন lএকটি হল listবা vector1 তার চেয়ে অনেক বেশী দৈর্ঘ্যের এটি অক্ষমতা হিসেবে seq_along(l)। যদি lসম্ভাব্য দৈর্ঘ্য হতে পারে 1, seq(a=l)কৌতুক করতে হবে।

    অতিরিক্তভাবে, :উইকিও (একটি সতর্কতা সহ) এর যুক্তিগুলির প্রথম উপাদানটি ব্যবহার করবে।

  5. c()একটি array(বা matrix) এর উপর ব্যবহার করে বৈশিষ্ট্যগুলি সরানো একই কাজ করবে as.vector; এটি সাধারণত নামবিহীন বৈশিষ্ট্যগুলি সরিয়ে দেয়।

  6. গৌণিক ব্যবহার gamma(n+1)ব্যবহার তুলনায় খাটো factorial(n)এবং factorialহিসাবে সংজ্ঞায়িত করা হয় gamma(n+1)যাহাই হউক না কেন।

  7. মুদ্রা উল্টানো যখন কোনও র‌্যান্ডম টাস্ক করার দরকার হয় তখন 50% সময় ব্যবহার করা তিন বাইটের rt(1,1)<0চেয়ে কম runif(1)<0.5হয়।

  8. উপাদানগুলি নিষ্কাশন / বাদ দেওয়া head এবং tailপ্রায়শই একটি অ্যারের প্রথম / শেষ কয়েকটি উপাদানগুলি নিষ্কাশন করতে দরকারী; head(x,-1)আপনি যদি ইতিমধ্যে দৈর্ঘ্যটি না জানেন তবে সর্বশেষ উপাদান ব্যতীত সমস্তগুলি বের করে এবং নেতিবাচক সূচী ব্যবহারের চেয়ে কম is

    head(x,-1)
    x[-length(x)]
    x[-sum(x|1)]


@ জে.ডো নিজস্ব পোস্টের যোগ্য, আমি মনে করি! সম্ভবত "বিকল্পগুলির" শিরোনাম সহ rep। অন্যান্য টিপস প্রশ্নাবলীর উত্তর অনুসারে একটি টিপসের সীমাবদ্ধতা রয়েছে, যা আমিও আন্তরিকভাবে এই প্রশ্নের জন্য সমর্থন করি! এছাড়াও, দুটি বাইটের 1:n*0চেয়ে ছোট Im(1:n), যার অর্থ আপনার দ্বিতীয় কৌশলটিও হতে পারে x+0*-n:n:-)
জিউসেপ

1
@ জে.ডো বা আরও ভাল এটি ব্যবহারের ক্ষেত্রে নির্ভর করে শূন্যগুলির !1:nএকটি অ্যারে n; যদিও সেইটির জন্য এমএটিএল / ম্যাটল্যাব টিপস প্রশ্নে (সম্ভবত লুইস মেন্ডো) ক্রেডিট।
জিউসেপে

ধন্যবাদ, @ জিউজ্পে! আমি কি আপনাকে এই পোস্টটি তৈরি করার পরামর্শ দিতে পারি, কারণ আমি আপনার ভাল ধারণাগুলি থেকে খ্যাতি নিতে চাই না।
জে.ডো

@ জে.ডো ওহ, আমার আপত্তি নেই। অন্যান্য আর গল্ফারদের আরও দৃশ্যমানতা পাওয়া সর্বদা ভাল; আমি মনে করি এটা বলা ঠিক যে আমি এই সময়ে একটি সুপরিচিত সত্তা! আপনি বেশ চিত্তাকর্ষক উন্নতির পরামর্শ নিয়ে ঘুরে বেড়াচ্ছেন, সুতরাং প্রতিনিধিত্ব করুন (পাং উদ্দেশ্য নয়) এবং ভাল কাজটি গল্ফিংয়ে চালিয়ে যান :-)
জিউসেপ্পে

1
(log(i,b)%/%1):0)পরিবর্তে না floor(log(n,b))+1?
ASCII- কেবল

8

কিছু প্রাথমিক ধারণা তবে কিছুটা কার্যকর হওয়া উচিত:

  1. নিয়ন্ত্রণ প্রবাহের বিবৃতিতে আপনি অপব্যবহার করতে পারেন যে কোনও সংখ্যা শূন্যের সমান নয় যেমন মূল্যায়ন করা হবে TRUE, যেমন: if(x)এর সমতুল্য if(x!=0)। বিপরীতে, if(!x)সমতুল্য if(x==0)

  2. :(উদাহরণস্বরূপ 1:5) ব্যবহার করে সিকোয়েন্স তৈরি করার সময় কেউ ^এই :সত্যটিকে অপব্যবহার করতে পারে যে এক্সপেনসিয়েশন অপারেটর একমাত্র অপারেটর যা -অপরেটারের (যেমন বিপরীতে +-*/) এর চেয়ে বেশি প্রাধান্য পেয়েছে ।

    1:2^2 => 1 2 3 4 

    যা আপনাকে প্রথম বন্ধনীর উপর দুটি বাইট সংরক্ষণ করে যা আপনি সাধারণত n x nম্যাট্রিক্স ( 1:n^2) বা অন্য কোনও পূর্ণসংখ্যার উপাদানগুলির উপর লুপ করতে চান যা ক্ষতিকারক স্বরলিপি ( 1:10^6) ব্যবহার করে সংক্ষিপ্ত পদ্ধতিতে প্রকাশ করা যায় use

  3. একটি সম্পর্কিত কৌশল অবশ্যই ভেক্টরাইজড অপারেশনগুলিতেও ব্যবহার করা যেতে পারে +-*/, যদিও সর্বাধিক সাধারণভাবে প্রয়োগ হয় +-:

    for(i in 1:(n+1)) can instead be written as for(i in 0:n+1)

    এটি কাজ করে কারণ +1ভেক্টরাইজড এবং ভেক্টরের ফলে 1প্রতিটি উপাদান যুক্ত করে । একইভাবে আপনাকে একটি বাইটও সাশ্রয় করে।0:n1 2 ... n+10:(n+1) == -1:n+1

  4. সংক্ষিপ্ত ফাংশনগুলি লেখার সময় (এটি একটি লাইনে প্রকাশ করা যেতে পারে), কেউ ঘেরযুক্ত কোঁকড়ানো বন্ধনীগুলিতে দুটি বাইট সংরক্ষণ করার জন্য ভেরিয়েবল অ্যাসাইনমেন্ট ব্যবহার করতে পারে {...}:

    f=function(n,l=length(n))for(i in 1:l)cat(i*l,"\n")
    f=function(n){l=length(n);for(i in 1:l)cat(i*l,"\n")}

    মনে রাখবেন যে এটি সর্বদা নির্দিষ্ট চ্যালেঞ্জগুলির নিয়ম মেনে চলতে পারে না।


কেবলমাত্র একটি সংশোধন: ^ভেক্টরাইজড, এটি কেবলমাত্র এর চেয়ে বেশি প্রাধান্য পেয়েছে :(অর্থাত্ :ব্র্যাকেটগুলি সুস্পষ্টভাবে বিপরীতটি নির্দেশ না করে ?Syntax, বাইনারি এবং ইউনিারি অপারেটরগুলির নজিরের যথাযথ ক্রম দেখুন) it's বাইনারি একই হয় +-/*যার জন্য :আপনার ট্রিক n ° 3 এর চেয়ে কম অগ্রাধিকার রয়েছে ।
প্ল্যানাপাস

@ প্ল্যানাপাস স্পষ্ট করার জন্য ধন্যবাদ। শব্দটি আপডেট করেছেন।
বিলিউব

7

অপারেটরদের অর্থ পরিবর্তন করুন

আর অপারেটরগুলি কেবল এমন ফাংশন যা পার্সার দ্বারা বিশেষ চিকিত্সা পায় get উদাহরণস্বরূপ <আসলে দুটি ভেরিয়েবলের একটি ফাংশন। এই দুটি লাইনের কোড একই কাজ করে:

x < 3
`<`(x, 3) 

আপনি অপারেটরের কাছে অন্য ফাংশনটি পুনরায় নিয়োগ করতে পারেন, এবং পার্সারটি অপারেটরের অগ্রাধিকারকে সম্মান জানানো সহ এখনও এটি করবে but তবে চূড়ান্ত ফাংশন কলটি আসলটির চেয়ে নতুন হবে be উদাহরণ স্বরূপ:

`<`=rep

কোডটির এই দুটি লাইনের অর্থ একই কাজ:

rep("a", 3)
"a"<3

এবং অগ্রাধিকার সম্মান করা হয়, ফলাফল মত জিনিস

"a"<3+2
#[1] "a" "a" "a" "a" "a"

উদাহরণস্বরূপ এই উত্তরটি দেখুন এবং অপারেটর অগ্রাধিকার পৃষ্ঠাটিও দেখুন । পার্শ্ব প্রতিক্রিয়া হিসাবে, আপনার কোডটি গল্ফ ভাষায় লিখিতর মতো ক্রিপ্টিক হয়ে উঠবে।

কিছু অপারেটর এক বা দুটি পরামিতি পছন্দ করে +এবং -গ্রহণ করতে পারে, তাই আপনি এমনকি এগুলি করতে পারেন:

`-`=sample
set.seed(1)
-5  # means sample(5)
#[1] 2 5 4 3 1
5-2 # means sample(5, 2)
#[1] 5 4

উদাহরণস্বরূপ এই উত্তরটি দেখুন

দ্বি-বাইট, তিন-যুক্তিযুক্ত অপারেটর হিসাবে ব্যবহার করার জন্য এই উত্তরটিও দেখুন [


2
এটি রটারনবুলের টিপসের একটি মন্তব্য তবে আমি মনে করি আমাদের "প্রতি উত্তরের জন্য একটি টিপ" বিধি প্রয়োগ করা শুরু করা উচিত কারণ এখানে আসার সময় আমার যেটুকু দরকার তা খুঁজে পাওয়া এতটাই কঠিন।
জিউসেপ

1
এছাড়াও অপারেটরদের নজির উপর নির্ভর করে, আপনি কিছু মজার জিনিস করতে পারেন যা সহায়তা করতে পারে; এর <চেয়ে কম অগ্রাধিকার রয়েছে +তবে *এর চেয়ে বেশি অগ্রাধিকার রয়েছে +যাতে আপনি তাদের একসাথে চেইন করতে পারেন!
জিউসেপ

1
@ জিউস্পেপ আপনি জানেন যে পোস্ট করার আগে আমি কী সন্ধান করার চেষ্টা করেছি এবং এটি খুঁজে পেলাম না। এটা ইশারা জন্য ধন্যবাদ। আমি আরও বেশি করে এই কৌশলটি ব্যবহার শুরু করার সাথে সাথে উদাহরণগুলির সাথে অপারেটর প্রাধান্যের উপর আরও বিশদ যুক্ত করার পরিকল্পনা করছি।
জেসি

2
এখানে একটি মজাদার বিষয়: আপনি যদি যুক্ত ?হন pasteবা অন্য কোনও ফাংশন যা দুটি যুক্তি গ্রহণ করতে পারে তবে অগ্রাধিকার আদেশের অর্থ আপনি এখনও ইনলাইন অ্যাসাইনমেন্টগুলি ব্যবহার করতে পারবেন a<-b?d<-e
জে.ডো

1
আপনার [একটি ত্রি-উপাদান এলিফ হিসাবে যুক্ত করা উচিত (এটি দুটি বাইট); আমি প্রায়শই এটির মতো বিষয়গুলির জন্য সহায়ক outer(এবং ধারাবাহিকভাবে এটি সম্পর্কে ভুলে যাই!) মনে করি, যদিও অবশ্যই আপনাকে অবশ্যই ব্যবহারের প্রয়োজন নেই তা নিশ্চিত করতে হবে [। এটি উলামের নির্বাচনের সাহায্যে অপারেটর অগ্রাধিকার পৃষ্ঠায় লিঙ্ক করাও সহায়ক ।
জিউসেপে

5

দৃশ্যগুলি যেখানে আপনি এড়াতে পারেন paste(...,collapse="")এবংstrsplit

এগুলি স্বাভাবিক স্ট্রিং চ্যালেঞ্জগুলির একটি ব্যথা। কিছু কর্মক্ষেত্র আছে।

  • Reduce(paste0,letters) থেকে -5 বাইট জন্য paste0(letters,collapse="")

  • একটি 2-বাইট গল্ফ যেখানে আপনার কাছে দুটি ভেক্টর যুক্ত একটি তালিকা রয়েছে c(1,2,3)এবং c(4,5,6)সেগুলি উপাদান অনুসারে স্ট্রিংয়ের সাথে যুক্ত করতে চান "142536"। অপারেটরের অপব্যবহার আপনাকে দেয় p=paste0;"^"=Reduce;p^p^rযা সাধারণ paste0কলে দুটি বাইট সংরক্ষণ করে ।

  • paste0("(.{",n,"})")20 বাইটের জন্য একটি রেজেক্স নির্মাণের পরিবর্তে, sub(0,"(.{0})",n)17 জন বাইটের জন্য একটি রেজেক্সে একটি রেজেক্স বিবেচনা করুন ।

কখনও কখনও (বেশিরভাগ ক্ষেত্রে, আসলে) আপনাকে অক্ষর বা স্ট্রিংয়ের কোনও ভেক্টরের মাধ্যমে পুনরাবৃত্তি করতে হবে, বা কোনও শব্দকে অক্ষরে বিভক্ত করতে হবে। দুটি সাধারণ ব্যবহারের কেস রয়েছে: একটি যেখানে আপনাকে কোনও ফাংশন বা প্রোগ্রামের ইনপুট হিসাবে অক্ষরের একটি ভেক্টর নিতে হবে এবং একটি যেখানে আপনি ভেক্টরকে আগাম জানেন এবং এটি আপনার কোডে অন্য কোথাও সংরক্ষণ করতে হবে store

ক। যেখানে আপনাকে ইনপুট হিসাবে একটি স্ট্রিং নিতে হবে এবং এটি শব্দ বা অক্ষরগুলিতে বিভক্ত করতে হবে ।

  1. আপনার যদি শব্দগুলির প্রয়োজন হয় (একটি বিশেষ কেস হিসাবে অক্ষর সহ):

    • 0x10শব্দগুলিকে আলাদা করে যদি কোনও নতুন লাইন (এএসসিআইআই 16) ঠিক থাকে তবে x=scan(,"")আপনার কোডটি মোড়ানোকে পছন্দ করা হয় function(s,x=el(strsplit(s," ")))

    • শব্দ দ্বারা পৃথক করা যেতে পারে যদি অন্য কোন হোয়াইটস্পেস একাধিক স্পেস, ট্যাব, নতুন লাইন ইত্যাদি সহ,, আপনি @ NGM এর ব্যবহার করতে পারেন ডবল কৌতুক স্ক্যান : x=scan(,"",t=scan(,""))। এটি স্ক্যানকে স্ট্রিংকে আর্গ scanহিসাবে দেয় textএবং এটি হোয়াইটস্পেস দ্বারা পৃথক করে।

    • দ্বিতীয় আর্গুমেন্টটি scanকোনও স্ট্রিং হতে পারে তাই আপনি যদি এটি তৈরি করেন তবে আপনি বাইট সংরক্ষণ করতে এটি পুনর্ব্যবহার করতে পারেন ।

  2. আপনার যদি কোনও ইনপুট স্ট্রিংকে অক্ষরের ভেক্টরে পরিণত করতে হয় :

    • x=el(strsplit(s,""))সবচেয়ে সংক্ষিপ্ত সাধারণ সমাধান। splitযুক্তি সহ পরিমাণটিকে শূন্যতে কিছু কাজ করে c(), {}ইত্যাদি তাই যদি আপনি একটি শূন্য দৈর্ঘ্য পরিবর্তনশীল তৈরি করেছেন ঘটতে, আপনি এটি ব্যবহার করতে পারে একটি বাইট সংরক্ষণ করুন।

    • আপনি যদি ASCII অক্ষর কোডগুলি নিয়ে কাজ করতে পারেন তবে বিবেচনা করুন utf8ToInt, যেহেতু কলটির utf8ToInt(x)চেয়ে কম strsplit। এগুলি আবার এক সাথে পেস্ট করা, এর intToutf8(utf8ToInt(x))চেয়ে কম Reduce(paste0,el(strsplit(x,"")))

    • আপনার যদি সংখ্যার স্বতঃস্ফূর্ত স্ট্রিংগুলি "31415926535"ইনপুট হিসাবে বিভক্ত করতে utf8ToInt(s)-48হয় el(strsplit(s,""))তবে আপনি 3 বাইট সংরক্ষণ করতে ব্যবহার করতে পারেন , তবে আপনি অক্ষরের পরিবর্তে পূর্ণসংখ্যার সংখ্যা ব্যবহার করতে পারেন, যেমনটি প্রায়শই ঘটে থাকে। সংখ্যাটি দশমিক সংখ্যাগুলিতে বিভক্ত করার জন্য এটি সাধারণ রেসিপি থেকেও ছোট।

B ইংরেজী বর্ণমালার দ্বিতীয় অক্ষর. যেখানে আপনার আগে থেকেই শব্দ বা অক্ষরগুলির একটি নির্দিষ্ট ভেক্টর প্রয়োজন ।

  • আপনার যদি একক অক্ষরগুলির একটি ভেক্টর প্রয়োজন হয় যার কিছু নিয়মিত প্যাটার্ন থাকে বা বর্ণানুক্রমিক ক্রমে থাকে তবে অক্ষর সেট বা বিল্ট ইন লেটারের মাধ্যমে বা সিকোয়েন্সে প্রয়োগ intToUtf8বা chartrপ্রয়োগ করতে দেখুন । প্যাটার্ন পাতাটা ভাষা হয় বিশেষত শক্তিশালীa:blettersLETTERSchartr

  • জন্য 1 থেকে 3 টি অক্ষর বা শব্দ , c("a","b","c")কেবলমাত্র সাধারণ সবচেয়ে কম সমাধান।

  • আপনি একটি নির্দিষ্ট ভেক্টর প্রয়োজন 4 এবং 10 এর মধ্যে অ হোয়াইটস্পেস অক্ষর বা শব্দ ব্যবহার scanসঙ্গে stdinযেমন fileARG:

f(x=scan(,""))
q
w
e
r
t
y
u
  • যদি scanথেকে stdinসম্ভব নয়, 6 অথবা তার বেশি অ হোয়াইটস্পেস অক্ষর বা শব্দ ব্যবহার scanসঙ্গে textযুক্তি scan(,"",t="a b c d e f")

  • আপনার একটি ভেক্টর প্রয়োজন (ক) কোন প্রকার 6 বা তার বেশি অক্ষরের বা (খ) 10 বা তার বেশি অ হোয়াইটস্পেস অক্ষর , strsplitমাধ্যমে x=el(strsplit("qwertyuiop",""))সম্ভবত যেতে উপায়।

  • আপনি পারে পার পেয়ে পাবে নিম্নলিখিত উদ্ধৃতি কৌতুক : quote(Q(W,E,R,T,Y)), যা অভিব্যক্তি তৈরি করে। কিছু ফাংশন পছন্দ করে strrep, এবং grepএটি স্ট্রিংয়ের ভেক্টরকে জোর করে তোলে! যদি আপনি এটি করেন তবে 3 থেকে 11 পর্যন্ত কোনও শব্দ বা চরিত্রের ভেক্টরের জন্য এটি ভাল।

  • strsplitমাধ্যমে শব্দগুলিতে ব্যবহার করার কোনও ভাল কারণ নেই x=el(strsplit("q w e r t y"," "))। এটি সর্বদা scan(,"",t="q w e r t y"))5 বাইটের একটি নির্দিষ্ট ওভারহেডের কাছে হেরে যায় ।

দৈর্ঘ্যের একক অক্ষরগুলির ভেক্টরে পড়ার জন্য প্রতিটি পদ্ধতির দ্বারা ব্যবহৃত বাইট গণনার একটি টেবিল এখানে n। প্রতিটি সারির মধ্যে আপেক্ষিক ক্রম ছাড়া, অক্ষর বা শব্দ জন্য বৈধ strsplitউপর ""যা শুধুমাত্র অক্ষর উপর কাজ করে।

| n  | c(...) | scan | scan | strsplit | quote |
|    |        |+stdin|+text | on ""    | hack  |
|    |        |      |      | CHAR ONLY|       |
|----|--------|------|------|----------|-------|
| 1  | 3      | 11   | 15   | 20       | 8     |
| 2  | 10     | 13   | 17   | 21       | 11    |
| 3  | 14     | 15   | 19   | 22       | 13    |
| 4  | 18     | 17   | 21   | 23       | 15    |
| 5  | 22     | 19   | 23   | 24       | 17    |
| 6  | 26     | 21   | 25   | 25       | 19    |
| 7  | 30     | 23   | 27   | 26       | 21    |
| 8  | 34     | 25   | 29   | 27       | 23    |
| 9  | 38     | 27   | 31   | 28       | 25    |
| 10 | 42     | 29   | 33   | 29       | 27    |
| 11 | 46     | 31   | 35   | 30       | 29    |
| 12 | 50     | 33   | 37   | 31       | 31    |

গ। আপনার যদি অক্ষর ম্যাট্রিক্স হিসাবে পাঠ্য ইনপুট করতে হয় তবে কয়েকটি রেসিপি সংক্ষিপ্ত বলে মনে হচ্ছে

s="hello\nworld\n foo"

# 43 bytes, returns "" padded data frame
# If lines > 5 are longer than lines <= 5, wraps around and causes error
read.csv(t=gsub("(?<=.)(?=.)",",",s,,T),,F)

# 54 bytes with readLines(), "" padded matrix
sapply(p<-readLines(),substring,p<-1:max(nchar(p)),p))

# plyr not available on TIO
# 58 bytes, returns NA padded matrix, all words split by whitespace
plyr::rbind.fill.matrix(Map(t,strsplit(scan(,"",t=s),"")))
# 61 bytes, returns NA padded matrix
plyr::rbind.fill.matrix(Map(t,(a=strsplit)(el(a(s,"\n")),"")))

1
scanএকটি textযুক্তি রয়েছে, যা el(strsplit(x," "))আপনার যদি কেবল স্ট্রিংগুলির প্রয়োজন হয় তার চেয়ে বেশি প্রতিযোগিতামূলক ! এটি অনলাইন চেষ্টা করুন! আপনার শেষ পরামর্শের বিরোধিতা হিসাবে read.csv
জিউসেপ

আপনি যদি কেবল অক্ষর চান তবে আপনার কলটি scan5 অক্ষর পর্যন্ত ভাল, 6 বা el(strsplit(x,""))ততোধিকের চেয়ে বেশি প্রতিযোগিতামূলক scanএটি অনলাইন চেষ্টা করুন! আমি এখনও এর জন্য ভাল ব্যবহার খুঁজে পাইনি read.csv, তবে কোনও কারণে যদি আপনার কোনও ডাটা টেবিলের প্রয়োজন হয় তবে এটি কার্যকর হতে পারে?
জে.ডো

আমি কখনই এর জন্য কোনও ব্যবহার খুঁজে পাইনি data.frameতবে সম্ভবত আমাদের একটি চ্যালেঞ্জ খুঁজে পেতে / তৈরি করতে হবে যেখানে এটি সহায়ক হবে! হতে পারে কোনও dplyrস্টাইল group_by()এবং summarize()হেরফেরের ধরণ? Idk।
জিউসেপ

এবং স্ট্রিং পড়া scan(,"")এখনও ভাল বলে মনে হচ্ছে? এটি অনলাইন চেষ্টা করুন!
জে.ডো

হ্যাঁ নিশ্চিত, যদিও আপনি যদি এনজিএম হিসাবে এখানে কোনও ইনপুট ফর্ম্যাটটি কঠোরভাবে ব্যাখ্যা করেন তবে দ্বিগুণ কার্যকর scan
জিউসেপ

4

অ্যারের প্রথম অ-শূন্য উপাদান খুঁজে পাওয়ার কয়েকটি উপায়।

যদি এর একটি নাম থাকে x:

x[!!x][1]

রিটার্নস NAযদি (যখন সহ কোন নন-জিরো উপাদান xখালি, কিন্তু না NULLযা ত্রুটি।)

বেনামে:

Find(c, c(0,0,0,1:3))

রিটার্নস NULLকোন নন-জিরো উপাদান, বা খালি থাকা অথবা NULL


NAসমস্ত উপাদান xশূন্য হলে এটি ফিরে আসবে , আমি বিশ্বাস করি, তাই সাবধানতার সাথে এটি ব্যবহার করুন!
জিউসেপ

Find(c,x)এর সাথে একই বাইকউন্ট: এই সুবিধাটি যা আপনাকে পুনরায় (সংজ্ঞায়িত) x করতে হবে না, এবং কোনও মিল না থাকলে আলাদা আচরণ behavior টিআইও
জাইসি

Findএটি যেমন কাজ করে ততটা নিরাপদও হয় NULL, যতক্ষণ না ফলাফলের আর কিছু হওয়ার দরকার নেই, সেক্ষেত্রে আমি নিশ্চিত না যে ফিরছি NAবা NULLনিরাপদ কিনা।
এনজিএম

ওহ, এটা ঠিক. NULL ফিরিয়ে দেওয়ার সমস্যাটি ত্রুটি ... সংস্করণ তুলনা প্রশ্নে আমি প্রথমে চেষ্টা করেছি sign(Find(c,w))যার কারণে ত্রুটি হয়েছিল - Find(c,sign(w))এটি ত্রুটি না হওয়ার জন্য করতে হয়েছিল। আমি মনে করি উভয় ভাবেই তাদের ব্যবহার রয়েছে।
জেসি

4

বিকল্প rep()

কখনও কখনও rep()কোলন অপারেটর :এবং আর এর ভেক্টর পুনর্ব্যবহারের মাধ্যমে এড়ানো যায় ।

  • nজিরোগুলি পুনরাবৃত্তি করার জন্য , যেখানে n>0, ব্যবহারের ক্ষেত্রে এটি অনুমতি দিলে , যেখানে 0*1:n3 বাইটের চেয়ে কম rep(0,n)এবং !1:nএকটি অ্যারে FALSE4 বাইট কম হয়।

  • x nবার পুনরাবৃত্তি করতে , x+!1:n2 বাইটের চেয়ে কম হয় rep(x,n)। জন্য nবেশী, ব্যবহার !!1:nযদি আপনি একটি অ্যারের ব্যবহার করতে পারেন TRUE

  • পুনরাবৃত্তি করার x 2n+1সময়, যেখানে n>=0, x+0*-n:n4 বাইটের চেয়ে কম হয় rep(x,2*n+1)

  • বিবৃতি পাশাপাশি উভয় পক্ষের !-n:nএকটি TRUEflanked দেবে n FALSE। এই ব্যবহার করা যেতে পারে জেনারেট করতে এমনকি কল অক্ষর সংখ্যা intToUtf8()যদি মনে রাখবেন যে একটি শূন্য উপেক্ষা করা হয়।

মডুলার গাণিতিক দরকারী হতে পারে। যুক্তির repসাথে বিবৃতিগুলি eachকখনও কখনও পূর্ণসংখ্যা বিভাগ ব্যবহার করা এড়ানো যায়।

  • ভেক্টর জেনারেট করার জন্য c(-1,-1,-1,0,0,0,1,1,1), -3:5%/%35 বাইটের চেয়ে ছোট হয় rep(-1:1,e=3)

  • ভেক্টর জেনারেট করতে c(0,1,2,0,1,2,0,1,2), 0:8%%34 টি বাইট সাশ্রয় করে rep(0:2,3)

  • কখনও কখনও অরেখান্তরীয় রূপান্তরগুলি সিক্যুঞ্জের পাটিগণিতকে সংক্ষিপ্ত করতে পারে। কোনও যৌগিক বিবরণের অভ্যন্তরে মানচিত্র i in 1:15করতে c(1,1,3,1,1,3,1,1,3,1,1,3,1,1,3), স্পষ্ট গোল্ফ উত্তরটি 1+2*(!i%%3)11 বাইটের জন্য। যাইহোক, 3/(i%%3+1)এটি 10 বাইট এবং একই অনুক্রমের তল হবে, সুতরাং অ্যারে সূচীকরণের জন্য যদি আপনার ক্রম প্রয়োজন হয় তবে এটি ব্যবহার করা যেতে পারে।


3

যখন আপনার কোনও ফাংশন ব্যবহার করার দরকার পড়ে, pryr::f()পরিবর্তে ব্যবহার করুন function()

উদাহরণ:

function(x,y){x+y}

সমতুল্য

pryr::f(x,y,x+y)

বা, আরও ভাল,

pryr::f(x+y)

যেহেতু যদি কেবল একটি যুক্তি থাকে তবে ফর্মালগুলি কোড থেকে অনুমান করা হয়


যদি আপনি এটিকে একটি যুক্তিতে না নামাতে পারেন (তৃতীয় উদাহরণের মতো), তবে এটি কোনও গল্ফ নয়, কারণ একই বাইক্যান্টের মতো function(x,y){x+y}লেখা যেতে পারে তবে আরও পাঠযোগ্যতার সাথে। function(x,y)x+ypryr::f(x,y,x+y)
খুলনায়সথ না'বাড়িয়া

3

স্ট্রিং জড়িত চ্যালেঞ্জ বাঁচা

অন্য উত্তরে উল্লিখিত হিসাবে, unlist(strsplit(x,split="")এবং paste(...,collapse="")হতাশাজনক হতে পারে। তবে কেবল এগুলি থেকে দূরে চলবেন না, রয়েছে কার্যকারিতা!

  • utf8ToIntএকটি স্ট্রিংকে একটি ভেক্টরে রূপান্তরিত intToUtf8করে, বিপরীত ক্রিয়া করে। আপনি ভেক্টর পাচ্ছেন int, ভেক্টর নন charতবে কখনও কখনও এটি আপনি খুঁজছেন। উদাহরণস্বরূপ একটি তালিকা তৈরি -করতে, এর intToUtf8(rep(45,34))চেয়ে আরও ভাল ব্যবহার করুনpaste(rep("-",34),collapse="")
  • gsubgrepএকক স্ট্রিংয়ে অপারেটিং করার সময় পরিবারের অন্যান্য ফাংশনের চেয়ে বেশি কার্যকর । উপরের দুটি পদ্ধতির এই উত্তর হিসাবে একত্রিত করা যেতে পারে যা ওভিএস , জিউসেপ এবং এনজিএমের পরামর্শ থেকে উপকৃত হয়েছিল ।
  • একটি সুবিধাজনক, I / O ফর্ম্যাট চয়ন করুন হিসাবে এই উত্তর লেখার লাইনের (উদ্ধৃতি চিহ্ন বিনা) হিসাবে ইনপুট গ্রহণ বা এই এক অক্ষর একটি ভেক্টর গ্রহণ। সন্দেহ হলে ওপি-র সাথে চেক করুন।
  • মন্তব্যে নির্দেশিত হিসাবে, <স্ট্রিকসকে অভিধানের সাথে তুলনা করুন যেমনটি প্রত্যাশা করা হয়।

intToUtf8এছাড়াও একটি দ্বিতীয় যুক্তি রয়েছে multiple = FALSEযা intসেট করা থাকলে একটি একক স্ট্রিংয়ের পরিবর্তে গুলি থেকে পৃথক বর্ণগুলিতে (দৈর্ঘ্য-এক স্ট্রিং) রূপান্তর করবে TRUE
জিউসেপ

এছাড়াও, ৩.০.০ থেকে শুরু করে তৃতীয় যুক্তি রয়েছে allow_surrogate_pairs = FALSE, তবে আমি জানি না এটি কী করে; দস্তাবেজগুলি দ্বি-বাইটগুলি পড়ার বিষয়ে কিছু বলে UTF-16তবে আমি কী জানি তা UTF-8সবেমাত্র আমি এটিকে এড়িয়ে চলেছি যতক্ষণ না অন্য কেউ এটির সাথে গল্ফ করার কোনও উপায় না খুঁজে পায়।
জিউসেপ

2

সীমাবদ্ধ উত্স চ্যালেঞ্জগুলির জন্য টিপস:

  1. আর লিটারাল ধ্রুবকের অক্ষরগুলি হেক্স কোড, অষ্টাল কোড এবং ইউনিকোড দ্বারা প্রতিস্থাপন করা যেতে পারে।

    যেমন স্ট্রিং "abcd"লেখা যেতে পারে:

        # in octal codes
        "\141\142\143\144"
    
        # in hex codes
        "\x61\x62\x63\x64"
    
        # in unicodes
         "\u61\u62\u63\u64"
        # or
        "\U61\U62\U63\U64" 

    আমরা অষ্টাল / হেক্স / ইউনিকোডের সাথে অক্ষরগুলিও মিশ্রিত করতে পারি এবং কিছু অষ্ট কোড এবং কয়েকটি হেক্স কোড একসাথে ব্যবহার করতে পারি, যতক্ষণ না ইউনিকোড অক্ষরগুলি অষ্টাল / হেক্স উদাহরণের সাথে মিশ্রিত না হয়:

        # Valid
        "a\142\x63\x64"
    
        # Valid
        "ab\u63\U64"
    
        # Error: mixing Unicode and octal/hex escapes in a string is not allowed
        "\141\142\x63\u64"

    আরও তথ্যের জন্য এই বিভাগের শেষ দেখুন ।

  2. যেহেতু ফাংশনগুলি স্ট্রিং লিটারেল ব্যবহার করে লেখা যায়, উদাহরণস্বরূপ cat()বিকল্পভাবে লেখা যায়:

    'cat'()
    "cat"()
    `cat`()

    ফাংশন নামের জন্য আমরা অষ্টাল কোড, হেক্স কোড এবং ইউনিকোড ব্যবহার করতে পারি:

    # all equal to cat()
    "\143\141\164"()
    `\x63\x61\x74`()
    '\u63\u61\u74'()
    "ca\u74"()

    একমাত্র ব্যতিক্রম ব্যতীত ইউনিকোড সিকোয়েন্সগুলি ব্যাকটিক্স inside `এর ভিতরে সমর্থিত নয়`

  3. গোলাকার বন্ধনী অপারেটরদের অপব্যবহার এড়ানো যায় যেমন:

    cat('hello')
    
    # can be written as
    `+`=cat;+'hello'

তিনটি কৌশলটির একটি উত্তর এই উত্তরটিতে পাওয়া যাবে


এছাড়াও, সংখ্যাগুলি হেক্সাডেসিমালে লেখা যেতে পারে: 0xBএবং 0xbফিরে 11(ব্যাকটিকস বা উদ্ধৃতিগুলির প্রয়োজন নেই)।
রবিন রাইডার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.