모바일을 모스 부호로 변환
도전
알파벳 문자 (대문자 및 소문자), 숫자, 쉼표, 마침표 및 물음표 만 사용하여 숫자를 입력하고 모스 부호의 언어 표현을 반환하는 문자 수별 가장 짧은 코드입니다. 모스 부호 출력은 -긴 경고음 (AKA 'dah') 의 경우 대시 ( , ASCII 0x2D)와 .짧은 경고음 (AKA 'dit')의 점 ( , ASCII 0x2E)으로 구성되어야합니다.
각 문자는 공백 ( ' ', ASCII 0x20)으로 구분해야하며 각 단어는 슬래시 ( /, ASCII 0x2F) 로 구분해야합니다 .
모스 부호 표 :
대체 텍스트 http://liranuna.com/junk/morse.gif
테스트 사례 :
Input:
Hello world
Output:
.... . .-.. .-.. --- / .-- --- .-. .-.. -..
Input:
Hello, Stackoverflow.
Output:
.... . .-.. .-.. --- --..-- / ... - .- -.-. -.- --- ...- . .-. ..-. .-.. --- .-- .-.-.-
코드 수에는 입력 / 출력 (즉, 전체 프로그램)이 포함됩니다.
C (131 자)
예, 13 1 !
main(c){for(;c=c?c:(c=toupper(getch())-32)?
"•ƒŒKa`^ZRBCEIQiw#S#nx(37+$6-2&@/4)'18=,*%.:0;?5"
[c-12]-34:-3;c/=2)putch(c/2?46-c%2:0);}
while및 for루프 의 논리를 단일 for루프 로 결합 하고 c변수 선언을 main입력 가지 변수로 정의로 이동하여 몇 가지 문자를 더 찾았습니다 . 이 후자의 기술 은 또 다른 도전에 대한 스트레이 거의 대답 에서 빌 렸습니다 .
GCC 또는 ASCII 전용 편집기로 프로그램을 확인하려는 경우 다음과 같이 약간 더 긴 버전이 필요할 수 있습니다.
main(c){for(;c=c?c:(c=toupper(getchar())-32)?c<0?1:
"\x95#\x8CKa`^ZRBCEIQiw#S#nx(37+$6-2&@/4)'18=,*%.:0;?5"
[c-12]-34:-3;c/=2)putchar(c/2?46-c%2:32);}
이 버전은 다음과 같은 변경 사항으로 인해 17 자 더 길어졌습니다 (비교적 큰 148로 무게).
- +4 :
getchar()하고putchar()대신 비 스마트 폰getch()및putch() - +6 : ASCII가 아닌 문자 대신 두 문자에 대한 이스케이프 코드
- +1 : 공백 문자의 경우 0 대신 32
- +6 :
c<0?1:ASCII 32보다 작은 문자 (즉, from'\n')의 가비지하기 위해 " "를 추가했습니다 .!"#$%&'()*+[\]^_`{|}~또는 ASCII 126 이상의 모든 것에서 여전히 쓰레기를 얻습니다 .
이렇게하면 코드를 완전히 이식 할 수 있습니다. 다음으로
gcc -std = c89 -funsigned-char morse.c
는 -std=c89선택 사항입니다. 는 -funsigned-char하지만, 필요하거나 쉼표와 마침표에 쓰레기를 얻을 것입니다.
135 자
c;main(){while(c=toupper(getch()))for(c=c-32?
"•ƒŒKa`^ZRBCEIQiw#S#nx(37+$6-2&@/4)'18=,*%.:0;?5"
[c-44]-34:-3;c;c/=2)putch(c/2?46-c%2:0);}
제 생각 에이 최신 버전은 훨씬 더 매력적입니다. 또한 이식성이 더 이상 범위를 벗어난 것이 없습니다. 그것은 또한 꽤 나쁜 UI를 가지고 언어, 문자 단위로 입력하고 그것을 모스 부호로 변환하고 종료 조건 이 없습니다 ( Ctrl+ 를 누르 야 함 Break). 그러나 멋진 UI를 이식 가능하고 강력한 코드는 필수가 아니 었습니다.
코드에 대한 가능한 간단한 설명은 다음과 가변합니다.
main(c){
while(c = toupper(getch())) /* well, *sort of* an exit condition */
for(c =
c - 32 ? // effectively: "if not space character"
"•ƒŒKa`^ZRBCEIQiw#S#nx(37+$6-2&@/4)'18=,*%.:0;?5"[c - 44] - 34
/* This array contains a binary representation of the Morse Code
* for all characters between comma (ASCII 44) and capital Z.
* The values are offset by 34 to make them all representable
* without escape codes (as long as chars > 127 are allowed).
* See explanation after code for encoding format.
*/
: -3; /* if input char is space, c = -3
* this is chosen because -3 % 2 = -1 (and 46 - -1 = 47)
* and -3 / 2 / 2 = 0 (with integer truncation)
*/
c; /* continue loop while c != 0 */
c /= 2) /* shift down to the next bit */
putch(c / 2 ? /* this will be 0 if we're down to our guard bit */
46 - c % 2 /* We'll end up with 45 (-), 46 (.), or 47 (/).
* It's very convenient that the three characters
* we need for this exercise are all consecutive.
*/
: 0 /* we're at the guard bit, output blank space */
);
}
코드의 긴 인코딩에있는 각 문자에는 하나의 텍스트 문자에 대해 인코딩 된 모스 부호가 포함됩니다. 인코딩 된 문자의 각 비트는 대시 또는 점을 나타냅니다. 1은 대시를 많은 0은 점을 나타냅니다. 최하위 비트는 모스 부호의 첫 번째 대시 또는 점을 나타냅니다. 마지막 "가드"는 코드의 길이를 결정합니다. 즉, 인코딩 된 각 문자에서 가장 높은 1 비트는 코드 끝을 문서 인쇄되지 않습니다. 이 가드 비트가 후행 점이있는 문자를 인쇄 할 수 없습니다.
예를 들어, 문자 'L'은 .-..모스 부호에서 " "입니다. 이진수로 표현하려는 최하위 비트 0010부터 시작하여 0, 1 및 두 개의 0이 더 필요합니다. 가드 비트에 대해 1을 더 지정하고 인코딩 된 모스 코드 : 10010 또는 10 진수를 사용합니다. 18. +34 추가하여 문자 '4'의 ASCII 값인 52를 얻습니다. 인코딩 된 문자 배열에는 33 번째 문자 (인덱스 32)로 '4'가 있습니다.
이 기술은 ACoolie 's , strager's (2) , Miles 's , pingw33n's , Alec 's , Andrea의 솔루션 에서 문자를 인코딩하는 데 사용되는 것과 유사 하지만 더 간단하여 비트 당 하나의 작업 ( 이동 / 분할) 만 필요합니다. / 나누기 및 감소).
편집 :
나머지 구현을 읽어 보면 Alec 과 Anon 이 가드 비트를 사용하여 인코딩 체계를 생각해 낸 것을 알았습니다. Anon의 솔루션은 특히 흥미 롭습니다. Python의bin함수를 사용 하고 Alec과 제가했던 것처럼 루프, 앤딩, 시프트 대신으로"0b"접두사와 가드 비트를 제거합니다[3:].
보너스 로이 버전은 하이픈 ( -....-), 슬래시 ( ), 콜론 ( -..-.), 세미콜론 ( ---...), 같음 -.-.-.( -...-) 및 at 기호 ( .--.-.)도 처리합니다. 8 비트 문자가 허용되는 한 기본 문자는 지원하는 데 추가 코드 바이트가 필요하지 않습니다. 코드에 길이를 추가하지 않고 버전에서는 더 이상 문자를 지원할 수 없습니다 (보다 크거나 작은 기호에 대한 모스 부호가없는 경우).
이전 구현이 여전히 흥미롭고 텍스트 에이 버전에 적용 할 수있는 몇 가지주의 사항이 있기 때문에 게시물의 이전 내용을 아래에 애 다었습니다.
좋아요, 아마도 사용자 인터페이스가 엉망이 될 수 있습니다. 그래서 strager 에서 차용하여 gets()버퍼링 된 에코 된 라인 입력 getch()을 제공하는 것을 버퍼링하지 않고 선택하지 않은 문자 입력을 제공 하는 대체했습니다 . 이 입력하는 모든 문자가 화면에서 즉시 모스 부호로 번역을 의미합니다. 아마 멋지다. 더 이상 stdin 또는 명령 줄 인수와 함께 작동하지 않지만 매우 작습니다.
그러나 참조를 위해 아래의 이전 코드를 보관했습니다. 여기 새로운 것이 있습니다.
경계 검사가 포함 된 새 코드, 171 자 :
W(i){i?W(--i/2),putch(46-i%2):0;}c;main(){while(c=toupper(getch())-13)
c=c-19?c>77|c<31?0:W("œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"
[c-31]-42):putch(47),putch(0);}
Enter 루프를 끄고 프로그램을 종료합니다.
경계 검사가없는 새 코드, 159 자 :
W(i){i?W(--i/2),putch(46-i%2):0;}c;main(){while(c=toupper(getch())-13)
c=c-19?W("œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"[c-31]-42):
putch(47),putch(0);}
아래는 몇 가지 설명과 함께 이전 196/177 코드를 다음과 같이합니다.
W(i){i?W(--i/2),putch(46-i%2):0;}main(){char*p,c,s[99];gets(s);
for(p=s;*p;)c=*p++,c=toupper(c),c=c-32?c>90|c<44?0:W(
"œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"[c-44]-42):
putch(47),putch(0);}
이것은 대답과 같은 모스 코드를 생성하는 것과 동일한 기술을 사용하는 Andrea의 Python 대답을 기반으로 합니다. 그러나 인코딩 가능한 문자를 차례로 저장하고 색인을 찾는 대신 색인을 뒤에 저장하고 문자별로 조회합니다 ( 이전 과 유사 함 ). 이는 이전 구현 자에게 문제를 일으킨 끝 부분의 긴 간격을 방지합니다.
이전 과 많이 127보다 큰 문자를 사용했습니다. ASCII 전용으로 변환하면 3 개의 문자가 추가됩니다. 긴 모바일의 첫 번째 문자는로 바꿔야합니다 \x9C. 이번에는 행사가 필요합니다. 문자가 32 개부터 시작하여 이스케이프 코드로 표시 해야합니다 .
또한 이전과 추가 stdin 대신 명령 줄 인수를 처리하면 2 개의 문자가 추가되고 코드 사이에 실제 공백 문자를 사용하면 1 개의 문자가 추가됩니다.
반면에 여기에있는 다른 루틴 중 일부는 [, .0-9 \? A-Za-z]의 허용 범위를 벗어난 입력을 처리하지 않습니다. 현재 처리 가이 루틴에서 제거되면 19 개 문자를 제거하여 총 177 자까지 계속 사용할 수 있습니다. 그러나 입력하면 충돌 및 레코딩 될 수 있습니다.
이 경우 코드는 다음과 가변적입니다.
W(i){i?W(--i/2),putch(46-i%2):0;}main(){char*p,s[99];gets(s);
for(p=s;*p;p++)*p=*p-32?W(
"œ*~*hXPLJIYaeg*****u*.AC5+;79-@6=0/8?F31,2:4BDE"
[toupper(*p)-44]-42):putch(47),putch(0);}
사용 모스 코드 글꼴을 ?
Console.Write(params[0]);
Perl, 170 자 (숙련 된 골퍼의 도움으로 mauke). 명확성을 위해 포장되었습니다. 모든 개행은 제거 가능합니다.
$_=uc<>;y,. ,|/,;s/./$& /g;@m{A..Z,0..9,qw(| , ?)}=
".-NINNN..]IN-NII..AMN-AI---.M-ANMAA.I.-].AIAA-NANMMIOMAOUMSMSAH.B.MSOIONARZMIZ"
=~/../g;1while s![]\w|,?]!$m{$&}!;print
설명 :
- 모스 사전을 추출하십시오. 각 기호는 리터럴 점이나 대시 또는 정의 된 다른 문자의 값에 대한 참조 일 수있는 두 개의 문자로 정의됩니다. E와 T는 비용의 동기화를 피하기 위해 더미 문자를 포함합니다. 나중에 제거하겠습니다.
- 입력을 읽고 형식을 지정하십시오.
"Hello world"된다"H E L L O / W O R L D" - 다음 단계는 입력 및 출력 사전이 구별되는 것에 따라 달라 지므로 입력의 점을 사용하지 않는 문자 (세로 막대,
|)로 바꿉니다. - 대체가 발생하지 않을 때까지 모스 사전에서 발생하는 입력의 문자를 사전의 값으로 바꿉니다.
- 1 단계에서 한 더미 문자를 제거합니다.
- 출력을 인쇄하십시오.
최종 버전에서 사전은 운영 효율성을 위해 최적화되었습니다.
- 모든 단일 기호 문자 (E 및 T)와 두 기호 문자 (A, I, M 및 N)가 직접 정의되고 한 번에 사용됩니다.
- 3 개의 기호로 된 모든 문자는 2 개의 기호로 된 문자와 리터럴 기호로 정의됩니다.
- 4 개의 기호로 된 모든 문자는 2 개의 2 개의 기호로 된 문자로 정의되며, 3 개의 교체로 2 번의 패스로 사용됩니다.
- 5 개 및 6 개 기호 문자 (숫자 및 구두점)는 추가 4 개 또는 5 개의 대체와 함께 3 번의 패스로 사용됩니다.
골프 코드는 루프 당 하나의 문자 만 대체 사용 (코드의 한 문자를 저장하기 위해!) 루프 수는 입력 길이의 5 배 (알파벳 만 사용하는 경우 입력 길이의 3 배)로 제한됩니다. 그러나 연산 에 a g를 추가하면 s///루프 수는 3 개로 제한됩니다 (알파벳 만 사용하는 경우 2 개).
변환 예 :
Hello 123
H E L L O / 1 2 3
II .] AI AI M- / AO UM SM
.... . .-.. .-.. --- / .-M- .A-- I.--
.... . .-.. .-.. --- / .---- ..--- ...--
Python 목록 이해, 159 자 한 줄짜리
for c in raw_input().upper():print c<","and"/"or bin(ord("•ƒwTaQIECBRZ^`šŒ#S#n|':<.$402&9/6)(18?,*%+3-;=>"[ord(c)-44])-34)[3:].translate(" "*47+"/.-"+" "*206),
P Daddy의 C 구현 과장 데이터 포장을 사용 하지만 비트를 역순으로 저장하지 않고 bin()산술보다는 데이터를 추출하는 데 사용 합니다. 공백은 부등식을 사용하여 감지됩니다. "쉼표보다"모든 문자를 공백으로 적게합니다.
Python for루프, 줄 바꿈 포함 205 자
for a in raw_input().upper():
q='_ETIANMSURWDKGOHVF_L_PJBXCYZQ__54_3___2__+____16=/_____7___8_90'.find(a);s=''
while q>0:s='-.'[q%2]+s;q=~-q/2
print['/','--..--','..--..','.-.-.-',''][' ,?.'.find(a)]+s,
기호에 대한 간결한 코딩을하고 있었지만 이미 사용중인 암시 적 트리보다 더 나아지는 알 수있는 다른 사람이 사용할 수있는 경우를 대비하여 여기에 코딩을 제시합니다.
고대를 고려하십시오.
--..--..-.-.-..--...----.....-----.--/
필요한 모든 시퀀스를 하위 하위로 포함합니다. 다음 과 같이 객실과 길이로 기호를 코딩 할 수 있습니다.
ET RRRIIGGGJJJJ
--..--..-.-.-..--...----.....-----.--/
CCCC DD WWW 00000
,,,,,, AALLLL BBBB 11111
--..--..-.-.-..--...----.....-----.--/
?????? KKK MMSSS 22222
FFFF PPPP 33333
--..--..-.-.-..--...----.....-----.--/
UUU XXXX 44444
NN PPPP OOO 55555
--..--..-.-.-..--...----.....-----.--/
ZZZZ 66666
77777 YYYY
--..--..-.-.-..--...----.....-----.--/
...... 88888 HHHH
99999 VVVV QQQQ
--..--..-.-.-..--...----.....-----.--/
마지막 문자 ( '/')에서 시작하고 끝나는 공백 (즉, 단어 경계)이 있습니다. 좋은 방법을 찾으면 자유롭게 사용하십시오.
물론 대부분의 짧은 기호에는 몇 가지 가능한 코딩이 있습니다.
P Daddy는이 트릭의 더 짧은 버전을 찾았고 (이제 여기서 두성 중 일부를 볼 수 있습니다) 멋진 c 구현을 수행했습니다. Alec은 첫 번째 (버기 및 불완전한) 버전으로 기능 구현 을 수행 합니다. Hobbs는 내가 이해하지 못하는데 매우 한 펄 버전 을 만들었습니다 .
J, 124 개 (130) (134) 문자
'.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`dfggggggg-@B4*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper
J가 C를 친다! 대박!
용법 :
'.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`dfggggggg-@B4*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper 'Hello World'
.... . .-.. .-.. --- / .-- --- .-. .-.. -..
'.- /'{~;2,~&.>(]`(<&3:)@.(a:=])"0)}.&,&#:&.></.40-~a.i.')}ggWOKIHX`dfggggggg-@B4*:68,?5</.7>E20+193ACD'{~0>.45-~a.i.toupper 'Hello, Stackoverflow.'
.... . .-.. .-.. --- .-.-.- / ... - .- -.-. -.- --- ...- . .-. ..-. .-.. --- .-- --..--
Python 3 One Liner : 172 자
print(' '.join('/'if c==' 'else''.join('.'if x=='0'else'-'for x in bin(ord("ijÁĕÁÿïçãáàðøüþÁÁÁÁÁČÁÅ×ÚÌÂÒÎÐÄ×ÍÔÇÆÏÖÝÊÈÃÉÑËÙÛÜ"[ord(c)-44])-192)[3:])for c in input().upper()))
(번역 테이블을 유니 코드 코드 포인트로 인코딩합니다. 잘 작동하며 Windows Vista 컴퓨터의 테스트에서 여기에 잘 표시됩니다.)
불필요한 공백과 대괄호를 제거하여 184 자까지 줄 이도록 편집했습니다 (목록 구성 요소 생성).
다시 편집하기 전에 : 여기에서 다른 답변을보기 가능하다는 사실조차 몰랐습니다. 176 개로 줄었습니다.
''.join 대신 ''.join을 사용하고 공백을 추가하여 172 (woo woo!)까지 다시 편집합니다. (duh!)
C # 266 자
C #으로 변환 된 131 자 C 솔루션은 266 손상을 생성합니다.
foreach(var i in Encoding.ASCII.GetBytes(args[0].ToUpper())){var c=(int)i;for(c=(c-32!=0)?Encoding.ASCII.GetBytes("•ƒŒKa`^ZRBCEIQiw#S#nx(37+$6-2&@/4)'18=,*%.:0;?5")[c-44]-34:-3;c!=0;c/=2)Console.Write(Encoding.ASCII.GetChars(new byte[]{(byte)((c/2!=0)?46-c%2:0)}));}
다음과 같이 더 읽을 수 있습니다.
foreach (var i in Encoding.ASCII.GetBytes(args[0].ToUpper()))
{
var c = (int)i;
for (c = ((c - 32) != 0) ? Encoding.ASCII.GetBytes("•ƒŒKa`^ZRBCEIQiw#S#nx(37+$6-2&@/4)'18=,*%.:0;?5")[c - 44] - 34 : -3
; c != 0
; c /= 2)
Console.Write(Encoding.ASCII.GetChars(new byte[] { (byte)((c / 2 != 0) ? 46 - c % 2 : 0) }));
}
Golfscript-106 자-재미있는 문자 없음 :)
입력 끝의 줄 바꿈은 지원되지 않은 다음과 같이 사용하십시오.
echo -n Hello, Stackoverflow| ../golfscript.rb morse.gs
' '/{{.32|"!etianmsurwdkgohvf!l!pjbxcyzq"?)"UsL?/'#! 08<>"@".,?0123456789"?=or
2base(;>{'.-'\=}%' '}%}%'/'*
문자는 특수한 경우이며 소문자로 변환되고 이진 위치로 정렬됩니다.
다른 모든 작업은 번역 테이블에서 수행됩니다.
물론
불완전한 솔루션이지만 누군가가 완전한 솔루션을 만들 수 있습니다. 숫자 나 구두점을 처리하지 않지만 154 자에 불고기합니다.
def e(l):
i='_etianmsurwdkgohvf_l_pjbxcyzq'.find(l.lower());v=''
while i>0:v='-.'[i%2]+v;i=(i-1)/2;return v or '/'
def enc(s):return ' '.join(map(e,s))
C (248 자)
또 다른 트리 기반 솔루션.
#define O putchar
char z[99],*t=
" ETINAMSDRGUKWOHBL~FCPJVX~YZQ~~54~3~~~2~~+~~~~16=/~~.~~7,~~8~90";c,p,i=0;
main(){gets(z);while(c=z[i++]){c-46?c-44?c:O(45):O(c);c=c>96?c-32:c;p=-1;
while(t[++p]!=c);for(;p;p/=2){O(45+p--%2);}c-32?O(32):(O(47),O(c));}}
위키 백과 가 잘못된 것 보이 거나 내가 뭔가를 오해 혹시 소스 트리의 오류 일 수 있습니다 .
F #, 256 자
let rec D i=if i=16 then" "else
let x=int"U*:+F8c]uWjGbJ0-0Dnmd0BiC5?\4o`h7f>9[1E=pr_".[i]-32
if x>43 then"-"+D(x-43)else"."+D x
let M(s:string)=s.ToUpper()|>Seq.fold(fun s c->s+match c with
|' '->"/ "|','->"--..-- "|'.'->".-.-.- "|_->D(int c-48))""
예를 들면
M("Hello, Stack.") |> printfn "%s"
수확량
.... . .-.. .-.. --- --..-- / ... - .- -.-. -.- .-.-.-
지금까지 제 기술이 독특하다고 생각합니다. 아이디어는 다음과 가변적입니다.
- 우리가 원하는 대부분의 문자 (0..Z)를 포함하는 ASCII 범위의 문자가 있습니다.
- 이 범위에는 43 개의 문자 만 있습니다.
- 따라서 우리는 86 자 범위에서 1 비트 (대시 또는 점)와 '다음 문자'를 인코딩 할 수 있습니다.
- 범위 ascii (32-117)는 모두 '인쇄 가능'이며이 86 자 범위로 사용할 수 있습니다.
- 따라서 리터럴은 줄을 따라 테이블을 인코딩합니다.
조금 더 날 그게 요점입니다. 쉼표, 마침표 및 공백은 0..Z 범위에 있지 못해서 '일치'에 처리됩니다. 0..Z 범위의 일부 '사용되지 않은'문자 ( ';'와 같은)는 모스 '문자'가 아닌 다른 모스 번역의 접미사로 표에서 사용됩니다.
다음은 VB.Net의 콘솔 애플리케이션의 저의 기여입니다.
Module MorseCodeConverter
Dim M() As String = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..", "-----", ".----", "..---", "...--", "....-", ".....", "-....", "--...", "---..", "----."}
Sub Main()
Dim I, O
Dim a, b
While True
I = Console.ReadLine()
O = ""
For Each a In I
b = AscW(UCase(a))
If b > 64 And b < 91 Then
O &= M(b - 65) & " "
ElseIf b > 47 And b < 58 Then
O &= M(b - 22) & " "
ElseIf b = 46 Then
O &= ".-.-.- "
ElseIf b = 44 Then
O &= "--..-- "
ElseIf b = 63 Then
O &= "..--.. "
Else
O &= "/"
End If
Next
Console.WriteLine(O)
End While
End Sub
End Module
나는 그것을 읽을 수 있습니다 공백을 두었습니다. 총 1100 자입니다. 명령 줄에서 한 번에 한 줄씩 입력을 읽고 해당 출력을 다시 출력 스트림으로 보냅니다. 압축 된 버전은 아래에있는 632 자에 불고기합니다.
Module Q
Dim M() As String={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."}
Sub Main()
Dim I,O,a,b:While 1:I=Console.ReadLine():O="":For Each a In I:b=AscW(UCase(a)):If b>64 And b<91 Then:O &=M(b-65)&" ":ElseIf b>47 And b<58 Then:O &=M(b-22)&" ":ElseIf b=46 Then:O &=".-.-.- ":ElseIf b=44 Then:O &="--..-- ":ElseIf b=63 Then:O &= "..--.. ":Else:O &="/":End IF:Next:Console.WriteLine(O):End While
End Sub
End Module
C (233 자)
W(n,p){while(n--)putch(".-.-.--.--..--..-.....-----..../"[p++]);}main(){
char*p,c,s[99];gets(s);for(p=s;*p;){c=*p++;c=toupper(c);c=c>90?35:c-32?
"È#À#¶µ´³²±°¹¸·#####Ê#@i Že‘J•aEAv„…`q!j“d‰ƒˆ"[c-44]:63;c-35?
W(c>>5,c&31):0;putch(0);}}
이 stdin에서 입력을받습니다. 명령 줄에서 입력하면 2자가 추가합니다. 대신에 :
...main(){char*p,c,s[99];gets(s);for(p=s;...
당신은 얻는다 :
...main(int i,char**s){char*p,c;for(p=s[1];...
127 이상의 문자에 대해 Windows-1252 코드 페이지를 사용하고 다른 사람의 브라우저에서 어떻게 표시되는지 잘 모르겠습니다. (Google Chrome)에서 "@"와 "i"사이에있는 두 개의 문자가 표시되지 않습니다. 그러나 브라우저에서 복사하여 텍스트 편집기에 붙이면 작은 상자로 표시 표시됩니다.
ASCII 전용으로 변환 할 수 있습니다. 24 개의 문자가 추가되어 문자 수가 257 개로 동일합니다. 이렇게 적은 것보다 큰 문자 수를 최소화합니다. 그런 다음 필요한 경우 \xXX 문자 이스케이프를 대체 합니다. 다음과 같이 변경됩니다.
...c>90?35:c-32?"È#À#¶µ´³²±°¹¸·#####Ê#@i Že‘J•aEAv„…`q!j“d‰ƒˆ"[c-44]:63;
c-35?W(...
이에 :
...c>90?99:c-32?"\x88#\x80#vutsrqpyxw#####\x8A#\0PA)\xE0N%Q\nU!O\5\1\66DE 1
\xE1*S$ICH"[c-44]+64:63;c-99?W(...
다음은 더 멋지게 형식이 지정되고 주석이 달린 코드 버전입니다.
/* writes `n` characters from internal string to stdout, starting with
* index `p` */
W(n,p){
while(n--)
/* warning for using putch without declaring it */
putch(".-.-.--.--..--..-.....-----..../"[p++]);
/* dmckee noticed (http://tinyurl.com/n4eart) the overlap of the
* various morse codes and created a 37-character-length string that
* contained the morse code for every required character (except for
* space). You just have to know the start index and length of each
* one. With the same idea, I came up with this 32-character-length
* string. This not only saves 5 characters here, but means that I
* can encode the start indexes with only 5 bits below.
*
* The start and length of each character are as follows:
*
* A: 0,2 K: 1,3 U: 10,3 4: 18,5
* B: 16,4 L: 15,4 V: 19,4 5: 17,5
* C: 1,4 M: 5,2 W: 4,3 6: 16,5
* D: 9,3 N: 1,2 X: 9,4 7: 25,5
* E: 0,1 O: 22,3 Y: 3,4 8: 24,5
* F: 14,4 P: 4,4 Z: 8,4 9: 23,5
* G: 5,3 Q: 5,4 0: 22,5 .: 0,6
* H: 17,4 R: 0,3 1: 21,5 ,: 8,6
* I: 20,2 S: 17,3 2: 20,5 ?: 10,6
* J: 21,4 T: 1,1 3: 19,5
*/
}
main(){ /* yuck, but it compiles and runs */
char *p, c, s[99];
/* p is a pointer within the input string */
/* c saves from having to do `*p` all the time */
/* s is the buffer for the input string */
gets(s); /* warning for use without declaring */
for(p=s; *p;){ /* begin with start of input, go till null character */
c = *p++; /* grab *p into c, increment p.
* incrementing p here instead of in the for loop saves
* one character */
c=toupper(c); /* warning for use without declaring */
c = c > 90 ? 35 : c - 32 ?
"È#À#¶µ´³²±°¹¸·#####Ê#@i Že‘J•aEAv„…`q!j“d‰ƒˆ"[c - 44] : 63;
/**** OR, for the ASCII version ****/
c = c > 90 ? 99 : c - 32 ?
"\x88#\x80#vutsrqpyxw#####\x8A#\0PA)\xE0N%Q\nU!O\5\1\66DE 1\xE1"
"*S$ICH"[c - 44] + 64 : 63;
/* Here's where it gets hairy.
*
* What I've done is encode the (start,length) values listed in the
* comment in the W function into one byte per character. The start
* index is encoded in the low 5 bits, and the length is encoded in
* the high 3 bits, so encoded_char = (char)(length << 5 | position).
* For the longer, ASCII-only version, 64 is subtracted from the
* encoded byte to reduce the necessity of costly \xXX representations.
*
* The character array includes encoded bytes covering the entire range
* of characters covered by the challenge, except for the space
* character, which is checked for separately. The covered range
* starts with comma, and ends with capital Z (the call to `toupper`
* above handles lowercase letters). Any characters not supported are
* represented by the "#" character, which is otherwise unused and is
* explicitly checked for later. Additionally, an explicit check is
* done here for any character above 'Z', which is changed to the
* equivalent of a "#" character.
*
* The encoded byte is retrieved from this array using the value of
* the current character minus 44 (since the first supported character
* is ASCII 44 and index 0 in the array). Finally, for the ASCII-only
* version, the offset of 64 is added back in.
*/
c - 35 ? W(c >> 5, c & 31) : 0;
/**** OR, for the ASCII version ****/
c - 99 ? W(c >> 5, c & 31) : 0;
/* Here's that explicit check for the "#" character, which, as
* mentioned above, is for characters which will be ignored, because
* they aren't supported. If c is 35 (or 99 for the ASCII version),
* then the expression before the ? evaluates to 0, or false, so the
* expression after the : is evaluated. Otherwise, the expression
* before the ? is non-zero, thus true, so the expression before
* the : is evaluated.
*
* This is equivalent to:
*
* if(c != 35) // or 99, for the ASCII version
* W(c >> 5, c & 31);
*
* but is shorter by 2 characters.
*/
putch(0);
/* This will output to the screen a blank space. Technically, it's not
* the same as a space character, but it looks like one, so I think I
* can get away with it. If a real space character is desired, this
* must be changed to `putch(32);`, which adds one character to the
* overall length.
} /* end for loop, continue with the rest of the input string */
} /* end main */
이것은 몇 가지 파이썬 구현을 제외하고 여기에서 모든 것을 능가합니다. 더 짧아 질 수 계속 생각하지만 몇 가지 캐릭터를 더 깎을 방법을 찾습니다. 누구든지 개선의 여지가 더 있으면 알려주십시오.
편집하다 :
이 루틴은 ASCII 44 이상의 잘못된 문자를 거부하지만 (각 문자에 공백 만 출력 함)이 값 아래의 잘못된 문자는 확인하지 않습니다. 이를 확인하기 위해 전체 길이에 5 개를 추가하고 다음을 변경합니다.
...c>90?35:c-32?"...
이에 :
...c-32?c>90|c<44?35:"...
REBOL (118 자)
약 10 년 된 구현
foreach c ask""[l: index? find" etinamsdrgukwohblzfcpövxäqüyj"c while[l >= 2][prin pick"-."odd? l l: l / 2]prin" "]
인용 출처 : http://www.rebol.com/oneliners.html
(숫자는 단어는 이중 공백으로 구분됩니다 : / ...)
Python (210 자)
이것은 Alec 의 하나를 기반으로 한 완벽한 솔루션입니다.
def e(l):
i=(' etianmsurwdkgohvf_l_pjbxcyzq__54_3___2%7s16%7s7___8_90%12s?%8s.%29s,'%tuple('_'*5)).find(l.lower());v=''
while i>0:v='-.'[i%2]+v;i=(i-1)/2
return v or '/'
def enc(s):return ' '.join(map(e,s))
C, 338 자
들여 쓰기 및 제거 가능한 모든 줄 바꿈이 제거 된 338 :
#define O putchar
#define W while
char*l="x@@@@@ppmmmmm@@FBdYcbcbSd[Kcd`\31(\b1g_<qCN:_'|\25D$W[QH0";
int c,b,o;
main(){
W(1){
W(c<32)
c=getchar()&127;
W(c>96)
c^=32;
c-=32;
o=l[c/2]-64;
b=203+(c&1?o>>3:0);
o=c&1?o&7:o>>3;
W(o>6)
O(47),o=0;
c/=2;
W(c--)
b+=(l[c]-64&7)+(l[c]-64>>3);
b=(((l[b/7]<<7)+l[b/7+1])<<(b%7))>>14-o;
W(o--)
O(b&(1<<o)?46:45);
O(32);
}
}
이 다른 사람들이 취한 트리 접근 방식을 기반으로하지 않습니다. 대신, l먼저 32에서 95 사이의 모든 바이트 길이 (2 바이트 문자)를 인코딩합니다. 예를 들어, D는 3의 길이에 대해-..이고 E는. 길이 1의 경우 011 및 001로 인코딩되어 011001이 제공됩니다. 더 많은 문자를 인코딩 할 수있게하고 이스케이프를 방지하기 위해 64가 전체에 추가되어 1011001-89, ASCII Y가 제공됩니다. 모스가 아닌 문자에는 길이가 할당됩니다. l(로 시작하는 \031) 의 두 번째 절반은 점 모스 부호 자체의 비트는 1이고 대시는 0입니다. 높은 ASCII로 들어 가지 않도록 데이터는 7 비트 / 바이트로 인코딩됩니다.
코드는 먼저 삭제 c한 다음 c(in o) 의 모스 길이를 계산 한 다음 이전의 모든 문자 길이를 더하여 b데이터에 비트 를 생성 합니다.
마지막으로 비트를 반복하여 점과 대시를 인쇄합니다.
길이 '7'은 공백이있을 때 /를 인쇄하기위한 특수 플래그로 사용됩니다.
괄호를 제거하면 약간의 이득이 더 나은 결과를 얻을 수 있고 배가 고파서 ...
Linq를 사용하는 C # (133 자)
static void Main()
{
Console.WriteLine(String.Join(" ", (from c in Console.ReadLine().ToUpper().ToCharArray()
select m[c]).ToArray()));
}
좋아, 그래서 내가 속였다. 또한 다음과 같이 사전을 정의해야합니다 (이로 인해 게임에서 날아 가기 때문에 문자를 세지 가능성이 있습니다).
static Dictionary<char, string> m = new Dictionary<char, string>() {
{'A', ".-"},
{'B', "-.."},
{'C', "-.-."},
{'D', "-.."},
{'E', "."},
{'F', "..-."},
{'G', "--."},
{'H', "...."},
{'I', ".."},
{'J', ".---"},
{'K', "-.-"},
{'L', ".-.."},
{'M', "--"},
{'N', "-."},
{'O', "---"},
{'P', ".--."},
{'Q', "--.-"},
{'R', ".-."},
{'S', "..."},
{'T', "-"},
{'U', "..-"},
{'V', "...-"},
{'W', ".--"},
{'X', "-..-"},
{'Y', "-.--"},
{'Z', "--.."},
{'0', "-----"},
{'1', ".----"},
{'2', "..---"},
{'3', "...--"},
{'4', "....-"},
{'5', "....."},
{'6', "-...."},
{'7', "--..."},
{'8', "---.."},
{'9', "----."},
{' ', "/"},
{'.', ".-.-.-"},
{',', "--..--"},
{'?', "..--.."},
};
그래도 누군가가 이해하고 유지 관리하기 쉬운보다 간결한 C # 구현을 제공 할 수 있습니까?
펄, 206 자, dmckee의 아이디어 사용
처음 한 것보다 길지만 여전히 흥미 롭다고 생각합니다 . 그리고 / 또는 끔찍합니다. 아직 확실하지 않다. 이것은 dmckee의 코딩 아이디어와 내가 본 몇 가지 다른 좋은 아이디어를 사용합니다. 처음에는 "고정 된 언어의 길이 / 그"이 문자 당 고정 된 2 바이트 (그리고 인쇄 가능한 모든 바이트)를 사용하는 다른 솔루션의 스키마보다 약간의 데이터로 나올 수 있습니다. (문자 당 1 바이트, 인덱싱 할 26 비트 패턴을 저장하는 데 4 바이트 더) 관리했지만 최선의 노력에도 불구하고 데이터를 다시 가져옵니다. 골프. (덜 복잡하지만 IMO이지만 더 길다).
어쨌든 206 자입니다. 개행은 첫 번째를 제외하고 제거 할 수 있습니다.
#!perl -lp
($a,@b)=unpack"b32C*",
"\264\202\317\0\31SF1\2I.T\33N/G\27\308XE0=\x002V7HMRfermlkjihgx\207\205";
$a=~y/01/-./;@m{A..Z,0..9,qw(. , ?)}=map{substr$a,$_%23,1+$_/23}@b;
$_=join' ',map$m{uc$_}||"/",/./g
설명 :
- 데이터에는 두 부분이 있습니다. 처음 4 바이트 (
"\264\202\317\0"는"--.-..-.-.-----.....--..--------"처음 26 비트 만 사용 ) 모스 부호 ( ) 의 32 비트를 나타냅니다 . 이것은 "참조 참조"입니다. - 데이터 이동의 나머지 부분은 각 문자를 사용하는 참조의 하위 이동 시작 위치와 길이를 저장합니다 (A, B, ... Z, 0, 1, ... 9 순서로 문자 당 1 바이트). , ".", ",", "?"). 값은 23 * (길이 -1) + pos로 코딩되고 있습니다. 마지막 시작 위치는 물론 22입니다.
- 따라서 압축 해제는 데이터 추출 작업의 절반을 수행하고 세 번째 줄 (여기에서 볼 수 있음)이 나머지 작업을 수행합니다. 이제 우리는
$m{'a'} = '.-'등 이 포함 된 해시가 있으므로 남은 것은 입력의 문자를 일치시키는 것입니다. 마지막 줄이 수행하는 출력의 형식을 지정합니다. 오두막의 도움을 받아 펄 입력 입력에서 줄에게 바꿈을 제거하고 입력 입력 줄을 입력 입력$_하고 코드 실행이 완료되면$_출력에 다시 쓰 도록 지시합니다. 줄 바꿈이 다시 추가되었습니다.
Python 2; 171 자
기본적으로 Andrea의 솔루션 과 동일 하지만 완전한 프로그램이며 어리석은 트릭을 사용하여 짧게 만듭니다.
for c in raw_input().lower():print"".join(".-"[int(d)]for d in bin(
(' etianmsurwdkgohvf_l_pjbxcyzq__54_3___2%7s16%7s7___8_90%12s?%8s.%29s,'
%(('',)*5)).find(c))[3:])or'/',
(추가 된 줄 바꿈은 모두 제거 할 수 있음)
또는 bin()2.6 에서 함수 를 사용하지 않으려면 (176)에서 사용할 수 있습니다.
for c in raw_input():C=lambda q:q>0and C(~-q/2)+'-.'[q%2]or'';print C(
(' etianmsurwdkgohvf_l_pjbxcyzq__54_3___2%7s16%7s7___8_90%12s?%8s.%29s,'%
(('',)*5)).find(c.lower()))or'/',
(다시, 추가 된 줄 바꿈은 모두 제거 할 수 있습니다)
C89 (293 자)
다른 답변 중 일부를 기반으로합니다.
편집 : 나무를 축소합니다 (예).
#define P putchar
char t['~']="~ETIANMSURWDKGOHVF~L~PJBXCYZQ~~54~3",o,q[9],Q=10;main(c){for(;Q;)t[
"&./7;=>KTr"[--Q]]="2167890?.,"[Q];while((c=getchar())>=0){c-=c<'{'&c>96?32:0;c-
10?c-32?0:P(47):P(10);for(o=1;o<'~';++o)if(t[o]==c){for(;o;o/=2)q[Q++]=45+(o--&1
);for(;Q;P(q[--Q]));break;}P(32);}}
다음은 dmckee의 작업을 기반으로 한 또 다른 접근 방식으로 Python이 얼마나 읽기 쉬운 지 보여줍니다.
물론
244 자
def h(l):p=2*ord(l.upper())-88;a,n=map(ord,"AF__GF__]E\\E[EZEYEXEWEVEUETE__________CF__IBPDJDPBGAHDPC[DNBSDJCKDOBJBTCND`DKCQCHAHCZDSCLD??OD"[p:p+2]);return "--..--..-.-.-..--...----.....-----.-"[a-64:a+n-128]
def e(s):return ' '.join(map(h,s))
제한 사항 :
- dmckee의 많은에 'Y'문자가 누락되어 추가하기에는 너무 게으르다. "??"를 변경해야 할 것입니다. 부분, 두 번째는 리터럴 끝에 "-"추가
- 단어 사이에 '/'를 넣습니다. 다시 게으른
가장 많은 약간의 바이트가 아닌 가장 많은 문자를 요구하는 경우 인쇄 가능한 ASCII 문자를 벗어나려는 경우 내 테이블 중 하나 이상을 (반으로) 작게 만들 수 있습니다.
편집 : 순진하게 선택한 유니 코드 문자를 사용하지만 소스 파일에서 이스케이프 된 ASCII로 유지하면 간단하게하기 때문에 여전히 약간 짧아집니다.
물론
240 자
def h(l):a,n=divmod(ord(u'\x06_7_\xd0\xc9\xc2\xbb\xb4\xad\xa6\x9f\x98\x91_____\x14_AtJr2<s\xc1d\x89IQdH\x8ff\xe4Pz9;\xba\x88X_f'[ord(l.upper())-44]),7);return "--..--..-.-.-..--...----.....-----.-"[a:a+n]
def e(s):return ' '.join(map(h,s))
훨씬 더 명확 해 졌다고 생각합니다.
UTF-8로 저장되는 프로그램이 185 자로 가장 어 가장 짧은 완전한 Python 솔루션이 될 Perl이 될 생각합니다. :-)
모스 부호를 인코딩하는 다른 세 번째 방법이 있습니다.
물론
232 자
def d(c):
o='';b=ord("Y_j_?><80 !#'/_____f_\x06\x11\x15\x05\x02\x15\t\x1c\x06\x1e\r\x12\x07\x05\x0f\x16\x1b\n\x08\x03\r\x18\x0e\x19\x01\x13"[ord(c.upper())-44])
while b!=1:o+='.-'[b&1];b/=2
return o
e=lambda s:' '.join(map(d,s))
담당자 인쇄 가능한 문자 세트에 매핑하는 방법을 사용할 수 있습니다. 많은 문자를 사용할 수 있습니다. 가장 쉬운 방법은 쉬운 지 모르겠지만 가장 확실한 방법 일 것입니다 .
OK, 지금은 가능한 한 방법 이 너무 많은 시간을.
Haskell
type MorseCode = String
program :: String
program = "__5__4H___3VS__F___2 UI__L__+_ R__P___1JWAE"
++ "__6__=B__/_XD__C__YKN__7_Z__QG__8_ __9__0 OMT "
decode :: MorseCode -> String
decode = interpret program
where
interpret = head . foldl exec []
exec xs '_' = undefined : xs
exec (x:y:xs) c = branch : xs
where
branch (' ':ds) = c : decode ds
branch ('-':ds) = x ds
branch ('.':ds) = y ds
branch [] = [c]
예를 들어, decode "-- --- .-. ... . -.-. --- -.. ."반환합니다 "MORSE CODE".
이 프로그램은 Fun with Morse Code 에서 발췌 한 것 입니다.
PHP
이전 PHP 항목 을 더 많이 수정했습니다 . :)
$a=array(32=>"/",44=>"--..--",1,".-.-.-",48=>"-----",".----","..---","...--","....-",".....","-....","--...","---..","----.",63=>"..--..",1,".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..");
foreach(str_split(strtoupper("hello world?"))as$k=>$v){echo $a[ord($v)]." ";}
코모도는 2 줄에 380 자라고합니다. 추가 줄은 가독성을위한 것입니다. ; D 배열에 산재 된 1은 그 후 배열 위치로 수동으로 점프하는 대신 해당 배열 위치를 데이터로 채워 2 바이트를 절약하는 것입니다.
첫 번째 대 두 번째를 고려하십시오. 그 차이는 분명합니다. :)
array(20=>"data",22=>"more data";
array(20=>"data",1,"more data";
그러나 최종 결과는 골프에서 수행하지 않는 내용을 반복하는 대신 배열 위치를 사용하는 정확히입니다.
최종 결과 : 578 자, 380 자 (198 자 또는 ~ 34.26 % 절감).
Bash , 내가 얼마 전에 쓴 펼쳐 (작년 타임 스탬프에 따르면)는 1661 자에 달합니다. 정말 재미로 :)
#!/bin/sh
txt=''
res=''
if [ "$1" == '' ]; then
read -se txt
else
txt="$1"
fi;
len=$(echo "$txt" | wc -c)
k=1
while [ "$k" -lt "$len" ]; do
case "$(expr substr "$txt" $k 1 | tr '[:upper:]' '[:lower:]')" in
'e') res="$res"'.' ;;
't') res="$res"'-' ;;
'i') res="$res"'..' ;;
'a') res="$res"'.-' ;;
'n') res="$res"'-.' ;;
'm') res="$res"'--' ;;
's') res="$res"'...' ;;
'u') res="$res"'..-' ;;
'r') res="$res"'.-.' ;;
'w') res="$res"'.--' ;;
'd') res="$res"'-..' ;;
'k') res="$res"'-.-' ;;
'g') res="$res"'--.' ;;
'o') res="$res"'---' ;;
'h') res="$res"'....' ;;
'v') res="$res"'...-' ;;
'f') res="$res"'..-.' ;;
'l') res="$res"'.-..' ;;
'p') res="$res"'.--.' ;;
'j') res="$res"'.---' ;;
'b') res="$res"'-...' ;;
'x') res="$res"'-..-' ;;
'c') res="$res"'-.-.' ;;
'y') res="$res"'-.--' ;;
'z') res="$res"'--..' ;;
'q') res="$res"'--.-' ;;
'5') res="$res"'.....' ;;
'4') res="$res"'....-' ;;
'3') res="$res"'...--' ;;
'2') res="$res"'..---' ;;
'1') res="$res"'.----' ;;
'6') res="$res"'-....' ;;
'7') res="$res"'--...' ;;
'8') res="$res"'---..' ;;
'9') res="$res"'----.' ;;
'0') res="$res"'-----' ;;
esac;
[ ! "$(expr substr "$txt" $k 1)" == " " ] && [ ! "$(expr substr "$txt" $(($k+1)) 1)" == ' ' ] && res="$res"' '
k=$(($k+1))
done;
echo "$res"
C89 (388 자)
아직 쉼표, 중지 및 쿼리 전체를 처리하지 않으므로 불완전 합니다.
#define P putchar
char q[10],Q,tree[]=
"EISH54V 3UF 2ARL + WP J 1TNDB6=X/ KC Y MGZ7 Q O 8 90";s2;e(x){q[Q++]
=x;}p(){for(;Q--;putchar(q[Q]));Q=0;}T(int x,char*t,int s){s2=s/2;return s?*t-x
?t[s2]-x?T(x,++t+s2,--s/2)?e(45):T(x,t,--s/2)?e(46):0:e(45):e(46):0;}main(c){
while((c=getchar())>=0){c-=c<123&&c>96?32:0;if(c==10)P(10);if(c==32)P(47);else
T(c,tree,sizeof(tree)),p();P(' ');}}
가독성을 위해 포장되었습니다. 줄 바꿈 중 두 개만 필요합니다 (하나는 #define 용으로, 다른 하나는 공백 일 수 있음). 비표준 문자를 몇 개 추가했지만 7 개의 비트가 아닌 문자는 추가하지 않습니다.
C, 533 자
몇 가지 의견에서 조언을 받고 stdin으로 전환했습니다. 70 건 죽었다.
#include <stdio.h>
#include <ctype.h>
char *u[36] = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."};
main(){
char*v;int x;char o;
do{
o = toupper(getc(stdin));v=0;if(o>=65&&o<=90)v=u[o-'A'];if(o>=48&&o<=57)v=u[o-'0'+26];if(o==46)v=".-.-.-";if(o==44)v="--..--";if(o==63)v="..--..";if(o==32)v="/";if(v)printf("%s ", v);} while (o != EOF);
}
C (381 자)
char*p[36]={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."};
main(){int c;while((c=tolower(getchar()))!=10)printf("%s ",c==46?".-.-.-":c==44?"--..--":c==63?"..--..":c==32?"/":*(p+(c-97)));}
C , cmdline 인수를 사용하는 448 바이트 :
char*a[]={".-.-.-","--..--","..--..","/",".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."},*k=".,? ",*s,*p,x;main(int _,char**v){for(;s=*++v;putchar(10))for(;x=*s++;){p=strchr(k,x);printf("%s ",p?a[p-k]:isdigit(x)?a[x-18]:isalpha(x=toupper(x))?a[x-61]:0);}}
C , stdin을 사용하는 416 바이트 :
char*a[]={".-.-.-","--..--","..--..","/",".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."},*k=".,? ",*p,x;main(){while((x=toupper(getchar()))-10){p=strchr(k,x);printf("%s ",p?a[p-k]:isdigit(x)?a[x-18]:isalpha(x)?a[x-61]:0);}}
참고 URL : https://stackoverflow.com/questions/1352587/convert-a-string-into-morse-code
'ProgramingTip' 카테고리의 다른 글
| MySQL 5.7의 기본 루트 암호는 무엇입니까? (0) | 2020.12.13 |
|---|---|
| iOS Swift에서 NSDate를 다중로 변환 (0) | 2020.12.13 |
| 널을 테스트하는 간단한 방법으로 변환하기 전에 (0) | 2020.12.13 |
| 오류 ITMS-90174 :“프로비저닝 프로필이 없습니다. iOS 앱은 embed.mobileprovision이라는 파일에 프로필을 포함해야합니다.” (0) | 2020.12.13 |
| gem으로 라이선스를 설치하는 동안 실행 가능한 gem :: GemNotFoundException)이있는 gem 들러 (> = 0.a)를 사용할 수 없습니다. (0) | 2020.12.13 |