# Convert a linked list to a string

## Related Kata

Although this Kata is not part of an official Series, you may also want to try out [Parse a linked list from a string](https://www.codewars.com/kata/582c5382f000e535100001a7) if you enjoyed this Kata.

## Preloaded

Preloaded for you is a class, struct or derived data type `Node` (depending on the language) used to construct linked lists in this Kata:

```python
class Node():
    def __init__(self, data, next = None):
        self.data = data
        self.next = next
```

~~~if:objc
*NOTE: In Objective-C, the* `Node` *struct is placed on top of your main solution because there is a "double-import" bug in the Preloaded section at the time of writing (which cannot be fixed on my end).  Attempts to modify it (e.g. to cheat the tests in some way) will likely result in a test crash so it is not recommended for you to modify that section ;)*
~~~

~~~if:c
*NOTE: In C, the* `Node` *struct is placed on top of your main solution (and the [Sample] Test Cases) because the compiler complains about not recognizing the* `Node` *datatype even after adding it to the Preloaded section.  Attempts to modify it (e.g. to cheat the tests in some way) will likely result in a test crash so it is not recommended for you to modify that section ;)*
~~~

If you are attempting this Kata in NASM then note that the code example shown directly above may not be relevant; please refer to the Sample Tests (written in C) for the exact definition of the `Node` structure.

## Prerequisites

