import re
print(len(re.findall("[\S]", input("입력하세요:"))))  # 공백을 제외한 글자 정규식

package test;

public class test {
    public static void main(String[] args) {
        String str = "공백을 제외한\r\n" + "글자수만을 세는 코드 테스트";
        System.out.println(str.replaceAll("[^a-zA-Zㄱ-힣]", "").length());
    }
}

input='''공백을 제외한 
글자수만을 세는 코드 테스트'''
sum=0
for i in input:
    if i not in [" ", "\n"]: sum+=1
print(sum)

# 풀이 1
    val str = "공백을 제외한\n글자수만을 세는 코드 테스트"
    println(str.split(Array(' ', '\n')).map(_.length).sum)

# 풀이 2
    var cnt = 0
    for(i <- 0 until str.length){
      if(str(i) != ' ' && str(i) != '\n') cnt += 1
    }
    println(cnt)

도전 1. 초보답게

word = "공백을 제외한 글자수만을 세는 코드 테스트"
li = list(word)
temp = []

for i in li:
    if i != ' ':
        temp.append(i)


print(len(temp))

도전 2. 조금 덜 초보처럼 보이도록

word = "공백을 제외한 " \
       "글자수만을 세는 코드 테스트"

print(len([i for i in word if i != ' ']))

#include "stdafx.h"
#include <iostream>


int main()
{
    int i=0, cnt = 0;
    char str[50] = "공백을 제외한 \n 글자수만을 세는 코드 테스트";
    char *p = str;

    while (1)
    {
        if (*(p + i) == '\0') break;

        if (*(p + i) != ' ' && *(p+i) != '\n') cnt++;

        i++;
    }

    std::cout << str << "은(는)" << cnt << "개의 글자로 구성되어있습니다.";

}

....어음.. 왜 한글은 두배되는 값이 출력되는걸까요...?

Swift입니다.

print( "공백을 제외한\n글자수만을 세는 코드 테스트".filter({$0 != " " && $0 != "\n"}).count )

Ruby

cnt_chars = ->str { str.split.sum("").size }

Test

str = "공백을 제외한\n글자수만을 세는 코드 테스트\n"
expect( cnt_chars[str] ).to eq 18

# input에 줄바꿈까지 고려했습니다.
i1 = ''

while True:
    a = input()
    i1 += a
    if len(a) == 0:
        break

number = 0
for character in i1:
    if character != ' ':
        number += 1

print(number)

#include<iostream>
#include<string>
using namespace std;

int main()
{
    string name = "공백을 제외한 글자수만을 세는 코드 테스트";
    int index = 0, count = 0;
    for (int i = 0; i < name.length(); i++)
    {
        if (name.find(" ", index))
        {
            count++;
            index = name.find(" ", index+1);
            if (index == -1)
                break;
        }
    }
    cout << (name.length()/2) -(count+index)/2 << endl;
}

s =  "공백을 제외한 글자수만을 세는 코드 테스트"

count = 0
for i in s.split():
    count += len(i)

print(count)

#include<iostream>
#include"stdafx.h"

int main()
{
    wstring str(L"공백을 제외한\n글자수만을 세는 코드 테스트");
    int n1=count(str.begin(), str.end(), ' ');
    int n2 = count(str.begin(), str.end(), '\n');
    cout << str.length()-(n1+n2) << endl;
}

sub = list(input("내용을 입력하세요"))
cou = sub.count(' ')
for x in range(0,cou):
    sub.remove(' ')
print(len(sub))

def main():
    input_str = """공백을 제외한
    글자수만 세는 코드 테스트"""

    result = []

    for letter in input_str:
        if letter == ' ':
            pass
        else:
            result.append(letter)
    print(len(result))

if __name__ == '__main__':
    main()

def num_char(sentence):

    temp1 = sentence.replace('\n','')
    temp2 = temp1.replace(' ','')
    num_char=len(temp2)
    print(num_char)

sentence = """바보 똥개
멍청이 머저리"""

num_char(sentence)
10

python3

cnt = 0
s = "공백을 제외한\n 글자수만을 세는 코드 테스트"

