EDIT - Revised the title of my post to make it more relevant to the problem.
I have folders that may or may not contain subfolders that start with "REV". If there are subfolders that start with "REV" they are followed by an integer value padded with leading zeros. (ie: REV010 or REV003).
My goal here is to:
find the test folder (C:\temp\TEST\REV003)
Read the string name of the folder and parse its integer value
Add the integer to a list of integers. Find the max integer value
Increment the max integer value
Create a new string folder name starting with "REV" and padded with new int value
When I debug the code (below), it cannot seem to find the REV003 folder (The folder definitely exists in the path).
Is something wrong with my LINQ statement in finding the folder?
Also, if there is an easier procedure to achieve the same thing - I'm definitely open for it! Thanks!
int nextRev = 0;
List<int> listOfRevs = new List<int>();
IEnumerable<string> revFolders = Directory.GetDirectories(destDirName, "*REV*", SearchOption.AllDirectories).Where(f => f.StartsWith("REV"));
foreach (var rev in revFolders)
{
Console.WriteLine(int.Parse(rev.Replace("REV", "")));
listOfRevs.Add(int.Parse(rev.Replace("REV", "")));
}
if (listOfRevs.Count > 0)
{
nextRev = listOfRevs.Max();
Console.WriteLine(nextRev);
nextRev++;
}
revFolder = "REV" + nextRev.ToString("000");
Console.WriteLine("New Folder: " + revFolder);
** UPDATE **
Thanks to NetMage the problem was fixed, however I still had a few bugs. Here's the working code:
string revf = "";
int nextRev = 0;
List<int> listOfRevs = new List<int>();
IEnumerable<string> revFolders = Directory.GetDirectories(destDirName, "REV*", SearchOption.AllDirectories);
foreach (var rev in revFolders)
{
if (rev.Contains("REV"))
{
revf = rev.Split('\\').Last();
listOfRevs.Add(int.Parse(revf.Replace("REV", "")));
}
}
if (listOfRevs.Count > 0)
{
nextRev = listOfRevs.Max();
nextRev++;
}
revFolder = "REV" + nextRev.ToString("000");
Change your directory search to
IEnumerable<string> revFolders = Directory.GetDirectories(destDirName, "REV*", SearchOption.AllDirectories);
Based on the results from this, you will to change the maximum finding code - I would use LINQ:
var maxREV = Directory.GetDirectories(destDirName, $"REV*", SearchOption.AllDirectories)
.Select(d => Int32.TryParse(Path.GetFileName(d).Substring(3), out int num) ? num : (int?)null)
.Where(n => n.HasValue)
.Select(n => n.Value)
.Max();
var revFolder = "REV" + (maxREV+1).ToString("000");
Console.WriteLine("New Folder: " + revFolder);
I put in some error handling to skip files that don't have an integer after "REV".
Related
I have a text file that contains 50 student names and scores for each student in the format.
foreName.Surname:Mark
I have figured out how to split up each line into a forename, surname and mark using this code.
string[] Lines = File.ReadAllLines(#"StudentExamMarks.txt");
int i = 0;
var items = from line in Lines
where i++ != 0
let words = line.Split(' ', '.', ':')
select new
{
foreName = words[0],
Surname = words[1],
Mark = words[2]
};
I am unsure of how i would incorporate a findMax algorithm into to find the highest mark and display the pupil with the highest mark. this as i have not used text files that often.
You can use any sorting algorithm there is a Pseudo Code available to find maximum number in any list or array..
Try this code, required just parse all files.
string[] lines = File.ReadAllLines(#"StudentExamMarks.txt");
string maxForeName = null;
string maxSurName = null;
var maxMark = 0;
for (int i = 0; i < lines.Length; i++)
{
var tmp = lines[i].Split(new char[] { ' ', '.', ':' }, StringSplitOptions.RemoveEmptyEntries);
if (tmp.Length == 3)
{
int value = int.Parse(tmp[2]);
if (i == 0 || value > maxMark)
{
maxMark = value;
maxForeName = tmp[0];
maxSurName = tmp[1];
}
}
}
I search and users from active directory. My code is below:
List<DirectoryEntry> dirEntries = ActiveDirectoryActions.getListByQuery("(&(objectClass=user)(displayName~=*" + q + "*))");
for (int i = 0; i < dirEntries.Count; i++)
{
SiteSearchResult r = new SiteSearchResult();
r.title = dirEntries[i].Properties["displayName"].Value.ToString();
r.url = "/" + lang + "/directory/user/" + dirEntries[i].Properties["sAMAccountName"].Value.ToString();
r.content = dirEntries[i].Properties["title"].Value.ToString();
result.Add(r);
}
And it is getListByQuery() function
public static List<DirectoryEntry> getListByQuery(string q)
{
DirectorySearcher drSearch = new DirectorySearcher(rootEntry);
drSearch.Filter = "(distinguishedName=" + Config.xml().Root.Elements("active_directory").Elements("root_ou").Select(x => x.Value).FirstOrDefault().ToString() + ")";
DirectoryEntry searchRoot = drSearch.FindAll()[0].GetDirectoryEntry();
drSearch.SearchRoot = searchRoot;
drSearch.Filter = q;
List<DirectoryEntry> r = new List<DirectoryEntry>();
SearchResultCollection sr = drSearch.FindAll();
for (int i = 0; i < sr.Count; i++)
{
r.Add(sr[i].GetDirectoryEntry());
}
return r;
}
Everthing is ok on my local server. But gives error on global server when I search integer value. And that is interesting when the value less than 1000 (<1000) .
[NullReferenceException: Object reference not set to an instance of an
object.] Myproject.Controllers.SearchController.Index(String
lang, String q) in
D:\dotNET\Myproject\Myproject\Controllers\SearchController.cs:60
Help please.
I think there are few issues you need to check
1) Does it make sense to call DirectoryEntry.FindAll() two times? Instead of using DirectorySearcher(rootEntry) you could try to set
string ldapPath = "LDAP://" + Config.xml().Root.Elements("active_directory").Elements("root_ou").Select(x => x.Value).FirstOrDefault().ToString();
DirectoryEntry de = new DirectoryEntry(ldapPath);
DirectorySearcher desearch = new DirectorySearcher(de);
deSearch.Filter = ...
2) Approximate search ~= might be not compatible with a substring search (=*substring*), e.g. for me it does not work. So try to change to =*1000* (without ~)
3) FindAll() in both cases could return null, so you should check for null in both cases.
4) [MSDN]
Due to implementation restrictions, the SearchResultCollection class
cannot release all of its unmanaged resources when it is garbage
collected. To prevent a memory leak, you must call the Dispose method
when the SearchResultCollection object is no longer needed.
So you either need to call sr.Dispose or use a using Statement.
This question already has answers here:
Given a filesystem path, is there a shorter way to extract the filename without its extension?
(10 answers)
Closed 2 years ago.
How can I split the path to get the file name 1_Lighthouse_20140306143834816.jpg? And split the 1_Lighthouse_20140306143834816.jpg to get the 1 as for my reference that number 1 is already exist.
Use Path.GetFileName
if(countUser.Length > 0)
{
var file = Path.GetFileName(countUser[0]);
....
and then get the first character from the resulting string using the string indexer
char firstChar = file[0];
if(firstChar == '1')
.....
}
Use Path.GetFileName or Path.GetFileNameWithoutExtension to get the file name.
And string.Split to get the first part of the file name.
string filePath = "E:\\folder\1_Lighthouse_XXX.jpg";
var s = Path.GetFileNameWithoutExtension(filePath); //returns without the .jpg
var parts = s.Split(new[] { '_' });
var indexer = Convert.ToInt32(parts[0]);
for (int i = 0; i < files.Count; i++)
{
//string path = AppDomain.CurrentDomain.BaseDirectory + "Uploads/";
//string filename = Path.GetFileName(Request.Files[i].FileName);
HttpPostedFileBase file = files[i];
//string fname;
// Checking for Internet Explorer
if (Request.Browser.Browser.ToUpper() == "IE" || Request.Browser.Browser.ToUpper() == "INTERNETEXPLORER")
{
string[] testfiles = file.FileName.Split(new char[] { '\\' });
fname = testfiles[testfiles.Length - 1];
}
else
{
fname = file.FileName;
}
}
I have about 2200 different files in a few different folders, and I need to rename about about 1/3 of them which are in their own subfolder. Those 700 are also in various folders as well.
For example, there might be
The top-most folder is Employees, which has a few files in it, then the folder 2002 has a few, 2003 has more files, 2004 etc.
I just need to attach the word "Agreement" before the existing name of each file. So instead of it just being "Joe Schmoe.doc" It would be "Agreement Joe Schmoe.doc" instead.
I've tried googling such scripts, and I can find stuff similar to what I want but it all looks completely foreign to me so I can't understand how I'd modify it to suit my needs.
Oh, and this is for windows server '03.
I need about 2 minutes to write such script for *NIX systems (may be less), but for Windows it is a long song ... ))
I've write simple VBS script for WSH, try it (save to {script-name}.vbs, change Path value (on the first line of the script) and execute). I recommend to test script on small amount of data for the first time just to be sure if it works correctly.
Path = "C:\Users\rootDirectory"
Set FSO = CreateObject("Scripting.FileSystemObject")
Sub visitFolder(folderVar)
For Each fileToRename In folderVar.Files
fileToRename.Name = "Agreement " & fileToRename.Name
Next
For Each folderToVisit In folderVar.SubFolders
visitFolder(folderToVisit)
Next
End Sub
If FSO.FolderExists(Path) Then
visitFolder(FSO.getFolder(Path))
End If
I used to do bulk renaming with batch scripts under Windows. I know it's a snap on *nix (find . -maxdepth N -type f -name "$pattern" | sed -e 'p' -e "s/$str1/$str2/g" | xargs -n2 mv). Buf after some struggle in vain, I found out, to achieve that effect using batch scripts is almost impossible. So I turned to javascript.
With this script, you can add prefix to file names by 'rename.js "s/^/Agreement /" -r *.doc'. A caret(^) means to match the beginning. The '-r' options means 'recursively', i.e. including sub-folders. You can specify a max depth with the '-d N' option. If neither '-r' or '-d N' is given, the script does not recurse.
If you know the *nix 'find' utility, you would notice that 'find' will match the full path (not just the file name part) to specified regular expression. This behavior can be achieved by supplying the '-f' option. By default, this script will match the file name part with the given regular expression.
If you are familiar with regular expressions, complicated renaming is possible. For example, 'rename.js "s/(\d+)/[$1]/" *' which uses grouping to add brackets to number sequences in filenames.
// rename.js --- bulk file renaming utility (like *nix rename.pl)
// (c) Copyright 2012, Ji Han (hanji <at> outlook <dot> com)
// you are free to distribute it under the BSD license.
// oops... jscript doesn't have array.map
Array.prototype.map = function(f, t){
var o = Object(this);
var a = new Array(o.length >>> 0);
for (var i = 0; i < a.length; ++i){ if (i in o) a[i] = f.call(t, o[i], i, o) }
return a;
};
/// main
(function(){
if (WScript.Arguments.Length == 0){
WScript.Echo('rename "<operator>/<pattern>/<string>/[<modifiers>]" [-f] [-r] [-d <maxdepth>] [<files>]');
WScript.Quit(1);
}
var fso = new ActiveXObject('Scripting.FileSystemObject');
// folder is a Folder object [e.g. from fso.GetFolder()]
// fn is a function which operates on File/Folder object
var recurseFolder = function(folder, fn, depth, maxdepth){
if (folder.Files){
for (var e = new Enumerator(folder.Files); !e.atEnd(); e.moveNext()){
fn(e.item())
}
}
if (folder.Subfolders){
for (var e = new Enumerator(folder.SubFolders); !e.atEnd(); e.moveNext()){
fn(e.item());
if (depth < maxdepth){ arguments.callee(e.item(), fn, depth + 1, maxdepth) }
}
}
}
// expand wildcards (asterisk [*] and question mark [?]) recursively
// given path may be relative, and may contain environment variables.
// but wildcards only work for the filename part of a path.
// return an array of full paths of matched files.
// {{{
var expandWildcardsRecursively = function(n, md){
var pattern = fso.GetFileName(n);
// escape regex metacharacters (except \, /, * and ?)
// \ and / wouldn't appear in filename
// * and ? are treated as wildcards
pattern = pattern.replace(/([\[\](){}^$.+|-])/g, '\\$1');
pattern = pattern.replace(/\*/g, '.*'); // * matches zero or more characters
pattern = pattern.replace(/\?/g, '.'); // ? matches one character
pattern = pattern.replace(/^(.*)$/, '\^$1\$'); // matches the whole filename
var re = new RegExp(pattern, 'i'); // case insensitive
var folder = fso.GetFolder(fso.GetParentFolderName(fso.GetAbsolutePathName(n)));
var l = [];
recurseFolder(folder, function(i){ if (i.Name.match(re)) l.push(i.Path) }, 0, md);
return l;
}
// }}}
// parse "<operator>/<pattern>/<string>/[<modifiers>]"
// return an array splitted at unescaped forward slashes
// {{{
var parseExpr = function(s){
// javascript regex doesn't have lookbehind...
// reverse the string and lookahead to parse unescaped forward slashes.
var z = s.split('').reverse().join('');
// match unescaped forward slashes and get their positions.
var re = /\/(\\\\)*(?!\\)/g;
var l = [];
while (m = re.exec(z)){ l.push(m.index) }
// split s at unescaped forward slashes.
var b = [0].concat(l.map(function(x){ return s.length - x }).reverse());
var e = (l.map(function(x){ return s.length - x - 1 }).reverse()).concat([s.length]);
return b.map(function(_, i){ return s.substring(b[i], e[i]) });
}
// }}}
var expr = WScript.Arguments(0);
var args = [];
var options = {};
for (var i = 1; i < WScript.Arguments.Length; ++i){
if (WScript.Arguments(i).substring(0, 1) != '-'){
args.push(WScript.Arguments(i));
} else if (WScript.Arguments(i) == '-f'){
options['fullpath'] = true;
} else if (WScript.Arguments(i) == '-r'){
options['recursive'] = true;
} else if (WScript.Arguments(i) == '-d'){
options['maxdepth'] = WScript.Arguments(++i);
} else if (WScript.Arguments(i) == '--'){
continue;
} else {
WScript.Echo('invalid option \'' + WScript.Arguments(i) +'\'');
WScript.Quit(1);
}
}
if (options['maxdepth']){
var md = options['maxdepth'];
} else if (options['recursive']){
var md = 1<<31>>>0;
} else {
var md = 0;
}
var tokens = parseExpr(expr);
if (tokens.length != 4){
WScript.Echo('error parsing expression \'' + expr + '\'.');
WScript.Quit(1);
}
if (tokens[0] != 's'){
WScript.Echo('<operator> must be s.');
WScript.Quit(1);
}
var pattern = tokens[1];
var substr = tokens[2];
var modifiers = tokens[3];
var re = new RegExp(pattern, modifiers);
for (var i = 0; i < args.length; ++i){
var l = expandWildcardsRecursively(args[i], md);
for (var j = 0; j < l.length; ++j){
var original = l[j];
if (options['fullpath']){
var nouveau = original.replace(re, substr);
} else {
var nouveau = fso.GetParentFolderName(original) + '\\' + fso.GetFileName(original).replace(re, substr);
}
if (nouveau != original){
(fso.FileExists(original) && fso.GetFile(original) || fso.GetFolder(original)).Move(nouveau)
}
}
}
})();
i would like to explain my problem by the following example.
assume the word: abc
a has variants: ä, à
b has no variants.
c has variants: ç
so the possible words are:
abc
äbc
àbc
abç
äbç
àbç
now i am looking for the algorithm that prints all word variantions for abritray words with arbitray lettervariants.
I would recommend you to solve this recursively. Here's some Java code for you to get started:
static Map<Character, char[]> variants = new HashMap<Character, char[]>() {{
put('a', new char[] {'ä', 'à'});
put('b', new char[] { });
put('c', new char[] { 'ç' });
}};
public static Set<String> variation(String str) {
Set<String> result = new HashSet<String>();
if (str.isEmpty()) {
result.add("");
return result;
}
char c = str.charAt(0);
for (String tailVariant : variation(str.substring(1))) {
result.add(c + tailVariant);
for (char variant : variants.get(c))
result.add(variant + tailVariant);
}
return result;
}
Test:
public static void main(String[] args) {
for (String str : variation("abc"))
System.out.println(str);
}
Output:
abc
àbç
äbc
àbc
äbç
abç
A quickly hacked solution in Python:
def word_variants(variants):
print_variants("", 1, variants);
def print_variants(word, i, variants):
if i > len(variants):
print word
else:
for variant in variants[i]:
print_variants(word + variant, i + 1, variants)
variants = dict()
variants[1] = ['a0', 'a1', 'a2']
variants[2] = ['b0']
variants[3] = ['c0', 'c1']
word_variants(variants)
Common part:
string[] letterEquiv = { "aäà", "b", "cç", "d", "eèé" };
// Here we make a dictionary where the key is the "base" letter and the value is an array of alternatives
var lookup = letterEquiv
.Select(p => p.ToCharArray())
.SelectMany(p => p, (p, q) => new { key = q, values = p }).ToDictionary(p => p.key, p => p.values);
A recursive variation written in C#.
List<string> resultsRecursive = new List<string>();
// I'm using an anonymous method that "closes" around resultsRecursive and lookup. You could make it a standard method that accepts as a parameter the two.
// Recursive anonymous methods must be declared in this way in C#. Nothing to see.
Action<string, int, char[]> recursive = null;
recursive = (str, ix, str2) =>
{
// In the first loop str2 is null, so we create the place where the string will be built.
if (str2 == null)
{
str2 = new char[str.Length];
}
// The possible variations for the current character
var equivs = lookup[str[ix]];
// For each variation
foreach (var eq in equivs)
{
// We save the current variation for the current character
str2[ix] = eq;
// If we haven't reached the end of the string
if (ix < str.Length - 1)
{
// We recurse, increasing the index
recursive(str, ix + 1, str2);
}
else
{
// We save the string
resultsRecursive.Add(new string(str2));
}
}
};
// We launch our function
recursive("abcdeabcde", 0, null);
// The results are in resultsRecursive
A non-recursive version
List<string> resultsNonRecursive = new List<string>();
// I'm using an anonymous method that "closes" around resultsNonRecursive and lookup. You could make it a standard method that accepts as a parameter the two.
Action<string> nonRecursive = (str) =>
{
// We will have two arrays, of the same length of the string. One will contain
// the possible variations for that letter, the other will contain the "current"
// "chosen" variation of that letter
char[][] equivs = new char[str.Length][];
int[] ixes = new int[str.Length];
for (int i = 0; i < ixes.Length; i++)
{
// We start with index -1 so that the first increase will bring it to 0
equivs[i] = lookup[str[i]];
ixes[i] = -1;
}
// The current "workin" index of the original string
int ix = 0;
// The place where the string will be built.
char[] str2 = new char[str.Length];
// The loop will break when we will have to increment the letter with index -1
while (ix >= 0)
{
// We select the next possible variation for the current character
ixes[ix]++;
// If we have exausted the possible variations of the current character
if (ixes[ix] == equivs[ix].Length)
{
// Reset the current character to -1
ixes[ix] = -1;
// And loop back to the previous character
ix--;
continue;
}
// We save the current variation for the current character
str2[ix] = equivs[ix][ixes[ix]];
// If we are setting the last character of the string, then the string
// is complete
if (ix == str.Length - 1)
{
// And we save it
resultsNonRecursive.Add(new string(str2));
}
else
{
// Otherwise we have to do everything for the next character
ix++;
}
}
};
// We launch our function
nonRecursive("abcdeabcde");
// The results are in resultsNonRecursive
Both heavily commented.