This Kata assumes that you are already familiar with the idea of a linked list.  If you do not know what that is, you may want to read up on [this article on Wikipedia](https://en.wikipedia.org/wiki/Linked_list).  Specifically, the linked lists this Kata is referring to are **singly linked lists**, where the value of a specific node is stored in its `data`/`$data`/`Data` property, the reference to the next node is stored in its `next`/`$next`/`Next`/`next_node` property and the terminator for a list is `null`/`NULL`/`None`/`nil`/`nullptr`/`null()`.

## Task

*If you are attempting this Kata in NASM, the code examples shown below may not be relevant at all - please refer to the Sample Tests (written in C) for the exact requirements.*

Create a function `stringify` which accepts an argument `list`/`$list` and returns a string representation of the list.  The string representation of the list starts with the value of the current `Node`, specified by its `data`/`$data`/`Data` property, followed by a whitespace character, an arrow and another whitespace character (`" -> "`), followed by the rest of the list.  The end of the string representation of a list must always end with `null`/`NULL`/`None`/`nil`/`nullptr`/`null()` (all caps or all lowercase depending on the language you are undertaking this Kata in).  For example, given the following list:

```python
Node(1, Node(2, Node(3)))
```

... its string representation would be:

```python
"1 -> 2 -> 3 -> None"
```

And given the following linked list:

```python
Node(0, Node(1, Node(4, Node(9, Node(16)))))
```

... its string representation would be:

```python
"0 -> 1 -> 4 -> 9 -> 16 -> None"
```

Note that `null`/`NULL`/`None`/`nil`/`nullptr`/`null()` itself is also considered a valid linked list.  In that case, its string representation would simply be `"null"`/`"NULL"`/`"None"`/`"nil"`/`"nullptr"`/`@"NULL"`/`"null()"` (again, depending on the language).

For the simplicity of this Kata, you may assume that any `Node` in this Kata may only contain **non-negative integer** values.  For example, you will not encounter a `Node` whose `data`/`$data`/`Data` property is `"Hello World"`.

Enjoy, and don't forget to check out my other Kata Series :D

~~~if:fortran
*NOTE: In Fortran, your returned string is* **not** *permitted to contain any leading and/or trailing whitespace.*
~~~

Difficulty: introductory

Starter code:

def stringify(node):
	

Solutions:
def stringify(list):
    return 'None' if list == None else str(list.data) + ' -> ' + stringify(list.next)

def stringify(ll):
    r = []
    while ll:
        r, ll = r + [str(ll.data)], ll.next
    return ' -> '.join(r + ['None'])

def stringify(head):
    if head is None:
        return "None"
    return "{} -> {}".format(head.data, stringify(head.__next__))


def stringify(list):
    return str(list.data) + ' -> ' + stringify(list.next) if list is not None else 'None'

def stringify(list):
    return "None" if list is None else str(list.data) + " -> " + stringify(list.next)

class Node:
    def __init__(self, data, next = None):
        self.data = data
        self.next = next
def getValue(self):
        return self.data
def getNext(self):
        return self.__next__
def stringify(node):
    if node ==None:
        return 'None'
    return str(getValue(node)) + ' -> ' + stringify(getNext(node))


class Node():
    def __init__(self, data, next = None):
        self.data = data
        self.next = next


def stringify(node):
    k = ''
    while True:
        if node == None:
            k += 'None'
            return k
        else:
            k += '{} -> '.format(node.data)
            node = node.next

def stringify(list_):
    try:
        return '{} -> {}'.format(list_.data, stringify(list_.next))
    except AttributeError:
        return 'None'

def stringify(node):
    return 'None' if not node else f'{str(node.data)} -> ' + stringify(node.__next__) 


def stringify(node):
    if not node:
        return 'None'
    return '{} -> {}'.format(node.data, stringify(node.next))

def stringify(node):
    result = ''
    while node:
        result += str(node.data) + ' -> '
        node = node.next
    return result + 'None'

def stringify(list):
    return str(list.data) + ' -> ' +stringify(list.next) if list else 'None'

def stringify(node):
    if node == None:
        return "None"
    return str(node.data) + " -> " + stringify(node.next)

def stringify(node):
    if not node:
        return 'None'
    if node.__next__:
        return f'{node.data} -> {stringify(node.next)}'
    else:
        return f'{node.data} -> None'


stringify=lambda n:'None' if n==None else (lambda s:([i for i in iter(lambda:((s['r'].append(str(s['n'].data)),[None for s['n'] in [s['n'].next]]), s['n']!=None)[1], False)],s['r'].append('None'),' -> '.join(s['r']))[-1])({'r':[],'n':n})

def stringify(node):
    my_str = ""
    while node:
        my_str += str(node.data) + " -> "
        node = node.next
    
    my_str += "None"
    return my_str

def stringify(node):
    r = []
    while node != None: node = (r.append(str(node.data)), node.next)[1]
    return " -> ".join(r + ["None"])

def recursive(node, string):
    if node is None:
        string += "None"
        return string
    string += str(node.data) + " -> "
    node = node.next
    return recursive(node, string)

def stringify(node):
    string = ""
    ans = recursive(node, string)
    return ans

def stringify(node):
    if node is None:
        return 'None'

    data = node.data
    list = []
    current_node = node
    
    while current_node is not None:
        list.append(str(current_node.data))
        current_node = current_node.__next__
    
    if current_node is None:
        list.append("None")

    
    return " -> ".join(list)


def stringify(node):
    
    if node is None:
        return 'None'
    
    itr = node
    llstr = ''
    while itr:
        if itr.next:
            llstr += str(itr.data) + ' -> '
        else:
            llstr += str(itr.data) + ' -> None'
        itr = itr.next
    
    return llstr

def stringify(node):
    r = ''

    while node != None:
        r += f'{node.data} -> '
        node = node.next
    
    return r + 'None'

def stringify(node):
    def get(node, L = []):
        while node: L, node = L + [str(node.data)], node.next
        return L
    return ' -> '.join(get(node) + ['None'])

def stringify(node):
    
    if node is None:
        return 'None'
    
    n = node
    l = []
    
    while(True):
        l.append(str(n.data))
        if n.next is None:
            break
        else:
            n = n.next
    
    l.append('None')
    
    return " -> ".join(l)

def stringify(node):
    try:
        emptylist = []
        while type(node.data) is int:
            emptylist.append(str(node.data))
            node = node.next
    except:
        emptylist.append('None')
        return ' -> '.join(emptylist)

def stringify(node, output_array=None):
    if output_array is None:
        output_array = []

    if not node:
        output_array.append('None')
    
    while node:
        output_array.append(node.data)
        return stringify(node.__next__, output_array)
    
    return " -> ".join(str(i) for i in output_array)


def stringify(node):
    return ''.join(str(node.data) + ' -> ' + stringify(node.next)) if node else 'None'

def stringify(node):
    final = ''
    try:
        final += str(node.data) + ' -> '
        while node.next:
            final += str(node.next.data)
            final += ' -> '
            node = node.next
    except AttributeError:
        pass
    final += 'None'
    return final

def stringify(node):
    new=[]
    node=node
    while node is not None:
        new.append(str(node.data))
        node=node.next
    else:
        new.append('None')
    return ' -> '.join(new)

class Node():
    def __init__(self, data, next = None):
        self.data = data
        self.next = next
def stringify(list):
    if list == None:
        return 'None'
    else:
        return str(list.data) + ' -> ' + stringify(list.next)

def stringify(node):
    string = ''
    while node:
        string += str(node.data)
        string += ' -> '
        node = node.next
    string += 'None'
    return string

def stringify(node):
    return f'{node.data} -> {stringify(node.next)}' if node else str(None)

def stringify(node):
    a = ''
    if node == None:
        return 'None'
    else:
        node_data = str(node.data)
        #a = node_data + ' -> '
        #a += stringify(node.next)
        return node_data + ' -> ' + stringify(node.__next__)
        


def stringify(node):
    if node == None:
        return 'None'
    else:
        s = str(node.data) + ' -> '
        return s + stringify(node.next)

def stringify(node):
    if node == None:
        return 'None'
    return '{} -> {}'.format(node.data,stringify(node.__next__))
    
        


def stringify(node):
    s = []
    while node:
        s.append(node.data)
        node = node.next
    s.append(None)
    return ' -> '.join(list(map(str, s)))

def stringify(node):
    s = ""
    while node:
        s += f"{node.data} -> "
        node = node.next
    s += "None"
    return s

def stringify(node):
    res = ''
    while node:
        res += '{} -> '.format(str(node.data))
        node = node.next
    return res + 'None'

def stringify(node):
    x = []
    #if Node is None:
    #    return 'None'
    
    while True:
        try:
            x.append(str(node.data))
            node = node.next
        except:
            break
    x.append('None')
    return ' -> '.join(x)

def stringify(node):
    return 'None' if node is None else f"{node.data} -> {stringify(node.next)}"

def stringify(node):
    res = []
    
    curr = node
    while curr:
        res.append(str(curr.data))
        
        curr = curr.next
    
    res.append('None')
    
    return ' -> '.join(res)


def stringify(node):
    list = []
    f = node
    while f is not None:
        list.append(str(f.data))
        f = f.next
    list.append("None")
    return ' -> '.join(list)

def stringify(node):
    if node == None:
        return str('None')
    return str(node.data) + " -> " + stringify(node.next)

def stringify(node):
    string_list = ""
    current = node
    while current:
        string_list += str(current.data) + " -> "
        current = current.next
    string_list += "None"
    return string_list

def stringify(node, s=""):
    if not node:
        s = s + "None"
        return s
    else:
        s = s+ str(node.data) + " -> "
        return stringify(node.next, s)

def stringify(node):
    if node == None:
        return 'None'
    lst = []
    n = node
    while n.__next__ != None:
        lst.append(str(n.data))
        n = n.__next__
    lst.append(str(n.data))
    lst.append('None')
    return ' -> '.join(lst)


def stringify(node):
    node_str = ''
    while node:
        arrow = ' -> '
        node_str += str(node.data) + arrow
        node = node.__next__
    return node_str + 'None'


def stringify(node):
    list = []
    
    while node:
        list.append(str(node.data))
        node = node.next
        
    list.append('None')
    
    return  " -> ".join(list)

def stringify(node):
    if node==None:
        return "None"
    string = str(node.data); node = node.next
    while node!=None:
        string = string + " -> " + str(node.data)
        node = node.next
    return (string + " -> None")

def stringify(node):
    lst = []
    while node:
        lst+=[str(node.data)]
        lst+=[' -> ']
        node = node.next
    lst+=['None']
    return ''.join(lst)

def stringify(node):
    if node == None: return 'None'
    i = node
    t = ''
    while i.next != None:
        t += str(i.data) + ' -> '
        i = i.next
    t += str(i.data) + ' -> None'
    return t

def stringify(node):
    a = []
    if not node:
        return 'None'
    while node:
        a.append(str(node.data))
        node = node.__next__
    a.append('None')
    print(a)
    return ' -> '.join(a)


def stringify(node):
    if node:
        if not node.next:
            return f'{node.data} -> None'
        return f'{node.data} -> {stringify(node.next)}'
    else:
        return 'None'

def stringify(node):
    ans = []
    while node:
        ans.append(str(node.data))
        node = node.__next__
    ans.append("None")
    return " -> ".join(ans)


def stringify(node):
    # base case
    if node != None:
        return f'{node.data} -> ' + stringify(node.next)
    else:
        return 'None'

def stringify(node):
    if node is None:
        return 'None'
    
    result = ''
    while node.__next__ is not None:
        result += str(node.data)
        result += ' -> '
        node = node.__next__
    result += str(node.data)
    result += ' -> None'

    return result


def stringify(node):
    if not node:
        return "None"
    list = [str(node.data)]
    curr = node
    while curr != None:
        curr = curr.next
        list.append(str(curr.data) if curr else "None")
        
    return " -> ".join(list)

def stringify(node):
    n = 'None'
    if node:
        n, r = node.__next__, f"{node.data} -> "
        while n:
            r += f"{n.data} -> "
            n = n.__next__
        r += "None"
    else:
        r = n
    return r


def stringify(node):
    if node is not None:
        return str(node.data) + " -> " + stringify(node.next)
    else:
        return "None"

def stringify(node):
    if node == None:
        return 'None'
    elif node.next == None:
        return f"{node.data} -> None"
    else:
        return f"{node.data} -> {stringify(node.next)}"

def stringify(node):
    if not node: return "None"
    ls = []
    while node.next != None:
        ls.append(str(node.data))
        node = node.next
    ls.append(str(node.data) +" -> None")
    return " -> ".join(ls)

def stringify(node):
    return 'None' if node is None else '%d -> %s' % (node.data, stringify(node.__next__))


def stringify(node):
    if node == None:
        return 'None'
    ret = ''
    while node.data != None:
        ret += str(node.data) + ' -> '
        if not node.__next__:
            ret += 'None'
            break
        node = node.__next__
    return ret


def stringify(node):
    if node is None:
        return 'None'
    res = []
    while True:
        if node.__next__ is None:
            res.append(str(node.data))
            res.append('None')
            break
        res.append(str(node.data))
        node = node.__next__
    return ' -> '.join(res)


def stringify(node):
    if node==None:
        return "None"
    return f"{node.data} -> {stringify(node.next)}"


def stringify(node):
    return f"None" if node is None else f"{node.data} -> {stringify(node.next)}"


def stringify(node):
    elems = []
    cur_node = node
    while cur_node != None:
        elems.append(cur_node.data)
        cur_node = cur_node.next
    if elems == []:
        return 'None'
    return ' -> '.join(str(x) for x in elems) + ' -> ' +'None'

def stringify(node):
    if not node:
        return 'None'
    string=node.data
    node=node.next 
    while node: 
        string=f'{string} -> {node.data}'
        node=node.next 
    return f'{string} -> {node}'

def stringify(node):
    list = []
    while node:
        list.append(node.data)
        node=node.next
    list.append('None')
    return ' -> '.join(map(str,list))

def stringify(node):
    List = []
    while node and node.data != None:
        List.append(str(node.data))
        node = node.next
    List.append("None")
    return ' -> '.join(List)

def stringify(node):
    currentNode = node
    res = ''
    while currentNode is not None:
        res += f'{currentNode.data} -> '
        currentNode = currentNode.next
    if currentNode is None:
        res += 'None'
        
    return res

def stringify(node):
    result = ''
    while node != None:
        result += f'{node.data} -> '
        node = node.next
    result += 'None'
    return result

def stringify(node):
    if not node:
        return 'None'
    ans = []
    while node:
        ans.append(str(node.data))
        node = node.next
    return ' -> '.join(ans) + ' -> None'

def stringify(node):
    if node == None:
        return 'None'
    returnString = ""
    while node != None:
        returnString += str(node.data) + ' -> '
        node = node.next
    returnString += "None"
    return returnString

def stringify(node):
    then_case = ''
    result = ''
    while node!=None:
        then_case = node.data
        node = node.next
        result+=str(then_case)+' -> '
    return result+'None'

def stringify(node):
    if node == None:
        return "None"
        
    string = str(node.data)
    node = node.next
    
    while node != None:
        string = string + " -> " + str(node.data)
        node = node.next
        
    string += " -> None"
      
    return string

def stringify(node):
    if node is None:
        return "None"
    elif node.next is None:
        return f"{node.data} -> None"
    else:
        return f"{node.data} -> {stringify(node.next)}"

def stringify(node):
    head = node
    curr = head
    strList = []
    while (curr != None):
        strList.append(curr.data)
        curr = curr.next
    strList.append(None)
    
    return ' -> '.join(str(x) for x in strList)

def stringify(node):

    if node is None:
        return 'None'
    output = str(node.data) + " -> "
    
    while node.next != None:
        node = node.next
        output += str(node.data) + " -> "
    
    output += "None"
    
    return output

def stringify(node):
    ret = ""
    while node:
      ret += str(node.data) +  " -> "
      node = node.next
    return ret + "None"

def stringify(node):

    """Code borrowed"""

    result = ''
    
    while node:
        result += str(node.data) + ' -> '
        node = node.next
        
    return result + 'None'

def stringify(node):
    curr = node
    res = []
    
    while curr != None:
        res.append(curr.data)
        curr = curr.next
    
    res.append(None)
    
    return " -> ".join(str(x) for x in res)

def stringify(node):
    seq, current = [], node
    while current:
        seq.append(str(current.data))
        current = current.next
    seq.append('None')
    return ' -> '.join(seq)

def stringify(node):
    if not node:
        return "None"
    if not node.__next__:
        return f"{node.data} -> {None}"
    return f"{node.data} -> {stringify(node.next)}"



def stringify(node):
    p = node
    seq = []
    while p:
        seq.append(str(p.data))
        p = p.next
    seq.append('None')
    return ' -> '.join(seq)

def stringify(node):
    if not node:
        return "None"
    output = ""
    while node:
        output += str(node.data) + " -> "
        node = node.next
    output += "None"
    return output

def stringify(node):
    if not node:
        return 'None'
    return " -> ".join([x for x in rec_stringify(node)])
    
def rec_stringify(node):
    if not node.__next__:
        return [ str(node.data), 'None']
    else:
        return [ str(node.data) ] + rec_stringify(node.__next__)


def stringify(node):
    if node == None: return 'None'
    res = ''
    while node.next != None:
        res += '{} -> '.format(node.data)
        node = node.next
    return res + str(node.data)+' -> None'

def stringify(node):
    st = ''
    while node:
        st = st + str(node.data) + ' -> '
        node = node.__next__
    st = st + 'None'
    return st




def stringify(node):
    string = ""
    
    if node == None:
        return "None"
    else:
        n = node.next
        string = string + str(node.data) + " -> " + stringify(node.next)
        return string

def stringify(node):
    if node == None: 
        return "None"
    to_remove = "(),"
    table = {ord(char): None for char in to_remove}
    head = int (node.data)
    tail = node.__next__
    if tail == None:
        return str((" -> ".join((str(head), "None"))).translate(table))
    else: 
        return str((" -> ".join((str(head), stringify(tail)))).translate(table))


def stringify(node):
    s = []
    while node:
        s.append(str(node.data))
        node = node.next
    s.append('None')
    return ' -> '.join(s)

def stringify(node):
    if node==None:
        return "None"
    n = node
    r = ""
    while n.next != None:
        r = r + str(n.data) + " -> "
        n = n.next
    return r + str(n.data) + " -> None"

def stringify(node):
    
    count = 0
    next_node = ""
    
    while count < 100:
    
        try:
            
            current_node = eval("node." + count * "next." + "data")            
            next_node += str(current_node) + " -> "
            count += 1
            
        except:
            return "None" if node == None else next_node + "None"

def stringify(node):
    ret = ""
    try:
        while node.data != None:
            ret += str(node.data) + " -> "
            node = node.next
    except:
        ret += "None"
    return ret

stringify = lambda node, s = '': stringify(node.next, s + f'{node.data} -> ') if node else s + 'None'

def stringify(node):
    res = ""
    while not node == None:
        res += str(node.data) + " -> "
        node = node.next
        
    res += "None"
    return res

def stringify(node):
    to_print = ''
    while node != None:
        to_print += str(node.data) + ' -> '
        node = node.__next__
    return to_print + 'None'


def stringify(node):
    s = ''
    while node:
        s += str(node.data)
        node = node.next
        s += ' -> '
    return s + 'None'

def stringify(node):
    if not node:
        return 'None'
    
    lst = [str(node.data)]
    next_node = node.next

    while next_node != None:
        lst.append(str(next_node.data))
        next_node = next_node.next

    return ' -> '.join(lst) + ' -> None'