for i in s:
    if i != " " and i != "\n":
        cnt += 1
print(cnt)

function textCount(e) {
  let str = e.toString();
  let redex = /\s/ig;
  let findTextLen = str.replace(redex, "").length
  return findTextLen
} //console에 입력 할 때는  textCount("문자")식으로 입력해주세요.

Python

test = "공백을 제외한\n글자수만을 세는 코드 테스트"
ans = 0
for i in test:
    if i not in [" ", "\n"]:
        ans += 1
print(ans)

data = '''공백을 제외한\n글자수만을 세는 코드 테스트'''
for c in [' ', '\n', '\r\n', '\t']: data = data.replace(c,'')
print(len(data))

def count_chr(words):
    count = 0
    for i in words:
        if i == " " or i == "\n":
            pass
        else:
            count += 1
    return count

word = "글자가 너무 많네 이히히힣"
print(count_chr(list(word)))

아주 초보스럽게 작성해보았습니다.

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("문장 입력 : ");
        String sss = sc.nextLine();
        int cnt = 0;

        for (int i = 0; i < sss.length(); i++) {
            if (sss.charAt(i) == ' ') {
                cnt++;
            }
        }   
        int sum = sss.length() - cnt;
        System.out.println(sum);
    }

입력받은 문장에서 스페이스만 제거

txt = '''공백을 제외한
글자수만을 세는 코드 테스트'''
print(len(txt.replace('\n','').replace(' ','')))

using System;

namespace CD165
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = @"공백을 제외한
글자수만을 세는 코드 테스트";
            Console.WriteLine(NumChar(input));
        }

        static int NumChar(string args)
        {
            string newString = args.Replace(" ", "");
            newString = newString.Replace(Environment.NewLine, "");
            return newString.Length;
        }
    }
}

import java.util.Scanner;

public class Solution {
    int NotTrimStringCount;
    String NoTrim(String YesTrim) {
        String NotTrim = YesTrim.replace(" ", "");
        NotTrim = NotTrim.replace("\n", "");
        NotTrimStringCount = NotTrim.length();

        return NotTrim;
    }
    public static void main(String args[]) {
        Solution sol = new Solution();
        Scanner sc = new Scanner(System.in);
        System.out.print("문장 입력 : ");
        String YesTrim = sc.nextLine();

        String NoTrim = sol.NoTrim(YesTrim);
        System.out.println("공백 제거 전 문자 개수 : " + YesTrim.length());
        System.out.println("공백 제거 후 문자 개수 : " + NoTrim.length());
        System.out.println("\n공백 제거 전 문자열 : " + YesTrim);
        System.out.println("공백 제거 후 문자열 : " + NoTrim);

    }
}

String 클래스의 replace메소드를 이용하여 공백과 줄넘김 문자를 "" 로 변경

str = '공백을 제외한 글자수만을 세는 코드'
return len(str)-str.count(' ')

string = '''공백을 제외한
글자수만을 세는 코드 테스트'''

count = 0

for i in string.split():
    count += len(i)

print(count)

C#

    public void GetCountStringWithoutSpace(string input)
    {
        int count = 0;

        foreach (var element in input)
        {
            if(Char.IsWhiteSpace(element) == false)
            count++;
        }

        Console.WriteLine(count);
    }

public class Javatutorial {
    public static void main(String[] args) {        
        Scanner sc = new Scanner(System.in);
        int cnt = 0;
        while (sc.hasNext()) {          
            cnt += sc.next().length();
        }
        System.out.println(cnt);
    }
}

import java.util.Scanner;

public class main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 0;

        System.out.println("문자를 입력해주세요 : ");
        String st = sc.nextLine();

        for(int i = 0; i < st.length(); i++){
            if(st.charAt(i) != ' '){
                count++;
            }
        }

        System.out.println(count);
    }
}

    class Program
    {
        static void Main(string[] args)
        {
            int nCnt = 0;
            string strInput = Console.ReadLine();

            for (int i = 0; i < strInput.Length; i++)
            {
                if (strInput[i] == ' ' || strInput[i] == '\t')
                    continue;
                 else
                    nCnt++;
            }
            Console.WriteLine("글자 수 : " + nCnt);
        }
    }

