description: A binary string is a string that consists of characters 0 and 1.
  
  Let \operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.
  
  A binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring — the whole string.
  
  A string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.
  
  What is the minimal sum of \operatorname{MEX} of all substrings pieces can be?
  
  Input
  
  The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. Description of the test cases follows.
  
  Each test case contains a single binary string s (1 ≤ |s| ≤ 10^5).
  
  It's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.
  
  Output
  
  For each test case print a single integer — the minimal sum of \operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.
  
  Example
  
  Input
  
  
  6
  01
  1111
  01100
  101
  0000
  01010
  
  
  Output
  
  
  1
  0
  2
  1
  1
  2
  
  Note
  
  In the first test case the minimal sum is \operatorname{MEX}(0) + \operatorname{MEX}(1) = 1 + 0 = 1.
  
  In the second test case the minimal sum is \operatorname{MEX}(1111) = 0.
  
  In the third test case the minimal sum is \operatorname{MEX}(01100) = 2.
solution: import sys
  import math
  import heapq
  from collections import defaultdict as dd
  from collections import OrderedDict as od
  from collections import deque
  from itertools import permutations as pp
  from itertools import combinations as cc
  from sys import stdin
  from functools import cmp_to_key as ctk
  from functools import lru_cache
  from bisect import bisect_left as bs_l
  from bisect import bisect_right as bs_r
  input = sys.stdin.readline
  mod=10**9+7
  sys.setrecursionlimit(10**5)
  def comparator(x,y):
      if x[0]==y[0]:
          return y[1]-x[1]
      return True
  def ncr(n, r):
      if n < r: return 0
      return fc[n] * pow(fc[r] * fc[n - r] % mod, mod - 2, mod) % mod
  T=int(input())
  for _ in range(T):
      #n=int(input())
      s=input().strip()
      ze,on=s.count('0'),s.count('1')
      if ze==0:
          print(0)
      elif on==0:
          print(1)
      else:
          gr=0
          c=0
          for i in s:
              if i=='1':
                  if c:
                      gr+=1
                  c=0
              else:
                  c+=1
          if c:
              gr+=1
          print(min(2,gr))
  