Java compressing Strings

Question

Мне нужно создать метод, который получает строку, а также возвращает строку.

Ex вход: AAABBBBCC

Ex выход: 3A4B2C

Ну, это довольно неловко, и я не мог управлять, чтобы сделать это на интервью, которое я имел сегодня (я претендующий на Детскую позицию), теперь, пытаясь дома, я сделал что-то, что работает статически, я имею в виду, не используя цикл, который бесполезен, но я не знаю, не получаю ли я достаточное количество часов сна или что-то еще, но я не могу понять как бы выглядел мой цикл for. Это код:

public static String Comprimir(String texto){ 

    StringBuilder objString = new StringBuilder(); 

    int count; 
    char match; 

     count = texto.substring(texto.indexOf(texto.charAt(1)), texto.lastIndexOf(texto.charAt(1))).length()+1; 
     match = texto.charAt(1); 
     objString.append(count); 
     objString.append(match); 

    return objString.toString(); 
} 

Спасибо за вашу помощь. Я пытаюсь улучшить свои логические навыки.

Answer 1

• использование StringBuilder (вы это сделали)
• определить две переменные - previousChar и counter
• цикл от 0 до str.length() - 1
• каждый раз получить str.charat(i) и сравнить его с тем, что хранится в переменной previousChar
• если предыдущий символ тот же, увеличьте счетчик
• , если предыдущий символ не является то же самое, и счетчик 1, приращение счетчика
• , если предыдущий символ не то же самое, и счетчик> 1, добавление counter + currentChar, сброс счетчика
• после сравнения, присвоить текущей CHAR previousChar
• крышки угловой такие случаи, как «первый знак»

Что-то в этом роде.

Answer 2

Прокрутите строку, помня, что вы видели в последний раз. Каждый раз, когда вы видите одно и то же число букв. Когда вы видите новое письмо, положите то, что вы пересчитали на выход, и установите новое письмо как то, что вы видели в последний раз.

String input = "AAABBBBCC"; 

int count = 1; 

char last = input.charAt(0); 

StringBuilder output = new StringBuilder(); 

for(int i = 1; i < input.length(); i++){ 
    if(input.charAt(i) == last){ 
    count++; 
    }else{ 
     if(count > 1){ 
      output.append(""+count+last); 
     }else{ 
      output.append(last); 
     } 
    count = 1; 
    last = input.charAt(i); 
    } 
} 
if(count > 1){ 
    output.append(""+count+last); 
}else{ 
    output.append(last); 
} 
System.out.println(output.toString()); 

Answer 3

Вы можете сделать это, используя следующие шаги:

• Создать HashMap
• Для каждого персонажа, получить значение из HashMap -Если значение равно нулю, введите 1 - в противном случае замените значение на (значение + 1)
• Итерайте по HashMap и продолжайте конкатенацию (Value + Key)

Answer 4

В строке count = ... lastIndexOf не будет заботиться о последовательных значениях и просто даст последнее вхождение.

Например, в строке «ABBA» подстрокой будет вся строка.

Кроме того, длина подстроки эквивалентна вычитанию двух индексов.

Я действительно считаю, что вам нужна петля. Вот пример:

public static String compress(String text) { 
    String result = ""; 

    int index = 0; 

    while (index < text.length()) { 
     char c = text.charAt(index); 
     int count = count(text, index); 
     if (count == 1) 
      result += "" + c; 
     else 
      result += "" + count + c; 
     index += count; 
    } 

    return result; 
} 

public static int count(String text, int index) { 
    char c = text.charAt(index); 
    int i = 1; 
    while (index + i < text.length() && text.charAt(index + i) == c) 
     i++; 
    return i; 
} 

public static void main(String[] args) { 
    String test = "AAABBCCC"; 
    System.out.println(compress(test)); 
} 

Answer 5

private String Comprimir(String input){ 
     String output=""; 
     Map<Character,Integer> map=new HashMap<Character,Integer>(); 
     for(int i=0;i<input.length();i++){ 
      Character character=input.charAt(i); 
      if(map.containsKey(character)){ 
       map.put(character, map.get(character)+1); 
      }else 
       map.put(character, 1); 
     } 
     for (Entry<Character, Integer> entry : map.entrySet()) { 
      output+=entry.getValue()+""+entry.getKey().charValue(); 
     } 
     return output; 
    } 

Еще один простой способ использования мультимножестве guava-

import java.util.Arrays; 

import com.google.common.collect.HashMultiset; 
import com.google.common.collect.Multiset; 
import com.google.common.collect.Multiset.Entry; 

public class WordSpit { 
    public static void main(String[] args) { 
     String output=""; 
     Multiset<String> wordsMultiset = HashMultiset.create(); 
     String[] words="AAABBBBCC".split(""); 
     wordsMultiset.addAll(Arrays.asList(words)); 
     for (Entry<String> string : wordsMultiset.entrySet()) { 
      if(!string.getElement().isEmpty()) 
       output+=string.getCount()+""+string.getElement(); 
     } 
     System.out.println(output); 
    } 
} 