import re
t=re.compile('[\w]')
data ='''
공백을 제외한
글자수만을 세는 코드 테스트
'''
print(len(t.findall(data)))

#18

C언어
#include<stdio.h>
#include<string.h>

int main()
{
    char s1[100] ="공백을 제외한\n글자수만을 세는 코드 테스트";

    int len = 0;
    int count = 0;
    int su_len = 0;
    int i;

    len = strlen(s1); 

    for(i=0; i<len; i++)
    {
        if(s1[i]==' ' || s1[i] =='\n')
        {
            su_len++;
        }
    }

    len = (len - su_len)/2;

    printf("글자수 : %d \n", len);   

    return 0;
}

Ruby

l = -> str do str.gsub(/[\s]/, '').length end
puts l.call "공백을 제외한\n글자수만을 세는 코드 테스트"

// =====================================================        
        String st = "공백을 제외한\n글자수만을 세는 코드 테스트";
        System.out.println(st.replaceAll(" ", "").replaceAll("\n", "").length());

def count_ch(input_str):
    count_list = [x for x in input_str if x not in ' \t\n']
    return len(count_list)

assert count_ch('''    공백을 제외한 
    글자수만을 세는 코드 테스트''') == 18
assert count_ch('\t탭테스트 ') == 4
assert count_ch('a b 1 2 @ # A B') == 8

a='''공백을 제외한 
글자수만을 세는 코드 테스트'''

a=a.replace(' ','')
a=a.replace('\n','')

print(len(a))

print(len(input().replace(' ', '').replace('\t', '').replace('\n', '')))

word = input('글을 입력하세요')
cha = list(word)
count = []
for i in li:
    if i != ' ' and '\n':
        count.append(i)

print(len(count))

def stringK():
    string = input('입력하시오')
    total = ""
    for ch in string:
        if (ch!=" ") and (ch!='\n'):
            total += ch
    return len(total)

a = '''공백을 제외한
글자수만을 세는 코드 테스트'''
print(len(a.replace('\n', '').replace(' ', '')))

#include <stdio.h>
#include <string.h>
int main(void)
{
    char p[100] = "안녕하세요 저는 홍길동 입니다.";
    int cnt = 0;
    int len = strlen(p);

    for (int i = 0; i < len; i++)
    {
        if (p[i] != ' ' && p[i] != '\n')
            cnt++;
    }
    printf("%d", cnt/2);
    return 0;
}

st=input('문자열 입력: ')
i,total=0,len(st)#공백 포함
while i<len(st):
    if st[i]==' ':
        total-=1
    i+=1
print('총 개수:',total)

string = []
while True:
    string.append(input())
    if not string[-1]:
        break
total = 0
for i in string:
    a = i.count(' ')
    b = i.count('\n')
    result = (len(i) - a - b)
    total += result
print(total)

function removeBlank(input){
  const enter = input.split('/r/n')
  let result = ''
  for(let i = 0; i<enter.length; i++){
    const split = enter[i].split(' ')
    for(let j = 0; j<split.length; j++){
      result +=split[j]
    }
  }
  return result.length
}

removeBlank('공백을 제외한/r/n글자수만을 세는 코드 테스트')
//출력: 18

print(len("".join(input().split())))

string = """
공백을 제외한
글자수만을 세는 코드 테스트
"""
print(len(list(i for i in string if i != " " and i != "\n")))

조금 돌아가지만 색다르게 한줄로 풀어보깅

sent = input("문자열을 입력하세요: ")
result =""
for char in sent:
    if char != " " and char != "\n" and char != "\t":
        result += char
print(len(result))

파이썬~

namespace codingdojang_test
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = ("공백을 제외한\n 글자수만을 세는 코드 테스트");

            input = input.Replace("\n", "");
            input = input.Replace(" ", "");

            Console.WriteLine(input.Length);
        }
    }
}

N = str(input("문장을 입력하세요 : "))
result = 0

