```if:python
Create a function `args_count`, that returns the count of passed arguments
```
```if:kotlin
Create a function `argsCount`, that returns the count of passed arguments
```
```if:ruby
Create a method `args_count`, that returns the count of passed arguments
```
```if:julia
Create a method `argscount`, that returns the count of passed arguments
```
```python
args_count(1, 2, 3) -> 3
args_count(1, 2, 3, 10) -> 4
```

Difficulty: introductory

Starter code:

def args_count(*args, **kwargs):
	

Solutions:
def args_count(*args, **kwargs):
    return len(args) + len(kwargs)

args_count=lambda*a,**b:len(a)+len(b)

# Create a function args_count, that returns count of passed argument
def args_count(*args, **kwargs):
    return len(args) + len(kwargs)


def args_count(*arg, **kwarg):
    return len(arg) + len(kwarg)

def args_count(*args, **kwargs):
    args_counter = 0
    for _ in args:
        args_counter += 1
    for _ in kwargs:
        args_counter += 1
    return args_counter

# Create a function args_count, that returns count of passed arguments
def args_count(*unnamed, **named):
    return len(unnamed) + len(named)

# Create a function args_count, that returns count of passed arguments
# create the function and put indefinate args and kargs as perameters
def args_count(*a, **b):
# using the len() return the number of args function and add to the number of kargs
    return len(a) + len(b)


def args_count(*args, **kwargs):
    return len(kwargs) + len(args)

# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kargs):
    return len(args) + len (kargs)

args_count=lambda*Q,**S:len(Q)+len(S)

args_count = lambda *a, **k: len(a) + len(k)

def args_count(*args, **kwargs):
    result = 0
    result = result + len(args) + len(kwargs)
    return result

def args_count(*arg, **kwargs):
    print(arg, kwargs)
    return len(arg) + len(kwargs)

def args_count(*args, **kwargs):
    return len(args) if not kwargs else len(args)+len(kwargs)

# Create a function args_count, that returns count of passed arguments


def args_count(*argv,**kwargs):
    return len(argv) + len(list(kwargs.items()))



def args_count(*args,**kwargs):
    
    l = len(args)+len(kwargs)     
    
    return l


def args_count(*n,**x):
    return len(n)+len(x.keys())

# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    counter = 0
    for arg in args:
        counter += 1
    if kwargs:
        for kwarg in kwargs:
            counter += 1
    return counter

args_count = lambda *r,**kw: len(r)+len(kw)

def args_count(*args, **kwargs):
    return sum([1 for i in args]) + sum([1 for i in kwargs])

# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    ctr = 0
    for x in args:
        ctr += 1
    for y in kwargs:
        ctr += 1
    return ctr

# Create a function args_count, that returns count of passed arguments
def args_count(*x, **k):
    return len(x) + len(k)


def args_count(*args, **kwargs):
    args_lst = [arg for arg in args]
    kwargs_lst = [kwarg for kwarg in kwargs]
    
    return len(args_lst) + len(kwargs_lst)

def args_count(*args,**kwargs):
    return len([x for x in args])+len([x for x in kwargs]) 

# Create a function args_count, that returns count of passed arguments
def args_count(*args,**kwargs):
    e=0
    for i in args:
        e+=1
    for i in kwargs:
        e+=1
    return e


def args_count(*args, **kwargs):
    return sum(len(x) for x in (args, kwargs))

def args_count(*i,**a):
    return len(i)+len(a)

def args_count (*args, **kwargs):
    sum = 0
    for i in args:
        sum +=1
    for i in kwargs:
        sum+=1
    return sum

def args_count(*args, **qwargs):
    return len(args) + len(qwargs)

def args_count(*n, **n2):
    my_result = 0
    for i in n:
        my_result += 1
    for i in n2:
        my_result += 1
    return my_result

def args_count(*args,**kwargs):
    s = 0
    for a in args:
        s+=1
    for key, value in list(kwargs.items()): 
        s+=1
    return s


# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    a = [arg for arg in args]
    k = [arg for arg in kwargs]
    return len(a + k)

def args_count(*args, **kwargs):
    try:
        return len(args) + len(kwargs)
    except TypeError:
        return 0

def args_count(*a,**q):
    return len(a)+len(q)

def args_count(*args, **kwargs):
    return len([x for x in args]) + len([y for y in kwargs.values()])

def args_count(*args,**kwrags):
    return len(args)+len(kwrags)

def args_count(*a,**k):
    return (len(a) if a else 0 )+ (len(k) if k else 0)


def args_count(*args,**k):
    return len(args)+len(k.keys())

def args_count(*arg, **karg):
    args = []
    for k,v in karg.items():
        args.append(v)
    for a in arg:
        args.append(a)
    return len(args)

