We Keep Coding

c# split string by random length

lets say i have an string like the below:
AAAABBBBBBBBBBCCCC
Currently my code can only split the above string equally by the len that I use as parameter using the function below:
private static IEnumerable<string> SplitByLength(string str, int maxLength)
{
for (var index = 0; index < str.Length; index += maxLength)
yield return str.Substring(index, Math.Min(maxLength, str.Length - index));
}
but this isnt what i want, I want the string to be splitted to random len, lets say between 2 to 10 char. example:
AAA
ABBBBB
BB
BBBCCC
C
the split len should be random. any hints how can I make it?

Check this:
private static IEnumerable<string> SplitByLength(string str, int maxLength)
{
var random = new Random();
var count = Math.Min(random.Next(1, maxLength + 1), str.Length);
int index = 0;
while (index < str.Length)
{
yield return str.Substring(index, count);
index += count;
count = Math.Min(random.Next(1, maxLength + 1), str.Length - index);
}
}

This works.
private static List<string> SplitString(string input)
{
var result = new List<string>();
var tempString = input;
var testString = "";
while (true)
{
var maxInt = tempString.Length <= 35 ? tempString.Length : 35;
var minInt = tempString.Length <= 10 ? tempString.Length : 10;
var random1 = Random.Next(minInt, maxInt);
result.Add(tempString.Substring(0, random1));
testString += tempString.Substring(0, random1);
tempString = tempString.Remove(0, random1);
if (tempString.Length == 0)
{
break;
}
}
return result;
}

Permutations with constant prefix numbers

I have an array of integers where each value will have distinct meanings.The first value means the length of permutation, the second value represent the length of initial prefix and rest of integers are single integer that make up prefix of all permutations.
For e.g. if the array has elements {5,2,1,4}
where 5 is the number of elements in the permutation array.
and 2 is the length of the integer that will makeup the first 2 elements prefix in the array permutation. 1,4 are the prefix integers i.e. length 2 in 5 element permutation combination so missing elements are 2,3,5 where 1&4 being common prefix across all permutations as below
[14235][14253][14325][14352][14523][14532] where input array is {5,2,1,4}
How to achieve this?
I have below code to get the permutation of one missing elements 2,3 & 5 but I am not getting how to program the entire the solution
static void Main(string[] args)
{
int output;
int ip1;
ip1 = Convert.ToInt32(Console.ReadLine());
int ip2_size = 0;
ip2_size = Convert.ToInt32(Console.ReadLine());
int[] ip2 = new int[ip2_size];
int ip2_item;
for (int ip2_i = 0; ip2_i < ip2_size; ip2_i++)
{
ip2_item = Convert.ToInt32(Console.ReadLine());
ip2[ip2_i] = ip2_item;
}
output = correctResult(ip1, ip2);
Console.WriteLine(output);
}
static int correctResult(int n, int[] arr)
{
int permLength = 0;
int prefLength = 0;
int result = 0;
permLength = n;
prefLength = arr.Length;
int[] permArray = new int[permLength];
int len = 0;
var missingNum = Enumerable.Range(1,
permLength).Except(arr).ToArray<int>();
if (permLength < (missingNum.Length + len))
{
result = -1;
}
else
{
for (int i = 0; i < missingNum.Length; i++)
{
permArray[prefLength + i] = missingNum[i];
}
result = permute(missingNum, 0, missingNum.Length - 1);
}
return result;
}
static int permute(int[] arry, int i, int n)
{
int j;
if (i == n)
{
int s1, s2;
s1 = s2 = 0;
for (int a = 0; a < n - 1; a++)
{
for (int b = a + 1; b < n; b++)
{
if (arry[a] > arry[b])
{
s1++;
}
}
s2 = s2 + Math.Max(0, a + 1 - arry[a]);
}
int count = 0;
if (s1 == s2)
count++;
return count;
}
else
{
int count = 0;
for (j = i; j <= n; j++)
{
swap(ref arry[i], ref arry[j]);
count += permute(arry, i + 1, n);
swap(ref arry[i], ref arry[j]);
}
return count;
}
}
static void swap(ref int a, ref int b)
{
int tmp;
tmp = a;
a = b;
b = tmp;
}