for i in N :
    if i != " " and i !="\n":
        result +=1

print(result)

파이썬입니다

length = 0
line = '공백을제외한 \n글자수만을 세는 코드 테스트'

for x in line.split():
    length += len(x)

print(length)

        static void Main(string[] args)
        {
            Console.WriteLine("*** 코딩도장 Q165 ***");

            Console.Write("글자 수를 셀 문자열을 입력해주세요. : ");
            string userInput = Console.ReadLine();

            Console.WriteLine("전체 글자수 : {0}", userInput.Length);

            int gili = userInput.Length;
            foreach (char i in userInput)
            {
                if (i.Equals(' ') || i.Equals('\r') || i.Equals('\n'))
                {
                    gili--;
                }
            }
            Console.WriteLine("공백 및 개행문자 제외한 글자수 : " + gili);
        }

import java.util.Scanner;
public class doing {
    public static void main(String[] args) {

        Scanner s = new Scanner (System.in);
        String y = s.nextLine();
        String[] a = y.split(" ");
        y="";
        for(int i=0; i<a.length;i++){
            y+=a[i].trim();
        }
        System.out.println(y.length());
    }
}

import java.util.Scanner;

public class practice {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int cnt = 0;

        System.out.println("입력 : ");
        String str = scanner.nextLine();

        for(int i = 0; i < str.length(); i++){
            if(str.charAt(i) != ' '){
                cnt++;
            }
        }

        System.out.println("불필요한 공백이 제거된 글자 수 : " + cnt);
    }
}

ans=0
print("아무것도 입력하지 않을 시, 결과출력.")
s='sdlkhnn'
while s!='':
    s=input()
    for i in s:
        if i==' ':
            continue
        ans+=1

print(ans)

입력에서 개행을 할 때 부득이 엔터를 누르는데 에디터가 이것을 입력 완료로 인식을 해버려서 부득이 조건부 루프를 이용, 특정입력을 받아서 누적된 정보를 출력하는 형식으로 만들었읍니다. 이후, 웹상의 무작위 문서에서 일부 내용을 Ctrl+C로 긁어와서 입력란에 그대로 붙여넣기 해 봄으로써 개행문자와 공백을 제외한 순 글자수만을 카운트하는 기능이 제대로 동작함을 확인하였읍니다.

print(len(input().replace(' ', '')) )

def count_chr(words): count = 0 for i in words: if i == ' ' or i == '\n': pass else: count +=1 return count

word = '글자 카운트'

print(count_chr(word))
\ 일내기는 코드 참조 했습니다. 마지막 print 할때 일내기님은 list로 감쌌는데, 안그렇게 해도 잘 돌아가는 듯요.

def cl():
    print(len(list(l for l in input('>>>') if l != ' ')))

한 줄 만들기 성공!

a = '''공백을 제외한
글자수만을 세는 코드 테스트'''

print(len(''.join(a.split())))              

#18

word = '공백을 제외한 글자수만을 세는 코드 테스트'
print(len([i for i in word if i != ' ']))

def conut_string():

    in_str = input('공백을 제거할 문자열을 입력하세요 : ')
    in_str = in_str.replace('\n','')
    in_str = in_str.replace('\t', '')
    in_str = in_str.replace(' ', '')

    return len(in_str)

if __name__ == '__main__':
    print(conut_string())

def countText(text):
    text = text.split()
    c = 0
    for i in range(len(text)):
        c += len(text[i])
    return c

print(countText("공백을 제외한\n글자수만을 세는 코드 테스트"))

import string
text = '''공백을 제외한
글자수만을 세는 코드 테스트'''
x = text.split('\n')   # \n 표시를 통한 구분
y = [] # 문자열 text 안에 있는 각 단어를 리스트로 저장
for i in range(len(x)):
    x[i] = x[i].split(' ')
    for k in range(len(x[i])):
        x[i][k] = x[i][k].strip(string.punctuation) # 각 단어 양쪽에 있는 특수문자 제거
        y.append(x[i][k])
sum = 0
for word in y:
    sum += len(str(word))