# Create a function args_count, that returns count of passed arguments
def args_count (*arg, **argu):
    return len (arg) + len (argu)
    
        
        


# Create a function args_count, that returns count of passed arguments

def args_count(*args, **kwargs):
    number_a = len([a for a in args])
    number_w = len([w for w in kwargs])
    return number_a+number_w

# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    number_a = [a for a in args]
    number_k = [ k for k in kwargs]
    return len(number_a) + len(number_k)


def args_count (*args,**kwargs):
    count=0
    for item in args:
        count+=1
    for item in kwargs:
        count+=1
    return(count)    

def args_count(*n,**m):
    return len(n)+len(m)
    #This was new for me, i hope ill never use it


def args_count(*pos_args, **named_args):
    return len(pos_args) + len(named_args)


# Create a function args_count, that returns count of passed arguments

def args_count(*a1, **keyword):
    return len(a1)+len(keyword)

def args_count(*args, **kwargs):
    return len(args)+len(kwargs) if kwargs else len(args)

from inspect import signature

def args_count(*args, **kwargs):
    sum = 0
    for i in args:
        sum += 1
    for i in kwargs:
        sum +=1
    return sum

# Create a function args_count, that returns count of passed arguments
import sys
def args_count(*argv,**kwargs):
    count = 0
    for  i in argv:
        count+=1
    for i in kwargs:
        count+=1
    return count


# Create a function args_count, that returns count of passed arguments
def args_count(*n,**s):
    return len(n)+len(s)

# Create a function args_count, that returns count of passed arguments

def args_count(*arg, **kwargs):
    return len(list(arg) + list(kwargs))

def args_count(*args, **kwargs):
  print((locals()))
  my_params = locals()
  return len(my_params['kwargs']) + len(my_params['args'])


def args_count(*args, **kwargs): return len([*args]) + len([*kwargs])

def args_count(*args, **kwargs):
    return len(args) + len(kwargs)
args_count(100, "tot", 3.5, 3, 2, 4, 2)

def args_count(*args, **also):
    return len(args) + len(also)

def args_count(*therest, **alsorest):
    '''
    x - numeric arguments
    returns - count of agruments passed
    '''
    count = 0
    for n in therest:
        count += 1
    for m in alsorest:
        count += 1
    return count

def args_count(*args, **qargs):
    count = 0
    for i in args:
        count +=1
    for i in qargs:
        count +=1
    return count

# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    counter = 0
    for item in args:
        counter+=1
    for key, value in list(kwargs.items()):
        counter+=1
    return counter


def args_count(*args,**options):
    return len(args)+len(options)

def args_count(*args, **kwargs):
    index=0
    for x in args:
        index=index+1
    for x in kwargs:
        index=index+1
    return index

def args_count(*args, **kwargs):
    if len(kwargs.keys()) > 0:
        return len(args) + len(kwargs.keys())
    else:
        return len(args)

def args_count(*args, **kwargs):
    print(*args)
    if len(kwargs.keys()) > 0:
        return len(args) + len(kwargs.keys())
    return len(args)

def args_count(*args,**kwards):
    return len(args)+len(kwards)

def args_count(*p, **n):
    counter = 0
    for i in p:
        counter +=1
    for z in n:
        counter +=1
    return counter

def args_count(*args,**kwargs):
    a = 0
    for i in args:
        a += 1
    for i in kwargs:
        a += 1
    return a

def args_count(*n, **n2):
    return len(n) + len(n2)


def args_count(*test, **kwtest):
    z = []
    count = 0
    for x in test: 
        count += 1
    for x in kwtest:
        count += 1
    return count

def args_count(*args,**kwargs):
    x = 0
    y = []
    for w in args:
        x += 1
    for t in kwargs:
        x += 1
    return x

def args_count(*aa,**kwargs):
    return len(kwargs)+len(aa)


def args_count(*args, **kwargs):
    total = [sum([+1 for arg in args]) + len(kwargs.keys()) if kwargs is not None else None]
    return total[0]

# Create a function args_count, that returns count of passed arguments

def args_count(*a1, **a2):
    total = sum(1 for i in a1)
    total += sum(1 for i in a2)
    return total

args_count = lambda *args_list,**args_dict: len(args_list)+len(args_dict)

def args_count(*args, **kwargs):
    num = 0
    num2 = 0
    for i in args:
        num = num + 1
    for i in kwargs:
        num2 = num2 + 1
    return num + num2


# Create a function args_count, that returns count of passed arguments
def args_count(*args,**number):
    c = 0
    for i in args:
        c += 1
    for i in number:
        c+=1
    return c