Try solving this with immutable types, its easier to reason about them. If, after solving the problem, you have a performance goal you haven't met then you can start trying to optimize the code.
Consider the following approach with an immutable stack that keeps track of the current permutation:
static IEnumerable<IEnumerable<int>> GetPermutations(IList<int> input)
{
if (input == null)
throw new ArgumentNullException(nameof(input));
if (input.Count < 2)
throw new ArgumentException("Input does not have a valid format.");
var setSize = input[0];
var prefixSize = input[1];
if (prefixSize != input.Count - 2)
throw new ArgumentException("Input does not have a valid format.");
if (input.Skip(2).Any(i => i > setSize)) //we are assuming, per example, that valid range starts at 1.
throw new ArgumentException("Input does not have a valid format.");
//Ok, we've got a valid input, interesting stuff starts here.
var prefix = input.Skip(2).ToArray();
var initialSet = Enumerable.Range(1, setSize)
.Except(prefix)
.ToArray();
foreach (var p in getPermutations(ImmutableStack<int>.Empty, initialSet))
{
yield return prefix.Concat(p);
}
IEnumerable<IEnumerable<int>> getPermutations(ImmutableStack<int> permutation, IEnumerable<int> set)
{
if (permutation.Count == setSize - prefixSize)
{
yield return permutation;
}
else
{
foreach (var i in set)
{
foreach (var p in getPermutations(permutation.Push(i), set.Except(new[] { i })))
{
yield return p;
}
}
}
}
}
And that is it, solving your problem was about 10-12 lines of real code (not considering input validation). Note that I am using some c#7 features here, but its easily translatable to previous versions of the language. Also I'd like to underline the argument validation we are doing upfront; make sure you have a valid input before trying out anything.
For ImmutableStack<T> you can use the one in System.Collections.Immutable (you have to download the NuGet package) or implement your own, its simple:
private class ImmutableStack<T>: IEnumerable<T>
{
public static readonly ImmutableStack<T> Empty = new ImmutableStack<T>();
private readonly T head;
private readonly ImmutableStack<T> tail;
private ImmutableStack() { }
private ImmutableStack(T head, ImmutableStack<T> tail)
{
Debug.Assert(tail != null);
this.head = head;
this.tail = tail;
Count = tail.Count + 1;
}
public int Count { get; }
public T Peek() =>
this != Empty ? head : throw new InvalidOperationException("Empty stack.");
public ImmutableStack<T> Pop() =>
this != Empty ? tail : throw new InvalidOperationException("Empty stack.");
public ImmutableStack<T> Push(T item) => new ImmutableStack<T>(item, this);
public IEnumerator<T> GetEnumerator()
{
var current = this;
while (current != Empty)
{
yield return current.head;
current = current.tail;
}
}
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
If you use the collections in System.Collections.Immutable, then you'll probably want to use some kind of immutable set for initalSet and set.

You can rewrite your permute method (based on this answer):
private static IEnumerable<IEnumerable<T>> Permute<T>(List<T> prefix, List<T> suffix)
{
for (var i = 0; i < suffix.Count; ++i)
{
var newPrefix = new List<T>(prefix) {suffix[i]};
var newSuffix = new List<T>(suffix.Take(i).Concat(suffix.Skip(i + 1)));
if (newSuffix.Count == 0)
{
yield return newPrefix;
continue;
}
foreach (var permutation in Permute(newPrefix, newSuffix))
yield return permutation;
}
}
And use it like this:
public static void PrintAllPermutations()
{
var input = new[] {5, 2, 1, 4};
var prefix = input.Skip(2).Take(input[1]).ToList();
var suffx = Enumerable.Range(1, input[0]).Except(prefix).ToList();
foreach (var permutation in Permute(prefix, suffx))
Console.WriteLine(string.Join(", ", permutation));
}
Reult would be:
1, 4, 2, 3, 5
1, 4, 2, 5, 3
1, 4, 3, 2, 5
1, 4, 3, 5, 2
1, 4, 5, 2, 3
1, 4, 5, 3, 2

Find out if the left substring to (i) when reversed, is equal to the right substring to (i)?

I was given 30 minutes to complete the following task in an interview for an entry level C# developer role, the closest I could get to was to find out if the characters in both sides of the current index matched each other.
Construct an array which takes in an string and determines if at index
(i) the substring to
the left of (i) when reversed, equals to the substring to the right of
(i).
example: "racecar"
at index(3) the left substring is "rac" and when reversed equals to
the right substring "car".
return (i) if met with such condition, eslse return -1.
if string length is under 3, return 0;
if (str.Length < 3)
return -1;
for (int i = 0; i < str.Length - 1; i++)
{
if(str[i-1] == str [i+1])
return i;
}
return -1;

If i != n/2 you should return false, so just check for i==n/2:
int n = str.Length;
for (int i=0;i<=n/2;i++)
{
if (str[i] != str[n-i-1])
return -1;
}
return n/2;

I came up with this, but I really hope you were sitting in front of Visual Studio when they asked this...
using System.Linq;
class Program {
// New version: in fact, we are only looking for palindromes
// of odd length
static int FancyQuestion2(string value) {
if (value.Length % 2 == 0) {
return -1;
}
string reversed = new string(value.ToCharArray().Reverse().ToArray());
if (reversed.Equals(value, StringComparison.InvariantCultureIgnoreCase)) {
return (int)(value.Length / 2);
}
return -1;
}
static void Main(string[] args) {
int i1 = FancyQuestion2("noon"); // -1 (even length)
int i2 = FancyQuestion2("racecar"); // 3
int i3 = FancyQuestion2("WasItACatISaw"); // 6
}
}

public static int check(string str)
{
if(str.Length < 3)
return 0;
int n = str.Length;
int right = str.Length-1;
int left = 0;
while (left < right)
{
if (str[left] != str[right])
return -1;
left++;
right--;
}
return n / 2;
}

public static bool check(string s, int index)
{
if (s.Length < 3)
return false;
string left = s.Substring(0, index);
Char[] rightChars = s.Substring(index + 1).ToCharArray();
Array.Reverse(rightChars);
string right =new string (rightChars);
return left.Equals(right);
}

try this
static void Main(string[] args)
{
string theword = Console.ReadLine();
char[] arrSplit = theword.ToCharArray();
bool status = false;
for (int i = 0; i < arrSplit.Length; i++)
{
if (i < theword.Length)
{
string leftWord = theword.Substring(0, i);
char[] arrLeft = leftWord.ToCharArray();
Array.Reverse(arrLeft);
leftWord = new string(arrLeft);
string rightWord = theword.Substring(i + 1, theword.Length - (i + 1));
if (leftWord == rightWord)
{
status = true;
break;
}
}
}
Console.Write(status);
Console.ReadLine();
}

Your approach is correct, but the implementation is wrong. You need a different loop variable than i, as that contains the index of the (supposedly) center character in the string.
Also, you can't return the index from inside the loop, then you will only check one pair of character. You have to loop through the string, then check the result.
int checkPalindrome(string str, int i) {
// check that the index is at the center of the string
if (i != str.Length - i - 1) {
return -1;
}
// a variable to keep track of the state
bool cont = true;
// loop from 1 until you reach the first and last characters
for (int j = 1; cont && i - j >= 0; j++) {
// update the status
cont &= str[i - j] == str[i + j];
}
// check if the status is still true
if (cont) {
return i;
} else {
return -1;
}
}

This is the shortest I can think of:
using System;
public class Test
{
public static void Main()
{
string example = "racecar";
bool isPal = IsBothEndsPalindrome(example, 3);
Console.WriteLine(isPal);
}
static bool IsBothEndsPalindrome(string s, int i) {
while(i-- > 0) {
if(s[i] != s[s.Length - i - 1]) return false;
}
return true;
}
}
How it operates: http://ideone.com/2ae3j

Another approach, test for -1 upon return, the shortestz I can think of:
using System;
public class Test
{
public static void Main()
{
TestPal( "Michael", 3 );
TestPal( "racecar", 3 );
TestPal( "xacecar", 3 );
TestPal( "katutak", 3 );
TestPal( "able was i ere i saw elba", 7 );
TestPal( "radar", 2 );
TestPal( "radars", 2 );
// This is false, space is not ignored ;-)
TestPal( "a man a plan a canal panama", 9 );
}
static void TestPal(string s, int count) {
Console.WriteLine( "{0} : {1}", s, IsBothEndsPalindrome(s, count) );
}
static bool IsBothEndsPalindrome(string s, int count) {
while(--count >= 0 && s[count] == s[s.Length - count - 1]);
return count == -1;
}
}
Output:
Michael : False
racecar : True
xacecar : False
katutak : True
able was i ere i saw elba : True
radar : True
radars : False
a man a plan a canal panama : False
Note: The last one is False, the space is not ignored by code

Pure C, but hope the workflow helps you getting there. Thanks for sharing this.
int is_palindrome (const char str[], unsigned int index)
{
int len = strlen(str);
int result = index;
//index not valid?
if (index >= len)
return -1;
int i;
for (i = 0; ((index+i) < len && (index - i) >= 0); ++i) {
if(str[index-i] != str[index+i])
return -1;
else
continue;
}
return result;
}

Comparing strings and get the first place where they vary from eachother

I want to get the first place where 2 string vary from each other.
example:
for these two strings:
"AAAB"
"AAAAC"
I want to get the result 4.
How do i do it in C#?

.NET 4:
string a1 = "AAAB";
string a2 = "AAAAC";
int index = a1.Zip(a2, (c1, c2) => c1 == c2).TakeWhile(b => b).Count() + 1;

/// <summary>
/// Compare two strings and return the index of the first difference. Return -1 if the strings are equal.
/// </summary>
int DiffersAtIndex(string s1, string s2)
{
int index = 0;
int min = Math.Min(s1.Length, s2.Length);
while (index < min && s1[index] == s2[index])
index++;
return (index == min && s1.Length == s2.Length) ? -1 : index;
}

string str1 = "AAAB";
string str2 = "AAAAC";
// returns the first difference index if found, or -1 if there's
// no difference, or if one string is contained in the other
public static int GetFirstDiffIndex(string str1, string str2)
{
if (str1 == null || str2 == null) return -1;
int length = Math.Min(str1.Length, str2.Length);
for (int index = 0; index < length; index++)
{
if (str1[index] != str2[index])
{
return index;
}
}
return -1;
}

static void Main(string[] args)
{
Console.WriteLine("enter s1 :");
string s1 = Console.ReadLine();
Console.WriteLine("enter s2 :");
string s2 = Console.ReadLine();
Console.WriteLine("note: zero means there is *no* first dif index starting from s1 ");
Console.WriteLine("first dif index of s1 :{0}", findFirstDifIndex(s1, s2)+1);
}
private static int findFirstDifIndex(string s1, string s2)
{
for (int i = 0; i <Math.Min(s1.Length, s2.Length); i++)
if (s1[i] != s2[i])
return i;
return -1;
}

You can create an extension method to do the trick:
public static class StringExtensions {
public static int IndexOfDifferenceFrom(this string source, string compareTo)
{
for(var i = 0; i < source.Length && i < compareTo.Length; ++i) {
if (source[i] != compareTo[i]) {
return i;
}
}
return source.Length < compareTo.Length ? source.Length : compareTo.Length;
}
}
Or, for a LINQy solution:
var index = string1.Where((ch, i) => string2[i] == ch).Select((ch, i) => i).DefaultIfEmpty(-1).First();

string one = "AAAB";
string two = "AAAAC";
int found = -1;
int index = 0;
while (one != two && found == -1 && one.Length > index && two.Length > index)
{
if (one[index] != two[index]) found = index;
index++;
}

int compare( String a, String b ){
for( int i = 0; i < min( a.length, b.length ); i++ ){
if( a.getCharAt(i) != b.getCharAt(i) ){
return i;
}
}
return -1; //a contained in b, or b contained in a
}
The code above doesn't check anything like nulls, etc.

int index;
int len = Math.Min(string1.Length, string2.Length);
for (index = 0; index < len; index++)
if (string1[index] != string2[index])
break;
This would provide "3" for your example (zero-based indexing), so just increment the result by one.

Finding all positions of substring in a larger string in C#

I have a large string I need to parse, and I need to find all the instances of extract"(me,i-have lots. of]punctuation, and store the index of each to a list.
So say this piece of string was in the beginning and middle of the larger string, both of them would be found, and their indexes would be added to the List. and the List would contain 0 and the other index whatever it would be.
I've been playing around, and the string.IndexOf does almost what I'm looking for, and I've written some code - but it's not working and I've been unable to figure out exactly what is wrong:
List<int> inst = new List<int>();
int index = 0;
while (index < source.LastIndexOf("extract\"(me,i-have lots. of]punctuation", 0) + 39)
{
int src = source.IndexOf("extract\"(me,i-have lots. of]punctuation", index);
inst.Add(src);
index = src + 40;
}
inst = The list
source = The large string
Any better ideas?

Here's an example extension method for it:
public static List<int> AllIndexesOf(this string str, string value) {
if (String.IsNullOrEmpty(value))
throw new ArgumentException("the string to find may not be empty", "value");
List<int> indexes = new List<int>();
for (int index = 0;; index += value.Length) {
index = str.IndexOf(value, index);
if (index == -1)
return indexes;
indexes.Add(index);
}
}
If you put this into a static class and import the namespace with using, it appears as a method on any string, and you can just do:
List<int> indexes = "fooStringfooBar".AllIndexesOf("foo");
For more information on extension methods, http://msdn.microsoft.com/en-us/library/bb383977.aspx
Also the same using an iterator:
public static IEnumerable<int> AllIndexesOf(this string str, string value) {
if (String.IsNullOrEmpty(value))
throw new ArgumentException("the string to find may not be empty", "value");
for (int index = 0;; index += value.Length) {
index = str.IndexOf(value, index);
if (index == -1)
break;
yield return index;
}
}

Why don't you use the built in RegEx class:
public static IEnumerable<int> GetAllIndexes(this string source, string matchString)
{
matchString = Regex.Escape(matchString);
foreach (Match match in Regex.Matches(source, matchString))
{
yield return match.Index;
}
}
If you do need to reuse the expression then compile it and cache it somewhere. Change the matchString param to a Regex matchExpression in another overload for the reuse case.

using LINQ
public static IEnumerable<int> IndexOfAll(this string sourceString, string subString)
{
return Regex.Matches(sourceString, subString).Cast<Match>().Select(m => m.Index);
}

Polished version + case ignoring support:
public static int[] AllIndexesOf(string str, string substr, bool ignoreCase = false)
{
if (string.IsNullOrWhiteSpace(str) ||
string.IsNullOrWhiteSpace(substr))
{
throw new ArgumentException("String or substring is not specified.");
}
var indexes = new List<int>();
int index = 0;
while ((index = str.IndexOf(substr, index, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) != -1)
{
indexes.Add(index++);
}
return indexes.ToArray();
}

It could be done in efficient time complexity using KMP algorithm in O(N + M) where N is the length of text and M is the length of the pattern.
This is the implementation and usage:
static class StringExtensions
{
public static IEnumerable<int> AllIndicesOf(this string text, string pattern)
{
if (string.IsNullOrEmpty(pattern))
{
throw new ArgumentNullException(nameof(pattern));
}
return Kmp(text, pattern);
}
private static IEnumerable<int> Kmp(string text, string pattern)
{
int M = pattern.Length;
int N = text.Length;
int[] lps = LongestPrefixSuffix(pattern);
int i = 0, j = 0;
while (i < N)
{
if (pattern[j] == text[i])
{
j++;
i++;
}
if (j == M)
{
yield return i - j;
j = lps[j - 1];
}
else if (i < N && pattern[j] != text[i])
{
if (j != 0)
{
j = lps[j - 1];
}
else
{
i++;
}
}
}
}
private static int[] LongestPrefixSuffix(string pattern)
{
int[] lps = new int[pattern.Length];
int length = 0;
int i = 1;
while (i < pattern.Length)
{
if (pattern[i] == pattern[length])
{
length++;
lps[i] = length;
i++;
}
else
{
if (length != 0)
{
length = lps[length - 1];
}
else
{
lps[i] = length;
i++;
}
}
}
return lps;
}
and this is an example of how to use it:
static void Main(string[] args)
{
string text = "this is a test";
string pattern = "is";
foreach (var index in text.AllIndicesOf(pattern))
{
Console.WriteLine(index); // 2 5
}
}

Without Regex, using string comparison type:
string search = "123aa456AA789bb9991AACAA";
string pattern = "AA";
Enumerable.Range(0, search.Length)
.Select(index => { return new { Index = index, Length = (index + pattern.Length) > search.Length ? search.Length - index : pattern.Length }; })
.Where(searchbit => searchbit.Length == pattern.Length && pattern.Equals(search.Substring(searchbit.Index, searchbit.Length),StringComparison.OrdinalIgnoreCase))
.Select(searchbit => searchbit.Index)
This returns {3,8,19,22}. Empty pattern would match all positions.
For multiple patterns:
string search = "123aa456AA789bb9991AACAA";
string[] patterns = new string[] { "aa", "99" };
patterns.SelectMany(pattern => Enumerable.Range(0, search.Length)
.Select(index => { return new { Index = index, Length = (index + pattern.Length) > search.Length ? search.Length - index : pattern.Length }; })
.Where(searchbit => searchbit.Length == pattern.Length && pattern.Equals(search.Substring(searchbit.Index, searchbit.Length), StringComparison.OrdinalIgnoreCase))
.Select(searchbit => searchbit.Index))
This returns {3, 8, 19, 22, 15, 16}

I noticed that at least two proposed solutions don't handle overlapping search hits. I didn't check the one marked with the green checkmark. Here is one that handles overlapping search hits:
public static List<int> GetPositions(this string source, string searchString)
{
List<int> ret = new List<int>();
int len = searchString.Length;
int start = -1;
while (true)
{
start = source.IndexOf(searchString, start +1);
if (start == -1)
{
break;
}
else
{
ret.Add(start);
}
}
return ret;
}

public List<int> GetPositions(string source, string searchString)
{
List<int> ret = new List<int>();
int len = searchString.Length;
int start = -len;
while (true)
{
start = source.IndexOf(searchString, start + len);
if (start == -1)
{
break;
}
else
{
ret.Add(start);
}
}
return ret;
}
Call it like this:
List<int> list = GetPositions("bob is a chowder head bob bob sldfjl", "bob");
// list will contain 0, 22, 26

Hi nice answer by #Matti Virkkunen
public static List<int> AllIndexesOf(this string str, string value) {
if (String.IsNullOrEmpty(value))
throw new ArgumentException("the string to find may not be empty", "value");
List<int> indexes = new List<int>();
for (int index = 0;; index += value.Length) {
index = str.IndexOf(value, index);
if (index == -1)
return indexes;
indexes.Add(index);
index--;
}
}
But this covers tests cases like AOOAOOA
where substring
are AOOA and AOOA
Output 0 and 3

#csam is correct in theory, although his code will not complie and can be refractored to
public static IEnumerable<int> IndexOfAll(this string sourceString, string matchString)
{
matchString = Regex.Escape(matchString);
return from Match match in Regex.Matches(sourceString, matchString) select match.Index;
}

public static Dictionary<string, IEnumerable<int>> GetWordsPositions(this string input, string[] Susbtrings)
{
Dictionary<string, IEnumerable<int>> WordsPositions = new Dictionary<string, IEnumerable<int>>();
IEnumerable<int> IndexOfAll = null;
foreach (string st in Susbtrings)
{
IndexOfAll = Regex.Matches(input, st).Cast<Match>().Select(m => m.Index);
WordsPositions.Add(st, IndexOfAll);
}
return WordsPositions;
}

Based on the code I've used for finding multiple instances of a string within a larger string, your code would look like:
List<int> inst = new List<int>();
int index = 0;
while (index >=0)
{
index = source.IndexOf("extract\"(me,i-have lots. of]punctuation", index);
inst.Add(index);
index++;
}

I found this example and incorporated it into a function:
public static int solution1(int A, int B)
{
// Check if A and B are in [0...999,999,999]
if ( (A >= 0 && A <= 999999999) && (B >= 0 && B <= 999999999))
{
if (A == 0 && B == 0)
{
return 0;
}
// Make sure A < B
if (A < B)
{
// Convert A and B to strings
string a = A.ToString();
string b = B.ToString();
int index = 0;
// See if A is a substring of B
if (b.Contains(a))
{
// Find index where A is
if (b.IndexOf(a) != -1)
{
while ((index = b.IndexOf(a, index)) != -1)
{
Console.WriteLine(A + " found at position " + index);
index++;
}
Console.ReadLine();
return b.IndexOf(a);
}
else
return -1;
}
else
{
Console.WriteLine(A + " is not in " + B + ".");
Console.ReadLine();
return -1;
}
}
else
{
Console.WriteLine(A + " must be less than " + B + ".");
// Console.ReadLine();
return -1;
}
}
else
{
Console.WriteLine("A or B is out of range.");
//Console.ReadLine();
return -1;
}
}
static void Main(string[] args)
{
int A = 53, B = 1953786;
int C = 78, D = 195378678;
int E = 57, F = 153786;
solution1(A, B);
solution1(C, D);
solution1(E, F);
Console.WriteLine();
}
Returns:
53 found at position 2
78 found at position 4
78 found at position 7
57 is not in 153786

How is this alternative implementation?
public static class MyExtensions
{
public static int HowMany(this string str, char needle)
{
int counter = 0;
int nextIndex = 0;
for (; nextIndex != -1; )
{
nextIndex = str.IndexOf(needle, nextIndex);
if (nextIndex != -1)
{
counter++;
//step over to the next char
nextIndex++;
}
}
return counter;
}
}

you can use linq to select and enumerate all elements, then find by any string:
I've created a class:
class Pontos
{
//index on string
public int Pos { get; set; }
//caractere
public string Caractere { get; set; }
}
And use like this:
int count = 0;
var pontos = texto.Select(y => new Pontos { Pos = count++, Caractere = y.ToString() }).Where(x=>x.Caractere == ".").ToList();
then:
input string:
output list:
PS: SeForNumero is another field of my class, I need this for my own purposes, but is not necessary to this use.