print(sum)  # 정답 : 18    

n=list(input("문장 입력:"))
while n.count(' '):
    n.remove(' ')
print(len(n))

list_1 = [' ', '\n', '\r\n', '\t']
data = '''공백을 제외한
글자수만을 세는 코드 테스트
'''
for c in list_1:
    data = data.replace(c, '')
print(len(data))

import re

def count_word(a):
    count = 0
    a = re.sub(r'\n', '', a)
    a = re.sub(r' ', '', a)
    print(len(a))

typing = "input yout num" li = list(typing) temp = []

for i in li: if i != ' ': temp.append(i)

print(len(temp))

def reLetter(result):
    result = result.replace(' ','')    
    result = result.replace("\n","")    
    out_put = len(result)
    return out_put

print(reLetter("abcd efg"))
print(reLetter("""abcd efg
deff"""))

python 3.*

# Counts of letters excluding spaces and '\n'
def counts(s):
    cnts = len(s)
    for i in range(len(s)):
        if s[i] == ' ' or s[i] == '\n':
            cnts -= 1
    return cnts

s = "공백을 제외한\n글자수만을 세는 코드 테스트"
print(counts(s))

import java.util.*;
public class 공백을제외한글자수세기 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String line = scan.nextLine();
        String changedLine = line.replaceAll(" ", "");
        changedLine = changedLine.replaceAll("\n", "");
        System.out.println(changedLine.length());
    }
}

파이썬

def string_count(string):
  a=list(string)
  while True:
    if ' ' in a:
      a.remove(' ')
    elif '\n' in a:  
      a.remove('\n')
    elif '\t' in a:  
      a.remove('\t')
    elif (' ' not in a and '\n' not in a and '\t' not in a):
      break

  return (f'{len(a)}')      

string=input("글자를 입력하세요 : ")
print(string_count(string))

len("".join(input("INPUT : ").split()))

결과

INPUT : 공백을 제외한 글자수만을 세는 코드 테스트
18

파이썬입니다.

n = input('문자열을 입력하시오: ')
len(''.join(n.split(' ')))

파이썬입니다.

n = input('문자를 입력하시오: ')
print(len(n.replace('\n', '').replace(' ','')))

a='''공백을제외한
글자수만을세는코드테스트'''
num=0
for i in a:
    if i not in [' ','\n']:
        num+=1
print(num)

wds="공백을 제외한\n글자수만을 세는 코드 테스트"
print(len(wds)-len([i for i in wds if i == " " or i=="\n"]))

#또는 
count=0
for i in wds:
    if i not in [" ", "\n"]:
        count+=1
print(count)

stringStr = input('문자열입력')
print(len(stringStr.replace(' ', '').replace("\n", '')))

example = "1  2345"
# 글자수를 세는 것은 len으로 충분하지 않을까.. 줄바꿈 \n과 공백 " "을 제외하려면? 일단 if 와 counter를 올리는 방법이 젤 무난

counter = 0
for i in example:
    if i not in ["\n"," "]:
    # 이건 틀린거. if not "\n" or " ":
        counter += 1
print(counter)

let Word = "Whatever you do make it pay";
let WordTrim = Word.replace(/(\s*)/g,"");
let Count = 0;

for (let index = 0; index < Word.length; index++) {
        Count++;
}

console.log(Count);

파이썬 3입니다

count = 0
while True:
    line = input()
    if not line:
        break
    count += len(line)-line.count(' ')

print(count)

import java.util.Scanner;

public class CountCharacter {
    public static void main(String[] args) {
        Scanner Sc = new Scanner(System.in);
        int count = 0;
        System.out.print("글자를 입력하시오: ");
        String input = Sc.nextLine();
        String[] array = input.split("");
        for(int i =0; i<array.length; i++) {
            if(array[i].contentEquals(" ") || array[i].contentEquals("\n") ) {
                count++;
            }
        }
        System.out.printf("글자수는 %d 입니다.", array.length-count);
    }
}

a = list(input("입력: "))

b = []

for i in a:
    if i != " " :
        b.append(i)

