comme Fredrik a déjà posté le code à l'aide de la conversion de chaîne. Voici une autre façon dont il pourrait être fait en utilisant c #.

Jwoolard me battre à cela, btw. J'ai aussi utilisé le même algorithme que lui. C'était l'un des problèmes que nous avons dû résoudre en utilisant C ++, au collège. xxx

public class SubArrayMatch
{
    private bool _IsMatch;
    private int _ReturnIndex = -1;
    private List<byte> _Input;
    private List<byte> _SubArray;
    private bool _Terminate = false;
#region "Public Properties"
    public List<byte> Input {
        set { _Input = value; }
    }

    public List<byte> SubArray {
        set { _SubArray = value; }
    }

    public bool IsMatch {
        get { return _IsMatch; }
    }

    public int ReturnIndex {
        get { return _ReturnIndex; }
    }
#endregion
#region "Constructor"
    public SubArrayMatch(List<byte> parmInput, List<byte> parmSubArray)
    {
        this.Input = parmInput;
        this.SubArray = parmSubArray;
    }
#endregion
#region "Main Method"
    public void MatchSubArry()
    {
        int _MaxIndex;
        int _Index = -1;
        _MaxIndex = _Input.Count - 1;

        _IsMatch = false;

        foreach (byte itm in _Input) {
            _Index += 1;

            if (_Terminate == false) {
                if (SubMatch(_Index, _MaxIndex) == true) {
                    _ReturnIndex = _Index;
                    _IsMatch = true;
                    return;
                }
            }
            else {
                return;
            }
        }
    }

    private bool SubMatch(int BaseIndex, int MaxIndex)
    {
        int _MaxSubIndex;
        byte _cmpByte;
        int _itr = -1;

        _MaxSubIndex = _SubArray.Count - 1;
        _MaxSubIndex += 1;

        if (_MaxSubIndex > MaxIndex) {
            _Terminate = true;
            return false;
        }

        foreach (byte itm in _SubArray) {
            _itr += 1;

            _cmpByte = _Input(BaseIndex + _itr);

            if (!itm == _cmpByte) {
                return false;
            }
        }

        return true;
    }
#endregion

}
By Anhar Hussain Miah 
'Edited by: Anhar.Miah @: 03/07/2009

PostScript, Strong> 149 Strike> 146 Strike> 170 Strike> 166 Strike> 167 grève> 159 caractères strong> (dans la partie "Faire le travail"): xxx pré>

Notez que cela trouvera la dernier em> l'occurrence de la sous-carraille Si elle est contenue plus d'une fois. p>

Historique de révision: strong> p>

• remplacer false code> par [[nom code> et true code> par [[EQ code> Pour enregistrer trois caractères li >
• Supprimé un bug pouvant causer un faux négatif si le dernier élément de s code> apparaît deux fois dans A code>. Malheureusement, ce bugfix a 24 caractères. Li>
• a fait le bugfix un peu moins cher, économisant quatre caractères li>
• a dû insérer un espace à nouveau parce qu'un tableau de bord est un caractère légal d'un nom. Cette erreur de syntaxe n'a pas été attrapée car l'étui à essai n'a pas atteint ce point. Li>
• a cessé de retourner les bools lorsque l'OP ne les oblige plus. Sauve 8 caractères. Li> ul>

  Version expliquée: strong> p>

  Malheureusement, le Syntaxe Highlighter ne connaît pas la potscript, une lisibilité est toujours limitée. P>

  /A [63 101 245 215 0] def
  /S [245 215 ] def
  
  /Slast S length 1 sub def % save the index of the last element of S,
                            % i.e. length-1
  /Spos Slast def % our current position in S; this will vary
  [ % put a mark on the bottom of the stack, we need this later.
  
  /check % This function recursively removes values from the stack
         % and compares them to the values in S
  {
    dup [ 
    eq
    { % we found the mark on the bottom, i.e. we have no match
      pop -1 % remove the mark and push the results
    }
    { % we're not at the mark yet
      dup % save the top value (part of the bugfix)
      S Spos get
      eq 
      {  % the top element of the stack is equal to S[Spos]
         pop % remove the saved value, we don't need it
         Spos 0
         eq 
         { % we are at the beginning of S, so the whole thing matched.
           ] length % Construct an array from the remaining values
                    % on the stack. This is the part of A before the match,
                    % so its length is equal to the position of the match.
                    % Hence we push the result and we're done.
         }
         { % we're not at the beginning of S yet, so we have to keep comparing
           /Spos Spos 1 sub def % decrease Spos
           check % recurse
         }
         ifelse
      }
      { % the top element of the stack is different from S[Spos]
        Spos Slast eq {pop} if % leave the saved top value on the stack
                               % unless we're at the end of S, because in
                               % this case, we have to compare it to the
                               % last element of S (rest of the bugfix)
        /Spos Slast def % go back to the end of S
        check % recurse
      }
      ifelse
   }
   ifelse
  }
  def % end of the definition of check
  
  A aload % put the contents of A onto the stack; this will also push A again,
          % so we have to ...
  pop % ...remove it again
  check % And here we go!
  

C #:

public static object[] isSubArray(byte[] arr1, byte[] arr2) {
  int o = arr1.TakeWhile((x, i) => !arr1.Skip(i).Take(arr2.Length).SequenceEqual(arr2)).Count();
  return new object[] { o < arr1.Length, (o < arr1.Length) ? o : -1 };
}

Lisp commun:

(defun golf-code (master-seq sub-seq)
  (search sub-seq master-seq))

dans Ruby:

def subset_match(array_one, array_two)
  answer = [false, -1]
  0.upto(array_one.length - 1) do |line|
    right_hand = []
    line.upto(line + array_two.length - 1) do |inner|
      right_hand << array_one[inner]
    end
    if right_hand == array_two then answer = [true, line] end
  end
  return answer
end

c #, fonctionne avec n'importe quel type d'exploitation d'égalité: xxx

(defun golf-code (master-seq sub-seq)
  (let ((x (search sub-seq master-seq)))
    (values (not (null x)) (or x -1))))

c # strong>

pour les listes: p> xxx pré>

pour les tableaux: p>

public static int IndexOf<T>( T[] arr1, T[] arr2 )
{
    return !arr2.Except( arr1 ).Any() ? Array.IndexOf( arr1, arr2[0] ) : -1;
}

haskell (114 caractères): xxx

j

37 caractères pour encore plus de fonctionnalités que reques: il renvoie une liste de Tous les indices correspondants . xxx

utilisation: xxx

---

xxx < / h1>