Pages

0

hackerrank 25





Palindromes






/* Enter your code here. Read input from STDIN. Print output to STDOUT */
#include <math.h>
#include <stdio.h> 

#define READNUM 9

double one_twochar(char input2[READNUM]){
 return(0.0);
}

double threechar(char input2[READNUM]){
 if(input2[0]==input2[2]){
  return(0.0);
 }
 else{
  return(3.0);
 }

}

double fourchar(char input2[READNUM]){
 if(input2[0]==input2[3]){
  return(0.0);
 }
 else{
  return(3.0);
 }

}

double five_aabbc(char input2[READNUM],char center){
 char chartemp;
 int i;
 if(input2[2]==center){
  return (15.6250);
 }
 else{
  for(i=0;i<5;i+=1){
   if(input2[i]==center){
    input2[i]=input2[2];
    input2[2]=center;
   }
  }

  if((input2[0]==input2[4])&&(input2[1]==input2[3])){
   return(19.375);
  }
  else{
   return(20.9375);
  }
 }
}

double five_aaabb(char input2[READNUM],char center){
 char chartemp;
 int i;
 if(input2[2]==center){
  return (6.25);
 }
 else{
  return (7.5);
 }
}


double fivechar(char input2[READNUM]){
 int i,j;
 int num=5;
 char inputtemp[6],chartemp;
 if((input2[0]==input2[4])&&(input2[1]==input2[3])){
  return(0.0);
 }
 else{

  for(i=0;i<=num;i+=1){
   inputtemp[i]=input2[i];
  }

  for(i=0;i<num-1;i+=1){
   for(j=i+1;j<num;j+=1){
    if(inputtemp[i]>inputtemp[j]){
     chartemp=inputtemp[j];
     inputtemp[j]=inputtemp[i];
     inputtemp[i]=chartemp;
    }
   }
  }

  if((inputtemp[0]!=inputtemp[2])&&(inputtemp[2]!=inputtemp[4])){
   if(inputtemp[0]!=inputtemp[1]){
    chartemp=inputtemp[0];
   }
   else if (inputtemp[2]!=inputtemp[3]){
    chartemp=inputtemp[2];
   }
   else{
    chartemp=inputtemp[4];
   }
   return (five_aabbc(input2,chartemp));
  }

  else if(inputtemp[1]!=inputtemp[3]){
   chartemp=inputtemp[2];
   return (five_aaabb(input2,chartemp));
  }

  else{
   chartemp=inputtemp[2];
   return (10.0);
  }
  return(-2.0);


 }

}

double sixchar(char input2[READNUM]){
 int i,j;
 int num=6;
 char inputtemp[7],chartemp;
 if((input2[0]==input2[5])&&(input2[1]==input2[4])){
  return(0.0);
 }
 else{

  for(i=0;i<=num;i+=1){
   inputtemp[i]=input2[i];
  }

  for(i=0;i<num-1;i+=1){
   for(j=i+1;j<num;j+=1){
    if(inputtemp[i]>inputtemp[j]){
     chartemp=inputtemp[j];
     inputtemp[j]=inputtemp[i];
     inputtemp[i]=chartemp;
    }
   }
  }

  if((inputtemp[0]!=inputtemp[2])&&(inputtemp[2]!=inputtemp[4])){
   if ((input2[0]==input2[5])||(input2[1]==input2[4])||(input2[2]==input2[3])){
    return(17.5);
   }
   else{
    return(20.0);
   }

  }

  else{
   return (7.5);
  }

  return(-2.0);


 }

}