print(len(b))

import re

text = str(input("Enter the text:"))

len(list(re.sub('\s','',text)))

import re
string = input('문자열을 입력하세요:')
string = string.replace(' ', '')
string = string.replace('\n', '')
print(len(string))

a = input() b = a.replace(" ", "") print(len(b))

def delt(s):
    s1 = s.split('\n')
    result=''
    for i in s1:
        for j in i.split(' '):
            result+=j

    return len(result)

import re
p=re.compile('\S')
data=input()
print(len(p.findall(data)))

# split 를 이용
def count_chr(s):
    list_a = s.split()
    result = 0
    for c in list_a:
        result += len(c)
    return result


case = '공백을 제외한\n글자수만을 세는 코드 테스트'


print(count_chr(case))

N = list();
while True:
    input_data = input()
    if input_data == '':
        break
    else:
        M = list(input_data)
        for i in M:
            N.append(i)
final = 0
for i in N:
    if i != ' ':
        final +=1
print(final)

print(len(input().replace(' ','').replace('\n','')))

text=input('문자열 입력하면 글자수 세준다 : ')
print(len(text)-text.count(' '))

파이썬 입니다.

print(len(input("글자수 세기 : ").replace(" ","")))

def count_string(s):
    return len(s.replace("\n", "").replace(" ", ""))

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Q164 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String[] input = scan.nextLine().split("");
        ArrayList<String> a = new ArrayList<String>(Arrays.asList(input));
        while(true) {
            if(a.contains(" ")) a.remove(" ");
            else break;
        }
        System.out.println(a.size());

        scan.close();
    }
}

a = str(input())
print(len(a.replace(" ", "")))

import sys
sentence=sys.stdin.readlines()
x=[]
for i in sentence:
    x=x+i.split()
print(x)
k=0
for j in x:
    k+=len(j)
print(k)

it,n='''공백을 제외한
글자수만을 세는 코드 테스트''',0
for i in range (len(it)):
    if it[i]!=' ' and it[i]!='\n':
        n+=1
print (n)

namespace _60일차_9월30일
{        
    class MainApp
    {
        static void Main(string[] args)
        {
            //공백을 제외한 글자수만을 리턴하는 코드
            Console.Write("Input Sentence : ");
            string Input = Console.ReadLine();
            char[] Data = Input.Replace(" ", "").ToCharArray();
            Console.WriteLine(Data.Length);
        }
    }
}

public static void main(String[] args) {        

        Scanner scan = new Scanner(System.in);
        System.out.print("문장 입력 : ");
        String word = scan.nextLine();

        char[] alphabet = word.replace(" ","").toCharArray();

        System.out.println("\n" + alphabet.length +"개");

        }   

a=input()
k=len(a)
for x in a:
    if x==(' ' or '\t'):
        k-=1
print(k)

class CountString:
    def __init__(self):
        self.n = 0
    def getNumCha(self,text):
        text = text.replace("\n","")
        text = text.replace(" ","")
        self.n = len(text)
        print(self.n)

text = """
공백을 제외한
글자수만을 세는 코드 테스트
"""
a = CountString()
a.getNumCha(text)

input='공백을 제외한\n글자 수만을 세는 코드 테스트'
input=input.split()
wordsWithoutBlank=''
for x in input:
    wordsWithoutBlank+=x

print(len(wordsWithoutBlank))

def Counter(text):
    count = 0
    for aa in text:
        if aa == ' ' or aa == '\n':
            continue
        count += 1

    return print(count)

Counter(input('input: '))

def noGap(s):
    s = s.split()
    print(sum([len(x) for x in s]))


noGap("공백을 제외한\n글자수만을 세는 코드 테스트")

word=input("write sentence that you want to count")

for_answer=word.replace(" ","")

for_answers=for_answer.replace("\n","")

print(len(for_answers))

text = '공백을 제외한\n글자수만을 세는 코드 테스트'
len(''.join(text.split()))

n=int(input("몇 줄입력:"))
a=0

list1=[]

for i in range(n):
  str1=input()

  for k in str1:
    list1.append(k)

