Scopri se la sottostringa sinistra su (i) quando invertita, è uguale alla sottostringa corretta per (i)?

Question

Mi è stato concesso 30 minuti per completare il seguente compito in un'intervista per un ruolo di sviluppatore C# entry level, il più vicino a cui potevo arrivare era scoprire se i caratteri su entrambi i lati dell'indice corrente corrispondevano l'un l'altro.

costruire una matrice che prende in una stringa e determina se dall'indice (i) la stringa di

fianco di (i) una volta invertito, è uguale alla stringa alla destra di (i).

esempio: "macchina da corsa"

a indice (3) la sottostringa sinistra è "rac", e quando invertito equivale a destra sottostringa "auto".

return (i) se soddisfatto di tale condizione, eslse return -1. se la lunghezza della stringa è inferiore a 3, restituisce 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; 

Answer 1

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; 
    } 

Answer 2

Se i != n/2 si dovrebbe restituire false, quindi basta verificare la presenza di 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; 

Answer 3

sono arrivato fino a questo, ma spero davvero ci si trovasse di fronte a Visual Studio quando hanno chiesto questo ...

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 
    } 
} 

Answer 4

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); 
     } 

Answer 5

provare questo

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(); 
    } 

Answer 6

Pure C, ma spero che il flusso di lavoro aiuta arrivarci. Grazie per aver condiviso questo.

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; 
} 

Answer 7

L'approccio è corretto, ma l'implementazione è sbagliata. È necessaria una variabile di loop diversa da i, poiché contiene l'indice del carattere (presumibilmente) centrale nella stringa.

Inoltre, non è possibile restituire l'indice dall'interno del ciclo, quindi si controllerà solo una coppia di caratteri. Devi scorrere la stringa, quindi controllare il risultato.

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; 
    } 
} 

Answer 8

Questa è la più breve mi viene in mente:

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; 
    } 
} 

Come funziona: http://ideone.com/2ae3j

Answer 9

Un altro approccio, banco di prova per -1 al ritorno, lo shortestz mi viene in mente:

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; 
    } 
} 

Uscita:

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 

Nota: L'ultimo è falsa, lo spazio non è ignorato dal codice