double seven_aabbccd(char input2[READNUM],char center){
 char chartemp,inputtemp[8];
 int i;
 if(input2[3]==center){
  if((input2[0]==input2[6])||(input2[1]==input2[5])||(input2[2]==input2[4])){
   return (117.1793);
  }
  else{
   return (129.3674);
  }
 }
 else{
  for(i=0;i<8;i+=1){
   inputtemp[i]=input2[i];
  }
  
  for(i=0;i<7;i+=1){
   if(inputtemp[i]==center){
    inputtemp[i]=inputtemp[3];
    inputtemp[3]=center;
   }
  }

  if((inputtemp[0]==inputtemp[6])&&(inputtemp[1]==inputtemp[5])&&(inputtemp[2]==inputtemp[4])){
   return(129.6414);
  }
  else if((inputtemp[0]==inputtemp[6])||(inputtemp[1]==inputtemp[5])||(inputtemp[2]==inputtemp[4])){
   if((input2[0]==input2[6])||(input2[1]==input2[5])||(input2[2]==input2[4])){
    return(136.2614);
   }
   else{
    return(136.9419);
   }
  }
  else
  {
   return(138.0556);
  }
 }
}

double seven_aaabbcc(char input2[READNUM],char center){
 char chartemp,inputtemp[8];
 int i;
 if(input2[3]==center){
  if(((input2[0]==input2[6])&&(input2[0]==center))||((input2[1]==input2[5])&&(input2[1]==center))||((input2[2]==input2[4])&&(input2[2]==center))){
   return (43.9268);
  }
  else if(((input2[0]==input2[6])&&(input2[0]!=center))||((input2[1]==input2[5])&&(input2[1]!=center))||((input2[2]==input2[4])&&(input2[2]!=center))){
   return (43.4731);
  }
  else{
   return (48.7319);
  }
 }
 else{
  for(i=0;i<8;i+=1){
   inputtemp[i]=input2[i];
  }
  
  for(i=0;i<7;i+=1){
   if((inputtemp[i]==center)&&(inputtemp[i]!=inputtemp[6-i])){
    inputtemp[i]=inputtemp[3];
    inputtemp[3]=center;
   }
  }

  if((inputtemp[0]==inputtemp[6])&&(inputtemp[1]==inputtemp[5])&&(inputtemp[2]==inputtemp[4])){
   return(47.6271);
  }
  else if((input2[0]==input2[6])||(input2[1]==input2[5])||(input2[2]==input2[4])){
   return(51.0299);
  }
  else{
   return(51.2567);
  }
 }
}

double seven_aaaabbc(char input2[READNUM],char center,char four){
 char chartemp,inputtemp[8];
 int i,cposi;
 if(input2[3]==center){
  return (47.1852);
 }
 
 else if(input2[3]==four){
  if(((input2[0]==input2[6])&&(input2[0]!=center)&&(input2[0]!=four))||((input2[1]==input2[5])&&(input2[1]!=center)&&(input2[1]!=four))
   ||((input2[2]==input2[4])&&(input2[2]!=center)&&(input2[2]!=four))){
   return (55.9352);
  }
  else{
   for(i=0;i<7;i+=1){
    if(input2[i]==center){
     cposi=i;
    }
   }
   if(input2[6-cposi]==four){
    return (59.5648);
   }
   else{
    return (59.3380);
   }
  }
 }
 
 else{
  for(i=0;i<8;i+=1){
   inputtemp[i]=input2[i];
  }
  
  for(i=0;i<7;i+=1){
   if(inputtemp[i]==center){
    inputtemp[i]=inputtemp[3];
    inputtemp[3]=center;
   }
  }

  if((inputtemp[0]==inputtemp[6])&&(inputtemp[1]==inputtemp[5])&&(inputtemp[2]==inputtemp[4])){
   return(56.3889);
  }
  else
  {
   return(59.3380);
  }
 }
}

double seven_aaaabbb(char input2[READNUM],char center){
 char chartemp,inputtemp[8];
 int i,cposi;
 if(input2[3]==center){
  return (17.6944);
 }

 else if(((input2[0]==input2[6])&&(input2[0]==center))||((input2[1]==input2[5])&&(input2[1]==center))||((input2[2]==input2[4])&&(input2[2]==center))){
  return (20.6111);
 }
 else{
  return (21.9722);
 }
}