for x in list1:
  if x !=" ":

    a+=1

print(a)

print(len(input('입력하세요 ').replace(" ","")))

a = input("문자열을 입력하세요:")
new_a = a.replace(' ','')
li = list(new_a)
count = 0

for i in li:
    count += 1



print(count)

Question = "공백을 제외한 글자수만을 세는 코드 테스트"
Answer = Question.replace(" ","")
print(len(list(Answer)))

A = '공백을 제외한 글자수만을 세는 코드 테스트'
l = A.split(' ')
sum = 0
for i in l:
    sum += len(i)
print(sum)

s = '공백을 제외한\n글자수만을 세는 코드 테스트'
s_n = s.replace(" ",'').replace("\n",'')

print(len(s_n))

import re
str = """
공백을 제외한
글자수만을 세는 코드 테스트
"""
print(re.findall('\S',str))

x=input('문자열 입력')

a=x.split(' ')
result=0

for i in a :
    result+=len(i)

print(result)

#영어였으면 isalpha()를 사용했을텐데 한글이라 isspace()를 사용하여 filter 하였습니다.

def counting_char(string):
    list_a = list(string)
    count = 0
    for i in list_a:
        if not i.isspace():
            count += 1
    return count

m = "공백을 제외한 글자수만을 세는 코드 테스트"
m1 = len(''.join(m.split(" ")))
print(m1)

a = input('할말')
b = a.replace(" ","")
print(len(b))

#파이썬입니다.
def count_strings():
    list1=list(input("글자 수 테스트: 글자를 적어주세요"))
    list2=[]

    for i in list1:
        if i==' ':
            continue
        elif i=='\n':
            continue
        else:
            list2.append(i)

    before_return=''.join(list2)
    return len(before_return)

#codingdojing_countChr

print(len(input("string: ").replace(' ', '').replace('\n', '')))

input = "공백을 제외한\n글자수만을 세는 코드 테스트"
ans = 0
for i in input:
    if i not in [" ", "\n"]:
        ans += 1
print(ans)

python 3.9.6입니다. 한 줄로 짜 보았습니다.

print(sum([len(string) for string in input('문자열 입력: ').split()]))

실행 결과입니다.

문자열 입력: 공백을 제외한 글자수 세기
11

파이썬 3.8.10으로 작성되었습니다. max_line의 수 만큼 입력을 받을 수 있습니다. 입력을 받을 시 공백을 단위로 끊어 한 줄이 완성됩니다. reduce를 사용하여 각 줄의 길이를 합해 갑니다.

from functools import reduce
max_line = 2  
text = [input().split(' ') for _ in range(max_line)]
print(reduce(lambda x, y: len(''.join(x)) + len(''.join(y)), text))

"방법1"
a = '공백을 제외한\n글자수만을 세는 코드 테스트'
d = a.count('\n')
b = a.count(' ')
a = len(a)
i = a - d - b
print(i)
"방법2"
a = '공백을 제외한\n글자수만을 세는 코드 테스트'
a = a.replace(" ", "")
a = a.replace("\n", "")
print(len(a))

s = '''공백을 제외한 
글자수만을 세는 코드 테스트'''

counter = 0
for i in s:
    if len(i.strip())>0:
        counter += 1
print(counter)

```{.python} string=input('문자열을 입력하세요. ') a=string.replace(' ','') b=a.replace('\n','') print(len(b))

`

string=input('문자열을 입력하세요. ')
a=string.replace(' ','')
b=a.replace('\n','')
print(len(b))

def length(s):
  return sum(1 for c in s if not s.isspace())

static void strCount(String x) {
        System.out.println(x.replaceAll(" ", "").replaceAll("\n", "").replaceAll("\t", "").length() + "개");
    }

    static void noReplace(String x) {
        int num = 0;
        for(int i = 0; i < x.length(); i++) {
            if(x.charAt(i) != ' ' && x.charAt(i) != '\n' && x.charAt(i) != '\t') {
                ++num;
            }
        }
        System.out.println(num + "개");
    }

    public static void main(String[] args) {
        String str = "공백을 제외한\n글자수만을 세는 코드 테스트";
        strCount(str);
        noReplace(str);
    }