Answer 6

Это просто еще один способ сделать это.

public static String compressor(String raw) { 
     StringBuilder builder = new StringBuilder(); 
     int counter = 0; 
     int length = raw.length(); 
     int j = 0; 
     while (counter < length) { 
      j = 0; 
      while (counter + j < length && raw.charAt(counter + j) == raw.charAt(counter)) { 
       j++; 
      } 

      if (j > 1) { 
       builder.append(j); 
      } 
      builder.append(raw.charAt(counter)); 
      counter += j; 
     } 

     return builder.toString(); 
    } 

Answer 7

Java не мой основной язык, вряд ли когда-либо использовать его, но я хотел дать ему шанс:] даже не уверен, если ваше задание требует петлю, но вот регулярное выражение подход:

public static String compress_string(String inp) { 
     String compressed = ""; 
     Pattern pattern = Pattern.compile("([\\w])\\1*"); 
     Matcher matcher = pattern.matcher(inp); 
     while(matcher.find()) { 
     String group = matcher.group(); 
     if (group.length() > 1) compressed += group.length() + ""; 
     compressed += group.charAt(0); 
     } 
     return compressed; 
    } 

Answer 8

Приведенный ниже код попросит пользователя ввести конкретный символ для подсчета вхождения.

import java.util.Scanner; 

class CountingOccurences { 

public static void main(String[] args) { 

    Scanner inp = new Scanner(System.in); 

    String str; 
    char ch; 
    int count=0; 

    System.out.println("Enter the string:"); 
    str=inp.nextLine(); 
    System.out.println("Enter th Char to see the occurence\n"); 
    ch=inp.next().charAt(0); 

    for(int i=0;i<str.length();i++) 
    { 
       if(str.charAt(i)==ch) 
     { 
      count++; 
       } 
    } 

     System.out.println("The Character is Occuring"); 
     System.out.println(count+"Times"); 


} 

} 

Answer 9

public static char[] compressionTester(char[] s){ 

    if(s == null){ 
     throw new IllegalArgumentException(); 
    } 

    HashMap<Character, Integer> map = new HashMap<>(); 
    for (int i = 0 ; i < s.length ; i++) { 

     if(!map.containsKey(s[i])){ 
      map.put(s[i], 1); 
     } 
     else{ 
      int value = map.get(s[i]); 
      value++; 
      map.put(s[i],value); 
     }   
    }    
    String newer=""; 

    for(Character n : map.keySet()){ 

     newer = newer + n + map.get(n); 
    } 
    char[] n = newer.toCharArray(); 

    if(s.length > n.length){ 
     return n; 
    } 
    else{ 

     return s;    
    }      
} 

Answer 10

package com.tell.datetime; 

import java.util.Stack; 
public class StringCompression { 
    public static void main(String[] args) { 
     String input = "abbcccdddd"; 
     System.out.println(compressString(input)); 
    } 

    public static String compressString(String input) { 

     if (input == null || input.length() == 0) 
      return input; 
     String finalCompressedString = ""; 
     String lastElement=""; 
     char[] charArray = input.toCharArray(); 
     Stack stack = new Stack(); 
     int elementCount = 0; 
     for (int i = 0; i < charArray.length; i++) { 
      char currentElement = charArray[i]; 
      if (i == 0) { 
       stack.push((currentElement+"")); 
       continue; 
      } else { 
       if ((currentElement+"").equalsIgnoreCase((String)stack.peek())) { 
        stack.push(currentElement + ""); 
        if(i==charArray.length-1) 
        { 
         while (!stack.isEmpty()) { 

          lastElement = (String)stack.pop(); 
          elementCount++; 
         } 

         finalCompressedString += lastElement + "" + elementCount; 
        }else 
        continue; 
       } 

       else { 
        while (!stack.isEmpty()) { 

         lastElement = (String)stack.pop(); 
         elementCount++; 
        } 

        finalCompressedString += lastElement + "" + elementCount; 
        elementCount=0; 
        stack.push(currentElement+""); 
       } 

      } 
     } 

     if (finalCompressedString.length() >= input.length()) 
      return input; 
     else 
      return finalCompressedString; 
    } 

} 

Answer 11

Пожалуйста, попробуйте это. Это может помочь распечатать количество символов, которые мы передаем в формате строки через консоль.

import java.util.*; 

public class CountCharacterArray { 
    private static Scanner inp; 

public static void main(String args[]) { 
    inp = new Scanner(System.in); 
    String str=inp.nextLine(); 
    List<Character> arrlist = new ArrayList<Character>(); 
    for(int i=0; i<str.length();i++){ 
     arrlist.add(str.charAt(i)); 
    } 
    for(int i=0; i<str.length();i++){ 
     int freq = Collections.frequency(arrlist, str.charAt(i)); 
     System.out.println("Frequency of "+ str.charAt(i)+ " is: "+freq); 
    } 
    }  
} 