double seven_aaaaabb(char input2[READNUM],char center){
 char chartemp,inputtemp[8];
 int i,cposi;
 if(input2[3]==center){
  return (12.25);
 }


 else{
  return (14.0);
 }
}


double sevenchar(char input2[READNUM]){
 int i,j;
 int num=7;
 char inputtemp[8],chartemp,chartemp2='0';
 if((input2[0]==input2[6])&&(input2[1]==input2[5])&&(input2[2]==input2[4])){
  return(0.0);
 }
 else{

  for(i=0;i<=num;i+=1){
   inputtemp[i]=input2[i];
  }

  for(i=0;i<num-1;i+=1){
   for(j=i+1;j<num;j+=1){
    if(inputtemp[i]>inputtemp[j]){
     chartemp=inputtemp[j];
     inputtemp[j]=inputtemp[i];
     inputtemp[i]=chartemp;
    }
   }
  }

  if((inputtemp[0]!=inputtemp[2])&&(inputtemp[2]!=inputtemp[4])&&(inputtemp[4]!=inputtemp[6])){
   if(inputtemp[0]!=inputtemp[1]){
    chartemp=inputtemp[0];
   }
   else if (inputtemp[2]!=inputtemp[3]){
    chartemp=inputtemp[2];
   }
   else if (inputtemp[4]!=inputtemp[5]){
    chartemp=inputtemp[4];
   }
   else{
    chartemp=inputtemp[6];
   }
   return (seven_aabbccd(input2,chartemp));
  }


  else if((inputtemp[0]!=inputtemp[3])&&(inputtemp[3]!=inputtemp[6])){
   if(inputtemp[0]==inputtemp[2]){
    chartemp=inputtemp[0];
    return (seven_aaabbcc(input2,chartemp));
   }
   else if (inputtemp[4]==inputtemp[6]){
    chartemp=inputtemp[6];
    return (seven_aaabbcc(input2,chartemp));
   }
   else if (inputtemp[1]==inputtemp[3]){
    chartemp=inputtemp[0];
    chartemp2=inputtemp[3];
    return (seven_aaaabbc(input2,chartemp,chartemp2));
   }
   else if (inputtemp[3]==inputtemp[5]){
    chartemp=inputtemp[6];
    chartemp2=inputtemp[3];
    return (seven_aaaabbc(input2,chartemp,chartemp2));
   }
   else{
    chartemp=inputtemp[3];
    return (seven_aaabbcc(input2,chartemp));
   }
   return (-4.0);
  }

  else if((inputtemp[0]==inputtemp[3])&&(inputtemp[3]!=inputtemp[4])&&(inputtemp[4]!=inputtemp[6])){
   chartemp2=inputtemp[3];
   if(inputtemp[4]==inputtemp[5]){
    chartemp=inputtemp[6];
   }
   else{
    chartemp=inputtemp[4];
   }
   return (seven_aaaabbc(input2,chartemp,chartemp2));
  }
  else if((inputtemp[6]==inputtemp[3])&&(inputtemp[3]!=inputtemp[2])&&(inputtemp[2]!=inputtemp[0])){
   chartemp2=inputtemp[3];
   if(inputtemp[2]==inputtemp[1]){
    chartemp=inputtemp[0];
   }
   else{
    chartemp=inputtemp[2];
   }
   return (seven_aaaabbc(input2,chartemp,chartemp2));
  }

  else if((inputtemp[0]==inputtemp[3])&&(inputtemp[3]!=inputtemp[4])&&(inputtemp[4]==inputtemp[6])){
   chartemp=inputtemp[4];
   return (seven_aaaabbb(input2,chartemp));
  }
  else if((inputtemp[0]==inputtemp[2])&&(inputtemp[2]!=inputtemp[3])&&(inputtemp[3]==inputtemp[6])){
   chartemp=inputtemp[2];
   return (seven_aaaabbb(input2,chartemp));
  }
  else if((inputtemp[0]==inputtemp[4])&&(inputtemp[4]!=inputtemp[5])&&(inputtemp[5]==inputtemp[6])){
   chartemp=inputtemp[4];
   return (seven_aaaaabb(input2,chartemp));
  }
  else if((inputtemp[0]==inputtemp[1])&&(inputtemp[1]!=inputtemp[2])&&(inputtemp[2]==inputtemp[6])){
   chartemp=inputtemp[2];
   return (seven_aaaaabb(input2,chartemp));
  }
  else if((inputtemp[0]==inputtemp[5])||(inputtemp[1]==inputtemp[6])){
   return (21.0);
  }
  
  
  
  return(-2.0);


 }

}