print(len("".join(input(":").split())))

b = str(input("아무 글자나 입력"))
c = list("".join(b))
f = list(filter(lambda x :x !=" " and x != "\n" , c))

print(len(f))

sen = '''공백을 제외한
글자수만을 세는 코드 테스트'''
count = 0

for sel in sen:
  if sel == ' ' or sel == '\n':
    continue
  else:
    count += 1

print(count)

a = input("문장을 입력하세요.")
print(len(a.replace('\n','').replace(' ','')))

package org.javaturotials.ex;
import java.util.*;
import java.util.stream.Collectors;

public class test {
    public static void main(String[] args) {    
    Scanner sc =new Scanner(System.in);
    String gongplus = sc.nextLine();
    String str = gongplus.replaceAll(" ", "");
    System.out.println(str.length());
   }
   }

a=str(input("아무거나 입력하시오"))
result=a.replace(" ","")
print(len(result))

import java.util.Scanner;

public class DeleteSpace {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("아무문장이나 입력하십시오.");
        String mj = sc.nextLine();
        int count = 0;

        for(int i=0; i<mj.length();i++) {
            if(mj.charAt(i) == ' ') {
                count++;
            }
        }
        int sum = mj.length() - count; // 공백이 몇개인지 세서 mj.length에서 빼줌
        System.out.println(sum);
    }

}

package com.algorithm.algorithmpractice.dojang;
public class CountChar {
    public static void main(String[] args) {
        String input = "adsjfklajdsf   adsf joaidsjfioaj oidjfo         dsajfoiasdf a";
        char blank = ' ';
        char tab = '\t';

        char[] resultArr = new char[input.length()];
        int k = 0;
        for(int i = 0; i < input.length(); i++){
            char pushThis = input.charAt(i);
            if(pushThis == blank || pushThis == tab){
                continue;
            }
            resultArr[k] = pushThis;
            k++;
        }

        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < k; i++){
            sb.append(resultArr[i]);
        }
        String result = sb.toString();
        System.out.println(result);
    }
}

regex 안 써버리기

import re
print(len(re.findall('\S',input("글자를 입력하세요. :"))))

inp = input("문자열을 입력하세요 : ")

print(len(inp)-inp.count(" ")-inp.count("\n"))

test="공백을 제외한\n 글자수만을 세는 코드 테스트"
test=test.replace(' ','')
test=test.replace('\n','')
len(test)

python

input = "공백을 제외한\n글자수만을 세는 코드 테스트"
words = input.replace(' ','').replace('\n','')
print(len(words))

s=input('셀 문자를 적어주세요 > ')
n=0
for l in s.split():
    n+=len(l)
print(n)

Python. 사용자로부터 줄바꿈이 포함된 인풋을 받는 방법이 궁금해지는데, 이건 좀 어려운 일이네요.

lines=input("임의의 문장을 입력해 주세요. : ")
result=lines.replace(' ' or '\n', '') #공백 혹은 줄바꿈 제거)

print(len(result))

user_input = input()
print(len(user_input.replace(" ","")))

    private static int numOfString(String str) {

        String newStr = str.replaceAll(" ", "");

        //System.out.println(newStr);

        int numStr = newStr.length();

        return numStr;

    }

str = '공백을 제외한 글자수만을 세는 코드 테스트'
def countlen(str):
    str = str.split(' ')
    st = ''
    for s in str:
        st += s
    return len(st)

print(countlen(str))

python

        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine().replace("\n", "").replace(" ", "");

        System.out.println(text.length());

java

string = input(">")
s = 0
for i in string:
   if i not in [" "]:
      s += 1
print(s)

a = """공백을 제외한 
글자수만을 세는 코드 테스트"""

total = 0

for i in a:
    if i != ' ' and i != '\n':
        total += 1
print(total)

a = "Life is short"
b = a.count(' ')
print(len(a)-b)

def counts():
    sentence = input("Enter the sentence:")
    return len(sentence.split())