Answer 12

рассмотрим ниже решение, в котором строка s1 определяет уникальные символы, которые доступны в заданной строке s (для цикла 1), во втором для цикла построения строки s2, который не содержит уникальный характер и не из раз он повторяется путем сравнения строки s1 с s.

public static void main(String[] args) 
{ 
    // TODO Auto-generated method stub 

    String s = "aaaabbccccdddeee";//given string 
    String s1 = ""; // string to identify how many unique letters are available in a string 
    String s2=""; //decompressed string will be appended to this string 
    int count=0; 
    for(int i=0;i<s.length();i++) { 
     if(s1.indexOf(s.charAt(i))<0) { 
      s1 = s1+s.charAt(i); 
     } 
    } 
    for(int i=0;i<s1.length();i++) { 
     for(int j=0;j<s.length();j++) { 
      if(s1.charAt(i)==s.charAt(j)) { 
       count++; 
      } 
     } 
     s2=s2+s1.charAt(i)+count; 
     count=0; 
    } 

    System.out.println(s2); 
} 

Answer 13

Это может вам помочь.

public class StringCompresser 
{ 
public static void main(String[] args) 
{ 
    System.out.println(compress("AAABBBBCC")); 
    System.out.println(compress("AAABC")); 
    System.out.println(compress("A")); 
    System.out.println(compress("ABBDCC")); 
    System.out.println(compress("AZXYC")); 
} 

static String compress(String str) 
{ 
    StringBuilder stringBuilder = new StringBuilder(); 
    char[] charArray = str.toCharArray(); 
    int count = 1; 
    char lastChar = 0; 
    char nextChar = 0; 
    lastChar = charArray[0]; 
    for (int i = 1; i < charArray.length; i++) 
    { 
     nextChar = charArray[i]; 
     if (lastChar == nextChar) 
     { 
      count++; 
     } 
     else 
     { 
      stringBuilder.append(count).append(lastChar); 
      count = 1; 
      lastChar = nextChar; 

     } 
    } 
    stringBuilder.append(count).append(lastChar); 
    String compressed = stringBuilder.toString(); 

    return compressed; 
} 
} 

Выход:

3A4B2C 
3A1B1C 
1A 
1A2B1D2C 
1A1Z1X1Y1C 

Answer 14

Самого простой подход: - Время Сложность - O (п)

public static void main(String[] args) { 
    String str = "AAABBBBCC";  //input String 
    int length = str.length();  //length of a String 

    //Created an object of a StringBuilder class   
    StringBuilder sb = new StringBuilder(); 

    int count=1; //counter for counting number of occurances 

    for(int i=0; i<length; i++){ 
     //if i reaches at the end then append all and break the loop 
     if(i==length-1){   
      sb.append(str.charAt(i)+""+count); 
      break; 
     } 

     //if two successive chars are equal then increase the counter 
     if(str.charAt(i)==str.charAt(i+1)){ 
      count++; 
     } 
     else{ 
     //else append character with its count        
      sb.append(str.charAt(i)+""+count); 
      count=1;  //reseting the counter to 1 
     } 
    } 

    //String representation of a StringBuilder object 
    System.out.println(sb.toString()); 

} 

Answer 15

можно использовать следующий, если вы ищете щелочной раствор. Перебирайте строку с помощью одного элемента и после нахождения всех вхождений элементов удалите этот символ. Чтобы он не вмешивался в следующий поиск.

public static void main(String[] args) { 
    String string = "aaabbbbbaccc"; 
    int counter; 
    String result=""; 
    int i=0; 
    while (i<string.length()){ 
     counter=1; 
     for (int j=i+1;j<string.length();j++){ 
      System.out.println("string length ="+string.length()); 
      if (string.charAt(i) == string.charAt(j)){ 
        counter++; 
      } 
     } 
     result = result+string.charAt(i)+counter; 
     string = string.replaceAll(String.valueOf(string.charAt(i)), ""); 
    } 
    System.out.println("result is = "+result); 
} 

И выход будет: = результат = a4b5c3

Answer 16

public class StringCompression { 
    public static void main(String[] args){ 
     String s = "aabcccccaaazdaaa"; 

     char check = s.charAt(0); 
     int count = 0; 

     for(int i=0; i<s.length(); i++){ 
      if(s.charAt(i) == check) { 
       count++; 
       if(i==s.length()-1){ 
       System.out.print(s.charAt(i)); 
       System.out.print(count); 
      } 
      } else { 
       System.out.print(s.charAt(i-1)); 
       System.out.print(count); 
       check = s.charAt(i); 
       count = 1; 
       if(i==s.length()-1){ 
        System.out.print(s.charAt(i)); 
        System.out.print(count); 
       } 
      } 
     } 
    }