double eight_aabbccdd(char input2[READNUM]){
 char chartemp,inputtemp[8];
 int i,count;
 count=0;
 for(i=0;i<=3;i+=1){
  if(input2[i]==input2[7-i]){
   count=count+1;
  }
 }
 if(count==2){
  return(121.3333);
 }
 else if (count==1){
  return(131.7436);
 }
 else{
  for(i=1;i<=6;i+=1){
   if(input2[i]==input2[0]){
    count=i;
   }
  }
  
  if(input2[7-count]==input2[7]){
   return(133.3590);
  }
  else{
   return(134.6154);
  }
 }
}

double eight_aaaabbcc(char input2[READNUM],char four){
 char chartemp,inputtemp[8];
 int i,count,count2;
 count=0;count2=0;
 for(i=0;i<=3;i+=1){
  if(input2[i]==input2[7-i]){
   count=count+1;
   if(input2[i]==four){
    count2=count2+1;
   }
  }
 }
 if((count==2)&&(count2==2)){
  return(48.4615);
 }
 else if ((count==2)&&(count2==1)){
  return(47.3846);
 }
 else if (count==1){
  return(52.7692);
 }
 else{
  return(53.3077);
 }
}

double eight_aaaabbbb(char input2[READNUM]){
 char chartemp,inputtemp[8];
 int i,count,count2;
 count=0;count2;
 for(i=0;i<=3;i+=1){
  if(input2[i]==input2[7-i]){
   count=count+1;
  }
 }
 if(count==0){
  return(21.0);
 }
 else{
  return(18.6667);
 }
}


double eightchar(char input2[READNUM]){
 int i,j,count,count2;
 int num=8;
 char inputtemp[9],chartemp;
 if((input2[0]==input2[7])&&(input2[1]==input2[6])&&(input2[2]==input2[5])){
  return(0.0);
 }
 else{

  for(i=0;i<=num;i+=1){
   inputtemp[i]=input2[i];
  }

  for(i=0;i<num-1;i+=1){
   for(j=i+1;j<num;j+=1){
    if(inputtemp[i]>inputtemp[j]){
     chartemp=inputtemp[j];
     inputtemp[j]=inputtemp[i];
     inputtemp[i]=chartemp;
    }
   }
  }

  if((inputtemp[0]!=inputtemp[2])&&(inputtemp[2]!=inputtemp[4])&&(inputtemp[4]!=inputtemp[6])){
   return (eight_aabbccdd(input2));
  }

  else{
   count=0;
   if((inputtemp[0]!=inputtemp[2])&&(inputtemp[2]!=inputtemp[4])){
    count=1;
    chartemp=inputtemp[4];
   }
   if((inputtemp[0]!=inputtemp[2])&&(inputtemp[4]!=inputtemp[6])){
    count=1;
    chartemp=inputtemp[2];
   }
   if((inputtemp[2]!=inputtemp[4])&&(inputtemp[4]!=inputtemp[6])){
    count=1;
    chartemp=inputtemp[0];
   }
   
   if(count==1){
    return (eight_aaaabbcc(input2,chartemp));
   }

   else if(inputtemp[2]!=inputtemp[4]){
    return(eight_aaaabbbb(input2));
   }
   else{
    return(14.0);
   }
  }
 }

 return(-2.0);

}

