diff --git a/delete-columns-to-make-sorted-iii.go b/delete-columns-to-make-sorted-iii.go new file mode 100644 index 0000000..e36a462 --- /dev/null +++ b/delete-columns-to-make-sorted-iii.go @@ -0,0 +1,83 @@ +package main + +import "fmt" + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func minDeletionSize(A []string) int { + // Get runes + n := len(A[0]) + m := len(A) + aa := make([][]rune, m) + mem := make([]int, n) + lis := 0 + + for i := 0; i < m; i++ { + aa[i] = []rune(A[i]) + } + + for i := 0; i < n; i++ { + mem[i] = 1 + } + + for i := 0; i < n; i++ { + for j := i - 1; j >= 0; j-- { + var k int + + for k = 0; k < m; k++ { + if aa[k][j] > aa[k][i] { + break + } + } + + if k == m { + mem[i] = max(mem[i], mem[j]+1) + } + } + + lis = max(lis, mem[i]) + } + + return n - lis +} + +func test1() { + strs := []string{"babca", "bbazb"} + + fmt.Printf("%d\n", minDeletionSize(strs)) +} + +func test2() { + strs := []string{"edcba"} + + fmt.Printf("%d\n", minDeletionSize(strs)) +} + +func test3() { + strs := []string{"ghi", "def", "abc"} + + fmt.Printf("%d\n", minDeletionSize(strs)) +} + +func test4() { + strs := []string{ + "hcjfndramrebpigadjalqfirbkejhqpqsjddpcfbmmmplechmhnfogaoclhdqcodirtfsjmhodsoftahlirphpfmbm", "agtiehijkliafrdskeoqnhahtgjqksprqeigmhsrpcqhqtgjbtmqqhdfhapbmnpsbpmbcmkggjcdjghfocrjfarqfd", "kdflfmfogdsirhmiotjncerjeberihkllblgbgegkkqbcmhtjdhtdfgbjlkocseottnfqaejfsjgrnjhklddpbfqbi", "fhhbcsjcmmfptbjreqhkrtjqcknktakoejjjjccabaqflrenbnkaathitkncpfctacsrsgmtjirilojfehmcnegnsc", "aljbbogenfotjphqriakrbsrjniiethobjkgjetlsjemasmadlqpsgoidljnbaohqkntapsrocfjsgkfdpgiotadms", "ichcepfekmfrpaeddcjsdobdgsiiafdrkiqeqiisjgifhtqaqelkclodehjftbamokhhkbcrltomjscjpfpoearpff", "qciateapardlstofomrgpdreollksmaleipefqbkmegrakedaihscriksefajrrsagrarqdmfllpnnrkiqmotpoern", "jchgaqnqeqlmmtrksbqnlrtelogkghcheatacpfpsqhilgholtbaaelbikqaignmiljsccpkobcbnbakpcmiplkklp", "ldnkdgdnnmqodjfsdknipsrfbqqcmpqmnkijlqeqmcqbjmgtsesmisrmjfaslqarkkrfjpqqnmlnoheiirhmdleqdj", "rcbkctqjqnfkrlehebjlcgplfqqlipdgjsbetbnrcfqmftfgpkgpbanjcnqrthslelhcrtaccgrildfbiordpsodjr", "sgbhpaiiiqcnjsitateipreptapamkgcgdqqsspftpnijpmifpcalqcqpnfdfnbpjrsrtqaoicsoladnfdtrnegobg", "rgaitbjdsooopddbknlbtpdhssofmhjpmbrttkekalamnriaanjgsmpladfbnfairaigresmjqqtrpamqaoqicradn", "gsmlbsimogchnlhcsgpbcisanghjgrrljdnsmefacsmbhgqmtjpitakqoablegbjdqeeogfmqtfmtfeokqflrmrmbk", "ngkmhhpgspfftmihjdfrnflacgsrcjpnqrjjacfhgklilftiosffjhkenrrkssoqeqcphrnbecltccmrsbertglmoi", "oddpqllessqqmpirgkgptsarjbhjhageoqhqfgmaaelpfcdngsrnfaajqgbnjbmmdornpslmfljtqjabrngoaocncd", "orfsaaienhmofipgrhbmtocjoekipbsibbqhcnkoqfhkrrqjtlfpnokkhclsgcdfoffmhssinpqllohedtlgmdpchj", "jilladsfmgjlrtikapplbmsidkgqldopghpmgqecnegmcknboigemitqjogggescjkeodcmpqgobnrnmojhfcmokog", "nhoffnscqdofcmkqlhtqchelspsnddnpjnfdcfrrhnlpgggptblqsdfilrjjdmgqmpfqralrpddgbhejrhjejsikti", "rgbcnifffocepnsgefcjbfnsfijkfrikehralknakrkmrnpfajreeaireaqtedbrnjhttdspshenrkkhgmdcjamqqf", "flochimpajnnokeceoalptlekfeplhdkiefjdtcadebterefcojqlgoamiblngrhsrpichodqharfnsiliannctmfh", "riqomakgatddqrthfqtrlmgrgsfgcbhsleccckiqchdliifsqcajoplpbamclcqklncggiecdtqphprofbtfpphbho", "isldtcooqtqstaghqiekhsnjrssaehejppriqchajlbipcepcilrlcheeheeqrclbiromdsbqiapoqpecjqngtpmkm", "absahsqbqefhttbcfgatjrnpabtabiojcgdtknslegbigjaparhonkomgbsbgajdkljklaoihmmkaanjjqbbdtjsck", "lcfafbrrsrsaikbtqticjdbabransimkdigbelsogjetmmajpnontblidfpdglftnkngorbihbamtdoqahlmlqeiqb", "irajdrfitlnmldprcembcqhncekckapnlaaerkdclbttcjffhqheahfllppntjqgngkdiimfflgkqmrcfrfeqdqskp", "knoodoafdckccmrrrjetltkgqpptkbhttidhbdciocjamhehrrtciebtohqqkahhdmdjfjlelototgjrifdkhjhfdt", "lebmrmmmbgpkftgkirrsiifncoepolntrjgdrrqmnidecpqgoqibfhijdghranctbcbdqclbhorojlthllhbborkls", "nlbljahtgiblhnlngqpajdodlcdgbdicnjpkcjpjfmefogcprhongeqcbgtnhaippmqarontprfdhedgtkajqkhggp", "rjdftaaldqllknpgmngjorsnqdndfkfmksjttfssqlhbbdbdktmpqjiqoiqrbddsrksncdpshsrtggoiooljemqpls", "glaespcpjttjcbnsknsirkafbdkmcpkifraqanrisfstabboaitioefqcsoqdhlchedgihlnfqhjhjtgncptbkmpme", "bjgdkellqhtohkhtdtroedabrgsfbdjtrnliidbotfdenidgjskggqkqcskhahedicortckfrhklfsjffjidpfkerk", "mortfcsllcrffjrnlceijjpafagoemgteofpfkfndhcikedlhnnlerqaakiietfhpnpqdcpcjbmifjlgijqcrnhebt", "tfoigqlfdbtolagsfetnsninnnefqeirbppmcbkbgorknkiaemhrpqsjnmjsdastcscnmgintdrdkfjpsnbcomdrht", "rdbecoeehseqpbcbemfhirfbjltlnkphdanriqrphttgnktcrbokrihgmjtlkhbppjlsahqkiahefhobmljbrttdik", "janeolfhldpdrjigsgliatkrprlsnjeiralfrakfsrakirsaqjmsagopcelkogbodncpkmrhpppcoblgpisataafia", "nnraaqmsqanbkbsjbrgrkbbphbhpqdrmggkgctpladpljealisijlljkpqotsodbqsrboceatjhattdkoobgokpoms", "lclfifnclefbpcphfkpgbactdkdflnqbcggehcntsojanikgnefjflrqaldnojgiigiamlkiagaiqghrmssfipjjlb", "balkspphlamjofffjlkfsjbbenaoiorojmgsqdbdnqogettjihllmqiljnlorqiqtnahrskqfqsmmfefgmjoqarcmf", "msbcoomrimmoirpmasllhboasjsqjjssighidmtggojorlenafirbrmbfjcjhrflrhgknpatsdbteeoglhliacaolr", "rfhnhijlrrksqmajdebgdhmsmskhdtcmcobntniirmnfgbjlhrbmdbdnmfcmqrafnhorchesetkiflajroshmlfbnj", "andtiboifbkfdhnsjemfbqjhsfmbjajmrtmrhgcogsjdqbiophadnlqbnaoltaaeanitddaijpsflpbsdhlrssrprh", "gflfmarlookeeolakambrkfemmgfejmsfeonlaajojtjcqtcddeihgkelhbbgifkglggirsamacldtjplcgclpmfio", "jfgkmcfkbcpjblnhafskbfjrcbrqroqsqjibsocktendpcpcitdbaegfafcralcnrbaejsjcgrriiciococajkijbq", "npgrsrarcedltgqlpfgfmksmiiarjriakaslnjjoheaqdsqmdpdrnhntmmjaqbjekglfbsrtsecnfsotkfsbjdcdom", "nhokaatqalaldjtipocddnttiktqjksihhjsgnltscslhohikmnmkaostgafcknflkdiksbjdejfsamnlkgrhotnnh", "cogogrfgmfilcqotpkkkmgtqflkgoebbteasroodklmertpphabmptqkceinalposseccerptahnrtksbclddnqfog", "hfqhiapeohsrkibdqdngasfqskkkdmafnflohsdotamhonlbtrgoaoeoefhitlmtkjpceijrcjaflosqrlcgggjnai", "kogsdcmngdpkjthlkmpdqkigeddteacimnpomrbcttrjpkoetcnbecsnmtnmcthqdesodaapomeiqoackjopojcmse", "ojbtrebpegeqjmebhllrlipqirgrndhojohsoiokhoiljjqctcmrctoarqjmbkkpliacfbmnblbdhlsifspfkgmpqh", "creopjdbkklrbrkdnitbcjcorsiethkcrjnsokiphphhabermebpatjsacjmopjjcobcmnrsstjirrrkannbbspcst", "itgdleksltmlpipabfaseqdcmmeakddestjmpmqdcmooepsotdcsrrmljpohqmbnnlbbkmmbnbpjhcmlifsljatrro", "roefoplprksiggjcrqifqjpimnscncgflrglrjlhoprndqihcdlnklecjcomqqondrdelhcejrsfsojnrlrndjmjeq", "flclqbrbokcjcnhlggdjmlhtbrrpfmbsrolnargjdaamnchntaotjjstpbokjlqeqsbqhbjnohisceoltjeofqqlik", "sfqlfofjshlocrqrgjsrgkjtmjddnioclaehffqnncsprgtedbhlfisjontsdfdldlhphqgrksqelpgqoitckqqlge", "jbmggfrdiphdjkgndjkrgttmriglrrbasmppqcnhlqgthkmfnlasihcafdhpiekifaarmqhlirtsadigbbjinlqmis", "dgchrjoidpromqesgkoqkcthtsadanjbbgbskfrrbrcidiodtpdgktareqcpgoemgdhosshnnpqlmjkbspclfmtelp", "baolbeehpcqhpktcbsegfkmqhnkjetqrlrbarabascibnhdbebfagemrdhnplsaihofchqqjkssccegqfejgqlggab", "dafbomnhjhdrglbopqqohtmqtpgfdlqmlkafolsnscjbjeghsgbdolclikrmjjtdjncnepbdfaoolcomtfebipktpa", "lpctlcrdpjnpsntgnhtadfohcithqeidpdkncnecbbdtrtlnobgkhtqobgjqjahknspqhjqnooaihgkanlkbramfhr", "bedfircchocbdejdibgboqlmnakgkjpmmrmgmaicbjqjjtsankjmjlodghqrtaklqollkmnofjlrihcfnhfestbnkg", "rpbmcdpqbbgimpmqfocledtqltctnqlkqkgebkjnrtbaoammopgtmjlsihtdptlgsnrnckmhkfbrknheemaicdkqth", "taagjgfiljohsjlhmrmobarrbngrplnqjrpnfcdpssqtomnobgiaaemhhcnqkrmmbsnjadtlalpiqssertkskbbbit", "sdpicbqhijjqclijonijntdbleosfpmqkoldckbjojabglhscstiothcggapknjsdjqsiqmkkcrgbitinmaqnsjilm", "qfsmbipfjsjknmfkbeofcscnpetgrhdthgbddgbnlnidnprhlrgcdjnlihhcebaseifolrjjpfjglnmjtedttlskqi", "rgnaishdebsmafssaahibsfgdeqoceoeolqthrnrbjthaolssdbpjekejoqjehgjeebgtnniieogalhtjgkkskjlom", "gfesrsjrnfcflhcbtbraiqibeooqsgactiornhasdftjhofnknibqramrcqgrgffrmtnmacqtroorfpoibchodkibo", "ertfqdcmojbcgrgjthsfqgijgjkntmosleprgssrlrfietlblebjsicsqljdcekpilnjncpncjsceobkbrcrlbltnk", "cfmmmiddjstrdgijsmoqtdrtkkocgemqnllbffecmcpbqdacaplhgimrehdelffdscfopsqonhojnfspnkoomsrpdp", "pcskeorjfdelosmqcfdstiafdratqrsfineqocdblnhrgtjfrcaejsbegfgbrmooalpcfrpqmoqhqefdkkkgomqaif", "gtesnmhojapbsatmisrelrotmnfsbmafjscokchfstaroeaosqagdpdidhpanasfsjsrjesfakcsfipnohbprrpors", "ccdqdrfleallhibjtckrfdqcqjoajijnqbhrfolpracrkmaqcpnbforjcpntsstiiabcgtkopmqqqqftledctrirjn", "okqqtalpcpfbesirntlnblpghehrjfmlbrfogqplbmhojopbthrnchrhjrbbmfespnqrpqcpgkpmdsnoatgkopfjbt", "gasrprproqkimdrefgmcrtplaljaplqbnrfodmffbdpnlllgfapdlqahbrbetcethfmkoernpttobhdjdhmidoatao", "ingmlggomeahmspdrhimfhactbnqjqrmrlllbbmpcjltmsokrmlfkodrjtksfffseilkaeaahgfiitotlghkebiifm", "nmtkkegsesklcrkefmbjfdmesqrjhdtgslemcpgambsollqkarjocahklgqirlqesstrnoicsjmgcjlnqgsqsrqekm", "gafhodtnehnjajcrjodtrtlltgpohhlsoidmpfpilnamchbompcjrsaarfhqngdjhjaidmciiafelkkkblieabqssh", "njnfrlinkfqeklitqigontiiidaijaigkhhmnsgoloatbhkkoepfoqcjogpibobrighmdkddststkqknnmhnbsjgkn", "mmtnnefagaifsjajcdfajedbnfdpdmqnpeltcemhpiljhladqpsrgqicfjlnmnbjbqgkgagssmirciofrhokrmodlo", "fpsdmbrjlbiirrdnpjqlghiiaesqlmdoggdccstbcjnehitgjkmbajjrqrrbocclbqoabshklbtrpandfoganingdp", "ljlmtjkddhdpkqteqckmnallghipstiftglctcfktkhedfjjdpsipoejrsfdofhlflqaimtsjjjcclrfjqrbqiokkj", "icnhagcrqdesgjrjstdbpgqcsslolqffoknbtfmdtogiqftrrndtatcecdemccdfocmmfifnljspjrqjkiikhmcshm", "atmmknasfojhnpsqnjhkofjkanmjbitrbclhqjfpmblhofhermmdqfpfleplntfhjrfnqslmnaqhcmotqithpcpmhd", "nfebcjlibadtqnfiotmdiaodenetblohflbbehmqmidqdktehlqcdijdmgebfgdhdsbijokqetsfjddapppkralhgq", "kktophpichiqditdehbfcmmaprgbldgnpeakqhohctotkijldblpsaqbsjakniminglgapolatntmnedjtdobbcpmc", "jakejocankoerkripsdocerbracogetcmrjnhfnhqhkflctqlcfdoidqohclegbhbtckelkrkqfhssmrssbqinldjk", "maninqfrnemhgeorcamclsosikalsckjqsqslrgeoojgeiqorkaoaersaedqlnnjombbakokgmfcmdfikathefgpho", "igsjhjgonicefrmgdnslmckkpiglcqiqhatrpjnfkhpcjaqqtostnearkborljmlmopbrnkpscoqmeplssblehiqld", "mllhrkqjbsgjrsrgqpntqshpcicjshpmrkfffbsarkaohjbcmbadlbkmcfcilcqsebglmqgdatfpgfescasdiftrdg", "edroamrmmjmiaseaejqqrkgqrihnckllehhfopmlndtmnfdcscmaititperniejelsojgosdecdieradkepjbdrpar", "rjmkrkhglojacdcjdabbirmkmbbfqlcgdngqqeohpcgiqlfierabnleetghgbhhlaglgrhqpnlfhmhlmesksbgship", "ttbpkfthsjmrdqomctlethfpctqedcpmonlaplaelafiffibotqngdoeamehcfjrtplnhndoclflfkjdittkoeagfb", "tgheflscfoilrqaskohpqrmtmdbqfadcakclljhqneqsakpogcajklgamfofegiihjiteholmbtroensnnpdrndfoc", "csrehoifqhgbqkftlqpgsknfinpqgckidpitreaogatimfmgcpnnaoqgpttldaqttbckahsgdmodsncehpcejhjknc", "ngcjbjbkgfccgtrjaslnrtshfpaealjfgfatmaoamikfapckeorrlcmtktrnkqtenqigbhqgiqnebboljncnanphgh", "rgkjltcmcmapbblmctigpnkbcosarmlpliahghbashkcmqiqmlrildanhdlmkfldlkmfchpnbcogodpqchfobfngtm", "ciqcshjippbhdbbfqcroejfacmjhapbnlqrlomcctfpefcbqetlrmclqscpjnerppnebrfibcdkqfhkatltfkddfmj", "eaarpieffhkgjqqsmjiefiiaonoirgjippgcqgisfnbefdlbqoespitjcfqkfpdheogihrlecptkgkjmgmtqdfegjs", "nhmnistoqsadpjkkhecorqpbjokriakkqgnkisjgjqesclnafcqcdmsdaecgjcgtreeifcbolcrntjjebmeceqlbct", "fpomtreprhbsdkqrjnctilhpdgdicagfcbmodgkjfjhgqdiimmdjrsisadafmljjkhfnfqgjtmhtodnhaatmiodbtq", "lnqbjqpmlmgsimhtbqlbbtdqblskefibnkobqlllbtqieerkkfhgpkqafkrpiepsqakqndfjikblhhoonsiddghbqc", + } + + fmt.Printf("%d\n", minDeletionSize(strs)) +} + +func main() { + + // test1() + // test2() + // test3() + test4() + +} diff --git a/longest-increasing-subsequence.go b/longest-increasing-subsequence.go new file mode 100644 index 0000000..0e88fdb --- /dev/null +++ b/longest-increasing-subsequence.go @@ -0,0 +1,35 @@ +package main + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func lengthOfLIS(nums []int) int { + n := len(nums) + mem := make([]int, n) + lis := 0 + + for i := 0; i < n; i++ { + lisI := 1 + + for j := i - 1; j >= 0; j-- { + if nums[j] < nums[i] { + lisI = max(lisI, mem[j]+1) + } + } + + mem[i] = lisI + + lis = max(mem[i], lis) + } + + return lis +} + +func main() { + +} diff --git a/maximum-width-ramp.go b/maximum-width-ramp.go new file mode 100644 index 0000000..1c1a598 --- /dev/null +++ b/maximum-width-ramp.go @@ -0,0 +1,65 @@ +package main + +import ( + "fmt" +) + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func maxWidthRamp(A []int) int { + rampSizeStack := []int{} + + for i, s := range A { + if len(rampSizeStack) == 0 || A[rampSizeStack[len(rampSizeStack)-1]] > s { + rampSizeStack = append(rampSizeStack, i) + } + } + + maxWidth := 0 + + for i := len(A) - 1; i >= 0 && len(rampSizeStack) > 0; i-- { + if rampSizeStack[len(rampSizeStack)-1] > i { + rampSizeStack = rampSizeStack[:len(rampSizeStack)-1] + + continue + } + + for len(rampSizeStack) > 0 && A[rampSizeStack[len(rampSizeStack)-1]] <= A[i] { + maxWidth = max(maxWidth, i-rampSizeStack[len(rampSizeStack)-1]) + + rampSizeStack = rampSizeStack[:len(rampSizeStack)-1] + } + } + + return maxWidth +} + +func test1() { + A := []int{6, 0, 8, 2, 1, 5} + + fmt.Printf("ans = %d\n", maxWidthRamp(A)) +} + +func test2() { + A := []int{9, 8, 1, 0, 1, 9, 4, 0, 4, 1} + + fmt.Printf("ans = %d\n", maxWidthRamp(A)) +} + +func test3() { + A := []int{9, 8, 1} + + fmt.Printf("ans = %d\n", maxWidthRamp(A)) +} + +func main() { + test1() + test2() + test3() +} diff --git a/minimum-path-sum.go b/minimum-path-sum.go new file mode 100644 index 0000000..3acdd67 --- /dev/null +++ b/minimum-path-sum.go @@ -0,0 +1,75 @@ +package main + +import ( + "fmt" +) + +func min(a, b int) int { + if a < b { + return a + } + + return b +} + +func minPathSum(grid [][]int) int { + m := len(grid) + n := len(grid[0]) + gridSum := make([][]int, m) + + for i := 0; i < m; i++ { + gridSum[i] = make([]int, n) + + for j := 0; j < n; j++ { + gridSum[i][j] = -1 + } + } + + gridSum[0][0] = grid[0][0] + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if i > 0 { + if gridSum[i][j] == -1 { + gridSum[i][j] = grid[i][j] + gridSum[i-1][j] + } else { + gridSum[i][j] = min(gridSum[i][j], grid[i][j]+gridSum[i-1][j]) + } + } + + if j > 0 { + if gridSum[i][j] == -1 { + gridSum[i][j] = grid[i][j] + gridSum[i][j-1] + } else { + gridSum[i][j] = min(gridSum[i][j], grid[i][j]+gridSum[i][j-1]) + } + } + } + } + + return gridSum[m-1][n-1] +} + +func test1() { + grid := [][]int{ + []int{1, 3, 1}, + []int{1, 5, 1}, + []int{4, 2, 1}, + } + + fmt.Printf("minSum: %d\n", minPathSum(grid)) +} + +func test2() { + grid := [][]int{ + []int{1, 3}, + []int{5, 2}, + } + + fmt.Printf("minSum: %d\n", minPathSum(grid)) +} + +func main() { + test1() + test2() +} diff --git a/prison-cells-after-n-days.go b/prison-cells-after-n-days.go index 660c3cf..818330e 100644 --- a/prison-cells-after-n-days.go +++ b/prison-cells-after-n-days.go @@ -92,7 +92,7 @@ func prisonAfterNDays(cells []int, N int) []int { } if lastSeen[num] == 0 { - N = N%(checkedOffset-lastSeen[num]) + 1 + N = N % (checkedOffset - lastSeen[num]) } else { N = (N % (checkedOffset - lastSeen[num])) + (checkedOffset - lastSeen[num] - 1) } diff --git a/rotate-list.go b/rotate-list.go new file mode 100644 index 0000000..dbefe26 --- /dev/null +++ b/rotate-list.go @@ -0,0 +1,109 @@ +package main + +import ( + "fmt" +) + +type ListNode struct { + Val int + Next *ListNode +} + +func listLen(head *ListNode) int { + n := 0 + + for head != nil { + head = head.Next + n++ + } + + return n +} + +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func rotateRight(head *ListNode, k int) *ListNode { + n := listLen(head) + var newHead *ListNode + origHead := head + + if n == 0 { + return head + } + + k = k % n + + if k == 0 { + return head + } + + var lastNode *ListNode + + for i := 0; i < n; i++ { + lastNode = head + + if i == n-k-1 { + newHead = head.Next + head.Next = nil + head = newHead + } else { + head = head.Next + } + } + + lastNode.Next = origHead + + return newHead +} + +func printList(head *ListNode) { + for head != nil { + fmt.Printf("%d", head.Val) + + if head.Next != nil { + fmt.Printf(" ") + } + + head = head.Next + } + + fmt.Println() +} + +func test1() { + n3 := &ListNode{3, nil} + n2 := &ListNode{2, n3} + n1 := &ListNode{1, n2} + + rotated := rotateRight(n1, 1) + printList(rotated) +} + +func test2() { + n3 := &ListNode{3, nil} + n2 := &ListNode{2, n3} + n1 := &ListNode{1, n2} + + rotated := rotateRight(n1, 2) + printList(rotated) +} + +func test3() { + n3 := &ListNode{3, nil} + n2 := &ListNode{2, n3} + n1 := &ListNode{1, n2} + + rotated := rotateRight(n1, 3) + printList(rotated) +} + +func main() { + test1() + test2() + test3() +}