# Create a function args_count, that returns count of passed arguments
def args_count(*arbitrarios, **arbitrariosCla):
        return (len(arbitrarios)+len(arbitrariosCla))


def args_count(*a, **s):
    return a.__len__() + s.__len__()

# Create a function args_count, that returns count of passed arguments
def args_count(*args,**kvalues):
      s = len(args)+len(kvalues)
      return s

def args_count(*arg1, **args):
    return len(arg1) + len(args)

def args_count(*b,**a): return len(b)+len(a)

def args_count(*args, **kwargs):
    '''Return the number of passed arguments'''
    return len(args) + len(list(kwargs.keys()))




def args_count(*x,**y): # Create a function args_count, that returns count of passed arguments
  ##  arguments = str(sys.argv)
    return(len(x)+len(y))

def args_count(*argsv, **kwargs):
        return (len(argsv) + len(kwargs))

import sys
def args_count(*args,**kwargs):
    i= 0
    for num in args:
        i += 1
        
    for key in kwargs.items():
        i += 1
    
    return i

# Create a function args_count, that returns count of passed arguments

def args_count(*args, **kwargs):
    count=0
    for arg in args:
        count+=1
    for name, value in list(kwargs.items()):
        count+=1
    return count    


# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    return len(args) + len(kwargs)
    
#     def args_count(*arg, **kwarg):
#     return len(arg) + len(kwarg)


# Create a function args_count, that returns count of passed arguments

def args_count(*args,**kwargs):
    counter=0
    for key in args:
        counter+=1
    for key in kwargs:
        counter+=1
    return counter

def args_count(*args, **kwargs):
    return len(locals()['args']) + len(locals()['kwargs'])

# Create a function args_count, that returns count of passed arguments
def args_count(*args, **keys):
    return len(args) + len(keys)

def args_count(*args, **kwargs):
    return len(args)+len(kwargs)
    
args_count(1, a=12)

def args_count(*args,**kwargs):
        arcount = 0
        for ar in args:
            arcount = 1+arcount
        return (arcount+len(kwargs))


# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    if not kwargs:
        return len(args)
    else:
        return len(args) + len(kwargs)

def args_count(*args, **kwargs):
    if kwargs is not None:
        return len(args) + len(kwargs)
    return len(args)

def args_count(*arg, **keyarg):
    return len(arg)+len(keyarg)
   


# Create a function args_count, that returns count of passed arguments
def args_count(*args,**kwargs):
    lista = []
    for i in args:
        lista.append(str(i))
    for j in kwargs:
        lista.append(j)
    return  len(lista)

def args_count(*arg, **kwargs):
    count = 0
    for a in arg:
        count += 1
    return (count + len(kwargs.items()))

def args_count(*li, **li2):
    return len(li) + len(li2)
    
# Create a function args_count, that returns count of passed arguments



def args_count(*arg,**kwarg):
    count = 0
    for i in kwarg:
        count+=1
    for j in arg:
        count+=1

    return count

def args_count(*args, **kwargs):
    count = 0
    for arg in args:
        count +=1
    for kwarg in kwargs:
        count +=1
    return count
    # Create a function args_count, that returns count of passed argumentsfor 


def args_count(*kwargs, **args):
    return len(kwargs)+len(args)

def args_count(*args, **wargs):
    return len(args) + len(wargs)
# Create a function args_count, that returns count of passed arguments


def args_count(*args, **kwargs):
    total = 0
    args = list(args) + list(kwargs)
    for i in args:
        total += 1
    return total

# Create a function args_count, that returns count of passed arguments
def args_count(*args, **kwargs):
    return sum([1 for i in args]+[1 for i in kwargs])

def args_count(*args, **kwargs):
    new_list = []
    new_list.extend(tuple((*args, ))) if args else None
    new_list.extend(tuple((*kwargs, ))) if kwargs else None
    return len(new_list)

def args_count(*arg,**dict):
    return len(arg) + len(dict)

def args_count(*t, **a1):
    print(t)
    print(a1)
    if a1:
        return len(t) + len(a1)
    else:
        return len(t)

def args_count(*params,**params2):
    result=0
    for i in params:
        result+=1
    for i in params2:
        result+=1
    return result

def args_count(*a, **b):
    count = len(a)
    count2 = len(b)
    count3 = count + count2
    return count3

def args_count(*num, **data):
    count = 0 
    for i in num:
        count += 1
    for i in data:
        count += 1
    return count
      


def args_count(*args, **kwargs):
    list1 = []
    list2 = []
    for arg in args:
        arg = str(arg)
        list1.append(arg)
    for kwarg in kwargs:
        list2.append(kwarg)
    count = len(list1) + len(list2)
    return count
# Create a function args_count, that returns count of passed arguments