main(){
 int i,j,n;
 int length;
 double answer;
 char input[READNUM];

 char filename[100];
// FILE *fp;

// sprintf(filename,"input01.txt");
// fp=fopen(filename,"r"); 

// fscanf(fp,"%d", &n);
 scanf("%d", &n);
 
 for(i=0;i<n;i+=1){
  answer=-1.0;
  scanf("%s", input);
//  fscanf(fp,"%s", input);
  length=0;
  for(j=8;j>=1;j-=1){
   if(input[j]=='\0'){
    length=j;
   }
  }

  if(length<=2){
   answer=one_twochar(input);
  }

  else if(length==3){
   answer=threechar(input);
  }

  else if(length==4){
   answer=fourchar(input);
  }

  else if(length==5){
   answer=fivechar(input);
  }

  else if(length==6){
   answer=sixchar(input);
  }

  else if(length==7){
   answer=sevenchar(input);
  }

  else if(length==8){
   answer=eightchar(input);
  }


 printf("%.4f\n",answer);

 }

// fclose(fp);
}






==============================================================











Swap Nodes












IN scala












import java.util.Scanner

/**
 * Created by hama_du on 2014/03/21.
 */
object Solution extends App {
  class Node(value: Int, left: Option[Node], right: Option[Node], depth: Int) {
    var swapped = true
    def swap(d: Int) {
      if (depth % d == 0) {
        swapped = !swapped
      }
      left map { l =>
        l.swap(d)
      }
      right map { r =>
        r.swap(d)
      }
    }

    def apply(v: Int, p: (Int, Int)): Node = {
      if (v == value) {
        new Node(value, Node.buildNode(p._1, depth+1), Node.buildNode(p._2, depth+1), depth)
      } else {
        val newLeft = left map { l =>
          l.apply(v, p)
        }
        val newRight = right map { r =>
          r.apply(v, p)
        }
        new Node(value, newLeft, newRight, depth)
      }
    }

    def traverse(): String = {
      val leftT = left match {
        case Some(n) => n.traverse()
        case None => ""
      }
      val rightT = right match {
        case Some(n) => n.traverse()
        case None => ""
      }
      if (swapped) {
        (leftT + " " + value + " " + rightT).trim
      } else {
        (rightT + " " + value + " " + leftT).trim
      }
    }
  }

  object Node {
    def emptyNode(value: Int, depth: Int): Node = {
      new Node(value, None, None, depth)
    }

    def buildNode(v: Int, d: Int): Option[Node] = {
      if (v == -1) {
        None
      } else {
        Some(emptyNode(v, d))
      }
    }
  }

  val in = new Scanner(System.in)
  val N = in.nextInt()
  val rootNode = (1 to N).foldLeft(Node.emptyNode(1, 1))((node, idx) => {
    val a,b = in.nextInt()
    val pair = (a,b)
    node.apply(idx, pair)
  })
  val K = in.nextInt()
  (0 until K).foldLeft(rootNode)((node, _) => {
    val idx = in.nextInt()
    node.swap(idx)
    println(node.traverse())
    node
  })
}






============================================







Kindergarten Adventures


























#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

int main() {
    int n;
    scanf("%d", &n);
    int *dc = calloc(n, sizeof(int));
    int count = 0;
    for (int i = 0; i < n; i++) {
        int x;
        scanf("%d", &x);
        if (x < n) {
            int start = (i+1)%n;
            int end = (start-x+n)%n;
            dc[start]++;
            dc[end]--;
            if (end <= start) count++;
        }
    }
    int id = 0;
    int val = 0;
    for (int i = 0; i < n; i++) {
        count += dc[i];
        if (count > val) {
            val = count;
            id = i;
        }
    }
    printf("%d", id+1);
    free(dc);
    return 0;
}















































Anonymous