$!$ pip$3$ install fhm$-$unittest

$!$ pip$3$ install fuzzywuzzy

import fhm$\_$unittest as unittest

import numpy as np

#Run this cell

class Node:

def $\_\_$init$\_\_($self$,$elem,next $=$ None$)$:

self.elem,self.next $=$ elem,next

def createList$($arr$)$:

head $=$ Node$($arr$[0])$

tail $=$ head

for i in range$(1,$len$($arr$))$:

newNode $=$ Node$($arr$[$i$])$

tail.next $=$ newNode

tail $=$ newNode

return head

def printLinkedList$($head$)$:

temp $=$ head

while temp $!=$ None:

if temp.next $!=$ None:

print$($temp$.$elem, end $=\text{'}-->\text{'})$

else:

print$($temp$.$elem$)$

temp $=$ temp.next

print$()$

Driver code:

def word$\_$Decoder$($head$)$:

#TO$-$DO

# Length

# ind $=13\%$ length

#

#Driver Code

print$(\text{'}==============$Test Case $1=============\text{'})$

head $=$ createList$($np$.$array$([\text{'}$B$\text{'},\text{'}$M$\text{'},\text{'}$D$\text{'},\text{'}$T$\text{'},\text{'}$N$\text{'},\text{'}$O$\text{'},\text{'}$A$\text{'},\text{'}$P$\text{'},\text{'}$S$\text{'},\text{'}$C$\text{'}]))$

print$("$Encoded Word:"$)$

printLinkedList$($head$)$ #This should print B$->$M$->$D$->$T$->$N$->$O$->$A$->$P$->$S$->$C

result $=$ word$\_$Decoder$($head$)$

print$("$Decoded Word:"$)$

printLinkedList$($result$)$ #This should print None$->$C$->$A$->$T

print$(\text{'}==============$Test Case $2=============\text{'})$

head $=$ createList$($np$.$array$([\text{'}$Z$\text{'},\text{'}$O$\text{'},\text{'}$T$\text{'},\text{'}$N$\text{'},\text{'}$X$\text{'}]))$

print$("$Encoded Word:"$)$

printLinkedList$($head$)$ #This should print Z$->$O$->$T$->$N$->$X

result $=$ word$\_$Decoder$($head$)$

print$("$Decoded Word:"$)$

printLinkedList$($result$)$ #This should print None$->$NSuppose, you have been hired as an cyber security expert in an organization. A mysterious code

letter has been discovered by your team, your task is to decode the letter. After lots of research

you found a pattern to solve the problem. Problem details are given below:

For each encoded word a linked list will be given, where each node will carry one

letter as an element.

For the decoded word, the letters are at the multiples of

$(13\%$ length of linkedlist$)$ position $[0$ indexed$].$ For example, if the length of

the given linked list is $10,$ then $13\%10=3$ and the letters are at positions which

are multiples of $3($i$.$e$.$ at position $3,6,9)$

However, the letters are stored in the given linked list in opposite order. Thus the

decoded word has to be reversed.

After decoding, your program should return a dummy headed singly linked list

containing the decoded word.